NumPy pour les débutants en deep learning : pourquoi le connaître avant PyTorch?
Pourquoi les débutants en deep learning devraient commencer par NumPy?
Dans la plupart des livres ou cours de deep learning, on introduit d’abord des frameworks comme PyTorch ou TensorFlow. Mais lorsqu’on commence à créer un modèle, on se retrouve souvent dans cette situation :
- "Qu’est‑ce qu’un tensor ?"
- "Pourquoi une erreur de shape ?"
- "Je pensais que je pouvais concaténer les batchs de cette façon…"
Ces confusions apparaissent surtout lorsqu’on passe directement aux frameworks sans comprendre les bases de NumPy.
- Le
Tensorde PyTorch est pratiquement le même que lendarrayde NumPy. - Le pré‑traitement des données, la création de batchs, les calculs statistiques restent basés sur la logique NumPy.
Donc, si vous voulez vraiment maîtriser le deep learning, NumPy est quasiment une condition préalable.
Qu’est‑ce que NumPy ?
NumPy (Numerical Python) est une bibliothèque qui permet de faire des calculs numériques rapidement en Python.
Les points clés :
- Tableaux multidimensionnels (
ndarray) : la base pour vecteurs, matrices, tensors. - Opérations vectorisées : traiter de gros volumes de données sans boucle
for. - Broadcasting : faire des opérations entre tableaux de formes différentes.
- Opérations linéaires : multiplication de matrices, transposition, inverse.
- Module aléatoire : échantillonnage, distribution normale, initialisation aléatoire.
Comme presque toutes les formules du deep learning se résument à des opérations sur vecteurs et matrices, NumPy est le langage de base du domaine.
Listes Python vs tableaux NumPy
Comparons rapidement les listes Python et les tableaux NumPy.
# Liste Python
a = [1, 2, 3, 4]
b = [10, 20, 30, 40]
# Addition de listes
print(a + b)
# Résultat : [1, 2, 3, 4, 10, 20, 30, 40] (concatenation)
L’opérateur + sur les listes concatène, pas additionne.
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
print(a + b)
# Résultat : [11 22 33 44] (addition élément par élément)
Le + sur les tableaux NumPy effectue l’opération élément‑par‑élément attendue en mathématiques. Les Tensor de PyTorch suivent exactement ce même style.
Vectorisation : réduire les boucles, coder comme une formule
On dit souvent de minimiser les boucles for dans le code deep learning. On utilise plutôt la vectorisation.
Exemple : appliquer le carré à chaque élément.
Liste Python + boucle for
data = [1, 2, 3, 4, 5]
squared = []
for x in data:
squared.append(x ** 2)
print(squared) # [1, 4, 9, 16, 25]
Vectorisation NumPy
import numpy as np
data = np.array([1, 2, 3, 4, 5])
squared = data ** 2
print(squared) # [ 1 4 9 16 25]
- Code plus court
- Plus lisible comme une formule mathématique
- Implémenté en C : performance nettement supérieure
Les opérations sur les tensors de PyTorch utilisent exactement ce même style vectorisé.
Broadcasting : faire des opérations même si les formes diffèrent
Le broadcasting est une règle qui ajuste automatiquement les formes des tableaux différents.
Exemple : ajouter une constante à chaque échantillon.
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]]
x est (2, 3) et b est (3,). NumPy étend b en (1, 3) puis en (2, 3) pour l’opération.
PyTorch applique la même règle :
import torch
x = torch.tensor([[1, 2, 3],
[4, 5, 6]])
b = torch.tensor([10, 20, 30])
y = x + b
print(y)
Comprendre le broadcasting en NumPy rend les opérations sur les tensors PyTorch beaucoup plus intuitives.
Vecteurs, matrices, tensors : exprimer le deep learning avec NumPy
Les concepts fréquents du deep learning vus à travers NumPy :
- Vecteur : tableau 1‑D →
shape : (N,) - Matrice : tableau 2‑D →
shape : (M, N) -
Tensor : tableau 3‑D ou plus
-
Exemple : lot d’images en niveaux de gris 28×28
batch_size = 32→shape : (32, 28, 28)
Exemple simple de multiplication matricielle
import numpy as np
# Vecteur d’entrée (3 caractéristiques)
x = np.array([1.0, 2.0, 3.0]) # shape : (3,)
# Matrice de poids (3 → 2)
W = np.array([[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6]]) # shape : (2, 3)
# Produit matriciel : y = W @ x
y = W @ x
print(y) # [1.4 3.2]
Ce code calcule exactement une couche linéaire simple. En 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)
La forme et le sens sont pratiquement identiques. Se familiariser avec les opérations matricielles NumPy, c’est apprendre à lire les formules du deep learning.
Comment NumPy et PyTorch se connectent-ils ?
1. Tensor et ndarray sont « cousins »
- Les deux offrent des tableaux n‑dimensionnels et des opérations vectorisées.
- Fonctions comme
shape,reshape,transpose,sum,meansont très similaires.
C’est pourquoi beaucoup utilisent NumPy comme un terrain d’entraînement pour comprendre les tensors PyTorch.
2. Le pré‑traitement des données est souvent NumPy‑style
Dans un projet deep learning :
- Lire CSV, images, logs
- Convertir en valeurs numériques
- Normaliser, standardiser, découper, mélanger, créer des batchs
Ces tâches se font souvent avec NumPy + pandas.
import numpy as np
import torch
# Pré‑traitement avec NumPy
np_data = np.random.randn(100, 3) # 100 échantillons, 3 caractéristiques
# Conversion en tensor PyTorch
tensor_data = torch.from_numpy(np_data).float()
print(tensor_data.shape) # torch.Size([100, 3])
Inversement, on convertit souvent un tensor PyTorch en NumPy pour un post‑traitement.
y = tensor_data.mean(dim=0) # Tensor PyTorch
y_np = y.detach().cpu().numpy()
En pratique, NumPy et PyTorch circulent constamment.
3. Calcul GPU : PyTorch, pratique NumPy
- Les tensors PyTorch s’exécutent sur GPU (CUDA) et supportent l’autodiff.
- NumPy reste CPU‑only mais est beaucoup plus simple pour tester des idées et déboguer.
Donc :
- Expérimentez d’abord en NumPy.
- Validez, puis passez à PyTorch.
Exemples de motifs NumPy courants en deep learning
1. Initialisation aléatoire & ajout de bruit
import numpy as np
# Initialisation des poids (distribution normale)
W = np.random.randn(3, 3) * 0.01
# Ajout de bruit à l’entrée
x = np.array([1.0, 2.0, 3.0])
noise = np.random.normal(0, 0.1, size=x.shape)
x_noisy = x + noise
2. Normalisation des données (moyenne 0, écart‑type 1)
X = np.random.randn(100, 3) * 10 + 50 # données fictives
mean = X.mean(axis=0) # moyenne par feature
std = X.std(axis=0) # écart‑type par feature
X_norm = (X - mean) / (std + 1e-8)
Cette normalisation influence grandement la performance et la stabilité de l’apprentissage.
3. One‑hot encoding
num_classes = 4
labels = np.array([0, 2, 1, 3]) # indices de classe
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 suit le même schéma.
4. Division en batchs
X = np.random.randn(100, 3) # 100 échantillons
batch_size = 16
for i in range(0, len(X), batch_size):
batch = X[i:i+batch_size]
# Imaginez que vous passez ce batch au modèle
Ce motif correspond directement au concept de DataLoader en PyTorch.
Points essentiels à retenir lorsqu’on étudie NumPy
Pour le deep learning, il n’est pas nécessaire de maîtriser toutes les fonctions de NumPy. Concentrez‑vous sur :
ndarrayde base :np.array,dtype,shape,reshape,astype- Indexation & découpage :
x[0],x[1:3],x[:, 0],x[:, 1:3],x[x > 0] - Opérations de base :
+,-,*,/,**, comparaisons,np.sum,np.mean,np.max,np.min,axis - Algèbre linéaire : produit matriciel
@ounp.dot, transpositionx.T - Broadcasting : addition/multiplication scalaire,
(N, D) + (D,),(N, 1) - Fonctions aléatoires :
np.random.randn,np.random.randint,np.random.permutation - Interopérabilité avec PyTorch :
torch.from_numpy,tensor.numpy()
Maîtriser ces bases rendra la lecture des tutoriels PyTorch beaucoup plus fluide.
Conclusion : NumPy est le "livre de syntaxe" du deep learning
En résumé :
- NumPy est une bibliothèque pour les calculs numériques sur des tableaux multidimensionnels.
- Le
Tensorde PyTorch est essentiellement un NumPyndarrayversion deep learning. - Apprendre la vectorisation, le broadcasting et l’algèbre linéaire en NumPy vous aide à éviter les erreurs de shape, à traduire les formules de papier en code et à améliorer vos compétences de pré‑traitement.
Si vous voulez comprendre le deep learning du point de vue mathématique plutôt que simplement apprendre un framework, NumPy est le meilleur point de départ.
Aucun commentaire.