PyTorch, qu'est-ce que c'est ?

PyTorch est une bibliothèque de logiciels Open Source qui permet aux équipes de développement d'assembler du code afin de créer un « cerveau » d'IA capable d'apprendre à identifier des schémas dans des données. En termes plus techniques, grâce à PyTorch, ces équipes peuvent utiliser des couches modulaires pour assembler et entraîner des réseaux de neurones complexes qui seront réservés à l'apprentissage automatique avancé. 

Découvrir Red Hat AI

L'utilisation du framework PyTorch s'est rapidement propagée parce qu'il accorde la priorité à l'expérience de développement et facilite le changement de structure de modèle en temps réel. Les utilisateurs interagissent avec ce framework en se servant du langage de programmation Python au niveau front-end. PyTorch utilise C++ comme langage de programmation (et CUDA lorsqu'un GPU NVIDIA est disponible) pour exécuter des calculs complexes au niveau back-end. Cette approche hybride permet d'associer une interface utilisateur simple à une puissance de calcul maximale.

PyTorch est une bibliothèque Open Source gérée par la PyTorch Foundation, membre de la Linux® Foundation. Cette gouvernance ouverte garantit sa gratuité, son amélioration continue par la communauté Open Source et son auditabilité complète. Les équipes de développement peuvent inspecter le code source et vérifier la manière dont le framework gère les données. 

Au-delà de ses origines Open Source, l'architecture sous-jacente de PyTorch privilégie la flexibilité, l'évolutivité et l'accessibilité pour tous les utilisateurs, sur différentes plateformes matérielles et auprès de divers fournisseurs de services cloud. 

Comprendre pourquoi l'avenir de l'IA dépend d'un écosystème PyTorch

PyTorch fournit les éléments essentiels dont les équipes de développement ont besoin pour concevoir et déployer des modèles d'intelligence artificielle. Plutôt que de les contraindre à assembler des systèmes complexes à partir de zéro, PyTorch se distingue en leur proposant une approche intuitive et native pour Python, ainsi qu'une bibliothèque de modèles d'apprentissage automatique prêts à l'emploi. Son principal atout est sa flexibilité, qui permet à ces équipes de modifier leurs modèles d'IA et de faire des expérimentations en temps réel pendant leur exécution. 

PyTorch intervient à chaque étape de l'assemblage et de l'exécution d'un modèle d'apprentissage automatique :

Organisation et préparation des données
La première étape consiste à définir le problème et à préparer les données. Comme PyTorch ne permet pas de nettoyer les données, les équipes de développement doivent utiliser des outils distincts (tels que Pandas et SQL) pour organiser les données. Elles peuvent avoir recours à Docling pour résumer des documents et les convertir en données structurées. PyTorch récupère ensuite ces données préparées et les transmet aux réseaux de neurones. 

Entraînement des modèles
Au cours de cette étape, les équipes de développement utilisent PyTorch comme principal espace de travail pour concevoir et entraîner un modèle d'IA. Lors du codage, PyTorch sert de pont universel qui transmet les tenseurs de données à l'accélérateur matériel, notamment les processeurs graphiques (GPU) NVIDIA utilisant CUDA, les GPU AMD via ROCm ou encore les systèmes basés sur des processeurs Intel et Apple Silicon (voir les sections sur les tenseurs et CUDA ci-dessous). Dans le cas des modèles d'IA d'entreprise, ce code d'entraînement est souvent mis en paquet dans un conteneur Docker puis envoyé à un cluster cloud Kubernetes (voir les sections sur Docker et Kubernetes ci-dessous).

Évaluation des modèles
Les équipes de développement utilisent PyTorch à cette étape pour tester les performances du modèle avec un nouvel ensemble de données. Elles gèlent alors les paramètres internes du modèle et suspendent l'apprentissage, afin d'évaluer ses performances prédictives brutes.

Déploiement
Après avoir entraîné un modèle avec PyTorch, les équipes de développement se retrouvent avec un énorme fichier rempli de paramètres mathématiques optimisés (pondérations et biais, également appelés « paramètres du modèle »). L'IA passe alors de l'entraînement à l'inférence. Elle cesse d'apprendre et commence à réaliser des prédictions fondées sur son entraînement. Pour la lancer, son « cerveau » peut être mis en paquet dans une image Docker de production et envoyé à des plateformes cloud comme Amazon Web Services, Google Cloud ou Microsoft Azure. Une fois que le modèle a intégré le cloud, Kubernetes gère l'infrastructure et la mise à l'échelle, tandis qu'un moteur d'inférence tel que vLLM optimise la vitesse et les performances des calculs. 

Le framework PyTorch peut servir à assembler des applications d'apprentissage automatique et d'apprentissage profond. Il est couramment utilisé pour entraîner les types de modèles suivants :

Grands modèles de langage : PyTorch a alimenté les premiers modèles GPT d'OpenAI et la famille Llama de Meta.

Vision par ordinateur : les voitures autonomes, l'imagerie médicale et les logiciels de reconnaissance faciale utilisent souvent PyTorch (plus particulièrement le paquet de la bibliothèque TorchVision) pour créer des pipelines qui nécessitent des fonctions de classification d'images et de détection d'objets. 

Générateurs d'images : il est possible d'entraîner des modèles de génération d'images à partir de texte avec PyTorch, qui fournit les calculs sous-jacents nécessaires pour analyser des millions, voire des milliards d'images, et apprendre à l'IA à en créer. 

Traitement du langage naturel et génération audio : PyTorch permet d'entraîner des modèles de synthèse vocale et de saisie vocale, en interprétant le lien entre les ondes sonores et un texte structuré et lisible. PyTorch peut également servir à créer des outils de traduction.

Les tenseurs sont les éléments fondamentaux de l'IA moderne. Chaque mot, image, vidéo et son est représenté sous la forme d'un tenseur avant d'être traité par un modèle d'IA. 

Le framework PyTorch est parfois décrit comme une bibliothèque pour coder avec des tenseurs, c'est-à-dire des dispositions organisées de chiffres qui représentent des données brutes et des paramètres de modèle. Il fournit les outils nécessaires pour assembler et exécuter des réseaux de neurones profonds. En injectant des tenseurs structurés dans ces réseaux, PyTorch alimente le « cerveau » de calcul d'un modèle d'IA. 

Pour faire simple, un tenseur est un conteneur de chiffres. Il peut aller d'un simple nombre (également appelé « scalaire ») à une grille multidimensionnelle de chiffres. Les tenseurs ont différentes tailles en fonction du nombre de dimensions qu'ils possèdent :

• Un scalaire est un tenseur à 0 dimension. Il s'agit d'un nombre unique.
• Un vecteur est un tenseur à 1 dimension. Il s'agit d'une ligne de scalaires ou d'une rangée de nombres.
• Une matrice est un tenseur à 2 dimensions. Il s'agit d'une grille de nombres, comme une feuille de calcul.
• Un tenseur à 3 dimensions ou plus est qualifié de multidimensionnel. Il s'agit d'un empilement imbriqué de grilles qui ressemble à un Rubik's Cube. 

Les tenseurs peuvent cumuler les dimensions, à l'instar des tenseurs 4D et 5D. Les tenseurs multidimensionnels permettent à PyTorch d'empiler et de structurer des données complexes, comme des images en couleurs ou des séquences vidéo.

Pourquoi parlons-nous ici de dimensions ?

Lorsqu'il traite des données, le framework PyTorch représente les informations sous forme de tenseurs au sein d'un « espace multidimensionnel ». Il s'agit d'un domaine mathématique abstrait qui comporte des dizaines, voire des milliers de directions et de dimensions. C'est dans cet espace qu'un modèle d'IA peut calculer et analyser des concepts en mettant en correspondance et en mesurant des coordonnées.

Parce que nous vivons dans un monde en trois dimensions, il nous est difficile d'imaginer un espace dans lequel il en existe des milliers. L'IA, elle, se sert de l'algèbre linéaire pour apprendre, en mettant en correspondance des données dans un espace multidimensionnel et en calculant les liens spatiaux entre les points. 

Avec PyTorch, il est possible de transformer des données en une grille structurée de nombres (les tenseurs) avant de les envoyer à un réseau de neurones. À mesure que ce dernier traite les données, PyTorch s'en sert pour ajuster progressivement les paramètres internes (qui peuvent se compter en dizaines, en centaines, voire en milliers de milliards, selon le modèle). Ce processus apprend au modèle à reconnaître des schémas et des relations dans les données. Et grâce aux schémas qu'il apprend, le modèle peut réaliser des prédictions concernant de nouvelles informations qu'il n'a jamais vues auparavant. Le « cerveau » d'IA se forme après avoir acquis ce comportement.

PyTorch et TensorFlow sont tous deux des outils Open Source qui permettent aux ordinateurs d'apprendre en transformant les données en tenseurs et en mettant en correspondance ces tenseurs dans un espace numérique. PyTorch privilégie la flexibilité et la facilité d'utilisation, tandis que TensorFlow cible l'évolutivité et la structure. 

C'est Meta (anciennement Facebook) qui a lancé PyTorch sous forme de produit Open Source en 2017. À l'origine, il s'agissait d'un outil interne conçu à partir de zéro comme un framework axé sur la recherche, qui offrait un moyen plus rapide et flexible pour tester les architectures de réseaux de neurones. Son adoption s'est rapidement propagée au sein des équipes de développement, qui l'ont trouvé plus facile à utiliser que TensorFlow, notamment pour accélérer l'itération.

C'est Google qui a lancé TensorFlow comme produit Open Source en 2015. Au début, il s'agissait d'un outil interne réservé à la recherche et à la production, qui devait fonctionner sur des systèmes d'entreprise de très grande envergure. Cet outil a donc été largement adopté dans les environnements professionnels comptant des millions d'utilisateurs et d'immenses serveurs cloud.

Aujourd'hui, PyTorch et TensorFlow partagent un grand nombre de fonctions et se sont mutuellement inspirés pour s'améliorer au fil du temps. 

L'acronyme CUDA (Compute Unified Device Architecture) désigne une plateforme logicielle qui permet aux équipes de développement d'écrire du code s'exécutant sur des GPU NVIDIA en vue d'un traitement parallèle. PyTorch utilise la plateforme CUDA comme un pont numérique pour décharger les calculs du processeur principal d'un ordinateur sur un GPU NVIDIA. De cette manière, des milliards de calculs peuvent s'exécuter très rapidement. 

Il n'est toutefois pas indispensable d'avoir une plateforme CUDA ou une carte graphique pour utiliser PyTorch. En l'absence d'une plateforme GPU prise en charge, telle que CUDA ou ROCm, PyTorch exécute par défaut la charge de travail sur le processeur de l'ordinateur. S'il suffit d'utiliser PyTorch avec un processeur pour le débogage ou l'exécution de petits modèles, il sera plus efficace d'associer PyTorch à une plateforme CUDA pour traiter des données via des réseaux de neurones à grande échelle en quelques millisecondes plutôt qu'en plusieurs heures. 

Un graphe de calcul est une représentation visuelle des opérations mathématiques. Il retrace le flux de données au sein d'un système mathématique et permet d'identifier les opérations qu'effectue PyTorch à chaque nœud, en mettant en évidence les dépendances entre les couches du réseau.

Dans le contexte du développement de l'IA, le graphe de calcul va fournir le modèle à suivre pour l'apprentissage. Il suit l'évolution d'une entrée jusqu'à la sortie, offrant ainsi à l'ordinateur une piste claire à remonter dès qu'il doit calculer des erreurs et ajuster ses paramètres internes.

Graphes de calcul dynamiques

PyTorch s'appuie sur des graphes de calcul dynamiques pour exécuter des modèles d'apprentissage profond. La différence entre ces graphes et les graphes de calcul standards (aussi appelés « graphes statiques ») se situe au niveau de leur flexibilité. 

Pour mieux comprendre la différence entre les graphes de calcul statiques et dynamiques, prenons l'exemple d'un train (les données) qui circule sur une voie (l'architecture du modèle d'apprentissage profond). 

L'utilisation d'un graphe statique pourrait être comparée à la construction d'une voie entière avant la mise en circulation d'un train. Chaque train serait contraint d'emprunter ce même itinéraire, et tous les détours ou virages nécessaires devraient être anticipés et construits en amont. Si un train qui transporte des données a besoin d'un itinéraire pour lequel aucune voie n'a encore été construite, le système se bloque et la voie doit être reconstruite. En d'autres termes, un graphe statique impose l'assemblage du modèle dans son intégralité avant de pouvoir y faire circuler des données. 

L'utilisation d'un graphe dynamique reviendrait à concevoir un nouvel itinéraire pour chaque train juste avant son départ, en l'adaptant en fonction de son chargement. Si les données prennent la forme d'une phrase courte, PyTorch construit une voie courte pour les transporter au travers du modèle. Si elles consistent en un long paragraphe de texte, le graphe dynamique de PyTorch construit une voie plus longue.

L'approche dynamique offre de la flexibilité à chaque itération et simplifie le débogage. Parce que PyTorch construit la voie ligne par ligne en temps réel, en cas de problème, le train s'arrête sur la ligne à l'origine de l'erreur. 

Avec les graphes statiques, les erreurs surviennent une fois que toute la voie est disposée, et rien n'indique clairement l'origine du problème. Cette situation peut naturellement être source d'une grande frustration. 

autograd

Intégré à PyTorch, le moteur autograd se charge d'effectuer automatiquement les calculs de dérivées et de gradients. PyTorch suit l'approche spécifique d'un système sur bande, dont le fonctionnement se rapproche de celui d'une cassette audio ou vidéo. 

Lorsque des données sont injectées dans un modèle PyTorch pendant son entraînement, autograd active la fonction de propagation avant ou d'« enregistrement » afin de capturer et d'enregistrer chaque opération mathématique et leur ordre d'exécution. Le moteur peut également déclencher la fonction de propagation arrière (ou de « rembobinage »). En exécutant les opérations mathématiques dans l'ordre inverse, autograd calcule la contribution de chaque paramètre à l'erreur et détermine comment l'ajuster. 

Lorsqu'autograd « rembobine » la bande, il agit comme un professeur de mathématiques qui corrigerait le devoir d'un élève. En partant de la réponse finale erronée, il remonte chaque calcul pour identifier l'endroit où la formule a posé problème et où apporter des ajustements pour la prochaine tentative. 

Utiliser autograd pour améliorer l'entraînement dans PyTorch

L'obtention d'une réponse correcte de la part d'un modèle d'IA ne représente que la moitié du travail. Les entreprises doivent également comprendre pourquoi un modèle prend une certaine décision. Lorsqu'elles privilégient la transparence et l'explicabilité, les équipes de développement peuvent mettre au point des systèmes d'IA aussi techniquement avancés que sûrs, équitables et conformes aux valeurs​et aux besoins des utilisateurs. 

Si les fonctions de base de PyTorch, telles que le graphe de calcul dynamique et le moteur autograd, suivent le flux mathématique des données étape par étape, elles ne sont toutefois pas lisibles par un humain. Afin de combler cette lacune, PyTorch propose une bibliothèque spécifique d'IA explicable, appelée Captum. Cette bibliothèque utilise les données issues du moteur autograd pour calculer les entrées ayant eu la plus grande influence mathématique sur le résultat final, ce qui aide les équipes de développement à pénétrer dans la boîte noire des modèles d'IA. 

Ce niveau de transparence apporte de nombreux avantages :

Accélération de la résolution des problèmes : quand les data scientists sont capables de comprendre la logique d'un modèle lors de la génération d'un résultat, les étapes de développement, de débogage et de prise de décision sont plus simples et rapides.

Renforcement de la conformité réglementaire : l'IA explicable peut aider les entreprises à respecter les réglementations et les lois sur la confidentialité.

Consolidation de la confiance : pour mettre en œuvre des technologies telles que l'IA agentique, il faut un lien de confiance entre les algorithmes et les utilisateurs.

Mise en œuvre de l'IA souveraine : l'IA souveraine désigne le droit pour une entreprise de contrôler ses systèmes d'IA. Ce concept nécessite une visibilité complète sur la manière dont un modèle traite les données et génère des informations utiles. 

Lire un article de blog sur l'architecture d'IA souveraine et la mise à l'échelle de l'entraînement distribué

PyTorch peut s'installer et s'exécuter tant sur des systèmes locaux que sur des plateformes cloud. Il suffit d'installer d'abord Python. Les équipes qui ont l'habitude de coder dans Python devraient trouver PyTorch assez intuitif, même si elles prennent tout juste l'outil en main. 

PyTorch est également accessible depuis des environnements cloud basés sur un navigateur, tels que Google Colab, pour lesquels PyTorch et l'accès à un GPU sont préinstallés. Les utilisateurs remarqueront vite que l'écosystème PyTorch comprend de nombreux outils courants, par exemple :

• Hugging Face : plateforme où les équipes de développement peuvent télécharger des modèles PyTorch préentraînés plutôt que d'en assembler à partir de zéro.
• PyTorch Lightning : « wrapper » de haut niveau pour PyTorch qui masque le code technique complexe pour fluidifier l'expérience de développement.
• ONNX (Open Neural Network Exchange) : écosystème qui permet de convertir les modèles PyTorch en un modèle standardisé pour faciliter leur lecture et leur exécution sur différents systèmes logiciels ou différentes puces matérielles, sans avoir besoin de réécrire le code. 

Parcourir les tutoriels officiels de PyTorch → 

Docker s'apparente à un conteneur d'expédition numérique qui stocke un instantané de l'environnement d'un ordinateur. L'utilisation d'un workflow basé sur Docker avec PyTorch vise à partager le code entre plusieurs machines, tout en évitant les erreurs de configuration et les pannes du système.

L'intégration du code PyTorch dans un fichier d'image Docker permet de mettre en paquet tous les éléments nécessaires à l'exécution de ce code dans un conteneur qui reste isolé du reste de la machine. Lorsque ce conteneur est envoyé à un collègue ou à un serveur cloud, il se télécharge et s'exécute avec toutes les configurations nécessaires.

Les créateurs et les membres de la communauté PyTorch mettent à disposition des images Docker officielles et préconçues. Ce système simplifie le développement et le déploiement, puisque les utilisateurs peuvent télécharger l'image Docker de PyTorch sans installer PyTorch sur leur ordinateur. 

La mise à l'échelle d'un modèle PyTorch pour des millions d'utilisateurs nécessite un parc de serveurs capable de gérer cette charge de travail. Une fois que le modèle PyTorch est conteneurisé dans une image Docker avec tous les éléments essentiels à son exécution, Kubernetes aide à déplacer ce conteneur dans l'environnement adapté. L'exécution des charges de travail d'IA sur Kubernetes offre plusieurs avantages :

Automatisation de l'orchestration des ressources : les modèles PyTorch ont besoin d'un grand nombre de ressources de calcul pour fonctionner, notamment des GPU, des processeurs, de la mémoire et de la bande passante réseau. Kubernetes contribue à assurer le bon fonctionnement des modèles PyTorch en suivant la disponibilité des ressources sur les différents serveurs et en ordonnançant les charges de travail en conséquence. En cas de panne d'un serveur, Kubernetes est capable de détecter l'erreur instantanément et de rediriger le trafic de données sans intervention humaine. 

Évolutivité : les charges de travail d'IA sont imprévisibles. Si un modèle connaît soudainement un pic de trafic, Kubernetes s'adapte en créant des copies du conteneur Docker sur plusieurs serveurs afin de maîtriser la situation. Lorsque le trafic est faible, Kubernetes ramène la quantité de ressources au niveau initial pour faire des économies.

Prise en charge de l'entraînement distribué : lorsqu'un modèle d'IA est trop volumineux pour être entraîné sur un seul ordinateur, les équipes de développement peuvent utiliser des conteneurs pour mettre à l'échelle la charge de travail sur plusieurs machines. L'utilisation de conteneurs Docker et d'une architecture cloud permet à PyTorch de distribuer le traitement mathématique intensif entre les GPU interconnectés d'un cluster.

Ensuite, Kubernetes gère la mise en réseau entre les conteneurs Docker pour les laisser communiquer entre eux, synchroniser leurs tenseurs et effectuer des calculs comme un seul et même « cerveau » unifié. Ce traitement parallèle permet de réduire la durée totale de l'entraînement.

Exécuter un entraînement d'IA distribué sur Red Hat OpenShift

La gamme Red Hat® AI offre des fonctionnalités d'inférence rapides, flexibles et efficaces au moyen d'un serveur basé sur vLLM. Elle relie de manière fiable les modèles aux données pour unifier la personnalisation et le développement d'agents spécialisés sur une seule et même plateforme. Conçus sur une base Open Source, nos produits donnent un contrôle total sur les workflows d'IA, de bout en bout et à toutes les échelles. 

La gamme Red Hat AI inclut Red Hat AI Enterprise, une plateforme qui permet de déployer, gérer et mettre à l'échelle des opérations d'inférence d'IA, des workflows d'IA agentique et des applications basées sur l'IA dans tous types d'infrastructures.

Découvrir Red Hat AI