Réseau neuronal convolutif – Implémentation de PyTorch sur l'ensemble de données CIFAR-10

Republié par Platon

Suiveurs: 0

Cet article a été publié dans le cadre du Blogathon sur la science des données

Introduction

Cifar 10 | Pytorch de réseaux de neurones convolutifs — image 1

Les réseaux de neurones convolutifs, également appelés ConvNets, ont été introduits pour la première fois dans les années 1980 par Yann LeCun, un chercheur en informatique qui a travaillé en arrière-plan. LeCun a construit sur les travaux de Kunihiko Fukushima, un scientifique japonais, un réseau de base pour la reconnaissance d'images.

L'ancienne version de CNN, appelée LeNet (d'après LeCun), peut voir des chiffres manuscrits. CNN aide à trouver les codes PIN de la poste. Mais malgré leur expertise, les ConvNets sont restés proches de la vision par ordinateur et de l'intelligence artificielle car ils étaient confrontés à un problème majeur : ils ne pouvaient pas beaucoup évoluer. Les CNN nécessitent beaucoup de données et intègrent des ressources pour bien fonctionner pour les grandes images.

À l'époque, cette méthode n'était applicable qu'aux images à faible résolution. Pytorch est une bibliothèque qui peut effectuer des opérations d'apprentissage en profondeur. Nous pouvons l'utiliser pour effectuer des réseaux de neurones convolutifs. Les réseaux de neurones convolutifs contiennent de nombreuses couches de neurones artificiels. Les neurones synthétiques, des simulations complexes d'homologues biologiques, sont des fonctions mathématiques qui calculent la masse pondérée de plusieurs entrées et l'activation de la valeur du produit.

Pytorch de réseaux de neurones convolutifs — image 2

L'image ci-dessus nous montre un modèle CNN qui prend une image de type chiffre de 2 et nous donne le résultat du chiffre affiché dans l'image sous forme de nombre. Nous allons discuter en détail de la façon dont nous obtenons cela dans cet article.

CIFAR-10 est un ensemble de données qui contient une collection d'images de 10 classes différentes. Cet ensemble de données est largement utilisé à des fins de recherche pour tester différents modèles d'apprentissage automatique et en particulier pour les problèmes de vision par ordinateur. Dans cet article, nous allons essayer de créer un modèle de réseau neuronal à l'aide de Pytorch et de le tester sur l'ensemble de données CIFAR-10 pour vérifier quelle précision de prédiction peut être obtenue.

Importation de la bibliothèque PyTorch

importer numpy en tant que np importer des pandas en pd

importer la torche importer torch.nn.fonctionnel en tant que F à partir des ensembles de données d'importation de torchvision, se transforme à partir de la torche importer nn importer matplotlib.pyplot en tant que plt importer numpy en tant que np importer seaborn en tant que sns # de tqdm.notebook importer tqdm de tqdm importer tqdm

Dans cette étape, nous importons les bibliothèques requises. Nous pouvons voir que nous utilisons NumPy pour les opérations numériques et les pandas pour les opérations de trame de données. La bibliothèque torche est utilisée pour importer Pytorch.

Pytorch a un composant nn qui est utilisé pour l'abstraction des opérations et des fonctions d'apprentissage automatique. Ceci est importé en tant que F. La bibliothèque torchvision est utilisée afin que nous puissions importer l'ensemble de données CIFAR-10. Cette bibliothèque contient de nombreux ensembles de données d'images et est largement utilisée pour la recherche. Les transformations peuvent être importées afin que nous puissions redimensionner l'image à la même taille pour toutes les images. Le tqdm est utilisé pour que nous puissions suivre les progrès pendant l'entraînement et est utilisé pour la visualisation.

Lire l'ensemble de données requis

trainData = pd.read_csv('cifar-10/trainLabels.csv') trainData.head()

Une fois que nous avons lu l'ensemble de données, nous pouvons voir diverses étiquettes comme la grenouille, le camion, le cerf, l'automobile, etc.

Analyser les données avec PyTorch

print("Nombre de points :",trainData.shape[0]) print("Nombre d'entités :",trainData.shape[1]) print("Caractéristiques :",trainData.columns.values) print("Nombre de Valeurs uniques") pour col dans trainData : print(col,":",len(trainData[col].unique())) plt.figure(figsize=(12,8))

Sortie :

Nombre de points : 50000 Nombre de fonctionnalités : 2 Fonctionnalités : ['id' 'label'] Nombre de valeurs uniques id : 50000 label : 10

Dans cette étape, nous analysons l'ensemble de données et constatons que nos données de train ont environ 50000 10 lignes avec leur identifiant et l'étiquette associée. Il y a un total de 10 classes comme dans le nom CIFAR-XNUMX.

Obtenir l'ensemble de validation à l'aide de PyTorch

de torch.utils.data import random_split val_size = 5000 train_size = len(dataset) - val_size train_ds, val_ds = random_split(dataset, [train_size, val_size]) len(train_ds), len(val_ds)

Cette étape est la même que l'étape d'apprentissage, mais nous souhaitons diviser les données en ensembles d'apprentissage et de validation.

(45000, 5000)

de torch.utils.data.dataloader import DataLoader batch_size=64 train_dl = DataLoader(train_ds, batch_size, shuffle=True, num_workers=4, pin_memory=True) val_dl = DataLoader(val_ds, batch_size, num_workers=4, pin_memory=True)

Torch.utils dispose d'un chargeur de données qui peut nous aider à charger les données requises en contournant divers paramètres tels que le numéro de travailleur ou la taille du lot.

Définir les fonctions requises

@torch.no_grad() def precision(sorties, labels): _, preds = torch.max(outputs, dim=1) return torch.tensor(torch.sum(preds == labels).item() / len(preds )) class ImageClassificationBase(nn.Module): def training_step(self, batch): images, labels = batch out = self(images) # Générer des prédictions loss = F.cross_entropy(out, labels) # Calculer la perte accu = precision(out ,labels) return loss,accu def validation_step(self, batch): images, labels = batch out = self(images) # Générer des prédictions de perte = F.cross_entropy(out, labels) # Calculer la perte acc = precision(out, labels) # Calculer le retour de précision {'Perte': loss.detach(), 'Précision': acc} def validation_epoch_end(self, sorties): batch_losses = [x['Loss'] pour x dans les sorties] epoch_loss = torch.stack(batch_losses ).mean() # Combiner les pertes batch_accs = [x['Précision'] pour x dans les sorties] epoch_acc = torch.stack(batch_accs).mean() # Combiner les précisions return {'Perte': epoch_loss.item(), ' Précision' : epoch_acc.item()} def epoch_end(self, epoch, result): pr int("Epoch :",epoch + 1) print(f'Précision du train :{result["train_accuracy"]*100:.2f}% Précision de validation :{result["Précision"]*100:.2f}%' ) print(f'Perte de train :{result["train_loss"]:.4f} Perte de validation :{result["Perte"]:.4f}')

Comme nous pouvons le voir ici, nous avons utilisé l'implémentation de classe de ImageClassification et cela prend un paramètre qui est nn.Module. Au sein de cette classe, nous pouvons implémenter les différentes fonctions ou différentes étapes comme la formation, la validation, etc. Les fonctions ici sont de simples implémentations python.

L'étape de formation prend les images et les étiquettes par lots. nous utilisons l'entropie croisée pour la fonction de perte et calculons la perte et renvoyons la perte. Ceci est similaire à l'étape de validation comme nous pouvons le voir dans la fonction. Les fins d'époque combinent les pertes et les précisions et enfin, nous imprimons les précisions et les pertes.

Implémentation du module de réseau de neurones convolutifs

class Cifar10CnnModel(ImageClassificationBase): def __init__(self): super().__init__() self.network = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), # sortie : 64 x 16 x 16 nn.BatchNorm2d(64) , nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1), nn .ReLU(), nn.MaxPool2d(2, 2), # sortie : 128 x 8 x 8 nn.BatchNorm2d(128), nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), # sortie : 256 x 4 x 4 nn.BatchNorm2d(256), nn.Flatten(), nn.Linéaire(256*4*4, 1024), nn.ReLU(), nn.Linéaire(1024, 512), nn.ReLU(), nn.Linéaire (512, 10)) def forward(self, xb): return self.network(xb)

C'est la partie la plus importante de la mise en œuvre d'un réseau de neurones. Tout au long, nous utilisons le module nn que nous avons importé de la torche. Comme nous pouvons le voir dans la première ligne, le Conv2d est un module qui permet de mettre en œuvre un réseau de neurones convolutifs. Le premier paramètre 3 représente ici que l'image est colorée et au format RVB. S'il s'agissait d'une image en niveaux de gris, nous aurions opté pour 1.

32 est la taille du canal de sortie initial et lorsque nous passerons à la couche conv2d suivante, nous aurions ce 32 comme canal d'entrée et 64 comme canal de sortie.

Le 3ème paramètre de la première ligne s'appelle la taille du noyau et il nous aide à prendre soin des filtres utilisés. L'opération de remplissage est le dernier paramètre.

L'opération de convolution est connectée à une couche d'activation et ici Relu. Après deux couches Conv2d, nous avons une opération de pooling max de taille 2 * 2. La valeur qui en sort est normalisée par lot pour la stabilité et pour éviter le décalage de covariable interne. Ces opérations sont répétées avec plus de couches pour approfondir le réseau et réduire sa taille. Enfin, nous aplatissons la couche afin de pouvoir créer une couche linéaire pour mapper les valeurs à 10 valeurs. La probabilité de chaque neurone de ces 10 neurones déterminera à quelle classe appartient une image particulière en fonction de la probabilité maximale.

Former le modèle

@torch.no_grad() def evaluation(model, data_loader): model.eval() sorties = [model.validation_step(batch) for batch in data_loader] return model.validation_epoch_end(outputs) def fit(model, train_loader, val_loader,epochs =10,learning_rate=0.001) : best_valid = None history = [] optimiseur = torch.optim.Adam(model.parameters(), learning_rate,weight_decay=0.0005) pour l'époque dans la plage(epochs) : # Phase de formation model.train( ) train_losses = [] train_accuracy = [] pour le lot dans tqdm(train_loader): loss,accu = model.training_step(batch) train_losses.append(loss) train_accuracy.append(accu) loss.backward() optimiseur.step() optimiseur .zero_grad() # Phase de validation result = evaluation(model, val_loader) result['train_loss'] = torch.stack(train_loss).mean().item() result['train_accuracy'] = torch.stack(train_accuracy). Mean().item() model.epoch_end(epoch, result) if(best_valid == None ou best_valid

histoire = ajustement (modèle, train_dl, val_dl)

Il s'agit d'une étape de base pour entraîner notre modèle afin d'obtenir le résultat requis. la fonction d'ajustement ici ajustera les données de train et de Val avec le modèle que nous avons créé. La fonction fit prend initialement une liste appelée historique qui prend en charge les données d'itération de chaque époque. Nous exécutons une boucle for afin de pouvoir itérer sur chaque époque. Pour chaque lot, nous nous assurons de montrer la progression à l'aide de tqdm. Nous appelons l'étape de formation que nous avons mise en œuvre auparavant et calculons la précision et la perte. Le go pour la propagation en arrière et l'optimiseur d'exécution que nous avons défini plus tôt. Une fois que nous avons fait cela, nous gardons une trace de notre liste et les fonctions nous aident à imprimer les détails et la progression.

La fonction d'évaluation, d'autre part, utilise la fonction eval, et pour chaque étape, nous prenons le lot chargé à partir du chargeur de données, et la sortie est calculée. La valeur est ensuite transmise à la fin de l'époque de validation que nous avons définie précédemment et la valeur respective est renvoyée.

Tracer les résultats

Dans cette étape, nous visualiserons la précision en fonction de chaque époque. Nous pouvons observer qu'au fur et à mesure que l'époque augmente, la précision du système continue d'augmenter et, de même, la perte continue de diminuer. La ligne rouge indique ici la progression des données d'entraînement et la bleue pour la validation. Nous pouvons voir qu'il y a eu une bonne quantité de surapprentissage dans nos résultats car les données d'entraînement surpassent largement le résultat de validation et de même en cas de perte. Après 10 époques, les données du train semblent contourner 90% de précision mais ont une perte d'environ 0.5. Les données de test sont d'environ 81% et les pertes sont proches de 0.2.

def plot_accuracies(history): Validation_accuracies = [x['Accuracy'] for x in history] Training_Accuracies = [x['train_accuracy'] for x in history] plt.plot(Training_Accuracies, '-rx') plt.plot(Validation_accuracies , '-bx') plt.xlabel('époque') plt.ylabel('exactitude') plt.legend(['Formation', 'Validation']) plt.title('Précision contre nombre d'époques') ; plot_accuracies(historique)

def plot_losses(history): train_losses = [x.get('train_loss') pour x dans l'histoire] val_losses = [x['Loss'] pour x dans l'histoire] plt.plot(train_loss, '-bx') plt.plot (val_losses, '-rx') plt.xlabel('epoch') plt.ylabel('loss') plt.legend(['Formation', 'Validation']) plt.title('Perte contre nombre d'époques '); plot_loss(historique)

test_dataset = ImageFolder(data_dir+'/test', transform=ToTensor()) test_loader = DeviceDataLoader(DataLoader(test_dataset, batch_size), device) result = evaluation(final_model, test_loader) print(f'Test Accuracy:{result["Précision" ]*100 : .2f} %')

Exactitude du test : 81.07 %

Nous pouvons voir que nous nous retrouvons avec une précision de 81.07 %.

Conclusion:

Image(s): https://unsplash.com/photos/5L0R8ZqPZHk

À propos de moi: Je suis un étudiant chercheur intéressé par le domaine de l'apprentissage en profondeur et du traitement du langage naturel et je poursuis actuellement des études supérieures en intelligence artificielle.

Image Source

Image 1: https://becominghuman.ai/cifar-10-image-classification-fd2ace47c5e8
Image 2 : https://www.analyticsvidhya.com/blog/2021/05/convolutional-neural-networks-cnn/

N'hésitez pas à me contacter sur :