5.3 Python Numpy (NpArray): De Kracht van Numerieke Berekeningen

Als je met data werkt, kom je vaak situaties tegen waarin je snel en efficiënt berekeningen wilt uitvoeren. Hier komt Numpy om de hoek kijken. Numpy is een van de meest gebruikte bibliotheken in Python en biedt een krachtige toolkit voor numerieke berekeningen. Met functies voor het werken met arrays, vectoren, en matrices, is Numpy de ruggengraat van veel data-analysetoepassingen.

Laten we ontdekken waarom Numpy zo krachtig is en hoe je het kunt gebruiken om complexe berekeningen eenvoudig te maken! 🚀

Wat is Numpy? #

Numpy (Numerical Python) is een open-source Python-bibliotheek die geoptimaliseerde tools biedt voor:

• Numerieke berekeningen: Wiskundige operaties zoals optellen, aftrekken, en matrixbewerkingen.
• Arrays: Efficiënte datastructuren die lijken op lijsten, maar veel sneller en krachtiger zijn.
• Geavanceerde operaties: Zoals transformaties, lineaire algebra, en statistieken.

Waarom Numpy?

• Snelheid: Numpy is geschreven in C en uitgevoerd in Python, waardoor het extreem snel is.
• Efficiëntie: Arrays gebruiken minder geheugen dan standaard Python-lijsten.
• Flexibiliteit: Ondersteuning voor complexe operaties zoals transformaties en multidimensionale data.

Wat is een Numpy Array (NpArray)? #

Een Numpy array is de basisdatastructuur van Numpy. Het is vergelijkbaar met een lijst in Python, maar biedt extra functionaliteit en prestaties. Arrays ondersteunen:

• Elementgewijze bewerkingen: Je kunt bewerkingen uitvoeren op alle elementen tegelijk.
• Multidimensionaliteit: Arrays kunnen meerdere dimensies hebben (bijvoorbeeld een matrix of een tensor).
• Geoptimaliseerd geheugen: Arrays gebruiken minder geheugen en zijn sneller bij numerieke operaties.

Voorbeeld: Een array maken #

import numpy as np

# Een 1D-array
array = np.array([1, 2, 3, 4, 5])
print(array)

# Een 2D-array (matrix)
matrix = np.array([[1, 2], [3, 4]])
print(matrix)

Belangrijke Eigenschappen van Arrays #

Een Numpy array heeft verschillende eigenschappen die je kunt bekijken:

1. Vorm (shape) #

In Numpy beschrijft de vorm (Engels: shape) van een array het aantal elementen in elke dimensie. Het is een tuple die weergeeft hoe de data gestructureerd is, bijvoorbeeld hoeveel rijen en kolommen een array bevat.

print(array.shape)   # (5,)
print(matrix.shape)  # (2, 2)

Waarom is de vorm belangrijk? #

De vorm helpt je te begrijpen hoe je data georganiseerd is en hoe je ermee kunt werken. Bij eenvoudige arrays (zoals lijsten) is dit misschien minder belangrijk, maar bij multidimensionale arrays (zoals matrices en tensors) wordt het essentieel om te weten hoe de data gerangschikt is.

Bijvoorbeeld:

• 1D-array: Alleen een rij met waarden.
• 2D-array (matrix): Bestaat uit rijen en kolommen.
• 3D-array of hoger: Meerdere lagen of blokken van data.

Hoe controleer je de vorm van een array? #

Met de eigenschap .shape kun je de vorm van een array opvragen. Dit geeft een tuple terug waarin elke waarde staat voor het aantal elementen in een bepaalde dimensie.

Voorbeeld:

import numpy as np

# Een 1D-array
array1 = np.array([1, 2, 3, 4, 5])
print(array1.shape)  # (5,)

# Een 2D-array (matrix)
array2 = np.array([[1, 2], [3, 4], [5, 6]])
print(array2.shape)  # (3, 2)

# Een 3D-array
array3 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(array3.shape)  # (2, 2, 2)

Wat betekent de output van .shape? #

De tuple die je krijgt van .shape geeft per dimensie het aantal elementen aan:

• 1D-array: (n,) → n is het aantal elementen in de array.
• 2D-array: (m, n) → m is het aantal rijen, n is het aantal kolommen.
• 3D-array: (x, m, n) → x is het aantal lagen, gevolgd door rijen en kolommen.

Best Practices bij het werken met de vorm #

1. Controleer de vorm regelmatig:
   Bij complexe operaties zoals matrixvermenigvuldiging of tensorberekeningen is het essentieel om de vorm te begrijpen.
2. Gebruik .reshape() zorgvuldig:
   Het aanpassen van de vorm moet logisch zijn; het totale aantal elementen moet gelijk blijven.Voorbeeld:

array = np.array([1, 2, 3, 4])
reshaped = array.reshape(2, 2)  
# Dit werkt, want 2 * 2 = 4

Werk met consistente dimensies:
Als je meerdere arrays combineert of bewerkingen uitvoert, zorg ervoor dat hun vormen compatibel zijn.

Voorbeeld:

array1 = np.array([1, 2, 3])
array2 = np.array([[1, 2], [3, 4]])
# np.dot(array1, array2) zal een 
# fout geven door incompatibele vormen.

2. Dimensie (ndim) #

In Numpy verwijst een dimensie naar het aantal niveaus waarin de data is georganiseerd. Simpel gezegd, het geeft aan hoeveel “assen” (axes) een array heeft. Dit concept is nauw verbonden met de vorm (shape) van een array, die beschrijft hoeveel elementen er in elke dimensie zijn.

print(array.ndim)    # 1 (1D-array)
print(matrix.ndim)   # 2 (2D-array)

Wat is een dimensie in een array? #

Een dimensie is een niveau van organisatie van data:

• 0D-array: Een enkel getal, zoals een scalar.
• 1D-array: Een lijst van waarden, zoals een vector.
• 2D-array: Een tabel met rijen en kolommen, zoals een matrix.
• 3D-array: Meerdere lagen van tabellen, bijvoorbeeld een kleurenafbeelding.
• nD-array: Hogere dimensies worden gebruikt voor complexere data, zoals tijdreeksen of volumetrische data.

De eigenschap ndim geeft het aantal dimensies van een array terug.

Relatie tussen Dimensie en Vorm #

De dimensie (ndim) geeft het aantal niveaus aan, terwijl de vorm (shape) specificeert hoeveel elementen zich in elke dimensie bevinden.
Voorbeeld:

• Een 2D-array heeft 2 dimensies (rijen en kolommen), en de vorm kan bijvoorbeeld (3, 4) zijn (3 rijen, 4 kolommen).
• Een 3D-array heeft 3 dimensies (lagen, rijen, en kolommen), en de vorm kan bijvoorbeeld (2, 3, 4) zijn.

Hoe controleer je de dimensie van een array? #

Je kunt de dimensie van een array opvragen met de eigenschap .ndim.

Voorbeeld:

import numpy as np

# Een 0D-array (scalar)
scalar = np.array(42)
print(scalar.ndim)  # 0
print(scalar.shape)  # ()

# Een 1D-array (vector)
vector = np.array([1, 2, 3, 4])
print(vector.ndim)  # 1
print(vector.shape)  # (4,)

# Een 2D-array (matrix)
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix.ndim)  # 2
print(matrix.shape)  # (2, 3)

# Een 3D-array
tensor = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(tensor.ndim)  # 3
print(tensor.shape)  # (2, 2, 2)

Voorbeelden van Dimensies en Vormen #

Waarom zijn dimensies belangrijk? #

Dimensies zijn essentieel om te begrijpen hoe je array georganiseerd is en om de juiste bewerkingen uit te voeren:

1. Bewerkingen afhankelijk van dimensies:
   Bijvoorbeeld, matrixvermenigvuldiging kan alleen worden uitgevoerd op 2D-arrays of hoger.
2. Compatibiliteit tussen arrays:
   Bij berekeningen moeten de dimensies en vormen van arrays vaak compatibel zijn.
3. Multidimensionale data verwerken:
   Complexe datasets, zoals afbeeldingen of 3D-modellen, hebben meerdere dimensies nodig.

3. Datatype (dtype) #

Arrays bevatten elementen van hetzelfde datatype.

print(array.dtype)   
# int32 (of een ander type, afhankelijk van je systeem)

Zie hier een tabel van alle mogelijke datatypes met voorbeelden:

Hoe kies je het juiste datatype? #

• Gehele getallen: Kies int of uint op basis van je datumbereik en geheugenbehoeften.
• Zwevend-komma: Gebruik float32 voor gemiddelde precisie en float64 voor hoge precisie.
• Boolean: Gebruik bool voor waar/niet-waar waarden.
• Strings: Kies S voor vaste lengte en U voor Unicode.
• Tijd: Gebruik datetime64 en timedelta64 voor datums en tijden.

Met Numpy’s datatype-opties kun je je arrays optimaal aanpassen aan je behoeften, zowel qua snelheid als geheugengebruik. 🎉

4. Grootte (size) #

Geeft het totale aantal elementen in de array.

print(array.size)    # 5

Basisbewerkingen met Numpy #

1. Elementgewijze bewerkingen #

Numpy arrays ondersteunen elementgewijze operaties, waardoor je snel berekeningen kunt uitvoeren op elke waarde in de array.

Voorbeeld:

# Optellen
print(array + 10)  
# [11, 12, 13, 14, 15]

# Vermenigvuldigen
print(array * 2)   
# [2, 4, 6, 8, 10]

# Kwadrateren
print(array ** 2)  
# [1, 4, 9, 16, 25]

2. Aggregatiefuncties #

Met Numpy kun je snel statistieken berekenen over een array.

Voorbeelden:

print(np.sum(array))       
# Som: 15
print(np.mean(array))      
# Gemiddelde: 3.0
print(np.median(array))    
# Mediaan: 3.0
print(np.std(array))       
# Standaarddeviatie: 1.414213562

3. Indexeren en Slicen #

Numpy arrays ondersteunen geavanceerd indexeren en slicen, waarmee je eenvoudig subarrays kunt maken.

Voorbeeld:

# Eerste element
print(array[0])    # 1

# Laatste element
print(array[-1])   # 5

# Subarray
print(array[1:4])  # [2, 3, 4]

Bij multidimensionale arrays gebruik je een komma om rijen en kolommen te scheiden:

print(matrix[0, 1])  
# 2 (eerste rij, tweede kolom)
print(matrix[:, 0])  
# [1, 3] (eerste kolom)

Werken met Multidimensionale Arrays #

Numpy maakt het eenvoudig om met multidimensionale data te werken, zoals matrices of tensors.

1. Transponeren #

Transponeren is een veelgebruikte bewerking in Numpy waarbij de rijen en kolommen van een array worden omgewisseld. Dit is vooral handig bij matrixberekeningen, data-analyse en wiskundige toepassingen zoals lineaire algebra.

In Numpy kun je een array eenvoudig transponeren met de eigenschap .T.

Wat betekent transponeren? #

Bij transponeren verander je de dimensies van een array:

• Rijen worden kolommen.
• Kolommen worden rijen.

Voorbeeld van een matrix vóór en na transponeren:

Oorspronkelijke matrix:
[[1, 2],
 [3, 4]]

Getransponeerde matrix:
[[1, 3],
 [2, 4]]

Hierbij wordt het element op positie (i, j) in de originele matrix verplaatst naar positie (j, i) in de getransponeerde matrix.

Hoe werkt .T in Numpy? #

De eigenschap .T retourneert de getransponeerde versie van een array. Het verandert de oorspronkelijke array niet, tenzij je de wijziging opslaat.

Voorbeeld: Een matrix transponeren #

import numpy as np

# Maak een 2D-array (matrix)
matrix = np.array([[1, 2],
                   [3, 4]])

# Transponeer de matrix
transposed = matrix.T

print("Originele matrix:")
print(matrix)
# Output:
# [[1, 2],
#  [3, 4]]

print("Getransponeerde matrix:")
print(transposed)
# Output:
# [[1, 3],
#  [2, 4]]

Data-analyse voorbeeld #

In datasets waarin rijen en kolommen bepaalde attributen of records vertegenwoordigen, kan transponeren handig zijn om een andere weergave van de data te krijgen.

Voorbeeld:

data = np.array([[25, 30, 35],  # Leeftijd
                 [70, 80, 90]]) # Gewicht

# Transponeer om data per individu te groeperen
data_T = data.T
print(data_T)
# Output:
# [[25, 70],
#  [30, 80],
#  [35, 90]]

2. Matrixvermenigvuldiging #

Matrixvermenigvuldiging is een fundamenteel concept in wiskunde en wordt veel toegepast in data-analyse, computergraphics, machine learning, en meer. In Numpy kun je matrixvermenigvuldiging eenvoudig uitvoeren met np.dot() of de @-operator.

Wat is een matrix? #

Een matrix is een rechthoekige tabel van getallen, georganiseerd in rijen en kolommen. Het wordt vaak gebruikt om gegevens te structureren en wiskundige berekeningen mee uit te voeren. Een matrix is een speciale vorm van een 2D-array.

Voorbeeld van een matrix:

1  2  3
4  5  6
7  8  9

Deze matrix heeft:

• 3 rijen
• 3 kolommen

Waarvoor is een matrix nuttig? #

Matrixen worden in veel domeinen gebruikt, zoals:

1. Data-analyse:
   Bijvoorbeeld, een tabel waarin rijen individuen vertegenwoordigen en kolommen hun eigenschappen (leeftijd, gewicht, lengte).
2. Beeldbewerking:
   Een afbeelding kan worden voorgesteld als een matrix van pixelwaarden.
3. Machine learning:
   Matrixen worden gebruikt om datasets en parameters van modellen te representeren.
4. Lineaire algebra:
   Matrixvermenigvuldiging is de kern van veel wiskundige modellen.

Wat is matrixvermenigvuldiging? #

Matrixvermenigvuldiging is een bewerking waarbij twee matrixen worden gecombineerd om een nieuwe matrix te maken. Dit werkt door de rijen van de eerste matrix te combineren met de kolommen van de tweede matrix.

Belangrijke regels:

1. Het aantal kolommen in de eerste matrix moet gelijk zijn aan het aantal rijen in de tweede matrix.
2. De resulterende matrix heeft:
   • Rijen: gelijk aan de rijen van de eerste matrix.
   • Kolommen: gelijk aan de kolommen van de tweede matrix.

Hoe werkt matrixvermenigvuldiging? #

Bij matrixvermenigvuldiging vermenigvuldig je elk element van een rij uit de eerste matrix met het overeenkomstige element van een kolom uit de tweede matrix en tel je de resultaten op.

Voorbeeld (handmatig):

Matrix A:      Matrix B:
1  2           5  6
3  4           7  8

Resultaat: C
(1*5 + 2*7)  (1*6 + 2*8)   ->  19  22
(3*5 + 4*7)  (3*6 + 4*8)   ->  43  50

Matrixvermenigvuldiging in Numpy #

In Numpy kun je matrixvermenigvuldiging uitvoeren met:

1. np.dot(): De traditionele manier.
2. @-operator: Een meer intuïtieve en kortere manier.

Voorbeeld:

import numpy as np

# Matrix A
A = np.array([[1, 2],
              [3, 4]])

# Matrix B
B = np.array([[5, 6],
              [7, 8]])

# Matrixvermenigvuldiging
C = np.dot(A, B)
print("Resultaat met np.dot():")
print(C)

# Of gebruik de @-operator
C_alt = A @ B
print("Resultaat met @-operator:")
print(C_alt)

Uitvoer:

Resultaat met np.dot():
[[19 22]
 [43 50]]

Resultaat met @-operator:
[[19 22]
 [43 50]]

Praktijkvoorbeeld: Data-analyse met Matrixvermenigvuldiging #

Scenario: Berekening van een scoresysteem #

Stel je hebt een dataset met studenten en hun behaalde punten in verschillende vakken. Je wilt hun totale scores berekenen door de punten te vermenigvuldigen met de gewichten van de vakken.

Data (punten):

Studenten  Wiskunde  Natuurkunde  Engels
Jan        85        90           80
Piet       78        88           84
Lisa       92        95           89

Gewichten van vakken:

• Wiskunde: 0.4
• Natuurkunde: 0.35
• Engels: 0.25

Oplossing met matrixvermenigvuldiging:

1. Representeren van de data als een matrix:

punten = np.array([[85, 90, 80],  # Jan
                   [78, 88, 84],  # Piet
                   [92, 95, 89]]) # Lisa

2. Representeren van de gewichten als een kolommatrix:

gewichten = np.array([[0.4],
                      [0.35],
                      [0.25]])

3. Matrixvermenigvuldiging toepassen:

totale_scores = np.dot(punten, gewichten)
print(totale_scores)

Uitvoer:

[[85.75]  # Jan
 [82.10]  # Piet
 [91.80]] # Lisa

Dit betekent dat Jan een totale score van 85.75 heeft, Piet 82.10, en Lisa 91.80.

Geavanceerde Functies #

1. Random getallen genereren #

Met de random module kun je arrays vullen met willekeurige getallen.

# Willekeurige waarden tussen 0 en 1
random_array = np.random.rand(5)
print(random_array)

# Willekeurige gehele getallen
random_ints = np.random.randint(1, 10, size=(2, 3))
print(random_ints)

2. Logische bewerkingen #

Je kunt logische operaties uitvoeren op arrays en maskers maken.

# Masker: Alle waarden groter dan 2
masker = array > 2
print(masker)         
# [False, False, True, True, True]

# Filter de array
print(array[masker])  # [3, 4, 5]

3. Reshaping #

Reshaping is een krachtige .reshape() functie in Numpy waarmee je de vorm (shape) van een array kunt wijzigen zonder de onderliggende gegevens te veranderen. Dit betekent dat de data zelf intact blijft, maar dat de manier waarop deze georganiseerd is in rijen en kolommen wordt aangepast.

reshaped = np.arange(1, 7).reshape(2, 3)
print(reshaped)
# [[1, 2, 3],
#  [4, 5, 6]]

Waarom Reshaping? #

In veel situaties wil je data anders structureren om deze eenvoudiger te analyseren of compatibel te maken met andere arrays. Bijvoorbeeld:

• Van 1D naar 2D: Een lijst omzetten naar een matrix.
• Van 2D naar 1D: Een tabel “plat” maken tot een enkele lijst.
• Meerdere dimensies toevoegen: Voor het werken met meerlagige data zoals afbeeldingen of tensors.

Met .reshape() kun je deze aanpassingen eenvoudig maken.

Hoe werkt .reshape()? #

De methode .reshape(new_shape) verandert de vorm van een array naar de opgegeven dimensies (new_shape). Hier zijn enkele belangrijke punten:

1. Het totale aantal elementen moet gelijk blijven: Je kunt de data niet zomaar uitbreiden of verkleinen zonder extra stappen.
2. new_shape is een tuple: Bijvoorbeeld (2, 3) voor 2 rijen en 3 kolommen.

Voorbeeld: Een 1D-array reshapen naar een 2D-array

import numpy as np

# Maak een 1D-array
array = np.arange(1, 7)  # [1, 2, 3, 4, 5, 6]

# Reshape naar een 2D-array met 2 rijen en 3 kolommen
reshaped = array.reshape(2, 3)

print(reshaped)
# Output:
# [[1, 2, 3],
#  [4, 5, 6]]

Wat gebeurt hier?

• Oorspronkelijke vorm: (6,) → Een array met 6 elementen.
• Nieuwe vorm: (2, 3) → 2 rijen en 3 kolommen.
• Elementen blijven hetzelfde: Alleen de organisatie van de data is veranderd.

“Flattening”: Van multidimensionaal naar 1D

matrix = np.array([[1, 2, 3], [4, 5, 6]])

flattened = matrix.reshape(-1)
print(flattened)
# Output:
# [1, 2, 3, 4, 5, 6]

Best Practices met Numpy #

1. Werk altijd met arrays, niet met lijsten:
   Zet je data om naar een Numpy array voor betere prestaties.

array = np.array(lijst)

2. Kies expliciete datatypes:
   Door een specifiek datatype te kiezen, kun je geheugen besparen.

array = np.array([1, 2, 3], dtype=np.float32)

3. Gebruik vectorisatie:
   Vermijd loops en gebruik de ingebouwde functies van Numpy voor betere prestaties.
4. Combineer met Pandas:
   Numpy is de perfecte partner voor Pandas en wordt vaak gebruikt om DataFrames te optimaliseren.

Samenvatting #

Numpy is een essentiële bibliotheek voor elke data-analist of wetenschapper. Met efficiënte arrays, geavanceerde wiskundige functies, en ondersteuning voor multidimensionale data, biedt Numpy alles wat je nodig hebt voor numerieke berekeningen. Experimenteer met de voorbeelden en ontdek hoe Numpy je workflow kan verbeteren! 🎉🚀