Scipy-tutorial: vectoren en arrays (lineaire algebra)

De basis van NumPy ndarray-objecten

Een array is, structureel gezien, niets meer dan pointers. Het is een combinatie van een geheugenadres, een datatype, een vorm en strides. Het bevat informatie over de ruwe data, hoe je een element lokaliseert en hoe je een element interpreteert.

Het geheugenadres en de strides zijn belangrijk wanneer je dieper ingaat op de low-level details van arrays, terwijl het datatype en de vorm dingen zijn die beginners zeker moeten kennen en begrijpen. Twee andere attributen die je kunt overwegen zijn data en size, waarmee je nog meer informatie over je array kunt verzamelen.

Fris het gebruik van de ndarray-attributen op in de volgende DataCamp Light-chunk. De array myArray is al ingeladen. Je kunt hem inspecteren door hem in te typen in de IPython-shell en op ENTER te drukken.

Je ziet in de resultaten van de code in de chunk hierboven dat het datatype van myArray int64 is. Als je intensief met arrays werkt, zul je zeker onthouden dat er manieren zijn om je arrays van het ene datatype naar het andere te converteren met de astype()-methode.

Toch zul je, wanneer je SciPy en NumPy samen gebruikt, de volgende NumPy-functies voor typehandling ook erg nuttig vinden, zeker als je met complexe getallen werkt:

Probeer print()-aanroepen toe te voegen om de resultaten van de bovenstaande code te zien. Dan zie je dat complexe getallen een reëel en een imaginair deel hebben. De functies np.real() en np.imag() zijn respectievelijk ontworpen om deze delen terug te geven.

Daarnaast kun je ook np.cast gebruiken om een array-object naar een ander datatype te casten, zoals float in het voorbeeld hierboven.

Het enige dat qua moeilijkheidsgraad echt opvalt in de bovenstaande codechunk is de functie np.real_if_close(). Wanneer je een complex invoer geeft, zoals myArray, krijg je een reële array terug als de complexe delen dicht bij nul liggen. Dit laatste, “dicht bij 0”, kun je zelf aanpassen met het argument tol dat je aan de functie kunt meegeven. Speel met de drempel om te zien wat er gebeurt!

Arrays maken

Je hebt nu gezien hoe je je array kunt inspecteren en het datatype ervan kunt aanpassen, maar je hebt nog niet expliciet gezien hoe je arrays maakt. Je weet waarschijnlijk al dat je np.array() kunt gebruiken om dit te doen, maar er zijn andere routines voor het maken van arrays die je moet kennen: np.eye() en np.identity().

Met de functie np.eye() maak je een vierkante matrix met dimensies die gelijk zijn aan het positieve geheel getal dat je als argument meegeeft. De elementen worden doorgaans gevuld met nullen, alleen de hoofddiagonaal wordt gevuld met enen. De functie np.identity() werkt hetzelfde en geeft ook een identiteitarray terug.

Let op dat np.eye() een extra argument k kan aannemen waarmee je de index van de diagonaal kunt kiezen die je met enen wilt vullen.

Andere functies om arrays te maken die enorm van pas komen wanneer je met matrices voor lineaire algebra werkt, zijn de volgende:

• De functie np.arange() maakt een array met gelijkmatig verdeelde waarden tussen twee getallen. Je kunt de stapgrootte tussen de elementen opgeven,
• Dat geldt ook voor np.linspace(), maar met deze functie specificeer je het aantal elementen dat je in je array wilt.
• Tot slot maakt de functie np.logspace() ook arrays met gelijkmatig verdeelde waarden, maar dan op een logaritmische schaal. Dat betekent dat de spreiding nu logaritmisch is: twee getallen zijn gelijkmatig verdeeld tussen de logaritmen van deze twee op basis 10.

Deze functies maken arrays in de vorm van rasters, die je kunt gebruiken om meshgrids te maken, waarover je eerder in dit artikel las.

Let op dat numpy al is geïmporteerd als np in de codechunk hieronder!

Nu je je geheugen hebt opgefrist en weet hoe je met de datatypes van je arrays omgaat, is het tijd om ook indexing en slicing aan te pakken.

SciPy installeren

Natuurlijk moet je eerst zeker weten dat je Python hebt geïnstalleerd. Ga naar deze pagina als je dat nog moet doen :) Als je op Windows werkt, zorg er dan voor dat je Python hebt toegevoegd aan de PATH-omgevingsvariabele. Vergeet daarnaast niet een package manager te installeren, zoals pip, zodat je de open-sourcebibliotheken van Python kunt gebruiken.

Let op dat recente versies van Python 3 met pip worden geleverd, dus controleer of je het hebt en werk het bij voordat je andere packages installeert:

 pip install pip --upgrade pip --version

Maar alleen een package manager installeren is niet genoeg; Je moet ook het wheel voor de bibliotheek downloaden: ga hierheen om je SciPy-wheel te halen. Open na het downloaden de terminal in de downloadmap op je pc en installeer het. Je kunt bovendien controleren of de installatie is geslaagd en de pakketversie bevestigen die je gebruikt:

# Install the wheel install "scipy‑0.18.1‑cp36‑cp36m‑win_amd64.whl"# Confirm successful installimport scipy# Check package versionscipy.__version__

Na deze stappen ben je klaar om te ga(a)n!

Tip: installeer het pakket door de Anaconda Python-distributie te downloaden. Dat is een makkelijke manier om snel te starten, want Anaconda bevat niet alleen 100 van de populairste Python-, R- en Scala-packages voor data science, maar ook meerdere open ontwikkelomgevingen zoals Jupyter en Spyder. Wil je met Jupyter Notebook beginnen, bekijk dan deze Jupyter Notebook-tutorial.

Als je het nog niet hebt gedownload, ga dan hierheen om het te halen.

Vectoren en matrices: de basis

Nu je zeker weet dat je werk­omgeving klaarstaat, kun je eindelijk aan de slag met lineaire algebra in Python. In essentie houdt deze discipline zich bezig met de studie van vectorruimten en de lineaire afbeeldingen die daartussen bestaan. Deze lineaire afbeeldingen kun je beschrijven met matrices, wat het berekenen ook eenvoudiger maakt.

Onthoud dat een vectorruimte een fundamenteel concept is in lineaire algebra. Het is een ruimte waar je een verzameling objecten (vectoren) hebt en waar je twee vectoren kunt optellen of schalen zonder dat de resulterende vector de ruimte verlaat. Onthoud ook dat vectoren rijen (of kolommen) van een matrix zijn.

Maar hoe werkt dit in Python?

Je maakt eenvoudig een vector met de functie np.array(). Evenzo kun je elke één- of tweedimensionale ndarray een matrixstructuur geven met de commando’s np.matrix() of np.mat().

Probeer het in de volgende codechunk:

Dus arrays en matrices zijn hetzelfde, afgezien van de opmaak?

Niet helemaal. Er zijn enkele verschillen:

• Een matrix is 2D, terwijl arrays doorgaans n-dimensionaal zijn,
• Zoals de functies hierboven al suggereerden, is de matrix een subklasse van ndarray,
• Zowel arrays als matrices hebben .T(), maar alleen matrices hebben .H() en .I(),
• Matrixvermenigvuldiging werkt anders dan elementgewijze arrayvermenigvuldiging, en
• Daarnaast levert de **-bewerking verschillende resultaten op voor matrices en arrays

Als je met matrices werkt, heb je soms matrices waarin de meeste elementen nul zijn. Deze matrices noem je “spaarzame matrices” (sparse), terwijl die met vooral niet-nul elementen “dichte matrices” (dense) worden genoemd.

Op zich lijkt dit triviaal, maar als je SciPy gebruikt voor lineaire algebra kan dit verschil soms uitmaken voor de modules die je gebruikt om dingen gedaan te krijgen. Concreet kun je scipy.linalg gebruiken voor dichte matrices, maar wanneer je met spaarzame matrices werkt, kun je ook de module scipy.sparse overwegen, die ook een eigen scipy.sparse.linalg bevat.

Voor spaarzame matrices zijn er behoorlijk wat opties om ze te maken. De onderstaande codechunk somt er een paar op:

Daarnaast zijn er ook andere functies die je kunt gebruiken om spaarzame matrices te maken: Block Sparse Row-matrices met bsr_matrix(), COOrdinate-format spaarzame matrices met coo_matrix(), DIAgonaal-opslag spaarzame matrices met dia_matrix(), en rijgebaseerde linked-list spaarzame matrices met lil_matrix().

Er zijn echt veel opties, maar welke kies je als je zelf een spaarzame matrix maakt?

Zo moeilijk is het niet.

Het komt er in de basis op neer hoe je hem gaat initialiseren. Bedenk daarna wat je met je spaarzame matrix wilt doen.

Concreter kun je de volgende checklist doorlopen om te beslissen welk type spaarzame matrix je wilt gebruiken:

• Als je van plan bent de matrix element voor element te vullen, kies dan coo_matrix() of dok_matrix() om je matrix te maken.
• Als je de matrix wilt initialiseren met een array als diagonaal, kies dan dia_matrix() om je matrix te initialiseren.
• Voor slice-gebaseerde matrices gebruik je lil_matrix().
• Als je de matrix opbouwt uit blokken van kleinere matrices, overweeg dan bsr_matrix().
• Als je snelle toegang tot je rijen en kolommen wilt, converteer je matrices dan met respectievelijk de functies csr_matrix() en csc_matrix(). De laatste twee zijn niet ideaal om mee te initialiseren, maar bij vermenigvuldigen merk je zeker het snelheidsverschil.

Appeltje-eitje!

Eigenwaarden en eigenvectoren

Het eerste onderwerp dat je aanpakt, zijn de eigenwaarden en eigenvectoren.

Eigenwaarden zijn een nieuwe manier om in het hart van een matrix te kijken. Maar voordat we daarop ingaan, leggen we eerst uit wat eigenvectoren zijn. Bijna alle vectoren veranderen van richting wanneer ze met een matrix worden vermenigvuldigd. Bepaalde uitzonderlijke resulterende vectoren hebben echter dezelfde richting als de vectoren die het resultaat zijn van de vermenigvuldiging. Dit zijn de eigenvectoren.

Met andere woorden, vermenigvuldig een eigenvector met een matrix, en de resulterende vector van die vermenigvuldiging is gelijk aan een vermenigvuldiging van de oorspronkelijke eigenvector met \(\lambda\), de eigenwaarde: \[Ax = \lambda x. \]

Dit betekent dat de eigenwaarde je zeer waardevolle informatie geeft: ze vertelt of een van de eigenvectoren wordt uitgerekt, gekrompen, omgekeerd of onveranderd blijft — wanneer hij met een matrix wordt vermenigvuldigd.

Je gebruikt de functie eig() uit de SciPy-module linalg om gewone of gegeneraliseerde eigenwaardeproblemen voor vierkante matrices op te lossen.

Let op dat de functie eigvals() een andere manier is om de eigenwaarden van een matrix uit te pakken.

Wanneer je met spaarzame matrices werkt, kun je terugvallen op de module scipy.sparse die de juiste functies biedt om eigenwaarden en eigenvectoren te vinden:

la, v = sparse.linalg.eigs(myMatrix,1)

Let op dat de code hierboven het aantal op te halen eigenwaarden en eigenvectoren specificeert, namelijk 1.

De eigenwaarden en eigenvectoren zijn belangrijke concepten in veel computer vision- en machine learning-technieken, zoals Principal Component Analysis (PCA) voor dimensionality reduction en EigenFaces voor gezichtsherkenning.

Singular Value Decomposition (SVD)

Vervolgens moet je SVD kennen als je echt data science wilt leren. De singular value decomposition van een matrix \(A\) is de ontbinding of factorisatie van \(A\) in het product van drie matrices: \(A = U * \Sigma * V^t\).

De grootte van de afzonderlijke matrices is als volgt als je weet dat matrix \(A\) van grootte \(M\) x \(N\) is:

• Matrix \(U\) is van grootte \(M\) x \(M\)
• Matrix \(V\) is van grootte \(N\) x \(N\)
• Matrix \(\Sigma\) is van grootte \(M\) x \(N\)

De \(*\) geeft aan dat de matrices worden vermenigvuldigd en de \(^t\) die je in \(V^t\) ziet, betekent dat de matrix is getransponeerd, wat inhoudt dat rijen en kolommen zijn verwisseld.

Eenvoudig gezegd biedt singular value decomposition een manier om een matrix op te delen in eenvoudigere, betekenisvolle stukken. Deze stukken kunnen data bevatten waarin we geïnteresseerd zijn.

Let op dat je voor spaarzame matrices de functie sparse.linalg.svds() kunt gebruiken om de decompositie uit te voeren.

Als je nieuw bent in data science, zal de matrixdecompositie vrij ondoorzichtig voor je zijn: je ziet misschien niet meteen toepassingen. Maar SVD is nuttig bij veel taken, zoals datacompressie, ruisreductie en data-analyse. Hieronder zie je hoe SVD kan worden gebruikt om afbeeldingen te comprimeren:

# Import the necessary packagesimport numpy as npfrom scipy import linalgfrom skimage import dataimport matplotlib.pyplot as plt# Get an image from `skimage`img= data.camera()# Check number of singular valueslinalg.svdvals(img)# Singular Value DecompositionU, s, Vh = linalg.svd(img)# Use only 32 singular valuesA = np.dot(U[:,0:32],           np.dot(np.diag(s[0:32]), Vh[0:32,:]))fig = plt.figure(figsize=(8, 3))# Add a subplot to the figureax = fig.add_subplot(121)# Plot `img` on grayscaleax.imshow(img, cmap='gray')# Add a second subplot to the figureax2 = fig.add_subplot(122)# Plot `A` in the second subplotax2.imshow(A)# Add a titlefig.suptitle('Image Compression with SVD', fontsize=14, fontweight='bold')# Show the plotplt.show()

Dit levert je het volgende resultaat op:

Bekijk ook de volgende voorbeelden waar SVD wordt gebruikt:

• SVD is nauw verbonden met Principal Component Analysis (PCA), dat wordt gebruikt voor dimensionality reduction: beide resulteren in een set “nieuwe assen” die zijn geconstrueerd uit lineaire combinaties van de assen van je feature space. Deze “nieuwe assen” splitsen de variantie in de datapunten op, gebaseerd op de bijdrage van elke richting aan de variantie in de data. Voor een concreet voorbeeld van hoe PCA op data werkt, ga naar onze Scikit-Learn-tutorial.
• Een andere link is die met data mining en natural language processing (NLP): Latent Semantic Indexing (LSI). Dat is een techniek die wordt gebruikt bij documentopvraag en woordgelijkenis. Latente semantische indexering gebruikt SVD om documenten te groeperen bij de concepten die kunnen bestaan uit verschillende woorden die in die documenten worden gevonden. Diverse woorden kunnen worden gegroepeerd tot een concept. Ook hier reduceert SVD de ruisachtige correlatie tussen woorden en hun documenten, en verlaagt het het aantal dimensies dat de oorspronkelijke data heeft.

Je ziet, SVD is een belangrijk concept in je data science-reis dat je moet behandelen. Daarom is het de moeite waard om dieper in SVD te duiken dan wat deze tutorial behandelt: ga bijvoorbeeld naar deze pagina om meer te lezen over deze matrixdecompositie.