NumPy‑basisbewerkingen voor deep learning: +, -, *, /, **, vergelijkingen, sum/mean/max/min, axis
1. Waarom moeten we eerst de basisbewerkingen leren?
In deep learning komt alles uiteindelijk neer op:
- invoer/gewichten optellen (
+) - vermenigvuldigen (
*, matrixproduct) - een niet‑lineaire functie toepassen (
**,relu,sigmoid, enz.) - de loss berekenen en vervolgens
- het gemiddelde (
mean) nemen of - de som (
sum) berekenen
PyTorch‑tensorbewerkingen volgen exact de stijl van NumPy‑basisbewerkingen, dus als je de intuïtie in NumPy opdoet, zie je de deep‑learning‑formules meteen duidelijker.
2. Element‑wise aritmetische bewerkingen: +, -, *, /, **
NumPy‑arraybewerkingen zijn element‑wise.
import numpy as np
x = np.array([1, 2, 3])
y = np.array([10, 20, 30])
print(x + y) # [11 22 33]
print(x - y) # [ -9 -18 -27]
print(x * y) # [10 40 90]
print(y / x) # [10. 10. 10.]
print(x ** 2) # [1 4 9]
- Arrays van dezelfde lengte: element‑wise
- 2‑D, 3‑D arrays: ook element‑wise op dezelfde posities
2.1 Werken met scalars
Werken met een enkele scalar is net zo eenvoudig.
x = np.array([1, 2, 3])
print(x + 10) # [11 12 13]
print(x * 2) # [2 4 6]
print(x / 2) # [0.5 1. 1.5]
Deze “zelfde waarde toevoegen/verdubbelen” wordt vaak gebruikt voor normalisatie, scaling en bias‑toevoeging.
PyTorch‑tensors werken precies hetzelfde.
x_t + y_t,x_t * 2,x_t ** 2zijn vrijwel identiek.
3. Vergelijkingsbewerkingen: >, <, >=, <=, ==, !=
Een vergelijking tussen NumPy‑arrays levert een Boolean‑array op.
import numpy as np
x = np.array([1, 2, 3, 4, 5])
print(x > 3) # [False False False True True]
print(x == 2) # [False True False False False]
Deze Boolean‑array kan:
- als masker gebruikt worden om specifieke elementen te selecteren
- het aantal elementen dat aan een voorwaarde voldoet tellen
Voorbeeld:
x = np.array([1, -2, 3, 0, -5, 6])
mask = x > 0
print(mask) # [ True False True False False True]
# Positieve waarden
pos = x[mask]
print(pos) # [1 3 6]
# Aantal positieve waarden
num_pos = np.sum(mask) # True wordt 1, False 0
print(num_pos) # 3
In deep learning gebruiken we dit voor:
- de accuracy (percentage correcte voorspellingen)
- alleen de verliezen op bepaalde posities meenemen
PyTorch volgt hetzelfde patroon.
4. Aggregatiefuncties: np.sum, np.mean, np.max, np.min
4.1 Zonder axis: berekening over het geheel
Standaard berekent men de som, het gemiddelde, het maximum en het minimum over het volledige array.
import numpy as np
x = np.array([1, 2, 3, 4])
print(np.sum(x)) # 10
print(np.mean(x)) # 2.5
print(np.max(x)) # 4
print(np.min(x)) # 1
Ook voor 2‑D of hogere arrays geldt hetzelfde.
X = np.array([[1, 2, 3],
[4, 5, 6]])
print(np.sum(X)) # 21
print(np.mean(X)) # 3.5
In deep learning:
- gemiddelde loss over een hele batch
- gemiddelde en standaardafwijking van alle data voor normalisatie
5. Het begrip axis
axis bepaalt over welke as de bewerking wordt uitgevoerd.
- Geen
axis→ berekening over alle elementen axisopgegeven → de bewerking wordt uitgevoerd langs die as, waardoor die as wordt “gereduceerd” en de overige as(sen) behouden blijven
5.1 Voorbeeld met 2‑D
import numpy as np
X = np.array([[1, 2, 3],
[4, 5, 6]]) # shape: (2, 3)
axis=0: berekening per kolom
print(np.sum(X, axis=0)) # [5 7 9]
print(np.mean(X, axis=0)) # [2.5 3.5 4.5]
- Resultaat shape:
(3,) - Gemiddelde/som per kolom – vaak gebruikt voor feature‑wise statistieken
axis=1: berekening per rij
print(np.sum(X, axis=1)) # [ 6 15]
print(np.mean(X, axis=1)) # [2. 5.]
- Resultaat shape:
(2,) - Gemiddelde/som per rij – vaak gebruikt voor sample‑wise statistieken
5.2 Veelvoorkomende axis‑scenario’s in deep learning
Stel je een batch hebt met vorm (batch_size, feature_dim).
# (batch_size, feature_dim)
X = np.random.randn(32, 10) # 32 samples, 10 features
- Feature‑wise gemiddelde
mean_per_feature = np.mean(X, axis=0) # shape: (10,)
axis=0→ reduce over batch
- Sample‑wise gemiddelde
mean_per_sample = np.mean(X, axis=1) # shape: (32,)
axis=1→ reduce over features
5.3 axis bij een batch van afbeeldingen
Een afbeelding‑batch in PyTorch‑stijl (N, C, H, W).
# N=32, C=3 (RGB), H=W=64
images = np.random.randn(32, 3, 64, 64)
Voorbeeld:
- Globale maximale pixelwaarde
global_max = np.max(images) # scalar
- Gemiddelde per kanaal (RGB)
# axis=(0, 2, 3): reduce over batch, height, width
channel_mean = np.mean(images, axis=(0, 2, 3)) # shape: (3,)
Dit patroon wordt vaak gebruikt voor kanaal‑wise normalisatie.
6. Aggregatiefuncties + vergelijkingen: veelgebruikte patronen
6.1 Accuracy berekenen
Voor een binaire classificatie:
import numpy as np
# voorspellingen (0‑1‑probabiliteit)
pred = np.array([0.2, 0.8, 0.9, 0.3])
# echte labels (0 of 1)
target = np.array([0, 1, 1, 0])
# voorspelde klasse op basis van 0.5
pred_label = (pred > 0.5).astype(np.int32) # [0 1 1 0]
# correcte voorspellingen
correct = (pred_label == target) # [ True True True True]
accuracy = np.mean(correct) # True=1, False=0
print(accuracy) # 1.0
Vergelijking → Boolean‑array → mean geeft de accuracy.
PyTorch gebruikt vrijwel dezelfde code.
6.2 Verlies berekenen met een masker
loss = np.array([0.1, 0.5, 0.2, 0.9])
mask = np.array([True, False, True, False])
masked_loss = loss[mask] # [0.1, 0.2]
mean_loss = np.mean(masked_loss)
print(mean_loss) # 0.15000000000000002
Dit patroon – masker + aggregatie – is erg gebruikelijk.
7. Samenvatting: basisbewerkingen die we vandaag hebben behandeld
- Aritmetische bewerkingen (
+,-,*,/,**) * Element‑wise * Werkt ook met scalars - Vergelijkingsbewerkingen (
>,<,>=,<=,==,!=) * Resultaat: Boolean‑array * Gebruik als masker voor filtering, telling, accuracy, etc. - Aggregatiefuncties (
np.sum,np.mean,np.max,np.min) * Zonderaxis: over het geheel * Metaxis: reduce over een as axisconcept *axis=0: kolom‑wise (feature‑wise) *axis=1: rij‑wise (sample‑wise) * Essentieel voor(batch, feature),(N, C, H, W)
Door vertrouwd te raken met deze basisbewerkingen kun je:
- loss, accuracy, statistieken direct in NumPy/PyTorch schrijven
- complexe tensor‑bewerkingen minder vreemd vinden
댓글이 없습니다.