Comment utiliser PyTorch ? Le guide complet

Vous voulez vous mettre au deep learning en Python ? Découvrez comment commencer à faire de l’apprentissage machine gratuitement avec PyTorch !

Pour commencer à utiliser PyTorch, il faut l’installer localement sur une machine, ou accéder depuis un service Cloud comme ceux de Google Cloud, Microsoft Azure ou AWS. Il faudra ensuite préparer des données, définir le modèle, entraîner le modèle, évaluer le modèle et faire des predictions.

Dans cet article, nous verrons :

• Ce qu’est PyTorch
• Comment l’installer
• Comment créer votre premier réseau neuronal

Partons sans plus tarder à la découverte de PyTorch

À quoi sert PyTorch ?

PyTorch est un framework pour créer des modèles de deep learning. Le deep learning est un type d’apprentissage machine qui est utilisé pour des applications de reconnaissance d’images ou de traitement automatique du langage. PyTorch est facile à apprendre et utiliser comme il est écrit en Python.

C’est la version Python du framework Torch qui était écrit en Lua (et C et C++) de base. PyTorch a remplacé Torch en 2017.

Pourquoi utiliser PyTorch ?

On utilise PyTorch et le Deep Learning plutôt que la programmation traditionnelle :

• quand on est confrontés à des problèmes avec une liste de règles qui reste la meme et quand l’approche traditionnelle ne fonctionne pas
• quand l’environnement change continuellement
• pour tirer des conclusions à partir d’une large collection de données

Si vous n’avez pas besoin de Deep Learning, ne l’utilisez pas. Une approche conventionnelle sera probablement plus adaptée.

PyTorch sera probablement un mauvais choix si vous n’avez pas beaucoup de données ou que vous ne pouvez pas vous permettre d’avoir des erreurs.

Comment accéder à PyTorch dans le Cloud ?

Avant de voir comment installer PyTorch sur votre machine, je vous propose de l’essayer gratuitement dans le cloud sur les 3 plateformes dominantes du marché (AWS, Google Cloud et Azure).

Lancer PyTorch dans le Cloud permet d’avoir des performances élevées sans devoir installer quoi que ce soit localement. En plus, les VM et conteneurs utilisés pour PyTorch sont optimisés pour l’apprentissage machine.

Vous trouverez ci-dessous des tutoriels et des essais gratuits pour différents services dans le cloud.

🧠 Si vous ne savez pas lequel prendre, je vous conseille de suivre les étapes ci-dessous pour commencer à utiliser PyTorch avec Google Colab, car vous avez déjà sûrement un compte Google et qu’ils proposent de commencer gratuitement en quelques clics.

Accéder à PyTorch sur Google Colab

Vous pouvez accéder gratuitement à PyTorch dans le Cloud en vous rendant sur le site officiel de Google Colab.

1. Se connecter sur Google Colab

Connectez-vous si besoin et puis créez un nouveau projet en cliquant sur le bouton “New notebook”.

Et voilà, vous avez accès à PyTorch 🎉 !

Si vous avez la moindre erreur ou que vous voulez être sûr d’utiliser la dernière version de PyTorch, vous pouvez verifier la version de vos modules Python avec la commande :

!pip list

2. Mettre à jour PyTorch

Si vous n’avez pas une version récente ou que vous voulez une version spécifique de PyTorch. Vous pouvez réinstaller les modules à la dernière version avec la commande suivante :

!pip3 uninstall --yes torch torchaudio torchvision torchtext torchdata
!pip3 install torch torchaudio torchvision torchtext torchdata

3. Vérifier que PyTorch est installé correctement

Vous pouvez enfin vérifier que PyTorch fonctionne en tapant :

import torch
print(torch.__version__)

4. Créer votre premier modèle PyTorch sur Google Colab

L’avantage de Google Colab est que vous pouvez importer des datasets depuis Google Drive directement avec la fonction drive de google.colab :

from google.colab import drive
drive.mount('/content/drive')

Suivez les étapes et vous pourrez ensuite ouvrir les fichiers qui sont sur votre Google Drive comme vous le feriez localement sur votre machine :

with open('/content/drive/My Drive/ficher_de_test.txt', 'w') as f:
  f.write('Test Google Drive')

On peut ensuite cat le contenu de notre nouveau fichier :

!cat /content/drive/My\ Drive/ficher_de_test.txt

Ce qui affichera : "Test Google Drive".

Ça veut dire que vous pouvez importer des datasets sur Google Drive et commencer à construire votre modèle avec.

Accéder à PyTorch sur Google Cloud

Si vous préférez utiliser un autre service Cloud de Google, vous pouvez commencer facilement avec un des liens ci-dessous :

• Deep Learning VM : Créer une instance Deep Learning VM PyTorch
• Conteneurs de deep learning

Accéder à PyTorch sur AWS

Sur AWS, vous pourrez avoir accès à PyTorch en suivant une de ces pages :

• PyTorch sur AWS
• PyTorch SageMaker
• AWS Deep Learning Containers
• AWS Deep Learning AMIs

Vous voulez en apprendre plus sur AWS ? Alors mon article sur les Amazon Web Services vous intéressera sûrement !

Accéder à PyTorch sur Microsoft Azure

Pareil pour Microsoft Azure :

• PyTorch sur Azure
• Azure Machine Learning : Entraîner des modèles PyTorch à grande échelle avec Azure Machine Learning
• Azure Functions : Tutoriel : Déployer un modèle de classification d’image pré-entraîné sur Azure Functions avec PyTorch

Comment installer PyTorch ?

Pour installer PyTorch, on va avoir besoin de Python et pip ou Anaconda. PyTorch est un module Python qui s’installe comme les autres, je vous explique comment l’obtenir.

Comment installer PyTorch avec pip ?

Pour installer PyTorch avec pip, on utilise la commande pip install.

pip install torch torchvision

🐍 Si vous n’avez pas pip, vous n’avez probablement pas Python. J’ai écrit un article pour vous aider à installer Python sur votre machine.

Comment installer PyTorch avec Anaconda ?

Pour installer PyTorch avec Anaconda, on utilise la commande conda install.

conda install pytorch torchvision -c pytorch

Si vous n’avez pas conda, vous pouvez l’installer en téléchargeant l’installateur directement sur le site officiel d’Anaconda.

Ou bien en ligne de commande :

• sur les nouveaux Mac qui ont un processeur Apple Silicon (M1, M2, …)

curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh
sh Miniconda3-latest-MacOSX-arm64.sh

• sur les autres Mac (Intel) :

curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
sh Miniconda3-latest-MacOSX-x86_64.sh

• sur Linux :

curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
sh Miniconda3-latest-Linux-x86_64.sh

Comment vérifier si j’ai PyTorch ?

Pour verifier si vous avez bien PyTorch d’installer sur votre machine, vous pouvez lancer Python (en tapant python dans le terminal) et taper les lignes suivantes :

import torch
x = torch.rand(4, 2)
print(x)

Vous devriez voir une matrice du style :

tensor([[0.6085, 0.8563],
        [0.3631, 0.4141],
        [0.3685, 0.3265],
        [0.3324, 0.0082]])

💥 Si vous avez une erreur, vérifiez que vous avez bien Python d’installé et que vous êtes dans l’environnement dans lequel vous avez installé PyTorch.

Vous pouvez aussi installer PyTorch depuis le code source disponible sur son repo github.

Qu’est-ce que CUDA ?

CUDA (Compute Unified Device Architecture) est une technologie qui permet d’utiliser les cartes graphiques (GPU) pour executer des calculs plutôt que le processeur (CPU).

Avec PyTorch, vous pourrez utiliser CUDA si vous avez une carte graphique et ça permettra d’executer votre code plus rapidement.

Pour ça, vous devrez donner la valeur cuda au paramètre “device”.

cuda = torch.device('cuda')

x = torch.tensor([1, 2, 3], device=cuda)

CUDA n’est disponible que pour Linux et Windows.

PyTorch Lightning

PyTorch Lightning est un framework open-source de haut niveau basé sur PyTorch qui a pour but de simplifier l’entraînement et le déploiement de modèles en proposant une interface plus intuitive.

PyTorch Lightning permet donc de mieux structurer son code et éviter les erreurs humaines pendant le développement de modèles en abstrayant la difficulté de PyTorch.

Vous pouvez installer PyTorch Lightning en passant par leur site officiel lightning.ai, ou bien en l’installant vous même dans votre environnement.

Vous pouvez aussi l’installer avec `pip“ :

pip install lightning

Ou avec conda :

conda install lightning -c conda-forge

Qu’est ce qu’un tensor ?

Un tensor (tenseur en français) est un tableau à un nombre de dimensions indéfini qui contient une représentation numérique des données. C’est la principale structure de données pour représenter des données et effectuer des opérations dans les modèles de deep learning.

Les différents types sont :

• scalaire : un tensor à 0 dimensions, c’est un nombre réel ou complexe
• vecteur : un tableau à 1 dimension
• matrice : un tableau à 2 dimensions
• tenseur : nombre quelconque de dimensions

Avec PyTorch, on peut définir un tensor avec la fonction torch.tensor(...).

Exemple d’utilisation de PyTorch

Voyons un exemple de régression linéaire en utilisant PyTorch.

Une régression linéaire permet de créer une ligne droite à partir d’ensemble de points issus de données.

Ce qui permettra ensuite de :

• Modéliser la relation entre les données d’entrée et de sortie
• Apprendre des paramètres pour optimiser la droite de prédiction
• Prédire et analyser de nouveaux résultats grâce à ce qu’il sait déjà

Concrètement, ce genre d’entraînement de données pourrait, par exemple, permettre de :

• prédire le prix de l’immobilier en fonction de critères (données d’entrée) pour attribuer la valeur du bien
• prédire la consommation d’énergie en utilisant la température extérieure, du jour de la semaine, etc
• trouver des relations dans le secteur médical avec le poids, l’age, le mode de vie ou le sexe du patient
• analyser les performances des étudiants en prenant leur taux de frequentation des cours ou leur temps d’étude

1. Importer les modules

La première étape pour notre code est d’importer les bons modules (bibliothèques) Python.

• torch est le module PyTorch
• nn veut dire “Neural Network” ou “Réseau Neuronal” en français
• optim est un “optimisateur”
• numpy pour les calculs sur matrice
• matplotlib va nous permettre d’afficher un graphique visuel

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

2. Préparer les données

Nous générons des données d’exemple sous forme de matrices NumPy : X pour les données d’entrée et y pour les valeurs de sortie (cibles). Nous convertissons ces données en tenseurs PyTorch (X_tensor et y_tensor) pour être utilisées dans notre modèle.

On crée un matrice numpy avec les données d’entrée (X) et les données de sortie (y).

💡 En machine learning, on utilises les symbole X et y pour représenter les entrées (X) et la cible (y) 🎯.

X_tensor et y_tensor sont les tensors PyTorch crées à partir de notre dataset généré par numpy.

np.random.seed(0)
X = np.random.rand(100, 1)
y = 2 * X + 1 + 0.1 * np.random.rand(100, 1)

X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32)

3. Définir le modèle

On définit une classe LinearRegressionModel qui hérite de la classe nn.Module qui est la classe pour créer des modèles PyTorch.

On utilise ensuite nn.Linear pour définir “une couche linéaire”. Ici, on n’a qu’une entrée (X, une valeur générée aléatoirement avec np.random.rand) et on ne veut qu’une valeur de sortie y. On parle de “régression linéaire simple”.

On a une méthode de propagation avant forward permet de représenter les données d’entrée en leur attribuant une valeur numérique pour les utiliser dans le réseau neuronal.

class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        return self.linear(x)

model = LinearRegressionModel()

4. Définir la fonction de perte et l’Optimiseur

On définit la fonction de perte (perte quadratique moyenne) c’est la différence entre nos prédictions et la valeur de sortie réelle mise au carré.

• MSE = “Mean Squared Error” ou “Erreur Quadratique Moyenne”

L’optimisateur permet, comme son nom le laisse entendre, d’optimiser les résultats de notre modèle en apprenant de ses erreurs avec le temps.

• SGD = “Stochastic Gradient Descent” ou “Descente de Gradient Stochastique”

criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

5. Entraîner le modèle

Nous calculons la perte (l’erreur) entre les prédictions et les valeurs réelles en utilisant la fonction de perte définie précédemment. Ensuite, nous effectuons une rétropropagation (backward pass) pour calculer les gradients par rapport aux poids du modèle et ajuster ces poids avec l’optimiseur. Nous affichons la perte à intervalles réguliers pour suivre la progression de l’entraînement.

On définit 1000 nombres d’epochs pour passer 1000 fois dans la boucle pour entraîner le modèle.

À chaque itération on va effectuer une propagation avant (forward pass) et utiliser les données d’entrée X_tensor pour obtenir les prédictions du modèle outputs.

On calcule aussi la perte loss entre les prédictions et les valeurs réelles.

On diminue les erreurs et optimise nos résultats en ajustant l’optimiseur avec nos prédictions en faisant une rétropropagation (backward pass).

num_epochs = 1000
for epoch in range(num_epochs):
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(f'Époque [{epoch + 1}/{num_epochs}], Perte : {loss.item():.4f}')

6. Afficher les résultats

Finalement, on affiche les résultats avec matplotlib (graphique plus bas).

predicted = model(X_tensor).detach().numpy()
plt.scatter(X, y, label='Données réelles')
plt.plot(X, predicted, label='Régression linéaire', color='red')
plt.legend()
plt.xlabel('X')
plt.ylabel('y')
plt.title('Régression linéaire avec PyTorch')
plt.show()

7. Tout mettre ensemble

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

np.random.seed(0)
X = np.random.rand(100, 1)
y = 2 * X + 1 + 0.1 * np.random.rand(100, 1)

X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32)

class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        return self.linear(x)

model = LinearRegressionModel()

criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

num_epochs = 1000
for epoch in range(num_epochs):
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(f'Époque [{epoch + 1}/{num_epochs}], Perte : {loss.item():.4f}')

predicted = model(X_tensor).detach().numpy()
plt.scatter(X, y, label='Données réelles')
plt.plot(X, predicted, label='Régression linéaire', color='red')
plt.legend()
plt.xlabel('X')
plt.ylabel('y')
plt.title('Régression linéaire avec PyTorch')
plt.show()

Voici le log de l’exécution du code ci-dessus :

Époque [100/1000], Perte : 0.1653
Époque [200/1000], Perte : 0.1005
Époque [300/1000], Perte : 0.0769
Époque [400/1000], Perte : 0.0590
Époque [500/1000], Perte : 0.0453
Époque [600/1000], Perte : 0.0348
Époque [700/1000], Perte : 0.0268
Époque [800/1000], Perte : 0.0207
Époque [900/1000], Perte : 0.0160
Époque [1000/1000], Perte : 0.0124

Et sa représentation avec matplotlib :

Aller plus loin avec PyTorch

Et voila, vous savez comment installer et utiliser PyTorch 🎉

Pour aller plus loin, vous pourrez prendre un set de données réelles et utiliser PyTorch pour créer un modèle de prédiction !

Si vous voulez en apprendre plus, je recommande ce cours PyTorch for Deep Learning in 2024: Zero to Mastery qui m’a permis de me lancer avec PyTorch. Si vous cliquez sur ce lien, je touche une petite commission si vous décidez d’acheter le cours.