Tutoriel PyTorch CNN : Construire et entraîner des réseaux neuronaux convolutifs en Python

Les réseaux neuronaux convolutifs (CNN) sont la pierre angulaire de la vision par ordinateur moderne, permettant des applications telles que la reconnaissance d'images, la détection faciale et les voitures autonomes. Ces réseaux sont conçus pour extraire automatiquement des motifs et des caractéristiques des images, ce qui les rend plus puissants que les techniques traditionnelles d'apprentissage automatique pour les tâches visuelles.

Dans ce tutoriel, nous allons mettre en œuvre un CNN en utilisant PyTorch, un cadre d'apprentissage profond qui est à la fois convivial et très efficace pour la recherche et les applications de production.

Prérequis : Apprentissage profond et PyTorch

Avant d'entrer dans les détails des CNN, vous devez vous familiariser avec le domaine du deep learning et les bibliothèques Python que nous utiliserons lors de la mise en place de notre environnement.

L'apprentissage profond est un sous-ensemble de l'apprentissage automatique, où la structure fondamentale du modèle est un réseau d'entrées, de couches cachées et de sorties. Un tel réseau peut comporter une ou plusieurs couches cachées. L'intuition initiale de l'apprentissage profond était de créer des modèles inspirés de la manière dont le cerveau humain apprend : par l'intermédiaire de cellules interconnectées appelées neurones. C'est pourquoi nous continuons à appeler les modèles d'apprentissage profond des réseaux "neuronaux". L'apprentissage de ces modèles en couches nécessite beaucoup plus de données que les autres modèles d'apprentissage supervisé pour dériver des modèles à partir de données non structurées. Nous parlons normalement d'au moins des centaines de milliers de points de données.

Bien qu'il existe plusieurs frameworks et packages pour la mise en œuvre d'algorithmes d'apprentissage profond, nous nous concentrerons sur PyTorch, l'un des frameworks les plus populaires et les mieux entretenus. En plus d'être utilisé par les ingénieurs en apprentissage profond dans l'industrie, PyTorch est un outil privilégié par les chercheurs. De nombreux articles sur l'apprentissage profond sont publiés à l'aide de PyTorch. Il est conçu pour être intuitif et convivial, et partage de nombreux points communs avec la bibliothèque Python NumPy. 

Si vous avez besoin d'une initiation à ces concepts, inscrivez-vous dès aujourd'hui au cours Deep Learning with PyTorch. 

Qu'est-ce qu'un réseau neuronal convolutif (CNN) ?

Les réseaux neuronaux convolutifs, communément appelés CNN ou ConvNet, sont un type particulier de réseau neuronal profond bien adapté aux tâches de vision par ordinateur. L'invention des CNN remonte aux années 1980. Toutefois, ils ne sont devenus courants que dans les années 2010, à la suite des percées informatiques résultant de la mise en œuvre des unités de traitement graphique (GPU). En effet, la popularisation rapide des CNN a permis au domaine des réseaux neuronaux de reprendre de l'importance, ce qui a conduit à ce que l'on appelle la "troisième vague de réseaux neuronaux", que nous vivons encore aujourd'hui.

Les CNN sont spécifiquement inspirés du cortex visuel biologique. Le cortex comporte de petites régions de cellules sensibles aux zones spécifiques du champ visuel. Cette idée a été élargie par une expérience captivante menée par Hubel et Wiesel en 1962. 

Les CNN tentent de reproduire cette caractéristique en créant des réseaux neuronaux complexes composés de différentes couches spécifiques à une tâche. Les CNN sont appelés "feed-forward" car l'information circule directement à travers le modèle. Il n'y a pas de connexions de rétroaction dans lesquelles les sorties du modèle sont renvoyées vers lui-même, contrairement à d'autres modèles qui utilisent des techniques telles que la rétropropagation.

En particulier, un CNN se compose généralement des couches suivantes :

Couche convolutive

C'est le premier élément constitutif d'un CNN. Comme son nom l'indique, la principale tâche mathématique effectuée s'appelle la convolution, qui consiste à appliquer une fonction de fenêtre coulissante à une matrice de pixels représentant une image. La fonction de glissement appliquée à la matrice est appelée noyau ou filtre. Dans la couche de convolution, plusieurs filtres de taille égale sont appliqués, et chaque filtre est utilisé pour reconnaître un motif spécifique de l'image, comme la courbure des chiffres, les bords, la forme entière des chiffres, etc. 

Fonction d'activation

Normalement, une fonction d'activation ReLU est appliquée après chaque opération de convolution. Cette fonction aide le réseau à apprendre les relations non linéaires entre les caractéristiques de l'image, ce qui rend le réseau plus robuste pour l'identification de différents modèles. Elle permet également d'atténuer les problèmes de gradient de fuite. 

Couche de mise en commun

L'objectif de la couche de mise en commun est d'extraire les caractéristiques les plus significatives de la matrice convoluée. Cela se fait en appliquant certaines opérations d'agrégation qui réduisent la dimension de la carte des caractéristiques (matrice convoluée), réduisant ainsi la mémoire utilisée lors de l'apprentissage du réseau.  La mise en commun permet également d'atténuer les effets de l'adaptation excessive.

Couches entièrement connectées

Ces couches se trouvent dans la dernière couche du réseau neuronal convolutif et leurs entrées correspondent à la matrice unidimensionnelle aplatie générée par la dernière couche de mise en commun. Des fonctions d'activation ReLU leur sont appliquées pour assurer la non-linéarité. 

Architecture des réseaux neuronaux à convolution. Source : DataCamp

Vous pouvez lire une explication plus détaillée des mathématiques qui sous-tendent les CNN dans notre tutoriel, Les réseaux neuronaux convolutifs en Python.

Pourquoi utiliser les CNN pour la classification d'images ?

Les réseaux neuronaux convolutifs ont été l'une des innovations les plus influentes dans le domaine de la vision par ordinateur. Ils ont obtenu de bien meilleurs résultats que les modèles traditionnels d'apprentissage automatique, tels que les SVM et les arbres de décision, et ont produit des résultats à la pointe de la technologie. 

En outre, les couches convolutives confèrent aux CNN leurs caractéristiques invariantes par rapport à la traduction, ce qui leur permet d'identifier et d'extraire des modèles et des caractéristiques des données indépendamment des variations de position, d'orientation, d'échelle ou de traduction.


Les CNN ont fait leurs preuves dans de nombreuses études de cas et applications réelles, comme par exemple :

• Classification d'images, détection d'objets, segmentation, reconnaissance de visages ;
• Voitures auto-conduites utilisant des systèmes de vision basés sur le CNN ;
• Classification de la structure cristalline à l'aide d'un réseau neuronal convolutionnel ;
• Systèmes de caméras de sécurité.

Au-delà des tâches de classification d'images, les CNN sont polyvalents et peuvent être appliqués à une série d'autres domaines, tels que le traitement du langage naturel, l'analyse des séries temporelles et la reconnaissance vocale.

Implémentation d'un CNN avec PyTorch

Maintenant que vous connaissez la théorie des CNN, nous sommes prêts à mettre la main à la pâte. Dans cette section, nous allons construire et entraîner un CNN simple avec PyTorch. Notre objectif est de construire un modèle de classification des chiffres dans les images. Pour former et tester notre modèle, nous utiliserons le célèbre ensemble de données MNIST, une collection de 70 000 images 28x28 en niveaux de gris contenant des chiffres écrits à la main.

1. Importation des bibliothèques requises

Vous trouverez ci-dessous les bibliothèques que nous utiliserons pour ce tutoriel. Essentiellement, nous utiliserons PyTorch pour construire notre CNN, et le module de vision artificielle de PyTorch torchvision, pour télécharger et charger l'ensemble de données MNIST. Enfin, nous utiliserons également torchmetrics pour évaluer la performance de notre modèle.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


import torch
from torch import optim
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

# !pip install torchvision
import torchvision

import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# !pip install torchmetrics
import torchmetrics

2. Chargement et prétraitement de l'ensemble des données

PyTorch s'accompagne également d'un riche écosystème d'outils et d'extensions, dont torchvision, un module de vision par ordinateur. Torchvision comprend plusieurs ensembles de données d'images qui peuvent être utilisés pour entraîner et tester les réseaux neuronaux. Dans notre tutoriel, nous utiliserons l'ensemble de données MNIST. 

Tout d'abord, nous allons télécharger et convertir l'ensemble de données MNIST en un tenseur, la structure de données principale de PyTorch, similaire aux tableaux NumPy mais avec des capacités d'accélération GPU.

Ensuite, nous utiliserons également DataLoader pour gérer la mise en lot et le mélange des ensembles de données de formation et de test. Un PyTorch DataLoader peut être créé à partir d'un Dataset pour charger des données, les diviser en lots et effectuer des transformations sur les données si vous le souhaitez. Il produit ensuite un échantillon de données prêt pour la formation. Dans le code ci-dessous, nous chargeons les données et les enregistrons dans DataLoaders avec une taille de lot de 60 images :

batch_size = 60

train_dataset = datasets.MNIST(root="dataset/", download=True, train=True, transform=transforms.ToTensor())

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = datasets.MNIST(root="dataset/", download=True, train=False, transform=transforms.ToTensor())

test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

En option, l'ensemble de données de formation peut être divisé en deux partitions, l'une de formation et l'autre de validation. La validation est une technique utilisée dans l'apprentissage profond pour évaluer les performances du modèle pendant la formation. Il permet de détecter d'éventuels surajustements ou sous-ajustements de nos modèles, et il est particulièrement utile pour optimiser les hyperparamètres. Toutefois, par souci de simplicité, nous n'utiliserons pas la validation dans le cadre de ce tutoriel. Si vous souhaitez en savoir plus sur la validation, vous pouvez consulter une explication complète dans notre cours Introduction à l'apprentissage profond avec PyTorch.

Maintenant que nous disposons de nos données, voyons à quoi ressemble un lot aléatoire de chiffres :

def imshow(img):
   npimg = img.numpy()
   plt.imshow(np.transpose(npimg, (1, 2, 0)))
   plt.show()

# get some random training images
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# show images
imshow(torchvision.utils.make_grid(images))

3. Définition de l'architecture du CNN

Pour résoudre le problème de la classification, nous utiliserons la classe nn.Module, le bloc de construction de PyTorch qui permet de créer intuitivement des architectures de réseaux neuronaux sophistiqués. 

Dans le code ci-dessous, nous créons une classe appelée CNN, qui hérite des propriétés de la classe nn.Module. La classe CNN sera le modèle d'un CNN avec deux couches convolutives, suivies d'une couche entièrement connectée. 

Dans PyTorch, nous utilisons nn.Conv2d pour définir une couche convolutive. Nous lui transmettons le nombre de cartes de caractéristiques d'entrée et de sortie. Nous avons également défini certains paramètres pour que la couche convolutive fonctionne, notamment la taille du noyau ou du filtre et le remplissage. 

Ensuite, nous ajoutons une couche de mise en commun maximale avec nn.MaxPool2d. ​Nous y faisons glisser une fenêtre non chevauchante sur la sortie de la couche convolutive précédente. À chaque position, nous sélectionnons la valeur maximale de la fenêtre à transmettre. Cette opération réduit les dimensions spatiales des cartes de caractéristiques, ce qui diminue le nombre de paramètres et la complexité de calcul dans le réseau. Enfin, nous ajoutons une couche linéaire entièrement connectée. 

La fonction forward() définit la manière dont les différentes couches sont connectées, en ajoutant plusieurs fonctions d'activation ReLU après chaque couche convolutive.

class CNN(nn.Module):
   def __init__(self, in_channels, num_classes):

       """
       Building blocks of convolutional neural network.

       Parameters:
           * in_channels: Number of channels in the input image (for grayscale images, 1)
           * num_classes: Number of classes to predict. In our problem, 10 (i.e digits from  0 to 9).
       """
       super(CNN, self).__init__()

       # 1st convolutional layer
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max pooling layer
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2nd convolutional layer
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Fully connected layer
       self.fc1 = nn.Linear(16 * 7 * 7, num_classes)

   def forward(self, x):
       """
       Define the forward pass of the neural network.

       Parameters:
           x: Input tensor.

       Returns:
           torch.Tensor
               The output tensor after passing through the network.
       """
       x = F.relu(self.conv1(x))  # Apply first convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = F.relu(self.conv2(x))  # Apply second convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x

Une fois que nous avons défini la classe CNN, nous pouvons créer notre modèle et le déplacer vers l'appareil où il sera entraîné et exécuté. 

Les réseaux neuronaux, y compris les CNN, sont plus performants lorsqu'ils sont exécutés sur des GPU, mais il se peut que ce soit le cas sur votre ordinateur. Par conséquent, nous n'exécuterons le modèle sur un GPU que s'il est disponible ; sinon, nous utiliserons un CPU normal.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = CNN(in_channels=1, num_classes=10).to(device)
print(model)
>>> CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

4. Formation du modèle CNN

Maintenant que nous avons notre modèle, il est temps de l'entraîner. Pour ce faire, nous devons d'abord déterminer comment nous allons mesurer la performance du modèle. Comme il s'agit d'un problème de classification multi-classes, nous utiliserons la fonction de perte d'entropie croisée, disponible dans PyTorch sous la forme nn.CrossEntropyLoss. Nous utiliserons également l'optimiseur Adam, l'un des algorithmes d'optimisation les plus populaires. 

# Define the loss function
criterion = nn.CrossEntropyLoss()

# Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

Nous allons itérer sur dix époques et lots d'entraînement pour entraîner le modèle et effectuer la séquence habituelle d'étapes pour chaque lot, comme indiqué ci-dessous.

num_epochs=10
for epoch in range(num_epochs):
 # Iterate over training batches
   print(f"Epoch [{epoch + 1}/{num_epochs}]")

   for batch_index, (data, targets) in enumerate(tqdm(dataloader_train)):
       data = data.to(device)
       targets = targets.to(device)
       scores = model(data)
       loss = criterion(scores, targets)
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()

Epoch [1/10]
100%|██████████| 1000/1000 [00:13<00:00, 72.94it/s]
Epoch [2/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.27it/s]
Epoch [3/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.16it/s]
Epoch [4/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.00it/s]
Epoch [5/10]
100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]
Epoch [6/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.24it/s]
Epoch [7/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.23it/s]
Epoch [8/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.16it/s]
Epoch [9/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.96it/s]
Epoch [10/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.93it/s]

5. Évaluation du modèle

Une fois le modèle formé, nous pouvons évaluer ses performances sur l'ensemble de données de test. Nous utiliserons la précision, une mesure populaire pour les problèmes de classification. La précision mesure la proportion de cas correctement classés par rapport au nombre total d'objets dans l'ensemble de données. Il est calculé en divisant le nombre de prédictions correctes par le nombre total de prédictions faites par le modèle. 

Tout d'abord, nous avons mis en place la métrique de précision de torchmetrics. Ensuite, nous utilisons la méthode .eval du modèle pour le mettre en mode évaluation, car certaines couches des modèles PyTorch se comportent différemment selon qu'il s'agit d'une phase d'apprentissage ou d'une phase de test. Nous ajoutons également un contexte Python avec torch.no_grad, indiquant que nous n'effectuerons pas de calcul de gradient.

Ensuite, nous itérons sur des exemples de test sans calcul de gradient. Pour chaque lot de tests, nous obtenons les sorties du modèle, retenons la classe la plus probable et la transmettons à la fonction de précision avec les étiquettes. Enfin, nous calculons les métriques et imprimons les résultats. Nous avons obtenu une précision de 0,98, ce qui signifie que notre modèle a correctement classé 98 % des chiffres. Pas mal !

# Set up of multiclass accuracy metric
acc = Accuracy(task="multiclass",num_classes=10)

# Iterate over the dataset batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Get predicted probabilities for test data batch
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

#Compute total test accuracy
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Vous pouvez également utiliser d'autres mesures de classification courantes, telles que le rappel et la précision. Nous vous expliquons tout sur ces métriques avec des exemples pratiques dans notre cours Intermediate Deep Learning with PyTorch.

Améliorer les performances du modèle

Bien que notre modèle CNN soit très performant, plusieurs stratégies peuvent être utilisées pour améliorer sa précision, sa robustesse et sa généralisation à de nouvelles données. 

Dans cette section, nous explorerons des techniques clés telles que l'augmentation des données, l'ajustement des hyperparamètres et l'apprentissage par transfert afin d'optimiser les performances de notre modèle.

Techniques d'enrichissement des données

L'augmentation des données est une technique utilisée pour améliorer la précision de notre modèle en créant aléatoirement de nouvelles données de formation. Par exemple, pendant le chargement, il est possible d'appliquer des transformations aux images d'apprentissage, telles que le redimensionnement, le retournement horizontal ou vertical, la rotation aléatoire, etc. De cette manière, il est possible de créer des images augmentées et de leur attribuer la même étiquette que l'image originale, ce qui augmente la taille de l'ensemble d'apprentissage.

L'ajout de transformations aléatoires aux images originales nous permet de générer davantage de données tout en augmentant la taille et la diversité de l'ensemble d'apprentissage. Il rend le modèle plus résistant aux variations et aux distorsions que l'on trouve couramment dans les images du monde réel et réduit l'adaptation excessive, car le modèle apprend à ignorer les transformations aléatoires. 

Cependant, il est important de faire preuve de prudence en ce qui concerne l'augmentation des données, car elle peut parfois nuire au processus de formation. Par exemple, dans notre problème, si nous appliquons le retournement vertical au nombre "6", il ressemblera au nombre "9". Le fait de le transmettre au modèle étiqueté "6" le rendra confus et entravera la formation. Ces exemples montrent que, parfois, des augmentations spécifiques peuvent avoir un impact sur l'étiquette.

Réglage des hyperparamètres

Une autre stratégie pour améliorer les performances de notre modèle consiste à modifier les valeurs des hyperparamètres impliqués dans les différentes couches du modèle. Ce réglage des hyperparamètres nécessite une compréhension approfondie des mathématiques qui sous-tendent les réseaux neuronaux et de la signification des différents hyperparamètres. 

Par exemple, vous pouvez adapter vos couches CNN en modifiant la taille des filtres ou en augmentant le remplissage. Vous pouvez également définir une valeur différente pour les poids initiaux des neurones. 

Comme nous ne connaissons pas à l'avance les valeurs optimales des hyperparamètres, un certain degré d'essais et d'erreurs sera nécessaire. Cela se fait normalement par le biais d'une technique connue sous le nom de "grid search", qui vous permet d'évaluer systématiquement un modèle à travers une grille de valeurs de paramètres. 

Cependant, soyez prudent lorsque vous utilisez cette technique, car elle est généralement coûteuse en termes de calcul, en particulier lorsqu'il s'agit de réseaux neuronaux complexes et de grands ensembles de données d'entraînement.

De même, vous pouvez accroître la complexité de votre modèle en ajoutant davantage de couches convolutives et linéaires. Cependant, faites attention lorsque vous ajoutez de nouvelles couches, car le nombre de neurones peut augmenter considérablement, ce qui entraîne des temps d'apprentissage plus longs et des surajustements potentiels.

Vous pouvez en savoir plus sur le réglage des hyperparamètres dans notre cours Introduction à l'apprentissage profond avec PyTorch.

Utilisation de modèles pré-entraînés

La formation de modèles d'apprentissage profond à partir de zéro est un processus long et fastidieux, qui nécessite généralement beaucoup de données de formation. Au lieu de cela, nous pouvons souvent utiliser des modèles pré-entraînés, c'est-à-dire des modèles qui ont déjà été entraînés sur une tâche donnée. 

Parfois, nous pouvons directement réutiliser un modèle pré-entraîné s'il peut déjà résoudre la tâche qui nous intéresse. Dans d'autres cas, il peut s'avérer nécessaire d'adapter le modèle pré-entraîné à la nouvelle tâche. C'est ce que l'on appelle l'apprentissage par transfert.

L'utilisation de modèles pré-entraînés dans PyTorch est relativement simple. Torchvision fournit une collection de modèles pré-entraînés pour diverses tâches liées à l'image. Ces modèles sont pré-entraînés sur des ensembles de données d'images à grande échelle et sont facilement disponibles. Consultez notre cours Deep Learning for Images with PyTorch pour apprendre tout ce que vous devez savoir à ce sujet.

Déployer le modèle CNN

Après avoir entraîné votre modèle de classification très précis dans PyTorch, vous pouvez maintenant enregistrer le modèle et ses poids pré-entraînés pour une utilisation future et le partager avec votre équipe, en vous assurant qu'ils peuvent le charger de manière transparente.

Pour sauvegarder un modèle, nous pouvons utiliser torch.save. L'extension de fichier la plus courante pour les modèles de torche est pt ou pth. Pour enregistrer les poids du modèle, nous passons model.state_dict à torch.save en indiquant le nom du fichier de sortie, par exemple MulticlassCNN.pth.

Pour charger un modèle sauvegardé, nous initialisons un nouveau modèle avec la même architecture. Nous utilisons ensuite la méthode load state dict avec torch.load pour charger les paramètres dans le nouveau modèle.

# Save the model
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Create a new model
loaded_model = CNN(in_channels=1, num_classes=10)

# Load the saved model
loaded_model.load_state_dict(torch.load('MulticlassCNN.pth'))
print(loaded_model)


CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

Conclusion

Nous avons donné un aperçu complet des CNN, en fournissant des détails sur chaque couche de l'architecture des CNN. En outre, nous avons fourni un guide sur la manière d'implémenter un CNN dans PyTorch, couvrant les principales étapes, du chargement des données et de la conception du modèle à l'entraînement et à l'évaluation du modèle. Enfin, nous analysons également plusieurs stratégies visant à améliorer les performances de notre modèle. Nous avons appliqué tous ces ensembles de compétences à un scénario réel lié à une tâche de classification multiclasse. 

Il y a beaucoup à apprendre sur l'apprentissage profond, sans doute l'un des domaines les plus passionnants et les plus exigeants de l'IA. Heureusement, DataCamp est là pour vous aider. Consultez nos supports et cours dédiés et devenez un expert en réseaux neuronaux :

• Introduction aux réseaux neuronaux convolutifs : Un guide complet sur les CNN dans l'apprentissage profond 
• Réseaux neuronaux convolutifs en Python avec Keras
• Tutoriel sur les réseaux neuronaux convolutifs (CNN) en Python avec TensorFlow
• Introduction aux fonctions d'activation dans les réseaux neuronaux 
• Cours sur l'apprentissage profond pour le texte avec PyTorch
• Apprentissage profond en Python
• Comment apprendre l'apprentissage profond en 2025 : Un guide complet
• Cours intermédiaire sur l'apprentissage profond avec PyTorch
• Guide des certifications et certificats PyTorch