Opérations de base NumPy pour le deep learning : +, -, *, /, **, comparaisons, sum/mean/max/min, axis
1. Pourquoi commencer par les opérations de base ?
Ce que nous faisons en deep learning se résume à :
- ajouter des entrées/poids (
+) - multiplier (
*, multiplication matricielle) - appliquer des fonctions non linéaires (
**,relu,sigmoid, etc.) - calculer la perte (loss) puis la moyenne (
mean) ou la **somme (sum)
PyTorch suit exactement le style d'opérations de base de NumPy, donc maîtriser ces concepts dans NumPy rend les formules de deep learning beaucoup plus claires.
2. Opérations arithmétiques élément par élément : +, -, *, /, **
Les opérations de base entre tableaux NumPy sont élément par élément.
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]
- Les tableaux 1‑D de même longueur sont opérés élément par élément.
- Les tableaux 2‑D, 3‑D, etc. suivent le même principe : les éléments aux mêmes positions sont combinés.
2.1 Opérations avec un scalaire
Les opérations avec un scalaire (un seul nombre) se font naturellement.
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]
Ces “ajouts/produits de même valeur à chaque élément” sont couramment utilisés en deep learning pour la normalisation, le scaling ou l’ajout de biais.
Les tenseurs PyTorch fonctionnent de la même façon. Des expressions comme
x_t + y_t,x_t * 2,x_t ** 2sont pratiquement identiques.
3. Opérations de comparaison : >, <, >=, <=, ==, !=
Lorsque vous comparez deux tableaux NumPy, le résultat est un tableau booléen.
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]
Ce tableau booléen peut être utilisé comme :
- masque pour sélectionner certains éléments
- pour compter le nombre d’éléments satisfaisant une condition.
Exemple :
x = np.array([1, -2, 3, 0, -5, 6])
mask = x > 0
print(mask) # [ True False True False False True]
# Sélectionner les positifs
pos = x[mask]
print(pos) # [1 3 6]
# Nombre de positifs
num_pos = np.sum(mask) # True = 1, False = 0
print(num_pos) # 3
En deep learning, on utilise souvent ce schéma pour :
- calculer le taux de bonnes prédictions (accuracy)
- inclure uniquement certaines positions dans la perte (loss)
PyTorch suit exactement le même modèle.
4. Fonctions d'agrégation : np.sum, np.mean, np.max, np.min
4.1 Sans axis : calcul sur l’ensemble
La forme de base calcule la somme, la moyenne, le maximum ou le minimum sur l’ensemble du tableau.
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
Les tableaux 2‑D ou plus se comportent de la même façon.
X = np.array([[1, 2, 3],
[4, 5, 6]])
print(np.sum(X)) # 21
print(np.mean(X)) # 3.5
En deep learning, on l’utilise pour :
- la moyenne de la perte sur toute la batch ou l’ensemble de données
- la normalisation après calcul de la moyenne/écart‑type
5. Comprendre le concept d'axis
axis détermine l’axe le long duquel l’opération est effectuée.
- Sans axis → calcul sur tous les éléments
- Avec axis → réduction le long de cet axe, les autres axes restent
5.1 Exemple 2‑D
import numpy as np
X = np.array([[1, 2, 3],
[4, 5, 6]]) # shape: (2, 3)
axis=0 : calcul colonne par colonne
print(np.sum(X, axis=0)) # [5 7 9]
print(np.mean(X, axis=0)) # [2.5 3.5 4.5]
- Résultat : shape
(3,) - Utilisé pour calculer la moyenne/écart‑type de chaque feature.
axis=1 : calcul ligne par ligne
print(np.sum(X, axis=1)) # [ 6 15]
print(np.mean(X, axis=1)) # [2. 5.]
- Résultat : shape
(2,) - Correspond au calcul de la somme/moyenne par échantillon.
5.2 Exemples fréquents en deep learning
Supposons une batch de données :
# (batch_size, feature_dim)
X = np.random.randn(32, 10) # 32 échantillons, 10 dimensions
- Moyenne par feature
mean_per_feature = np.mean(X, axis=0) # shape: (10,)
- Moyenne par échantillon
mean_per_sample = np.mean(X, axis=1) # shape: (32,)
5.3 Envisager axis dans un batch d’images
Considérons un batch d’images en style PyTorch (N, C, H, W).
# N=32, C=3 (RGB), H=W=64
images = np.random.randn(32, 3, 64, 64)
Exemples :
- Maximum global
global_max = np.max(images) # scalaire
- Moyenne par canal
# axis=(0, 2, 3) : réduire batch, hauteur, largeur, garder canal
channel_mean = np.mean(images, axis=(0, 2, 3)) # shape: (3,)
C’est un motif courant pour la normalisation par canal.
6. Fonctions d'agrégation + comparaisons : schémas fréquents
6.1 Calcul de l’accuracy
Pour une classification binaire :
import numpy as np
# Prédictions (probabilités 0‑1)
pred = np.array([0.2, 0.8, 0.9, 0.3])
# Vraies étiquettes (0 ou 1)
target = np.array([0, 1, 1, 0])
# Convertir en classes
pred_label = (pred > 0.5).astype(np.int32) # [0 1 1 0]
# Vrai = True
correct = (pred_label == target) # [ True True True True]
accuracy = np.mean(correct) # True=1, False=0
print(accuracy) # 1.0
6.2 Perte masquée
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
On combine masque + agrégation pour ne compter que les positions souhaitées.
7. Résumé : opérations de base abordées
Voici un récapitulatif des concepts clés :
- Opérations arithmétiques (
+,-,*,/,**) * Opérations élément par élément * Fonctionnent aussi avec des scalaires - Opérations de comparaison (
>,<,>=,<=,==,!=) * Résultat booléen * Utilisé comme masque pour filtrer, compter ou calculer l’accuracy - Fonctions d'agrégation (
np.sum,np.mean,np.max,np.min) * Sans axis : sur l’ensemble * Avec axis : réduction le long d’un axe - Concept d'
axis*axis=0: colonne (feature‑wise) *axis=1: ligne (sample‑wise) * Essentiel pour(batch, feature),(N, C, H, W)
Une fois à l’aise avec ces opérations, vous pourrez traduire rapidement des formules mathématiques en code NumPy/PyTorch, et rendre les calculs de perte, d’accuracy ou de normalisation plus intuitifs.
Aucun commentaire.