Introduction

Construire son premier réseau de neurones est un moment clé dans l’apprentissage du Deep Learning. Dans ce tutoriel, nous allons créer un réseau capable de classifier des chiffres manuscrits (dataset MNIST) avec PyTorch.

Étape 1 : Préparer les données

PyTorch fournit des utilitaires pour charger et pré-traiter les données efficacement grâce à torchvision.

import torch
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_data = datasets.MNIST("data", train=True, download=True, transform=transform)
test_data = datasets.MNIST("data", train=False, transform=transform)

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000)

Étape 2 : Définir le modèle

En PyTorch, un modèle est une classe qui hérite de nn.Module. On définit les couches dans __init__ et le flux de données dans forward.

import torch.nn as nn
import torch.nn.functional as F

class MonReseau(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)
        self.dropout = nn.Dropout(0.2)

    def forward(self, x):
        x = x.view(-1, 784)  # Aplatir l'image
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = MonReseau()
print(model)  # Affiche l'architecture

Étape 3 : Entraîner le modèle

La boucle d’entraînement en PyTorch suit toujours le même schéma : forward pass, calcul de la loss, backward pass, mise à jour des poids.

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

for epoch in range(5):
    model.train()
    total_loss = 0
    for batch_x, batch_y in train_loader:
        optimizer.zero_grad()
        output = model(batch_x)
        loss = criterion(output, batch_y)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    print(f"Epoch {epoch+1}, Loss: {total_loss/len(train_loader):.4f}")

Étape 4 : Évaluer les performances

model.eval()
correct = 0
total = 0

with torch.no_grad():
    for batch_x, batch_y in test_loader:
        output = model(batch_x)
        _, predicted = torch.max(output, 1)
        total += batch_y.size(0)
        correct += (predicted == batch_y).sum().item()

print(f"Précision : {100 * correct / total:.1f}%")
# Résultat attendu : ~97-98%

Conclusion

Avec quelques dizaines de lignes de code, vous venez de construire un réseau de neurones capable de reconnaître des chiffres avec plus de 97% de précision. C’est la porte d’entrée vers des architectures plus avancées : CNN, RNN, Transformers…

Dans notre formation Deep Learning, nous allons bien plus loin : réseaux convolutifs, transfer learning, GANs et architectures avancées. Le tout avec des cas pratiques concrets.