NumPy Tutorial: Data-analyysi Pythonilla

Älkää jättäkö väliin tämän postauksen lopussa olevaa ILMAISTA NumPy-huijauslomakettamme

NumPy on yleisesti käytetty Python-data-analyysipaketti. Käyttämällä NumPy:tä voit nopeuttaa työnkulkuasi ja liittyä muihin Python-ekosysteemin paketteihin, kuten scikit-learniin, jotka käyttävät NumPy:tä konepellin alla. NumPy kehitettiin alun perin 2000-luvun puolivälissä, ja se syntyi vielä vanhemmasta paketista nimeltä Numeric. Tämä pitkäikäisyys tarkoittaa sitä, että lähes jokainen Pythonille tarkoitettu data-analyysi- tai koneoppimispaketti hyödyntää NumPy:tä jollakin tavalla.

Tässä opetusohjelmassa käymme läpi NumPy:n käyttöä viinin laatua koskevien tietojen analysointiin. Data sisältää tietoja viinien eri ominaisuuksista, kuten pH ja fixed acidity, sekä laatupisteet 0 ja 10 välillä kullekin viinille. Laatupistemäärä on vähintään 3 inhimillisten makutestaajien keskiarvo. Kun opettelemme työskentelemään NumPyn kanssa, yritämme selvittää lisää viinin koetusta laadusta.

Analysoimamme viinit ovat Portugalin Minhon alueelta.

Aineisto ladattiin UCI:n Machine Learning Repositorysta, ja se on saatavilla täältä. Tässä ovat ensimmäiset rivit winequality-red.csv-tiedostosta, jota käytämme koko tämän opetusohjelman ajan:

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

Data on muodossa, jota aion kutsua ssv-muodoksi (semicolon separated values, puolipisteellä erotetut arvot) – jokainen tietue erotetaan toisistaan puolipisteellä (;), ja rivit erotetaan toisistaan uudella rivillä. Tiedostossa on 1600 riviä, mukaan lukien otsikkorivi, ja 12 saraketta.

Ennen kuin aloitamme, nopea versiohuomautus – käytämme Python 3.5:tä. Koodiesimerkkimme tehdään käyttäen Jupyter notebookia.

Lists Of Lists for CSV Data

Ennen NumPy:n käyttämistä yritämme ensin työskennellä datan kanssa käyttäen Pythonia ja csv-pakettia. Voimme lukea tiedoston csv.reader-olion avulla, jonka avulla voimme lukea ja jakaa koko ssv-tiedoston sisällön.

Alhaalla olevassa koodissa:

• Importoimme csv-kirjaston.
• Avaamme winequality-red.csv-tiedoston.
  • Tiedoston ollessa auki luomme uuden csv.reader-olion.
    • Syötä avainsana-argumentti delimiter=";" varmistaaksesi, että tietueet jaetaan puolipiste-merkillä oletusarvoisen pilkku-merkin sijasta.
  • Kutsu listatyyppiä hakemaan kaikki rivit tiedostosta.
  • Määritä tulos wines:lle.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

Kun olemme lukeneet tiedot, voimme tulostaa ensimmäiset 3 riviä:

print(wines)

, , ]

Tiedot on luettu luetteloksi. Jokainen sisempi lista on rivi ssv-tiedostosta. Kuten olet ehkä huomannut, koko listojen luettelon jokainen kohde esitetään merkkijonona, mikä vaikeuttaa laskutoimitusten tekemistä.

Muotoilemme tiedot taulukoksi, jotta niitä olisi helpompi tarkastella:

Kuten yllä olevasta taulukosta näkyy, olemme lukeneet kolme riviä, joista ensimmäinen sisältää sarakeotsikot. Jokainen rivi otsikkorivin jälkeen edustaa viiniä. Kunkin rivin ensimmäinen elementti on fixed acidity, toinen volatile acidity ja niin edelleen. Voimme löytää viinien keskiarvon quality. Alla olevalla koodilla saadaan:

• Poimitaan jokaiselta otsikkorivin jälkeiseltä riviltä viimeinen elementti.
• Muunnetaan jokainen poimittu elementti liukuluvuksi.
• Asetetaan kaikki poimitut elementit listaan qualities.
• Jaa kaikkien qualities:ssä olevien elementtien summa qualities:ssä olevien elementtien kokonaismäärällä saadaksesi keskiarvon.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Vaikka saimmekin tehtyä haluamamme laskutoimituksen, koodi on melko monimutkaista, eikä ole hauskaa joutua tekemään jotakin vastaavaa joka kerta, kun haluamme laskea jonkin suureen. Onneksi voimme käyttää NumPy:tä helpottaaksemme datamme käsittelyä.

Numpy 2-ulotteiset matriisit

NumPy:n avulla työskentelemme moniulotteisten matriisien kanssa. Sukellamme myöhemmin kaikkiin mahdollisiin moniulotteisten matriisien tyyppeihin, mutta nyt keskitymme 2-ulotteisiin matriiseihin. 2-ulotteinen matriisi tunnetaan myös nimellä matriisi, ja se on jotain, joka sinun pitäisi tuntea. Itse asiassa se on vain erilainen tapa ajatella listojen luetteloa. Matriisissa on rivejä ja sarakkeita. Määrittämällä rivin numeron ja sarakkeen numeron voimme poimia elementin matriisista.

Alla olevassa matriisissa ensimmäinen rivi on otsikkorivi ja ensimmäinen sarake on fixed acidity-sarake:

Jos valitsisimme elementin ensimmäiseltä riviltä ja toisesta sarakkeesta, saisimme volatile acidity. Jos valitsisimme elementin kolmannelta riviltä ja toiselta sarakkeelta, saisimme tulokseksi 0.88.

NumPy-matriisissa ulottuvuuksien lukumäärää kutsutaan rankiksi, ja jokaista ulottuvuutta kutsutaan akseliksi. Rivit ovat siis ensimmäinen akseli ja sarakkeet toinen akseli.

Nyt kun olet ymmärtänyt matriisien perusteet, katsotaanpa, miten pääsemme listoistamme NumPy-matriisiin.

NumPy-matriisin luominen

Voimme luoda NumPy-matriisin numpy.array-funktiolla. Jos annamme listan listoja, se luo automaattisesti NumPy-massan, jossa on sama määrä rivejä ja sarakkeita. Koska haluamme, että kaikki matriisin elementit ovat float-alkioita laskennan helpottamiseksi, jätämme pois otsikkorivin, joka sisältää merkkijonoja. Yksi NumPy:n rajoituksista on se, että matriisin kaikkien elementtien on oltava samantyyppisiä, joten jos otamme mukaan otsikkorivin, kaikki matriisin elementit luetaan merkkijonoina. Koska haluamme pystyä tekemään laskutoimituksia, kuten löytämään viinien keskiarvon quality, tarvitsemme kaikkien elementtien olevan liukulukuja.

Alhaalla olevassa koodissa:

• Importoimme numpy-paketin.
• Syötämme listan wines funktioon array, joka muuntaa sen NumPy-matriisiksi.
  • Poistamme otsikkorivin pois listan viipaloimalla.
  • Määritämme avainsana-argumentin dtype varmistaaksemme, että jokainen elementti muunnetaan floatiksi. Sukelletaan myöhemmin tarkemmin siihen, mitä dtype on.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

Kokeile ajaa yllä oleva koodi ja katso, mitä tapahtuu!

Jos näytämme wines, saamme nyt NumPy-matriisin:

wines

array(,,,...,,,])

Voimme tarkistaa datamme rivien ja sarakkeiden määrän NumPy-matriisien shape-ominaisuuden avulla:

wines.shape

(1599, 12)

Vaihtoehtoiset NumPy-matriisien luomismenetelmät

On olemassa erilaisia menetelmiä, joita voit käyttää NumPy-matriisien luomiseen. Aluksi voit luoda joukon, jonka jokainen alkio on nolla. Alla oleva koodi luo matriisin, jossa on 3 riviä ja 4 saraketta ja jossa jokainen alkio on 0, käyttämällä numpy.zeros:

import numpy as np

empty_array = np.zeros((3,4)) empty_array

On hyödyllistä luoda matriisi, jonka kaikki alkiot ovat nolla-alkioita, tapauksissa, joissa tarvitset kiinteäkokoisen matriisin, mutta sinulla ei ole vielä arvoja sille.

Voit myös luoda matriisin, jonka jokainen alkio on satunnaisluku, käyttämällä numpy.random.rand. Tässä on esimerkki:

np.random.rand(3,4)

array(,,])

Satunnaislukuja täynnä olevien arrayjen luominen voi olla hyödyllistä, kun haluat nopeasti testata koodiasi esimerkkimatriisien avulla.

NumPyn käyttäminen tiedostojen sisäänlukemiseen

NumPy:n avulla on mahdollista lukea suoraan csv- tai muita tiedostoja arrayihin. Voimme tehdä tämän käyttämällä numpy.genfromtxt-funktiota. Voimme käyttää sitä lukeaksemme sisään punaviinejä koskevat lähtötietomme.

Alla olevassa koodissa:

• Käytä genfromtxt-funktiota lukeaksesi sisään winequality-red.csv-tiedoston.
• Määritä avainsana-argumentti delimiter=";", jotta kentät jäsennetään oikein.
• Määritä avainsana-argumentti skip_header=1, jotta otsikkorivi ohitetaan.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

wines näyttää lopulta samalta kuin jos lukisimme sen listaksi ja muuttaisimme sen sitten liukulukujen joukoksi. NumPy valitsee automaattisesti tietotyypin matriisin elementeille niiden muodon perusteella.

NumPy-matriisien indeksointi

Me osaamme nyt luoda matriiseja, mutta ellemme voi hakea niistä tuloksia, emme voi tehdä NumPyllä paljoakaan. Voimme käyttää matriisien indeksointia yksittäisten elementtien, elementtiryhmien tai kokonaisten rivien ja sarakkeiden valitsemiseen. Yksi tärkeä asia, joka on syytä pitää mielessä, on se, että aivan kuten Python-listat, NumPy on nollaindeksoitu, mikä tarkoittaa, että ensimmäisen rivin indeksi on 0 ja ensimmäisen sarakkeen indeksi on 0. Jos haluamme työskennellä neljännen rivin kanssa, käytämme indeksiä 3, jos haluamme työskennellä toisen rivin kanssa, käytämme indeksiä 1 ja niin edelleen. Työskentelemme jälleen wines-joukon kanssa:

Valitaan elementti rivillä 3 ja sarakkeessa 4. Alla olevassa koodissa annamme rivin indeksiksi indeksin 2 ja sarakkeen indeksiksi indeksin 3. Näin haetaan arvo kolmannen rivin neljännestä sarakkeesta:

wines

2.2999999999999998

Koska työskentelemme NumPy:ssä kaksiulotteisen matriisin kanssa, määrittelemme kaksi indeksiä elementin hakemiseen. Ensimmäinen indeksi on rivin eli akselin 1 indeksi ja toinen indeksi on sarakkeen eli akselin 2 indeksi. Mikä tahansa wines:n elementti voidaan hakea 2-indeksien avulla.

Slicing NumPy Arrays

Jos sen sijaan haluamme valita kolme ensimmäistä elementtiä neljännestä sarakkeesta, voimme tehdä sen kaksoispisteen avulla (:). Kaksoispiste ilmaisee, että haluamme valita kaikki elementit alkuindeksistä aina loppuindeksiin asti, mutta ei sitä myöten. Tämä tunnetaan myös nimellä viipalointi:

wines

array()

Aivan kuten listan viipaloinnissa, on mahdollista jättää 0 pois, jolloin voimme vain hakea kaikki elementit alkuindeksistä elementtiin 3 asti:

wines

array()

Voimme valita kokonaisen sarakkeen määrittelemällä, että haluamme kaikki elementit ensimmäisestä viimeiseen. Määrittelemme tämän käyttämällä vain kaksoispistettä (:) ilman alku- tai loppuindeksiä. Alla oleva koodi valitsee koko neljännen sarakkeen:

wines

array()

Valitsimme edellä kokonaisen sarakkeen, mutta voimme myös poimia kokonaisen rivin:

wines

array()

Jos viemme indeksoinnin äärimmilleen, voimme valita koko joukon käyttämällä kahta kaksoispistettä kaikkien rivien ja sarakkeiden valitsemiseksi wines. Tämä on hieno juhlatemppu, mutta sillä ei ole paljon hyviä sovelluksia:

wines

array(,,<br />,<br />...,,,<br />])

Arvojen antaminen NumPy-matriiseille

Voimme käyttää indeksointia myös arvojen antamiseen tietyille elementeille matriiseissa. Voimme tehdä tämän osoittamalla suoraan indeksoituun arvoon:

wines = 10

Voidaan tehdä sama viipaleille. Jos haluamme korvata kokonaisen sarakkeen, voimme tehdä näin:

wines = 50

Yllä oleva koodi korvaa kaikki yhdennentoista sarakkeen arvot arvolla 50.

1-ulotteiset NumPy-matriisit

Tähän mennessä olemme työskennelleet 2-ulotteisten matriisien, kuten wines kanssa. NumPy on kuitenkin paketti moniulotteisten matriisien kanssa työskentelyyn. Yksi yleisimmistä moniulotteisten matriisien tyypeistä on 1-ulotteinen matriisi eli vektori. Kuten ehkä huomasit edellä, kun viipaloimme wines, haimme 1-ulotteisen matriisin. Yksiulotteinen array tarvitsee vain yhden indeksin elementin hakemiseen. Kaksiulotteisen matriisin jokainen rivi ja sarake on yksiulotteinen matriisi. Aivan kuten listojen luettelo vastaa 2-ulotteista joukkoa, yksittäinen lista vastaa 1-ulotteista joukkoa. Jos viipaloimme viinejä ja haemme vain kolmannen rivin, saamme 1-ulotteisen joukon:

third_wine = wines

Tältä näyttää third_wine:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Voimme hakea yksittäisiä elementtejä third_wine:stä yhdellä indeksillä. Alla oleva koodi näyttää third_wine:n toisen elementin:

third_wine

0.28000000000000003

Suurinta osaa NumPy-funktioista, joiden kanssa olemme työskennelleet, kuten numpy.random.rand, voidaan käyttää moniulotteisten matriisien kanssa. Näin käyttäisimme numpy.random.rand:tä satunnaisvektorin tuottamiseen:

np.random.rand(3)

array()

Edellisenä kutsuessamme np.random.rand annoimme muodon 2-ulotteiselle joukolle, joten tulos oli 2-ulotteinen joukko. Tällä kertaa annoimme muodon yksiulotteiselle arraylle. Shape määrittää ulottuvuuksien lukumäärän ja joukon koon kussakin ulottuvuudessa. Shape (10,10) on 2-ulotteinen array, jossa on 10 riviä ja 10 saraketta. Shape (10,) on 1-ulotteinen array, jossa on 10 elementtiä.

Missä NumPy muuttuu monimutkaisemmaksi, on silloin, kun alamme käsitellä matriiseja, joissa on enemmän kuin 2 ulottuvuutta.

N-ulotteiset NumPy-matriisit

Tätä ei tapahdu äärimmäisen usein, mutta on tapauksia, joissa haluat käsitellä matriiseja, joilla on enemmän kuin 3 ulottuvuuksia. Yksi tapa ajatella tätä on lista listojen listojen listoista. Oletetaan, että haluamme tallentaa myymälän kuukausittaiset tulot, mutta haluamme pystyä nopeasti etsimään tulokset vuosineljännekseltä ja vuodelta. Yhden vuoden tulos voisi näyttää seuraavalta:

Liike tienasi tammikuussa 0, helmikuussa 5 ja niin edelleen. Voimme jakaa nämä ansiot vuosineljänneksittäin luetteloksi:

year_one = , , , ]

Voimme hakea tammikuun ansiot kutsumalla year_one. Jos haluamme koko vuosineljänneksen tulokset, voimme kutsua year_one tai year_one. Meillä on nyt 2-ulotteinen array eli matriisi. Mutta entä jos haluamme nyt lisätä tulokset toiselta vuodelta? Meidän on lisättävä kolmas ulottuvuus:

earnings = , , , ], , , , ]]

Voimme hakea ensimmäisen vuoden tammikuun tulokset kutsumalla earnings. Tarvitsemme nyt kolme indeksiä yhden elementin hakemiseen. Kolmiulotteinen matriisi NumPy:ssä on paljolti samanlainen. Itse asiassa voimme muuntaa earnings:n array:ksi ja saada sitten ensimmäisen vuoden tammikuun ansiot:

earnings = np.array(earnings)earnings

500

Voimme myös löytää array:n muodon:

earnings.shape

(2, 4, 3)

Indeksointi ja viipalointi toimivat täsmälleen samalla tavalla kolmiulotteisen array:n kanssa, mutta nyt meillä on ylimääräinen akseli välitettävänä. Jos haluaisimme saada kaikkien vuosien tammikuun ansiot, voisimme tehdä näin:

earnings

array()

Jos haluaisimme saada ensimmäisen vuosineljänneksen ansiot molemmilta vuosilta, voisimme tehdä näin:

earnings

array(,])

Lisäulottuvuuksien lisääminen voi helpottaa huomattavasti tietojen kyselyä, jos ne on järjestetty tietyllä tavalla. Kun siirrymme 3-ulotteisista matriiseista 4-ulotteisiin ja suurempiin matriiseihin, samat ominaisuudet pätevät, ja niitä voidaan indeksoida ja viipaloida samalla tavalla.

NumPy-tietotyypit

Kuten aiemmin mainitsimme, kukin NumPy-matriisi voi tallentaa yhden tietotyypin elementtejä. Esimerkiksi wines sisältää vain float-arvoja. NumPy tallentaa arvoja käyttäen omia tietotyyppejään, jotka eroavat Python-tyypeistä, kuten float ja str. Tämä johtuu siitä, että NumPyn ydin on kirjoitettu C-nimisellä ohjelmointikielellä, joka tallentaa tietoja eri tavalla kuin Pythonin tietotyypit. NumPy:n tietotyypit kartoittavat Pythonin ja C:n välillä, minkä ansiosta voimme käyttää NumPy:n matriiseja ilman muunnosongelmia.

Saat selville NumPy:n matriisin tietotyypin käyttämällä dtype-ominaisuutta:

wines.dtype

dtype('float64')

NumPy:llä on useita eri tietotyyppejä, jotka enimmäkseen kartoittavat Pythonin tietotyyppejä, kuten float ja str. Löydät täydellisen listan NumPy:n tietotyypeistä täältä, mutta tässä muutama tärkeä:

• float – numeerinen liukulukutieto.
• int – kokonaislukutieto.
• string – merkkidata.
• object – Python-objektit.

Tietotyypit päättyvät lisäksi suffiksiin, joka ilmaisee, kuinka monta bittiä muistia ne vievät. Niinpä int32 on 32-bittinen kokonaislukutietotyyppi ja float64 on 64-bittinen liukulukutietotyyppi.

Datatyyppien muuntaminen

Voit käyttää numpy.ndarray.astype-metodia matriisin muuntamiseen eri tyypiksi. Metodi itse asiassa kopioi joukon ja palauttaa uuden joukon, jolla on määritetty tietotyyppi. Voimme esimerkiksi muuntaa wines tietotyypiksi int:

wines.astype(int)

array(,,,...,,,])

Kuten yllä näkyy, kaikki tuloksena saadun joukon kohteet ovat kokonaislukuja. Huomaa, että käytimme Pythonin int-tyyppiä NumPy-tietotyypin sijasta muunnettaessa wines. Tämä johtuu siitä, että useita Python-tietotyyppejä, kuten float, int ja string, voidaan käyttää NumPy:n kanssa, ja ne muunnetaan automaattisesti NumPy:n tietotyypeiksi.

Voidaan tarkistaa tuloksena syntyvän matriisin dtype-ominaisuuden name-ominaisuudesta, että nähdään, millaiseksi tietotyypiksi NumPy on tuloksena syntyvän matriisin kartoittanut:

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

Matriisin on muunnettu 64-bittiseen kokonaislukutyyppiin. Tämä mahdollistaa hyvin pitkät kokonaislukuarvot, mutta vie enemmän tilaa muistissa kuin arvojen tallentaminen 32-bittisinä kokonaislukuina.

Jos haluat enemmän kontrollia siihen, miten array tallennetaan muistiin, voit luoda suoraan NumPy:n dtype-objekteja kuten numpy.int32:

np.int32

numpy.int32

Voit käyttää näitä suoraan tyyppien väliseen muuntamiseen:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

NumPy Array Operations

NumPy tekee matemaattisten operaatioiden suorittamisesta matriiseille helppoa. Tämä on yksi NumPyn tärkeimmistä eduista, ja se tekee laskutoimitusten tekemisestä melko helppoa.

Single Array Math

Jos teet jonkin matemaattisen perusoperaation (/, *, -, +, ^) joukolla ja arvolla, se soveltaa operaatiota jokaiselle joukon elementille.

Asettakaamme, että haluamme lisätä 10 pistettä jokaiseen laatupisteeseen, koska olemme humalassa ja tunnemme itsemme anteliaiksi. Näin toimimme näin:

wines + 10

array()

Huomaa, että ylläoleva operaatio ei muuta wines-matriisia – se palauttaa uuden yksiulotteisen matriisin, jossa 10 on lisätty viinien laatusarakkeen jokaiseen elementtiin.

Jos sen sijaan tekisimme operaation +=, muuttaisimme matriisia tilalle:

wines += 10wines

array()

Kaikki muut operaatiot toimivat samalla tavalla. Jos esimerkiksi haluaisimme kertoa jokaisen laatupistemäärän luvulla 2, voisimme tehdä sen näin:

wines * 2

array()

Multiple Array Math

Mahdollista on myös tehdä matemaattisia operaatioita arrayjen välillä. Tämä soveltaa operaatiota elementtipareihin. Jos esimerkiksi lisäämme sarakkeen quality itseensä, saamme seuraavan tuloksen:

wines + wines

array()

Huomaa, että tämä vastaa wines * 2 – tämä johtuu siitä, että NumPy laskee yhteen jokaisen elementtiparin. Ensimmäisen matriisin ensimmäinen elementti lisätään toisen matriisin ensimmäiseen elementtiin, toinen toiseen ja niin edelleen.

Voidaan käyttää tätä myös matriisien kertomiseen. Sanotaan, että haluamme valita viinin, joka maksimoi alkoholipitoisuuden ja -laadun (haluamme humaltua, mutta olemme tyylikkäitä). Kertoisimme alcohol luvulla quality ja valitsisimme viinin, jonka pistemäärä on suurin:

wines * wines

array()

Kaikki yleiset operaatiot (/, *, -, +, ^) toimivat matriisien välillä.

Lähetystoiminnot

Jollei matriiseja, joiden kanssa operoit, ole täsmälleen samankokoisia, elementtikohtaisia operaatioita ei voi tehdä. Tällaisissa tapauksissa NumPy suorittaa broadcastingin yrittäessään sovittaa elementit yhteen. Yleisradiointiin kuuluu olennaisesti muutama vaihe:

• Vertaillaan kummankin matriisin viimeistä dimensiota.
  • Jos dimensioiden pituudet ovat yhtä pitkiä tai yksi dimensioista on pituudeltaan 1, jatketaan.
  • Jos dimensioiden pituudet eivät ole yhtä pitkiä eikä yksikään dimensio ole pituudeltaan 1, tulee virhe.
• Jatketaan dimensioiden tarkistamista, kunnes lyhimmän joukon dimensiot loppuvat.

Esimerkiksi seuraavat kaksi muotoa ovat yhteensopivia:

A: (50,3)B (3,)

Tämä johtuu siitä, että joukon A jälkimmäisen dimensioiden pituus on 3 ja joukon B jälkimmäisen dimensioiden pituus on 3. Ne ovat yhtä suuret, joten tuo ulottuvuus on kunnossa. Joukosta B loppuvat tällöin elementit, joten kaikki on kunnossa, ja joukot ovat yhteensopivia matemaattisia operaatioita varten.

Myös seuraavat kaksi muotoa ovat yhteensopivia:

A: (1,2)B (50,2)

Viimeinen ulottuvuus täsmää, ja A:n ensimmäisen ulottuvuuden pituus on 1.

Nämä kaksi matriisia eivät sovi yhteen:

A: (50,50)B: (49,49)

Dimensioiden pituudet eivät ole yhtä pitkiä, eikä kummankaan matriisin kummankaan dimensiopituus ole yhtä suuri kuin 1.

Tässä on yksityiskohtainen selitys lähetyksestä, mutta käymme läpi muutaman esimerkin havainnollistaaksemme periaatetta:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

Ylläoleva esimerkkikuvio ei toiminutkaan, koska molemmilla matriiseilla ei ole yhteensopivaa jälkimmäistä ulottuvuutta. Tässä on esimerkki, jossa viimeinen ulottuvuus täsmää:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

Kuten näet, array_two on lähetetty array_one:n jokaiselle riville. Tässä on esimerkki wines-tiedoillamme:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Elementit rand_array lähetetään wines:n jokaiselle riville, joten wines:n ensimmäiseen sarakkeeseen on lisätty rand_array:n ensimmäinen arvo, ja niin edelleen.

NumPy Array Methods

Yleisten matemaattisten operaatioiden lisäksi NumPy:llä on myös useita metodeja, joita voit käyttää monimutkaisempiin laskutoimituksiin matriiseilla. Esimerkki tästä on numpy.ndarray.sum-metodi. Tämä löytää oletusarvoisesti matriisin kaikkien elementtien summan:

wines.sum()

9012.0

Kaikkien laatuluokitusten summa on 154.1788. Voimme välittää axis-avainsana-argumentin sum-metodiin löytääksemme summat akselilla. Jos kutsumme sum-menetelmää wines-matriisin yli ja annamme parametrina axis=0, löydämme summat matriisin ensimmäisen akselin yli. Näin saamme jokaisen sarakkeen kaikkien arvojen summan. Tämä saattaa vaikuttaa takaperoiselta, että summat ensimmäisen akselin yli antaisivat meille jokaisen sarakkeen summan, mutta yksi tapa ajatella tätä on, että määritetty akseli on se, joka ”lähtee pois”. Jos siis määrittelemme axis=0, haluamme, että rivit menevät pois, ja haluamme löytää summat jokaiselle jäljelle jäävälle akselille jokaisen rivin yli:

wines.sum(axis=0)

array()

Voimme tarkistaa, että teimme summan oikein tarkistamalla muodon. Muodon pitäisi olla 12, joka vastaa sarakkeiden lukumäärää:

wines.sum(axis=0).shape

(12,)

Jos välitämme axis=1, löydämme summat joukon toisen akselin yli. Näin saamme kunkin rivin summan:

wines.sum(axis=1)

array()

On olemassa useita muitakin metodeja, jotka käyttäytyvät sum-metodin tavoin, kuten:

• numpy.ndarray.mean – löytää joukon keskiarvon.
• numpy.ndarray.std – löytää joukon keskihajonnan.
• numpy.ndarray.min – löytää joukon pienimmän arvon.
• numpy.ndarray.max – löytää joukon maksimiarvon.

Kokonaisen listan joukkojen metodeista löydät täältä.

NumPy Array Comparisons

NumPy:n avulla on mahdollista testata, täsmäävätkö rivit tiettyihin arvoihin käyttämällä matemaattisia vertailuoperaatioita, kuten <, >, >=, <= ja ==. Jos esimerkiksi haluamme nähdä, millä viineillä on korkeampi laatuluokitus kuin 5, voimme tehdä näin:

wines > 5

array(, dtype=bool)

Saamme Boolean-määritteen, joka kertoo, millä viineillä on korkeampi laatuluokitus kuin 5. Voimme tehdä jotakin vastaavaa muiden operaattoreiden kanssa. Voimme esimerkiksi nähdä, onko jollain viinillä laatuluokitus yhtä suuri kuin 10:

wines == 10

array(, dtype=bool)

Subsetting

Yksi tehokkaista asioista, joita voimme tehdä Boolean-määritteellä ja NumPy-määritteellä, on valita vain tietyt rivit tai sarakkeet NumPy-määritteestä. Esimerkiksi alla oleva koodi valitsee vain ne rivit wines:stä, joiden laatu on yli 7:

high_quality = wines > 7wines

array(,,])

Valitaan vain ne rivit, joissa high_quality sisältää arvon True, ja kaikki sarakkeet. Tämän aluerajauksen avulla on helppo suodattaa matriiseja tiettyjen kriteerien perusteella. Voimme esimerkiksi etsiä viinejä, joissa on paljon alkoholia ja jotka ovat korkealaatuisia. Määrittääksemme useita ehtoja meidän on asetettava kukin ehto sulkuihin ja erotettava ehdot toisistaan amperandilla (&):

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Voimme yhdistää alitusta ja osoittamista korvataksemme tietyt arvot matriisissa:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

NumPy-matriisien muokkaaminen

Voimme muuttaa matriisien muotoa säilyttäen silti kaikki niiden elementit. Tämä voi usein helpottaa matriisin elementtien käyttämistä. Yksinkertaisin muodonmuutos on kääntää akselit, jolloin riveistä tulee sarakkeita ja päinvastoin. Voimme toteuttaa tämän numpy.transpose-funktiolla:

np.transpose(wines).shape

(12, 1599)

Voidaan käyttää numpy.ravel-funktiota muuttamaan array yksiulotteiseksi esitykseksi. Se lähinnä litistää joukon pitkäksi arvojen sarjaksi:

wines.ravel()

array()

Tässä on esimerkki, jossa näemme järjestyksen numpy.ravel:

array_one = np.array( , ])array_one.ravel()

array()

Viimeiseksi voimme käyttää numpy.reshape-funktiota muokkaamaan joukon tiettyyn määrittelemäämme muotoon. Alla oleva koodi muuttaa toisen rivin wines kaksiulotteiseksi matriisiksi, jossa on 2 riviä ja 6 saraketta:

wines.reshape((2,6))

array(,])

NumPy-matriisien yhdistäminen

NumPy:n avulla on hyvin yleistä yhdistää useita matriiseja yhdeksi yhtenäiseksi matriisiksi. Voimme käyttää numpy.vstack-ohjelmaa useiden matriisien vertikaaliseen pinoamiseen. Ajattele, että toisen matriisin kohteet lisätään uusina riveinä ensimmäiseen matriisiin. Voimme lukea tietokokonaisuuden winequality-white.csv, joka sisältää tietoa valkoviinien laadusta, ja yhdistää sen sitten olemassa olevaan tietokokonaisuuteemme wines, joka sisältää tietoa punaviineistä.

Alla olevassa koodissa me:

• Luemme sisään winequality-white.csv.
• Näytämme muodon white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

Kuten näet, meillä on attribuutteja 4898 viineille. Nyt kun meillä on valkoviinien tiedot, voimme yhdistää kaikki viinitiedot.

Alla olevassa koodissa:

• Käytä vstack-funktiota yhdistämään wines ja white_wines.
• Näytä tuloksen muoto.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

Kuten näet, tuloksessa on 6497 riviä, joka on wines:n rivien lukumäärän ja red_wines:n rivien lukumäärän summa.

Jos haluamme yhdistää matriiseja vaakasuoraan, jolloin rivien lukumäärä pysyy vakiona, mutta sarakkeet yhdistetään, voimme käyttää numpy.hstack-funktiota. Yhdistettävillä matriiseilla on oltava sama rivimäärä, jotta tämä toimisi.

Viimeiseksi voimme käyttää numpy.concatenate -funktiota yleiskäyttöisenä versiona hstack:stä ja vstack:stä. Jos haluamme ketjuttaa kaksi matriisia, välitämme ne concatenate:een ja määrittelemme sitten axis-avainsana-argumentin, jonka mukaan haluamme ketjuttaa. Ensimmäistä akselia pitkin ketjuttaminen on samanlaista kuin vstack, ja toista akselia pitkin ketjuttaminen on samanlaista kuin hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Free NumPy Cheat Sheet

Jos olet kiinnostunut oppimaan lisää NumPy:stä, tutustu vuorovaikutteiseen kurssiimme NumPysta ja Pandasista. Voit rekisteröityä ja tehdä ensimmäiset tehtävät ilmaiseksi.

Voit myös viedä NumPy-taitosi seuraavalle tasolle ilmaisella NumPy-huijauslomakkeellamme!

Lisälukemista

Sinulla pitäisi nyt olla hyvä käsitys NumPystä ja siitä, miten sitä voi soveltaa datasarjaan.

Jos haluat sukeltaa syvemmälle, tässä on joitain resursseja, joista voi olla apua:

• NumPy Quickstart – sisältää hyviä koodiesimerkkejä ja kattaa useimmat NumPy:n perustoiminnot.
• Python NumPy Tutorial – hyvä opas NumPy:stä ja muista Python-kirjastoista.
• Visual NumPy Introduction – opas, joka käyttää elämän peliä havainnollistamaan NumPy:n käsitteitä.

Seuraavassa oppaassamme sukellamme tarkemmin Pandasiin, kirjastoon, joka perustuu NumPy:hen ja tekee data-analyysistä entistä helpompaa. Se ratkaisee kaksi suurinta kipupistettä, jotka ovat:

• Et voi sekoittaa useita tietotyyppejä matriisissa.
• Joudut muistamaan, minkä tyyppistä dataa kukin sarake sisältää.