Créer et entraîner des CNN avec PyTorch
nn.Conv2d, nn.MaxPool2d, nn.Linear, boucle d’entraînement, optimiseur, fonction de perte, suivi de la précision.
Créer et entraîner des CNN avec PyTorch est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
Pourquoi utiliser des CNN pour les images ?
Les réseaux neuronaux convolutifs apprennent les motifs spatiaux : bords, textures, puis formes et objets. Les convolutions partagent leurs poids sur toute l'image, ce qui rend les CNN efficaces et capables de prendre en compte les translations ; ils constituent l'ossature de la vision par ordinateur.
import torch
import torch.nn as nnLa classe de base nn.Module
Les modèles héritent de nn.Module. Vous définissez les couches dans __init__ et le flux des données dans forward. PyTorch suit automatiquement les paramètres et les gradients.
class CNN(nn.Module):
def __init__(self):
super().__init__()Couches de convolution
nn.Conv2d(in_channels, out_channels, kernel_size) fait glisser des filtres apprenables sur l'image pour produire des cartes de caractéristiques. La première convolution reçoit 3 canaux (RGB) et en produit davantage, qui capturent différentes caractéristiques.
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)Couches de mise en commun
nn.MaxPool2d réduit la résolution des cartes de caractéristiques en conservant le maximum dans chaque fenêtre. Cela diminue la taille spatiale, réduit les calculs et ajoute une légère invariance aux translations.
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)Couches entièrement connectées
Après les convolutions, aplatissez les caractéristiques et faites-les passer par des couches nn.Linear pour produire les scores des classes. La couche Linear finale produit une valeur par classe.
self.fc1 = nn.Linear(32 * 8 * 8, 128)
self.fc2 = nn.Linear(128, 10) # 10 classesLa méthode forward
La méthode forward définit le flux des données : convolution, ReLU, mise en commun, puis répétition de cette séquence, avant l'aplatissement et le passage dans les couches linéaires. F.relu ajoute la non-linéarité qui permet au réseau d'apprendre des motifs complexes.
import torch.nn.functional as F
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(x.size(0), -1) # flatten
x = F.relu(self.fc1(x))
return self.fc2(x)Fonction de perte et optimiseur
Pour la classification, utilisez CrossEntropyLoss. Un optimiseur tel que Adam met à jour les poids à l'aide des gradients. Transmettez-lui les paramètres du modèle et un taux d'apprentissage.
model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)Boucle d'entraînement : mise à zéro des gradients
Chaque étape commence par l'effacement des anciens gradients avec optimizer.zero_grad(). Si vous l'omettez, les gradients s'accumulent d'un lot à l'autre et faussent vos mises à jour.
for images, labels in loader:
optimizer.zero_grad()Propagation avant et fonction de perte
Faites passer le lot dans le modèle pour obtenir des prédictions, puis calculez la perte en comparant les prédictions aux vraies étiquettes. La perte est un nombre unique qui mesure l'écart entre les prédictions du modèle et la réalité.
outputs = model(images)
loss = criterion(outputs, labels)Rétropropagation et mise à jour
loss.backward() calcule les gradients via la différentiation automatique, et optimizer.step() ajuste légèrement les poids pour réduire la perte. Ensemble, ces opérations constituent une étape d'apprentissage.
loss.backward()
optimizer.step()Suivre la précision
Suivez les progrès en comptant les prédictions correctes. Prenez l'argmax des sorties pour obtenir les classes prédites, comparez-les aux étiquettes, puis divisez le nombre de réussites par le total.
preds = outputs.argmax(dim=1)
correct = (preds == labels).sum().item()
acc = correct / labels.size(0)
print("batch acc:", acc)Vérification rapide
Vérifiez vos connaissances sur la boucle d'entraînement.
Récapitulatif : construire et entraîner des CNN
Vous avez construit un CNN en créant une sous-classe de nn.Module avec des couches nn.Conv2d, nn.MaxPool2d et nn.Linear, ainsi qu'une méthode forward. Vous l'avez entraîné avec la boucle suivante : zero_grad, propagation avant, loss.backward(), optimizer.step(), puis suivi de la précision avec argmax.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 53
- Leçons
- 225
Questions Fréquemment Posées
La leçon « Créer et entraîner des CNN avec PyTorch » est-elle gratuite ?
Oui — le texte complet de « Créer et entraîner des CNN avec PyTorch » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Créer et entraîner des CNN avec PyTorch » ?
nn.Conv2d, nn.MaxPool2d, nn.Linear, boucle d’entraînement, optimiseur, fonction de perte, suivi de la précision. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Créer et entraîner des CNN avec PyTorch » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Tenseurs PyTorch et Autograd
- Jeux de données et DataLoaders personnalisés
- Créer et entraîner des CNN avec PyTorch
- Détection d’objets avec YOLOv8