Deep LearningIntermédiaire4 min de lecture · 41 vues

Deep Learning Pratique avec PyTorch

Construisez vos premiers réseaux de neurones avec PyTorch : CNN pour les images, entraînement sur GPU et transfer learning.

Par Alex Perey

Pourquoi PyTorch ?

PyTorch est le framework dominant en recherche et de plus en plus en production. Développé par Meta, il est utilisé par OpenAI, Tesla, et la majorité des labos de recherche.

PyTorch vs les Autres

Critère	PyTorch	TensorFlow	JAX
Facilité	Très intuitif	Plus verbeux	Fonctionnel
Debug	Comme du Python normal	Plus complexe	Difficile
Recherche	Standard	En déclin	En montée
Production	TorchServe, ONNX	TF Serving	Encore jeune

Tenseurs : La Brique de Base

Un tenseur, c'est un tableau multidimensionnel optimisé pour le GPU. Pensez-y comme un numpy array, mais qui tourne sur carte graphique.

import torch

# Créer un tenseur
x = torch.tensor([1.0, 2.0, 3.0])

# Opérations classiques
y = x * 2 + 1
print(y)  # tensor([3., 5., 7.])

# Vérifier si GPU disponible
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Device : {device}")

# Envoyer sur GPU
x_gpu = x.to(device)

Sur Google Colab (gratuit), vous pouvez activer un GPU via Runtime → Change runtime type → GPU.

Construire un Réseau de Neurones

En PyTorch, un réseau se définit comme une classe Python avec deux méthodes : __init__ (architecture) et forward (calcul).

Architecture d'un Réseau Simple

import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(784, 128),   # 784 pixels → 128 neurones
            nn.ReLU(),             # Activation non-linéaire
            nn.Dropout(0.2),       # Régularisation (évite l'overfitting)
            nn.Linear(128, 64),    # 128 → 64 neurones
            nn.ReLU(),
            nn.Linear(64, 10),     # 64 → 10 classes (chiffres 0-9)
        )

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

model = SimpleNet()
print(f"Paramètres : {sum(p.numel() for p in model.parameters()):,}")

La Boucle d'Entraînement

C'est le cœur de PyTorch. Contrairement à scikit-learn (un seul .fit()), ici on contrôle chaque étape.

import torch.optim as optim

# Configuration
criterion = nn.CrossEntropyLoss()    # Fonction de perte
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Boucle d'entraînement (simplifié)
for epoch in range(10):
    for batch_X, batch_y in dataloader:
        # 1. Forward : calculer les prédictions
        predictions = model(batch_X)

        # 2. Calculer l'erreur
        loss = criterion(predictions, batch_y)

        # 3. Backward : calculer les gradients
        optimizer.zero_grad()
        loss.backward()

        # 4. Mettre à jour les poids
        optimizer.step()

    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

N'oubliez jamais optimizer.zero_grad() avant loss.backward(). Sinon les gradients s'accumulent et le modèle diverge.

CNN : Réseaux pour les Images

Les Convolutional Neural Networks (CNN) sont spécialement conçus pour traiter des images. Ils détectent automatiquement les contours, textures et formes.

Comment Fonctionne une Convolution

Un filtre (petit carré de poids) glisse sur l'image et détecte des motifs locaux :

Couche 1 : détecte les contours (lignes, bords)
Couche 2 : combine les contours en textures (fourrure, écailles)
Couche 3 : combine les textures en parties (œil, patte, roue)

🛠️ Micro-Exercice : Classificateur d'Images CIFAR-10

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms

# 1. Charger CIFAR-10 (10 classes : avion, auto, oiseau, etc.)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(
    root="./data", train=True, download=True, transform=transform
)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32)

# 2. Définir un CNN simple
class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv_layers = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1),  # 3 canaux RGB → 32 filtres
            nn.ReLU(),
            nn.MaxPool2d(2),                 # Réduit la taille par 2
            nn.Conv2d(32, 64, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.fc_layers = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 8 * 8, 128),
            nn.ReLU(),
            nn.Linear(128, 10),
        )

    def forward(self, x):
        x = self.conv_layers(x)
        return self.fc_layers(x)

model = SimpleCNN()
print(f"Paramètres CNN : {sum(p.numel() for p in model.parameters()):,}")

Transfer Learning : Ne Pas Repartir de Zéro

Entraîner un CNN de zéro demande des millions d'images. Le transfer learning utilise un modèle déjà entraîné (sur ImageNet par exemple) et l'adapte à votre problème.

Le Principe

Prendre un modèle pré-entraîné (ResNet, EfficientNet)
Geler ses couches (ne pas modifier les poids appris)
Remplacer la dernière couche par la vôtre
Entraîner uniquement cette nouvelle couche

from torchvision import models

# Charger ResNet18 pré-entraîné
model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)

# Geler tous les paramètres
for param in model.parameters():
    param.requires_grad = False

# Remplacer la dernière couche (1000 classes ImageNet → 2 classes)
model.fc = nn.Linear(model.fc.in_features, 2)

# Seule model.fc sera entraînée
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
total = sum(p.numel() for p in model.parameters())
print(f"Paramètres entraînables : {trainable:,} / {total:,}")

Avec le transfer learning, vous pouvez obtenir d'excellents résultats avec seulement quelques centaines d'images au lieu de millions.

À propos de l'auteur

Alex Perey

Diplômé d'un master en intelligence artificielle, je travaille au quotidien sur des projets IA en entreprise. J'ai créé IwanttolearnAI pour rendre l'apprentissage de l'IA accessible à tous, gratuitement.

GitHub·En savoir plus

Retour à Deep Learning

Continuer à apprendre

Deep LearningIntermédiaire

RNN et LSTM : Modéliser les Séquences

Maîtrisez les réseaux récurrents : pourquoi les RNN oublient, comment les LSTM résolvent le vanishing gradient avec leurs 3 portes, et quand les utiliser face aux Transformers.

22 min de lecture · 65 vues

Deep LearningAvancé

Diffusion Models : l'Architecture de Stable Diffusion

Plongez dans l'architecture des modèles de diffusion : forward process, U-Net débruiteur, guidance CLIP et Latent Diffusion. Comprenez ce qui propulse Stable Diffusion, SDXL et Flux.

25 min de lecture · 33 vues

Deep LearningAvancé

Reinforcement Learning : Apprendre par l'Erreur

Maîtrisez le reinforcement learning : paradigme Agent/Environment, Q-Learning, DQN sur CartPole, PPO et le lien avec RLHF pour l'alignement des LLMs.

25 min de lecture · 32 vues