Peut-on se contenter de PyTorch sans NumPy ?

Si vous êtes développeur de deep learning, vous avez sûrement déjà été perplexe face à cette relation.

En parcourant des scripts de fine‑tuning, deux noms apparaissent toujours ensemble.

 import numpy as np
 import torch

« Mais les opérations sur les tenseurs sont déjà dans PyTorch… pourquoi avoir besoin de NumPy ? » « Ils semblent se chevaucher, faut‑on vraiment apprendre NumPy séparément ? »

Je me suis interrogé sur ce point et, grâce à une réponse claire, j’ai rédigé ce guide.

1. NumPy et PyTorch, qu'est-ce qui les différencie réellement ?

Commandbox 광고

En gros, on peut dire que PyTorch est :

« NumPy sur GPU + autograd »

En découpant les rôles :

  • NumPy
  • Bibliothèque de tableaux/matrices fonctionnant sur le CPU
  • Calcul numérique, algèbre linéaire, statistiques : le « standard » de Python

  • Fonctionne autour de la structure de données ndarray

  • PyTorch

  • API très proche de NumPy
  • Peut tourner sur le CPU et sur le GPU (CUDA)
  • Supporte l’auto‑différentiation → apprentissage profond possible

Les développeurs de PyTorch ont volontairement imité la syntaxe de NumPy.

  • np.array([...]) → torch.tensor([...])
  • x_np.shape → x_torch.shape
  • np.reshape(x, …) → x_torch.view(…) ou x_torch.reshape(…)

Ainsi, en apprenant les opérations sur les tenseurs PyTorch, on acquiert naturellement la pensée et la syntaxe NumPy.

2. Doit‑on d’abord apprendre NumPy ? Réponse pragmatique

De nombreux tutoriels commencent par NumPy, ce qui peut prêter à confusion. Du point de vue pratique, la réponse est :

Il n’est pas nécessaire de maîtriser NumPy avant PyTorch. PyTorch suffit pour commencer les opérations sur les tenseurs.

Pourquoi ? Parce que

  • Les concepts de forme, de broadcasting et d’indexation sont presque identiques entre NumPy et PyTorch.
  • En deep learning, ce que l’on utilise le plus, c’est l’opération sur les tenseurs + autograd, qui se trouve uniquement dans PyTorch.

Donc, si votre objectif est le deep learning :

  1. Apprenez d’abord les manipulations de tenseurs PyTorch.
  2. Quand vous voyez np.xxx dans le code, comprenez‑le comme « version CPU d’une opération PyTorch ».

3. Pourquoi NumPy apparaît‑t‑il encore ? Le « langage commun » de l’écosystème

Commandbox 광고

On se demande alors :

« PyTorch est plus puissant, pourquoi ne pas tout faire en tenseurs ? »

La réponse est simple : la plupart de l’écosystème Python de la science des données est conçu autour de NumPy.

3‑1. Pré‑traitement des données : le monde de NumPy

Les bibliothèques courantes pour préparer les données utilisent NumPy :

  • OpenCV, Pillow → lecture d’images renvoie un tableau NumPy
  • pandas → DataFrame.values / to_numpy()
  • Divers packages statistiques → entrées/sorties basées sur NumPy

En bref, tout ce qui se passe avant d’alimenter le modèle se fait souvent avec NumPy.

3‑2. Entraînement / inférence : le monde de PyTorch

Pour passer les données au modèle :

import numpy as np
import torch

x_np = ...  # résultat du pré‑traitement, tableau NumPy
x_tensor = torch.from_numpy(x_np)  # conversion en tenseur
x_tensor = x_tensor.to("cuda")     # mise sur GPU

out = model(x_tensor)

À partir de là, on est dans l’univers PyTorch.

3‑3. Visualisation / sauvegarde / post‑traitement : retour à NumPy

Les résultats du modèle sont souvent traités avec :

  • matplotlib pour tracer
  • pandas pour sauvegarder en CSV
  • Calculs statistiques simples

Ces bibliothèques fonctionnent également sur des tableaux NumPy, d’où la nécessité de reconvertir les tenseurs.

out_cpu = out.detach().cpu().numpy()

Une erreur fréquente : TypeError: can't convert cuda:0 device type tensor to numpy – il faut d’abord .cpu().

4. Point système important : partage de mémoire « Zero‑Copy »

Un détail intéressant en bas niveau :

x_np = np.random.randn(3, 3)
x_tensor = torch.from_numpy(x_np)  # ici !

Aucun copie n’est faite : torch.from_numpy partage la même mémoire que NumPy.

Inversement :

x_np2 = x_tensor.numpy()

Le même principe : le tableau NumPy pointe vers la même zone mémoire que le tenseur (si le tenseur est sur CPU).

Exemple :

x_np = np.zeros((2, 2))
x_tensor = torch.from_numpy(x_np)

x_tensor[0, 0] = 1
print(x_np)
# [[1. 0.]
#  [0. 0.]]  ← le tableau NumPy change aussi

En résumé :

  • PyTorch et NumPy peuvent partager la mémoire sur le CPU.
  • Cela permet de passer sans frais de copie entre pré‑traitement, entraînement et post‑traitement.

5. Exemple complet en un coup d’œil

Prenons un exemple très simple de classification d’image :

import cv2
import numpy as np
import torch

# 1. Chargement & pré‑traitement NumPy (zone NumPy)
img = cv2.imread("cat.png")          # shape: (H, W, C), BGR, NumPy array
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (224, 224))
img = img.astype(np.float32) / 255.0
img = np.transpose(img, (2, 0, 1))   # (C, H, W)

# 2. Conversion NumPy → PyTorch & déplacement sur GPU (zone PyTorch)
x = torch.from_numpy(img)            # shape: (3, 224, 224)
x = x.unsqueeze(0)                   # ajouter dimension batch : (1, 3, 224, 224)
x = x.to("cuda")

# 3. Inférence
with torch.no_grad():
    logits = model(x)
    probs = torch.softmax(logits, dim=1)

# 4. Retour à NumPy pour post‑traitement/visualisation (zone NumPy)
probs_np = probs.cpu().numpy()
pred_class = np.argmax(probs_np, axis=1)[0]

On voit que les frontières d’entrée/sortie restent NumPy, tandis que le cœur de l’apprentissage reste PyTorch.

6. Résumé final : points clés à retenir

  1. Étudier PyTorch, c’est apprendre un « NumPy futuriste ». La manipulation des tenseurs et le broadcasting sont les mêmes.
  2. Pas besoin d’approfondir NumPy si votre but est le deep learning : PyTorch suffit.
  3. En pratique, vous utiliserez NumPy pour : * Pré‑traitement des données * Post‑traitement, visualisation, statistiques * Conversion fréquente entre tenseurs et tableaux (.numpy(), torch.from_numpy, .cpu()).
  4. Sur le plan système, Zero‑Copy permet de partager la mémoire entre NumPy et PyTorch sans frais de copie.

En gardant ces deux mondes à l’esprit, vous pourrez naviguer aisément entre pré‑traitement, entraînement et post‑traitement dans vos projets de deep learning.

  • Tenseur sur GPU + autograd → PyTorch
  • Interaction avec d’autres bibliothèques ou manipulation de données → NumPy

Ces deux univers se complètent naturellement et constituent la compétence de base d’un développeur Python en deep learning.

image