NumPy voor beginners in deep learning: waarom je het eerst moet leren vóór PyTorch
Waarom beginners in deep learning eerst NumPy moeten leren
In de meeste boeken en cursussen over deep learning worden eerst frameworks zoals PyTorch en TensorFlow geïntroduceerd. Maar wanneer je daadwerkelijk een model bouwt, ontstaat er vaak de volgende verwarring:
- "Wat is een tensor?"
- "Waarom krijg ik een shape‑fout?"
- "Ik dacht dat ik batches op deze manier kon samenvoegen…"
Deze problemen ontstaan meestal wanneer je direct naar een deep‑learning framework springt zonder NumPy goed te begrijpen.
- Een PyTorch‑Tensor is conceptueel vrijwel identiek aan een NumPy‑ndarray.
- Data‑preprocessing, batch‑creatie en statistische berekeningen vereisen nog steeds een NumPy‑georiënteerde mindset.
Daarom is NumPy een bijna onmisbare basis als je goede deep learning wilt leren.
Wat is NumPy?
NumPy (Numerical Python) is een bibliotheek die snelle numerieke berekeningen in Python mogelijk maakt.
Belangrijkste concepten:
- Multidimensionale arrays (ndarray): de basis voor vectoren, matrices en tensors.
- Vectorisatie: grote berekeningen zonder
for‑loops. - Broadcasting: slimme operaties tussen arrays met verschillende vormen.
- Lineaire algebra: matrixvermenigvuldiging, transponeren, inverse, enz.
- Random module: data‑sampling, normale verdelingen, willekeurige initialisatie.
Alle wiskundige formules in deep learning kunnen worden teruggebracht tot vector- en matrixoperaties. NumPy maakt het beheren van deze operaties eenvoudig, waardoor het de taal van deep learning is.
Python‑lijsten vs. NumPy‑arrays
Laten we eerst de verschillen tussen een gewone Python‑lijst en een NumPy‑array kort vergelijken.
# Python‑lijst
a = [1, 2, 3, 4]
b = [10, 20, 30, 40]
# Lijsten optellen
print(a + b)
# Resultaat: [1, 2, 3, 4, 10, 20, 30, 40] (concatenatie)
De +‑operator voor lijsten voegt de lijsten samen, niet de elementen bij elkaar op.
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
print(a + b)
# Resultaat: [11 22 33 44] (element‑wise optellen)
NumPy‑arrays gebruiken de wiskundige betekenis van +. Deep‑learning‑tensors volgen dezelfde stijl.
Vectorisatie: minder loops, meer wiskundige code
In deep‑learning‑code wordt vaak gezegd: minimaliseer for‑loops en gebruik vectorisatie.
Voorbeeld: alle elementen kwadrateren.
Python‑lijst + for‑loop
data = [1, 2, 3, 4, 5]
squared = []
for x in data:
squared.append(x ** 2)
print(squared) # [1, 4, 9, 16, 25]
NumPy‑vectorisatie
import numpy as np
data = np.array([1, 2, 3, 4, 5])
squared = data ** 2
print(squared) # [ 1 4 9 16 25]
- Korte code
- Meer wiskundig leesbaar
- Intern in C, dus veel sneller
Tensor‑operaties in PyTorch en TensorFlow volgen dezelfde vectorisatie‑stijl.
Broadcasting: operaties met verschillende vormen
Broadcasting is een regel die arrays met verschillende vormen automatisch aanpast.
Voorbeeld: een constante toevoegen aan elke sample.
import numpy as np
x = np.array([[1, 2, 3],
[4, 5, 6]]) # shape: (2, 3)
b = np.array([10, 20, 30]) # shape: (3,)
y = x + b
print(y)
# [[11 22 33]
# [14 25 36]]
NumPy “breidt” b uit naar (1, 3) → (2, 3).
PyTorch werkt identiek:
import torch
x = torch.tensor([[1, 2, 3],
[4, 5, 6]])
b = torch.tensor([10, 20, 30])
y = x + b
print(y)
Een goed begrip van broadcasting in NumPy maakt het werken met PyTorch‑tensors veel intuïtiever.
Vectoren, matrices, tensors: deep learning met NumPy
In deep learning komen de volgende concepten vaak voor:
- Vector: 1‑D array →
shape: (N,) - Matrix: 2‑D array →
shape: (M, N) -
Tensor: 3‑D of hoger
-
Voorbeeld: een batch van grijswaarden‑beelden
batch_size = 32, 28×28 →shape: (32, 28, 28)
Voorbeeld: eenvoudige matrixvermenigvuldiging.
import numpy as np
# invoervector (3 kenmerken)
x = np.array([1.0, 2.0, 3.0]) # shape: (3,)
# gewichtenmatrix (3 → 2)
W = np.array([[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6]]) # shape: (2, 3)
# matrixvermenigvuldiging: y = W @ x
y = W @ x
print(y) # [1.4 3.2]
Dit is vrijwel hetzelfde als een eenvoudige lineaire laag. In PyTorch:
import torch
x = torch.tensor([1.0, 2.0, 3.0]) # shape: (3,)
W = torch.tensor([[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6]]) # shape: (2, 3)
y = W @ x
print(y)
Kennis van NumPy‑matrixoperaties = het begrijpen van deep‑learning‑formules.
Hoe verbinden NumPy en PyTorch zich?
1. Tensor en ndarray zijn “kinderbroers”
- Beide bieden n‑dimensionale arrays + vectorisatie
- Functies zoals
shape,reshape,transpose,sum,meanzijn bijna identiek
Veel mensen gebruiken NumPy als oefenomgeving voor PyTorch‑tensors.
2. Data‑preprocessing is meestal NumPy‑georiënteerd
Veel taken in een deep‑learning‑project:
- CSV, afbeeldingen, logs inlezen
- Numerieke waarden maken
- Normaliseren, standaardiseren, slicen, shuffelen, batch‑splitsen
Dit gebeurt vaak met NumPy + pandas.
import numpy as np
import torch
# Data voorbereiden in NumPy
np_data = np.random.randn(100, 3) # 100 samples, 3 features
# Omzetten naar PyTorch‑tensor
tensor_data = torch.from_numpy(np_data).float()
print(tensor_data.shape) # torch.Size([100, 3])
Omgekeerd kun je een PyTorch‑tensor terug naar NumPy sturen voor post‑processing.
y = tensor_data.mean(dim=0) # PyTorch‑tensor
y_np = y.detach().cpu().numpy()
In de praktijk NumPy en PyTorch wisselen continu.
3. GPU‑computing is PyTorch, concept‑oefening is NumPy
- PyTorch‑tensors draaien op GPU (CUDA) en ondersteunen automatische differentiatie
- NumPy is CPU‑gebaseerd, maar eenvoudiger voor concept‑oefeningen en debugging
Veel ontwikkelaars volgen deze workflow:
- Idee of formule eerst in NumPy testen
- Na validatie naar PyTorch‑code migreren
Veelgebruikte NumPy‑patronen in deep learning
1. Willekeurige initialisatie & ruis
import numpy as np
# Gewichten initialiseren (normale verdeling)
W = np.random.randn(3, 3) * 0.01
# Ruis toevoegen aan input
x = np.array([1.0, 2.0, 3.0])
noise = np.random.normal(0, 0.1, size=x.shape)
x_noisy = x + noise
2. Data normaliseren (gemiddelde 0, std 1)
X = np.random.randn(100, 3) * 10 + 50 # willekeurige data
mean = X.mean(axis=0)
std = X.std(axis=0)
X_norm = (X - mean) / (std + 1e-8)
Normalisatie heeft een grote invloed op prestaties en stabiliteit.
3. One‑hot encoding
num_classes = 4
labels = np.array([0, 2, 1, 3])
one_hot = np.eye(num_classes)[labels]
print(one_hot)
# [[1. 0. 0. 0.]
# [0. 0. 1. 0.]
# [0. 1. 0. 0.]
# [0. 0. 0. 1.]]
PyTorch gebruikt dezelfde aanpak.
4. Batch‑splitsen
X = np.random.randn(100, 3)
batch_size = 16
for i in range(0, len(X), batch_size):
batch = X[i:i+batch_size]
# Denk aan het invoeren van de batch in het model
Dit patroon is direct gerelateerd aan PyTorch‑DataLoader.
Wat je moet onthouden bij het leren van NumPy
Je hoeft niet alle functies te kennen, maar focus op:
- ndarray‑basis:
np.array,dtype,shape,reshape,astype - Indexering & slicing:
x[0],x[1:3],x[:, 0],x[:, 1:3], booleaanse indexering - Basis‑operaties:
+,-,*,/,**, vergelijkingen,np.sum,np.mean,axis - Lineaire algebra: matrixvermenigvuldiging (
@ofnp.dot), transponeren (x.T) - Broadcasting: scalars,
(N, D) + (D,),(N, 1) - Random functies:
np.random.randn,np.random.randint,np.random.permutation - PyTorch‑integratie:
torch.from_numpy,tensor.numpy(), shape‑consistentie
Met deze kennis kun je de meeste tensor‑operaties in PyTorch intuïtief begrijpen.
Conclusie: NumPy is het "taalboek" van deep learning
Samengevat:
- NumPy is een bibliotheek voor numerieke berekeningen met multidimensionale arrays.
- Een PyTorch‑Tensor is praktisch een deep‑learning‑versie van NumPy‑ndarray.
- Door vectorisatie, broadcasting en lineaire algebra in NumPy te beheersen,:
- Minder shape‑fouten
- Makkelijker wetenschappelijke formules omzetten naar code
- Verbeterde data‑preprocessing‑vaardigheden
Wil je deep learning niet alleen als framework‑gebruik leren, maar als wiskundige en array‑operaties, dan is NumPy de beste start.
댓글이 없습니다.