How to make the most out of PyTorch

PyTorch est une bibliothèque open source développée par Facebook qui permet de réaliser des calculs tensoriels sur des GPUs de manière efficace, ce qui en fait un outil idéal pour l’apprentissage profond. PyTorch est considéré comme l’une des bibliothèques les plus populaires pour l’apprentissage profond en raison de sa facilité d’utilisation, sa flexibilité et sa rapidité.

Dans ce tutoriel, nous allons vous montrer comment utiliser PyTorch de manière efficace pour vos projets d’apprentissage profond.

Installation de PyTorch : Pour commencer, vous devez installer PyTorch sur votre machine. Pour ce faire, vous pouvez utiliser pip en exécutant la commande suivante :

pip install torch torchvision

Vous pouvez également visiter le site officiel de PyTorch pour des instructions d’installation plus détaillées en fonction de votre configuration.

Importation de PyTorch : Une fois que vous avez installé PyTorch, vous pouvez l’importer dans votre script Python en utilisant la commande suivante :

import torch

Création de tenseurs : Les tenseurs sont les structures de données de base utilisées dans PyTorch pour représenter les données. Vous pouvez créer des tenseurs en utilisant la classe torch.Tensor. Voici comment vous pouvez créer un tenseur avec des valeurs aléatoires :

# Créer un tenseur de taille 3x3 rempli de valeurs aléatoires
tensor = torch.rand(3, 3)
print(tensor)

Ce code créera un tenseur 3×3 rempli de valeurs aléatoires entre 0 et 1.

Opérations sur les tenseurs : Vous pouvez effectuer des opérations mathématiques courantes sur les tenseurs tels que l’addition, la soustraction, la multiplication et la division. Par exemple, voici comment vous pouvez faire une addition de deux tenseurs :

# Créer deux tenseurs
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6], [7, 8]])

# Addition de deux tenseurs
result = tensor1 + tensor2
print(result)

Ce code ajoutera deux tenseurs de taille 2×2 et affichera le résultat.

Définition d’un modèle : PyTorch facilite la définition de modèles d’apprentissage profond en utilisant des classes héritées de torch.nn.Module. Voici un exemple d’une simple architecture de réseau de neurones à deux couches :

import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = nn.ReLU()(x)
        x = self.fc2(x)
        return x

Ce code définit un réseau de neurones à deux couches avec une couche d’entrée de taille 784, une couche cachée de taille 128 et une couche de sortie de taille 10.

Entraînement du modèle : Une fois que vous avez défini votre modèle, vous pouvez l’entraîner en utilisant des données réelles. Voici un exemple de code qui utilise une boucle d’entraînement simple pour entraîner un modèle sur un jeu de données MNIST :

import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# Créer un chargeur de données
train_data = datasets.MNIST(root='data/', train=True, download=True, transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True)

# Définir le modèle et un optimiseur
model = SimpleNN()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Boucle d'entraînement
for epoch in range(10):
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data.view(-1, 784))
        loss = nn.CrossEntropyLoss()(output, target)
        loss.backward()
        optimizer.step()

        if batch_idx % 100 == 0:
            print('Époque {}: Iteration {}: Loss: {}'.format(epoch, batch_idx, loss.item()))

Ce code utilise le jeu de données MNIST pour entraîner le modèle défini précédemment pendant 10 époques en utilisant la descente de gradient stochastique (SGD) comme optimiseur.

Évaluation du modèle : Une fois que vous avez entraîné votre modèle, vous pouvez l’évaluer en utilisant des données de test. Voici un exemple de code qui évalue la performance du modèle sur le jeu de données de test MNIST :

test_data = datasets.MNIST(root='data/', train=False, download=True, transform=transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(test_data, batch_size=32, shuffle=False)

model.eval()
correct = 0
total = 0
with torch.no_grad():
    for data, target in test_loader:
        output = model(data.view(-1, 784))
        _, predicted = torch.max(output, 1)
        total += target.size(0)
        correct += (predicted == target).sum().item()

print('Précision du modèle sur le jeu de données de test: {}%'.format(100 * correct / total))

Ce code évalue la performance du modèle entraîné sur le jeu de données de test MNIST en calculant la précision du modèle.

Conclusion : Dans ce tutoriel, nous avons couvert les bases de l’utilisation de PyTorch pour l’apprentissage profond, y compris la création de tenseurs, la définition de modèles, l’entraînement de modèles et l’évaluation de la performance. PyTorch offre une grande flexibilité et une facilité d’utilisation qui en fait un outil puissant pour l’apprentissage profond. Nous espérons que ce tutoriel vous a été utile pour commencer à utiliser PyTorch dans vos projets d’apprentissage profond.