Fondamentaux de l’`ndarray` NumPy pour les débutants en deep learning : `array`, `dtype`, `shape`, `reshape`, `astype`

Fondamentaux de l’ndarray NumPy pour les débutants en deep learning : array, dtype, shape, reshape, astype

1. Pourquoi commencer par l’ndarray ?

En deep learning, on voit souvent ces lignes de code :

• Vérifier le shape d’un tenseur d’entrée
• Utiliser reshape pour préparer un batch
• Convertir en float32 pour les calculs GPU…

Tout cela repose sur la structure de base NumPy ndarray.

• Le Tensor de PyTorch est pratiquement une copie du ndarray NumPy
• Les entrées, poids et sorties d’un modèle sont tous des tensors (arrays multidimensionnels)

Comprendre l’ndarray c’est donc maîtriser la syntaxe fondamentale des opérations sur les tensors.

2. Qu’est‑ce qu’un ndarray ?

ndarray signifie N‑dimensional array, c’est‑à‑dire un tableau à N dimensions.

• 1‑D : vecteur
• 2‑D : matrice
• 3‑D et plus : tenseur (batch d’images, séries temporelles, vidéos, etc.)

Exemple simple :

import numpy as np

x = np.array([1, 2, 3])            # 1‑D (vecteur)
M = np.array([[1, 2], [3, 4]])     # 2‑D (matrice)

print(type(x))          # <class 'numpy.ndarray'>
print(x.ndim, x.shape)  # nombre de dimensions, forme
print(M.ndim, M.shape)

• ndim : nombre de dimensions
• shape : taille de chaque dimension

3. À quel point le Tensor PyTorch est‑il similaire ?

Un tensor PyTorch est aussi un tableau multidimensionnel.

import torch

x_np = np.array([[1, 2], [3, 4]])   # NumPy ndarray
x_torch = torch.tensor([[1, 2], [3, 4]])  # PyTorch Tensor

print(type(x_np))      # numpy.ndarray
print(type(x_torch))   # torch.Tensor

print(x_np.shape)      # (2, 2)
print(x_torch.shape)   # torch.Size([2, 2])

Points communs :

• Deux structures de tableaux numériques multidimensionnels
• Concepts de shape, reshape, dtype quasiment identiques
• Opérations arithmétiques (+, *, @, etc.) similaires

Différences clés (important en deep learning) :

• NumPy : CPU uniquement, pas de différentiation automatique
• PyTorch Tensor : GPU support, auto‑diff

En pratique :

• Exercices conceptuels / manipulation de données → NumPy
• Entraînement réel de modèles → PyTorch

Plus vous êtes à l’aise avec ndarray, plus les opérations sur les tensors PyTorch deviennent naturelles.

4. np.array : la façon de base de créer un ndarray

La fonction la plus basique pour créer un ndarray est np.array.

4.1 Liste Python → ndarray

import numpy as np

# Tableau 1‑D (vecteur)
x = np.array([1, 2, 3])
print(x)
print(x.ndim)   # 1
print(x.shape)  # (3,)

# Tableau 2‑D (matrice)
M = np.array([[1, 2, 3],
              [4, 5, 6]])
print(M)
print(M.ndim)   # 2
print(M.shape)  # (2, 3)

• Une liste ou une liste de listes devient un ndarray.
• Les matrices batch_size x feature_dim que l’on voit souvent en deep learning sont exactement ce type.

4.2 Créer rapidement un tableau initialisé

Dans les exemples d’apprentissage ou les tests, on crée souvent des tableaux remplis de zéros ou de nombres aléatoires.

zeros = np.zeros((2, 3))       # 2x3, tout à zéro
ones = np.ones((2, 3))         # 2x3, tout à un
randn = np.random.randn(2, 3)  # nombres aléatoires suivant une loi normale

print(zeros.shape)  # (2, 3)

Ce schéma est quasiment identique en PyTorch.

import torch

zeros_t = torch.zeros((2, 3))
ones_t = torch.ones((2, 3))
randn_t = torch.randn((2, 3))

5. dtype : comprendre le type de données

dtype signifie data type : le type de chaque nombre dans le tableau.

Types fréquents :

• int32, int64 : entiers
• float32, float64 : flottants (virgule flottante)

Exemple :

x = np.array([1, 2, 3])
print(x.dtype)  # généralement int64 ou int32

y = np.array([1.0, 2.0, 3.0])
print(y.dtype)  # généralement float64

5.1 Spécifier le dtype lors de la création

x = np.array([1, 2, 3], dtype=np.float32)
print(x.dtype)  # float32

En deep learning, on utilise surtout float32 (ou torch.float32) : adapté aux calculs GPU et à la consommation mémoire.

6. shape : lire la forme des données

shape est un tuple indiquant la taille de chaque dimension.

import numpy as np

x = np.array([1, 2, 3])
print(x.shape)  # (3,)

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

Exemples courants en deep learning :

• Vecteur de caractéristiques : (feature_dim,) → ex : (3,)
• Batch de données : (batch_size, feature_dim) → ex : (32, 3)
• Batch d’images (PyTorch) : (batch_size, channels, height, width) → ex : (32, 3, 224, 224)

Se familiariser avec ces formes en NumPy rend la résolution d’erreurs de shape en PyTorch beaucoup plus intuitive.

7. reshape : changer la forme

reshape modifie la forme d’un tableau sans changer le nombre total d’éléments.

import numpy as np

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

M = x.reshape(2, 3)
print(M)
print(M.shape)  # (2, 3)

Points clés :

• Le nombre total d’éléments doit rester identique.

7.1 Utiliser -1 pour un calcul automatique

Dans le traitement d’images ou de batches, on utilise souvent -1. -1 indique que la dimension doit être calculée automatiquement.

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

# Aplatir complètement
flat = x.reshape(-1)        # shape: (6,)
print(flat)

# Reformer en 2 lignes, colonne calculée automatiquement
M = flat.reshape(2, -1)     # shape: (2, 3)
print(M)

PyTorch fonctionne de la même façon.

import torch

x_t = torch.tensor([[1, 2, 3],
                    [4, 5, 6]])  # (2, 3)

flat_t = x_t.reshape(-1)        # (6,)
M_t = flat_t.reshape(2, -1)     # (2, 3)

Une fois à l’aise avec reshape :

• Flatten les feature maps dans un CNN
• Organiser les entrées RNN/LSTM en (batch, seq_len, feature)
• Réarranger les dimensions de batch

8. astype : changer le type de données

astype convertit le type d’un tableau.

import numpy as np

x = np.array([1, 2, 3])      # entier
print(x.dtype)               # int32 ou int64

x_float = x.astype(np.float32)
print(x_float)
print(x_float.dtype)         # float32

Situations fréquentes en deep learning :

• Convertir des labels entiers en flottants pour le calcul de la perte
• Uniformiser des données en float32 lorsqu’elles arrivent en float64
• Adapter le type avant de passer à PyTorch

Exemple :

import torch
import numpy as np

x = np.array([1, 2, 3], dtype=np.int32)
x = x.astype(np.float32)              # conversion en float32
x_torch = torch.from_numpy(x)         # conversion en tensor
print(x_torch.dtype)                  # torch.float32

Sans cette conversion, PyTorch peut lever des erreurs de type comme « Expected Float but got Double ».

9. Résumé : les bases de l’ndarray abordées aujourd’hui

Ce que nous avons vu :

1. Qu’est‑ce qu’un ndarray ? * La structure de base de toutes les données en deep learning
2. Relation avec le Tensor PyTorch * Conceptuellement identique, mais PyTorch ajoute GPU et auto‑diff
3. np.array * Crée un ndarray à partir de listes Python
4. dtype * Type de données (int, float, 32/64 bits)
5. shape * Forme du tableau, propriété la plus vue en deep learning
6. reshape * Changer la forme sans modifier le nombre d’éléments (-1 utile)
7. astype * Convertir le type de données (int → float32, etc.)

Maîtriser ces sept éléments vous permet :

• De ne plus paniquer face aux erreurs de shape
• De passer plus aisément d’un papier de recherche à un code
• De suivre les tutoriels PyTorch sans accroc