Python est un langage de programmation général de haut niveau largement utilisé dans la science des données, ce qui en fait un choix intuitif pour les data scientists qui souhaitent approfondir leur travail en modélisant activement des réseaux d'apprentissage profond. La simplicité intrinsèque de Python en fait un langage facile à lire, dont l'apprentissage est relativement rapide et qui peut fonctionner sur n'importe quel système d'exploitation, y compris Windows, macOS, Linux ou Unix. Python est le deuxième langage de programmation le plus utilisé sur GitHub depuis plus de trois ans, ayant même dépassé Java en 2019. Il continue de gagner en popularité, avec une augmentation de 22,5 % en 2022¹.

Cette flexibilité et cette simplicité ont contribué à l'émergence d'une solide communauté en ligne de développeurs Python, qui collaborent à la création d'un large éventail de bibliothèques et d'API Python, telles que Numerical Python (NumPy) pour les opérations mathématiques, Pandas pour la manipulation de données ou matplotlib pour la visualisation des données et de ressources éducatives. Cette communauté a également généré un grand nombre de bibliothèques Pytorch qui limitent la monotonie et l'incertitude du codage pour le machine learning, permettant ainsi aux développeurs et aux data scientists de se concentrer sur l'innovation plutôt que sur l'écriture de tâches répétitives.

Dans tout algorithme de machine learning, même ceux appliqués à des informations apparemment non numériques telles que des sons ou des images, les données doivent être représentées numériquement. Dans PyTorch, cela est possible grâce aux tenseurs, qui sont les unités de données fondamentales utilisées pour les calculs sur la plateforme.

Dans un contexte de machine learning, un tenseur est un tableau multidimensionnel de nombres qui fonctionne comme un système de comptabilité mathématique. D'un point de vue linguistique, le terme « tenseur » est un terme générique qui englobe certaines entités mathématiques plus familières :

• Un scalaire est un tenseur à zéro dimension, contenant un seul nombre.
• Un vecteur est un tenseur unidimensionnel, contenant plusieurs scalaires du même type. Un tuple est un tenseur unidimensionnel contenant différents types de données.
• Une matrice est un tenseur bidimensionnel, contenant plusieurs vecteurs du même type.
• Les tenseurs à trois dimensions ou plus, comme les tenseurs tridimensionnels utilisés pour représenter les images RVB dans les algorithmes de vision par ordinateur, sont collectivement appelés tenseurs à N dimensions.

Les tenseurs PyTorch fonctionnent de manière similaire aux ndarrays utilisés dans NumPy, mais contrairement aux ndarrays, qui ne peuvent être exécutés que sur des unités centrales de traitement (CPU), les tenseurs peuvent également être exécutés sur des unités de traitement graphique (GPU). Les GPU offrent une vitesse de calcul nettement supérieure à celle des CPU, ce qui constitue un avantage majeur compte tenu des volumes massifs de données et du traitement parallèle propres à l'apprentissage profond.

En plus d'encoder les entrées et les sorties d'un modèle, les tenseurs PyTorch encodent également les paramètres du modèle : les poids, les biais et les gradients qui sont « appris » dans le cadre du machine learning. Cette propriété des tenseurs permet la différenciation automatique, qui est l'une des fonctionnalités les plus importantes de PyTorch.

PyTorch utilise des modules comme éléments constitutifs des modèles d'apprentissage profond, ce qui permet la création rapide et directe de réseaux neuronaux sans avoir à coder manuellement chaque algorithme, ce qui est fastidieux.

Les modules peuvent contenir d'autres modules imbriqués, et c'est souvent le cas. En plus de permettre la création de réseaux neuronaux multicouches plus élaborés, cela permet également à ces modèles d'apprentissage profond complexes d'être facilement sauvegardés en tant que module nommé unique et transférés entre différentes machines, CPU ou GPU. Les modèles PyTorch peuvent même être exécutés dans des environnements non-Python, comme C++, via Torchscript (lien externe à ibm.com), ce qui permet de faire le lien entre les prototypes de recherche et le déploiement de la production.

De manière générale, il existe trois catégories principales de modules utilisés pour créer et optimiser des modèles d'apprentissage profond dans PyTorch :

• Les modules nn sont déployés en tant que couches des réseaux neuronaux. Le package torch.nn contient une grande bibliothèque de modules qui effectuent des opérations courantes comme les convolutions, le pooling et la régression. Par exemple, torch.nn.Linear(n,m) lance un algorithme de régression linéaire avec n entrées et m sorties (dont les entrées et paramètres initiaux sont ensuite établis dans les lignes de code suivantes).

• Le module autograd offre un moyen simple de calculer automatiquement les gradients, utilisés pour optimiser les paramètres du modèle via la descente de gradient, pour toute fonction opérée au sein des réseaux neuronaux. L'ajout d'un tenseur avec requires_grad=True indique à autograd que chaque opération sur ce tenseur doit être suivie, ce qui permet une différenciation automatique.

• Les modules Optim appliquent des algorithmes d'optimisation à ces gradients. Torch.optim fournit des modules pour diverses méthodes d'optimisation, comme la descente de gradient stochastique (SGD) ou la propagation de la moyenne quadratique (RMSprop), afin de répondre à des besoins d'optimisation spécifiques.

Les graphiques de calcul dynamique (DCG) sont la manière dont les modèles d'apprentissage profond sont représentés dans PyTorch. En résumé, les graphiques de calcul représentent le flux de données entre les différentes opérations d'un système mathématique : dans le contexte de l'apprentissage profond, ils traduisent essentiellement le code des réseaux neuronaux en un organigramme indiquant les opérations effectuées à chaque nœud et les dépendances entre les différentes couches du réseau. Il s'agit de l'agencement des étapes et des séquences qui transforment les données d'entrée en données de sortie.

Ce qui différencie les graphiques de calcul dynamiques (comme ceux utilisés dans PyTorch) des graphiques de calcul statiques (comme ceux utilisés dans TensorFlow), c'est que les DCG reportent la spécification exacte des calculs et des relations entre eux jusqu'au moment de l'exécution. En d'autres termes, alors qu'un graphique de calcul statique exige que l'architecture de l'ensemble du réseau neuronal soit entièrement déterminée et compilée pour pouvoir fonctionner, les DCG peuvent être itérés et modifiés à la volée.

Cela rend les DCG particulièrement utiles pour le débogage et le prototypage, car des parties spécifiques du code d'un modèle peuvent être modifiées ou exécutées de manière isolée sans avoir à réinitialiser l'ensemble du modèle. Pour les modèles d'apprentissage profond de très grande taille utilisés pour les tâches sophistiquées de vision par ordinateur et de NLP, cela pourrait représenter une perte de temps et de ressources informatiques. Les avantages de cette flexibilité s'étendent à l'entraînement des modèles, car les graphiques de calcul dynamiques sont facilement générés à rebours pendant la rétropropagation.

Alors que leur structure fixe peut permettre une plus grande efficacité de calcul, les graphiques de calcul statiques ont une flexibilité limitée : par exemple, élaborer un modèle qui utilise un nombre variable de couches en fonction des données d'entrée, tel qu'un réseau neuronal convolutionnel (CNN) qui peut traiter des images de différentes tailles, est une tâche extrêmement difficile avec des graphiques statiques.

La rétropropagation est une méthode largement utilisée pour former les réseaux neuronaux, en particulier dans le cadre de l'apprentissage supervisé. Tout d'abord, un modèle est alimenté par des entrées (x) et prédit des sorties (y). En travaillant à rebours à partir de cette sortie, une fonction de perte est utilisée pour évaluer le taux d'erreur des prédictions du modèle pour différentes valeurs de x. En différenciant cette fonction de perte pour trouver sa dérivée, la descente de gradient peut être utilisée pour ajuster les poids dans le réseau neuronal, une couche à la fois.

Le module autograd de PyTorch utilise sa technique de différenciation automatique à l'aide d'une formule de calcul appelée règle de la chaîne, calculant les dérivées complexes en les divisant en dérivées plus simples et en les regroupant par la suite. Autograd calcule et enregistre automatiquement les gradients pour toutes les opérations exécutées dans un graphique de calcul, ce qui réduit considérablement le travail de rétropropagation.

Lors de l'exécution d'un modèle qui a déjà été entraîné, autograd devient une utilisation inutile des ressources informatiques. L'ajout d'une opération de tenseur avec requires_grad=False signalera à PyTorch de cesser de suivre les gradients.

Travailler avec les grands ensembles de données nécessaires pour entraîner les modèles d'apprentissage profond peut être complexe et exigeant en termes de calcul. PyTorch fournit deux primitives de données, les jeux de données et les dataloaders, pour faciliter le chargement des données et rendre le code plus facilement lisible.

• torch.utils.data.Dataset stocke les échantillons de données et leurs étiquettes correspondantes
• torch.Utils.Data.DataLoader insère un itérable (un objet sur lequel on peut opérer) autour de l'ensemble des jeux de données pour permettre un accès facile aux échantillons