NumPy-Grundoperationen für Deep Learning: +, -, *, /, **, Vergleiche, sum/mean/max/min, axis

1. Warum sollten wir zuerst die Grundoperationen festlegen?

Commandbox 광고

In Deep Learning reduziert sich unsere Arbeit im Wesentlichen auf:

  • Eingaben/gewichte addieren (+)
  • Multiplizieren (*, Matrixmultiplikation)
  • Nichtlineare Funktionen anwenden (**, relu, sigmoid usw.)
  • Den Verlust berechnen und anschließend
  • den Durchschnitt (mean) oder
  • die Summe (sum) bilden

PyTorch‑Tensoroperationen folgen exakt dem Stil von NumPy. Wenn man die Intuition in NumPy beherrscht, werden die Deep‑Learning‑Formeln viel klarer.

2. Elementweise arithmetische Operationen: +, -, *, /, **

NumPy‑Array‑Operationen sind elementweise.

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 gleicher Länge in 1‑D: elementweise
  • 2‑D, 3‑D: gleicher Index‑Ort

2.1 Operationen mit Skalar

Skalar‑Operationen funktionieren ebenfalls nahtlos.

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]

Solche „gleichmäßige Addition/Multiplikation“ werden in Deep Learning häufig für Normalisierung, Skalierung oder Bias‑Hinzufügung verwendet.

PyTorch‑Tensoren verhalten sich identisch: x_t + y_t, x_t * 2, x_t ** 2 usw.

3. Vergleichsoperationen: >, <, >=, <=, ==, !=

Commandbox 광고

Vergleiche zwischen NumPy‑Arrays liefern boolesche Arrays.

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]

Diese booleschen Arrays dienen als:

  • Masken zum Filtern bestimmter Elemente
  • Zählen von Elementen, die eine Bedingung erfüllen

Beispiel:

x = np.array([1, -2, 3, 0, -5, 6])

mask = x > 0
print(mask)          # [ True False  True False False  True]

# Positive Werte extrahieren
pos = x[mask]
print(pos)           # [1 3 6]

# Anzahl positiver Werte
num_pos = np.sum(mask)   # True als 1, False als 0
print(num_pos)           # 3

In Deep Learning nutzt man solche Muster für:

  • Accuracy (Anteil korrekter Vorhersagen)
  • Verlustberechnung nur an bestimmten Positionen

PyTorch folgt exakt demselben Muster.

4. Aggregationsfunktionen: np.sum, np.mean, np.max, np.min

4.1 Ohne axis: Gesamter Array

Standardmäßig wird die Summe, der Mittelwert, das Maximum und das Minimum über den gesamten Array berechnet.

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

Für 2‑D‑Arrays gilt dasselbe.

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

print(np.sum(X))   # 21
print(np.mean(X))  # 3.5

In Deep Learning:

  • Durchschnittlicher Verlust über die gesamte Batch
  • Mittelwert/Standardabweichung zur Normalisierung

5. Das Konzept von axis

axis bestimmt, entlang welcher Achse die Operation ausgeführt wird.

  • Kein axis → Berechnung über alle Elemente
  • axis angegeben → Reduktion entlang dieser Achse, andere Achsen bleiben

5.1 Beispiel mit 2‑D

import numpy as np

X = np.array([[1, 2, 3],
              [4, 5, 6]])  # shape: (2, 3)

axis=0: Spaltenweise (nach Zeilen herunter)

print(np.sum(X, axis=0))   # [5 7 9]
print(np.mean(X, axis=0))  # [2.5 3.5 4.5]
  • Ergebnisshape: (3,)
  • Häufig in Deep Learning für Feature‑weise Mittelwerte/Standardabweichungen

axis=1: Zeilenweise (über Spalten)

print(np.sum(X, axis=1))   # [ 6 15]
print(np.mean(X, axis=1))  # [2. 5.]
  • Ergebnisshape: (2,)
  • Entspricht Sample‑weise Summen/Mittelwerte

5.2 Häufige axis‑Beispiele in Deep Learning

Angenommen, wir haben Batch‑Daten:

# (batch_size, feature_dim)
X = np.random.randn(32, 10)  # 32 Samples, 10 Features
  1. Feature‑weise Mittelwerte
mean_per_feature = np.mean(X, axis=0)  # shape: (10,)
  1. Sample‑weise Mittelwerte
mean_per_sample = np.mean(X, axis=1)  # shape: (32,)

5.3 axis bei Bild‑Batch

Betrachten wir ein Bild‑Batch im PyTorch‑Stil (N, C, H, W).

# N=32, C=3 (RGB), H=W=64
images = np.random.randn(32, 3, 64, 64)
  1. Globaler Pixel‑Maximum
global_max = np.max(images)  # Skalar
  1. Channel‑weise Mittelwerte
# axis=(0, 2, 3): Batch, Höhe, Breite reduzieren, Kanal bleibt
channel_mean = np.mean(images, axis=(0, 2, 3))  # shape: (3,)

Dies ist ein gängiges Muster für Kanal‑weise Normalisierung.

6. Aggregationsfunktionen + Vergleichsoperationen: Häufige Muster

6.1 Accuracy‑Berechnung

Beispiel für binäre Klassifikation:

import numpy as np

# Vorhersagen (0–1 Wahrscheinlichkeiten)
pred = np.array([0.2, 0.8, 0.9, 0.3])
# Ground‑Truth (0 oder 1)
target = np.array([0, 1, 1, 0])

# Klassische Schwelle 0.5
pred_label = (pred > 0.5).astype(np.int32)   # [0 1 1 0]

# Richtig? → boolesches Array
correct = (pred_label == target)             # [ True True True True]

accuracy = np.mean(correct)                  # True=1, False=0
print(accuracy)  # 1.0

PyTorch verwendet nahezu denselben Code.

6.2 Verlust mit Masken

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

Masken + Aggregation sind ein häufiges Muster, um nur bestimmte Positionen im Verlust zu berücksichtigen.

7. Fazit: Die heute behandelten Grundoperationen

Zusammengefasst:

  1. Arithmetische Operationen (+, -, *, /, **) * Elementweise, auch mit Skalar
  2. Vergleichsoperationen (>, <, >=, <=, ==, !=) * Boolesche Arrays → Masken, Filtern, Zählen, Accuracy
  3. Aggregationsfunktionen (np.sum, np.mean, np.max, np.min) * Ohne axis: Gesamter Array * Mit axis: Reduktion entlang gewählter Achse
  4. axis‑Konzept * 2‑D: axis=0 (Spalten), axis=1 (Zeilen) * Deep Learning: (batch, feature), (N, C, H, W) – Feature‑, Sample‑, Channel‑weise Statistiken

Sobald man diese Grundoperationen beherrscht, lässt sich fast jede mathematische Formel direkt in NumPy/PyTorch‑Code übersetzen. Komplexe Tensor‑Operationen werden dadurch viel vertrauter.

image