Écrire VGG de zéro en PyTorch

Poursuivant ma série sur la construction de réseaux de neurones convolutionnels classiques qui ont révolutionné le domaine de la vision par ordinateur au cours des dernières décennies, nous construirons ici VGG, un réseau convolutionnel très profond, à partir de zéro en utilisant PyTorch. Vous pouvez consulter les articles précédents de la série sur mon profil, notamment LeNet5 et AlexNet.

Comme avant, nous examinerons l’architecture et l’intuition derrière VGG et comment les résultats étaient à l’époque. Nous explorerons ensuite notre jeu de données, CIFAR100, et le chargons dans notre programme en utilisant un code économisant en mémoire. Ensuite, nous implémenterons VGG16 (le numéro se réfère au nombre de couches, il existe deux versions essentiellement VGG16 et VGG19) à partir de zéro en utilisant PyTorch et le trainons sur notre jeu de données, ainsi que l’évaluations sur notre jeu de test pour voir comment il se comporte sur des données non vues.

VGG

Sur la base des travaux de AlexNet, VGG se concentre sur un autre aspect crucial des réseaux de neurones convolutionnels (CNN), la profondeur. Il a été développé par Simonyan et Zisserman. Il se compose normalement de 16 couches convolutionnelles, mais peut être étendu à 19 couches (deux versions donc, VGG-16 et VGG-19). toutes les couches convolutionnelles se composent de filtres de taille 3×3. Vous pouvez en savoir plus sur le réseau dans le papier officiel ici

Architecture VGG16. Source

Chargement des données

Jeu de données

Avant de construire le modèle, l’une des choses les plus importantes dans tout projet de apprentissage automatique est de charger, analyser et pré-traiter le jeu de données. Dans cet article, nous utiliserons le jeu de données CIFAR-100. Ce jeu de données est similaire au CIFAR-10, sauf qu’il contient 100 classes chacune contenant 600 images. Il y a 500 images d’entraînement et 100 images de test par classe. Les 100 classes du CIFAR-100 sont regroupées en 20 superclasses. Chaque image est accompagnée d’une étiquette « fine » (la classe à laquelle elle appartient) et d’une étiquette « coarse » (la superclasse à laquelle elle appartient). Nous utiliserons l’étiquette « fine » ici. Voici la liste des classes dans le CIFAR-100 :

Liste des classes pour le jeu de données CIFAR-100

Importation des bibliothèques

Nous travaillerons principalement avec torch (utilisé pour construire le modèle et l’entraîner), torchvision (pour le chargement/traitement des données, contenant les jeux de données et les méthodes pour traiter ces jeux de données dans le domaine de la vision par ordinateur) et numpy (pour la manipulation mathématique). Nous définirons également une variable device afin que le programme puisse utiliser la GPU si elle est disponible

import numpy as np
import torch
import torch.nn as nn
from torchvision import datasets
from torchvision import transforms
from torch.utils.data.sampler import SubsetRandomSampler


# Configuration de l'appareil
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

Chargement des données

torchvision est une bibliothèque qui offre un accès facile à de nombreuses bases de données de vision par ordinateur et des méthodes pour préparer ces bases de données de manière aisée et intuitive

• Nous définissons une fonction data_loader qui retourne soit les données d’entraînement/validation, soit les données de test en fonction des arguments
• Nous commençons par définir la variable normalize avec les valeurs moyennes et les écarts-types de chaque canal (rouge, vert et bleu) de la base de données. Ces valeurs peuvent être calculées manuellement, mais sont également disponibles en ligne. Cela est utilisé dans la variable transform où nous redimensionnons les données, les convertissons en tenseurs et les normalisons ensuite
• Si l’argument test est vrai, nous charge simplement la partie de test de la base de données et l’affichons à l’aide de chargeurs de données (expliqués ci-dessous)
• Dans le cas où test est faux (comportement par défaut également), nous chargeons la partie d’entraînement de la base de données et l’ions aléatoirement en une partie d’entraînement et une partie de validation (0,9:0,1)
• Enfin, nous utilisons des chargeurs de données. Cela peut ne pas affecter la performance dans le cas d’une petite base de données comme CIFAR100, mais il peut vraiment limiter la performance dans le cas de grandes bases de données et est généralement considérée comme une bonne pratique. Les chargeurs de données nous permettent d’itérer sur les données en lots, et les données sont chargées lors de l’itération et ne sont pas toutes chargées en même temps dans le début de votre RAM.

def data_loader(data_dir,
                batch_size,
                random_seed=42,
                valid_size=0.1,
                shuffle=True,
                test=False):
  
    normalize = transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2023, 0.1994, 0.2010],
    )

    # Définir les transformations
    transform = transforms.Compose([
            transforms.Resize((227,227)),
            transforms.ToTensor(),
            normalize,
    ])

    if test:
        dataset = datasets.CIFAR100(
          root=data_dir, train=False,
          download=True, transform=transform,
        )

        data_loader = torch.utils.data.DataLoader(
            dataset, batch_size=batch_size, shuffle=shuffle
        )

        return data_loader

    # Charger le jeu de données
    train_dataset = datasets.CIFAR100(
        root=data_dir, train=True,
        download=True, transform=transform,
    )

    valid_dataset = datasets.CIFAR10(
        root=data_dir, train=True,
        download=True, transform=transform,
    )

    num_train = len(train_dataset)
    indices = list(range(num_train))
    split = int(np.floor(valid_size * num_train))

    if shuffle:
        np.random.seed(random_seed)
        np.random.shuffle(indices)

    train_idx, valid_idx = indices[split:], indices[:split]
    train_sampler = SubsetRandomSampler(train_idx)
    valid_sampler = SubsetRandomSampler(valid_idx)

    train_loader = torch.utils.data.DataLoader(
        train_dataset, batch_size=batch_size, sampler=train_sampler)
 
    valid_loader = torch.utils.data.DataLoader(
        valid_dataset, batch_size=batch_size, sampler=valid_sampler)

    return (train_loader, valid_loader)


# Jeu de données CIFAR100
train_loader, valid_loader = data_loader(data_dir='./data',
                                         batch_size=64)

test_loader = data_loader(data_dir='./data',
                              batch_size=64,
                              test=True)

VGG16 à partir de zéro

Pour construire le modèle à partir de zéro, nous devons d’abord comprendre comment les définitions de modèles fonctionnent dans torch et les différents types de couches que nous utiliserons ici :

• Chaque modèle personnalisé doit hériter de la classe nn.Module car elle fournit certaines fonctions de base qui aident le modèle à s’entraîner.
• Deuxièmement, il y a deux choses principales à faire. Premièrement, définir les différentes couches de notre modèle à l’intérieur de la fonction __init__ et la séquence dans laquelle ces couches seront exécutées sur l’entrée à l’intérieur de la fonction forward

Maintenant, définissons les différents types de couches que nous utilisons ici :

• nn.Conv2d : Ces sont les couches de convolution qui acceptent le nombre de canaux d’entrée et de sortie en argument, ainsi que la taille du filtre pour le kernel. Elle accepte également toutes les strides ou le padding si vous souhaitez l’appliquer
• nn.BatchNorm2d : Cela applique la normalisation par lot à la sortie de la couche de convolution
• nn.ReLU : C’est l’activation appliquée à diverses sorties du réseau.
• nn.MaxPool2d : Cette fonction applique la max-pooling à l’output avec la taille de kernel donnée
• nn.Dropout : Il s’agit de l’application de la dropout à l’output avec une probabilité donnée
• nn.Linear : C’est essentiellement une couche pleinement connectée
• nn.Sequential : Techniquement, ce n’est pas un type de couche, mais il permet de combiner différentes opérations qui font partie de la même étape

Avec ces connaissances, nous pouvons maintenant construire notre modèle VGG16 en utilisant l’architecture du papier :

class VGG16(nn.Module):
    def __init__(self, num_classes=10):
        super(VGG16, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU())
        self.layer2 = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(), 
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU())
        self.layer4 = nn.Sequential(
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer5 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU())
        self.layer6 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU())
        self.layer7 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer8 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer9 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer10 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer11 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer12 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer13 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.fc = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(7*7*512, 4096),
            nn.ReLU())
        self.fc1 = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU())
        self.fc2= nn.Sequential(
            nn.Linear(4096, num_classes))
        
    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = self.layer5(out)
        out = self.layer6(out)
        out = self.layer7(out)
        out = self.layer8(out)
        out = self.layer9(out)
        out = self.layer10(out)
        out = self.layer11(out)
        out = self.layer12(out)
        out = self.layer13(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)
        out = self.fc1(out)
        out = self.fc2(out)
        return out

VGG16 de zéro

Hyperparamètres

L’une des parties importantes de tout projet de machine ou de apprentissage profond est l’optimisation des hyperparamètres. ICI, nous ne testerons pas différentes valeurs pour ceux-ci, mais nous devrons les définir à l’avance. Cela inclut la définition du nombre d’epochs, du taille du lot, de taux d’apprentissage, de fonction de perte ainsi que de l’optimiseur

num_classes = 100
num_epochs = 20
batch_size = 16
learning_rate = 0.005

model = VGG16(num_classes).to(device)


# Perte et optimiseur
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay = 0.005, momentum = 0.9)  


# Entraîner le modèle
total_step = len(train_loader)

Définition des hyperparamètres

Entraînement

Nous sommes maintenant prêts à trainer notre modèle. Nous allons d’abord regarder comment nous entraînons notre modèle en torch et ensuite voir le code :

• Pour chaque époch, nous parcourons les images et les étiquettes à l’intérieur de notre train_loader et déplaçons ces images et étiquettes sur le GPU si disponible. Cela se produit automatiquement
• Nous utilisons notre modèle pour prédire sur les étiquettes (model(images)) et then calculer la perte entre les prédictions et les véritables étiquettes en utilisant notre fonction de perte (criterion(outputs, labels))
• Ensuite, nous utilisons cette perte pour backpropagate (loss.backward) et mettre à jour les poids (optimizer.step()). N’oubliez pas de mettre les gradients à zéro avant chaque mise à jour. Cela est fait en utilisant optimizer.zero_grad()
• De plus, à la fin de chaque époch, nous utilisons notre jeu de vérification pour calculer l’exactitude du modèle également. Dans ce cas, nous n’avons pas besoin de gradient, donc nous utilisons with torch.no_grad() pour une évaluation plus rapide

Maintenant, nous combinons tout cela dans le code suivant :

total_step = len(train_loader)

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        # Deplacer les tenseurs vers l'appareil configuré
        images = images.to(device)
        labels = labels.to(device)
        
        # Passe avant
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Arrière et optimiser
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' 
                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))
            
    # Validation
    with torch.no_grad():
        correct = 0
        total = 0
        for images, labels in valid_loader:
            images = images.to(device)
            labels = labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
            del images, labels, outputs
    
        print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total)) 

Entraînement

Nous pouvons voir la sortie du code ci-dessus comme suit, qui montre que le modèle apprend vraiment car la perte est en diminution avec chaque époch :

Pertes d’entraînement

Testation

Pour la testation, nous utilisons exactement le même code que pour la validation mais avec le test_loader :

with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        del images, labels, outputs

    print('Accuracy of the network on the {} test images: {} %'.format(10000, 100 * correct / total))   

Testation

En utilisant le code ci-dessus et en entraînant le modèle pendant 20 épochs, nous avons réussi à atteindre une précision de 75% sur le jeu de test.

Conclusion

Maintenant, concluons ce que nous avons fait dans cet article :

• Nous avons d’abord理解 l’architecture et les différents types de couches dans le modèle VGG-16.
• Ensuite, nous avons chargé et pré-traité le jeu de données CIFAR100 en utilisant torchvision.
• Ensuite, nous avons utilisé PyTorch pour construire notre propre modèle VGG-16 à partir de zéro, en même temps que nous avons essayé de comprendre les différents types de couches disponibles dans torch.
• Finalement, nous avons entraîné et testé notre modèle sur le jeu de données CIFAR100, et le modèle semblait fonctionner bien avec une précision de 75% sur le jeu de test.

Travail Futur

En utilisant cet article, vous obtenez une bonne introduction et une formation pratique, mais vous apprendrez beaucoup plus si vous étendez cela et voyez ce que vous pouvez faire d’autre :

• Vous pouvez essayez d’utiliser différents jeux de données. Un de ces jeux de données est CIFAR10 ou une sous-partie du jeu de données ImageNet.
• Vous pouvez expérimenter avec différents hyperparamètres et voir la meilleure combinaison d’entre eux pour le modèle
• Enfin, vous pouvez essayez d’ajouter ou de supprimer des couches depuis le jeu de données pour voir leur impact sur la capacité du modèle. Autant que cela, essayez de construire la version VGG-19 de ce modèle.