Tensor : comprendre les tenseurs en informatique

Qu’est-ce qu’un tenseur (tensor) : définition intuitive et mathématique

Un tenseur est un objet mathématique qui prolonge les scalaires, vecteurs et matrices pour décrire des grandeurs avec plusieurs directions ou relations. En clair, il encode des “axes” (dimensions) et des valeurs associées à chaque combinaison d’indices. Sur le plan mathématique, on le formalise avec des produits tensoriels et des transformations qui gardent la structure.

Pour se repérer : un scalaire n’a qu’une valeur (rang 0), un vecteur est une liste ordonnée (rang 1), une matrice organise les valeurs en lignes et colonnes (rang 2). Le tenseur ajoute des axes : on obtient une structure indexée par plusieurs indices, un “tableau de tableaux” dans l’esprit. (Et oui, ça devient très concret quand on regarde les shapes dans un notebook.)

Ce n’est pas qu’une question de vocabulaire. La façon de combiner les données change. Le produit tensoriel construit un objet de rang supérieur, tandis que certaines transformations (selon le contexte) respectent la structure de ces axes. Le terme tensor est aussi historiquement lié à William Rowan Hamilton au XIXe siècle, dans un cadre algébrique où il décrivait une notion de norme. En informatique et en IA, on s’en sert pour exprimer des relations multidimensionnelles de manière cohérente.

En pratique, on croise souvent des tenseurs de rang 0 (scalaire), 1 (vecteur), 2 (matrice) et bien plus en apprentissage profond. Les frameworks manipulent fréquemment des tenseurs de rang 2 à 4 pour les données : images (hauteur, largeur, canaux), lots (batch), canaux, ou encore représentations de séquences (tokens, features).

Différence entre scalaire, vecteur, matrice et tenseur

• Rang 0 : scalaire (ex. une température, un score).
• Rang 1 : vecteur (ex. un embedding de taille 768).
• Rang 2 : matrice (ex. une multiplication de matrices, un poids de couche linéaire).
• Rang ≥ 3 : tenseurs (ex. images, lots, séquences, tenseurs d’attention).

Dimensions et “formes” : comprendre le shape, le rang et les axes

Un tenseur est décrit par sa forme (shape) : un tableau de tailles pour chaque axe. Le rang correspond au nombre d’axes. Une image en couleur est souvent un tenseur de forme (hauteur, largeur, canaux) ou (canaux, hauteur, largeur) selon la convention. Dans le deep learning, les opérations exigent des shapes compatibles.

Le shape, c’est votre carte routière. Chaque valeur du shape correspond à la taille d’un axe. Le rang indique combien d’axes vous avez. Ensuite, les indices servent à accéder à une composante précise : par exemple, (i, j, k) peut viser une position (ligne, colonne) et un canal. En IA, cette précision évite des erreurs discrètes qui font dérailler un modèle.

Pour les images, les conventions reviennent souvent : NHWC (batch, hauteur, largeur, canaux) ou NCHW (batch, canaux, hauteur, largeur). Le choix dépend du framework, des couches et parfois des performances visées. Et non, ce n’est pas “juste une permutation” : une convolution n’interprète pas les axes de la même façon si vous échangez hauteur/largeur/canaux.

La compatibilité des opérations repose sur des règles de broadcasting et d’alignement des axes. Une addition demande des shapes compatibles (identiques sur certains axes, ou ajustables selon des règles de diffusion). Résultat : les erreurs de type “shape mismatch” figurent parmi les causes les plus fréquentes de bugs lors de la mise en place de modèles.

Conventions et exemples concrets

Un batch d’images est typiquement un tenseur de forme (taille_batch, canaux, hauteur, largeur) ou (taille_batch, hauteur, largeur, canaux). Les pipelines IA utilisent aussi des tenseurs 1D, 2D, 3D et 4D : signaux (1D), matrices (2D), séquences (3D), images (4D). Ce n’est pas un hasard : chaque type de données se mappe assez naturellement sur une structure d’axes.

1. Images : (H, W, C) ou (N, H, W, C) ; parfois (C, H, W) ou (N, C, H, W).
2. Séries temporelles : (N, T) ou (N, T, F) selon le nombre de features.
3. Tabulaire : (N, F) pour batch et caractéristiques.

Quand vous codez, gardez en tête que la dimension batch est souvent celle qu’on oublie lors des conversions. Un modèle qui attend (N, …) mais reçoit (…) perd sa compatibilité très vite.

Opérations sur les tenseurs : produit scalaire, produit tensoriel, contraction

Les tenseurs se combinent via des opérations qui respectent leur structure. Le produit scalaire généralise la mesure d’alignement, le produit tensoriel construit un tenseur de rang supérieur, et la contraction (somme sur des indices) réduit le rang. Dans l’apprentissage profond, ces idées se retrouvent dans des couches comme les couches linéaires, les convolutions et les opérations d’attention.

Pour comprendre la “musique” des tenseurs, retenez trois gestes : comparer (produit scalaire), construire (produit tensoriel), fusionner (contraction). Le produit scalaire implique une somme (ou une projection) sur un axe : c’est ce qui permet de produire un score d’alignement ou d’effectuer une multiplication de matrices sous forme tensorisée.

Le produit tensoriel est plus “expansif” : il combine deux tenseurs en créant de nouveaux axes. Vous passez à un rang supérieur, utile quand vous voulez capturer des interactions plus riches. Ensuite, la contraction sert souvent à revenir à une forme exploitable en sommant sur des indices précis. C’est là que les calculs deviennent très efficaces.

Ces notions se traduisent directement dans les couches IA. Une multiplication de matrices se voit comme une contraction sur un axe : on somme sur l’indice partagé. Les convolutions réalisent une contraction locale (une fenêtre glisse) et agrègent sur des axes de canaux, parfois sur des dimensions spatiales. Dans l’attention, on calcule des produits et des contractions pour obtenir des scores, puis on applique des pondérations.

Produit scalaire, produit tensoriel et contraction : à quoi ça ressemble ?

• Produit scalaire : “aligner” deux objets en sommant sur un axe commun.
• Produit tensoriel : “concaténer” la structure mathématique en ajoutant des axes.
• Contraction : “réduire” en sommant sur certains indices pour revenir à un rang plus faible.

Si vous avez déjà eu une erreur de dimension dans une couche matmul ou une attention mal paramétrée, vous avez probablement buté sur une contraction qui ne correspondait pas à la structure attendue. Et franchement, qui n’a jamais eu ce moment de doute ?

Tenseurs en apprentissage profond : de l’entrée au calcul des gradients

En deep learning, tout devient tenseur : entrées (images, tokens), paramètres (poids) et sorties (logits). Les transformations apprises sont des fonctions construites à partir d’opérations tensorisées. La rétropropagation calcule des gradients en dérivant ces opérations : on propage des tenseurs de même structure à travers le graphe de calcul.

La raison est simple : un réseau neuronal est une composition de fonctions. Et une fonction de réseau s’écrit naturellement comme une suite d’opérations sur des tenseurs : multiplications, additions, activations, normalisations, convolutions, attention. Même quand vous “pensez” à un concept (un filtre, une similarité), le calcul réel passe par des axes et des contractions.

Les tenseurs de poids sont souvent de rang 2 dans les couches linéaires (une matrice de transformation), et de rang 4 dans les convolutions (poids organisés selon canaux d’entrée/sortie et dimensions du noyau). Les gradients, eux, gardent la même “forme” que les tenseurs dont ils dérivent : même shape, mêmes axes. C’est ce qui rend l’autodiff (différenciation automatique) si efficace.

Pendant le forward (passe avant), vous enchaînez les transformations apprises. Pendant le backward (rétropropagation), le système calcule les dérivées de chaque opération et propage des tenseurs de gradients. En 2025-2026, les frameworks modernes s’appuient sur des graphes de calcul et des optimisations GPU : tout est pensé pour enchaîner les tenseurs sans casser la compatibilité de forme.

Forward et backward : la logique d’un graphe

Un réflexe utile pour déboguer : vérifier les shapes à chaque étape, surtout après des manipulations comme reshape et permute. (C’est souvent là que “ça marche en théorie”, mais que le modèle produit des résultats incohérents.)

1. Forward : entrées → transformations → sorties.
2. Perte : comparaison prédiction vs cible, donnant un scalaire ou un tenseur agrégé.
3. Backward : gradients calculés couche par couche, en remontant le graphe.

Cette continuité structurelle explique pourquoi les tenseurs sont l’unité de base du calcul : ils portent à la fois les données et le chemin mathématique vers les gradients.

TensorFlow et PyTorch : comment lire et manipuler les tenseurs au quotidien

Dans TensorFlow et PyTorch, un tenseur est l’unité de base des calculs. Vous manipulez des shape via reshape/view, transpose/permute, et des indexations. Les bibliothèques gèrent aussi le device (CPU/GPU) et la précision (float32, float16). Le but reste le même : obtenir des shapes compatibles avec les couches et éviter les erreurs d’axes.

Au quotidien, vous ne pouvez pas vous contenter de “penser en théorie”. Il faut lire les shapes et les dtypes. Les modèles modernes utilisent souvent float32 et parfois float16 ou bfloat16 pour accélérer l’entraînement sur GPU. Le dtype ne change pas la structure des axes, mais il peut influencer la stabilité numérique et la vitesse.

Les opérations de forme sont vos outils principaux. reshape ou view modifient la structure sans changer le nombre total d’éléments (dans certaines conditions). transpose ou permute réordonnent les axes : c’est crucial pour passer de NHWC à NCHW ou pour aligner les attentes d’une couche. Ensuite, squeeze et unsqueeze rendent service pour ajouter ou retirer une dimension de taille 1 (par exemple, pour satisfaire un batch attendu).

L’indexation et le broadcasting suivent des règles strictes. Quand une addition “se diffuse”, c’est parce que certaines dimensions sont égales ou valent 1. Sinon, vous obtenez un message de dimension mismatch. Dans les pipelines IA, cette vérification devient une discipline : contrôler les shapes avant d’exécuter une couche coûteuse.

Checklist rapide pour éviter les erreurs de dimensions

• Inspectez shape et dtype avant chaque couche (surtout après reshape/permute).
• Vérifiez que la dimension batch est bien présente quand la couche l’attend.
• Contrôlez l’ordre des axes : NHWC vs NCHW, (T, F) vs (F, T), etc.
• Assurez la compatibilité pour matmul, conv et concat (axes alignés).

Ces habitudes réduisent nettement le temps perdu à “corriger” un modèle qui échoue à cause d’une permutation oubliée. (Et ça, c’est le genre de victoire qu’on apprécie.)

Cas d’usage concrets : images, séries temporelles et données tabulaires

Un tenseur s’adapte à la nature des données. Pour les images, il encode hauteur, largeur et canaux. Pour les séries temporelles, il représente des séquences (temps, features) et parfois des lots. Pour le tabulaire, on utilise souvent des tenseurs 2D (batch, features). Bien choisir la forme simplifie les couches et limite les conversions.

Le même modèle “voit” différemment selon la forme. Une image a une structure spatiale : hauteur et largeur, plus des canaux (couleurs ou cartes de caractéristiques). Une série temporelle suit une logique séquentielle : un axe temps, et parfois un axe pour les features (capteurs, variables dérivées). Le tabulaire, lui, se traite souvent comme un ensemble de lignes : batch et caractéristiques.

La convention d’axes change aussi vos opérations. Pour les images, les convolutions exploitent la structure locale : elles font une contraction sur une fenêtre tout en agrégeant les canaux. Pour les séries temporelles, vous utilisez des architectures qui mélangent l’information au fil du temps (convolutions 1D, RNN/GRU, ou attention). Pour le tabulaire, des couches linéaires et des normalisations travaillent sur un tenseur 2D (batch, features).

Mapper les données vers une forme de tenseur

Voici des correspondances fréquentes :

• Images : (H, W, C) ou (N, C, H, W) ; avec batch pour l’entraînement.
• Séries temporelles : (N, T) si une feature, ou (N, T, F) si plusieurs variables.
• Données tabulaires : (N, F), parfois (N, 1, F) si vous adaptez à une architecture qui attend une dimension “canaux”.

Quand la shape reste cohérente, vous évitez les conversions répétées (qui coûtent du temps et augmentent le risque d’erreur). Au final, tout se joue sur “axes + compatibilité de shapes” : c’est le fil conducteur pour comprendre, implémenter et déboguer.

FAQ

L’essentiel à retenir

• Un tenseur généralise scalaire, vecteur et matrice pour représenter des données avec plusieurs axes.
• Le shape (forme) et le rang déterminent comment accéder aux composantes et quelles opérations sont possibles.
• Les produits et contractions expliquent la logique derrière matmul, convolutions et attention.
• En deep learning, données, paramètres et gradients sont des tenseurs : tout s’enchaîne via un graphe de calcul.
• Dans TensorFlow/PyTorch, maîtriser reshape/view et permute/transpose réduit la majorité des bugs de dimensions.
• Choisissez une forme de tenseur cohérente avec votre type de données pour simplifier les couches et limiter les conversions.
• Pensez “axes + compatibilité de shapes” : c’est le meilleur fil conducteur pour comprendre et déboguer.

Quand vous relisez ce guide, gardez une image mentale simple : un tensor, c’est une structure d’axes où chaque opération respecte (ou casse) cette structure. À partir de là, les erreurs de dimensions deviennent des indices, pas des mystères. (Et ça, c’est plutôt rassurant.)

Pour aller plus loin, vous pouvez consulter : la définition du tenseur sur Wikipédia, le guide Tensor de TensorFlow, et la documentation PyTorch sur les tenseurs. (Une bonne base pour relier le concept à la pratique.)