Comment construire un réseau neuronal pour traduire la langue des signes en anglais

L’auteur a choisi Code Org ​​ pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

La vision par ordinateur est un sous-domaine de l’informatique qui vise à extraire une compréhension supérieure des choses à partir d’images et de vidéos. On la retrouve dans les technologies comme les filtres de chat vidéo amusants, l’authentification de visage sur votre appareil mobile et les voitures autonomes.

Dans ce tutoriel, vous utiliserez la vision par ordinateur pour créer un traducteur de la langue des signes américaine pour votre webcam. Au cours de ce tutoriel, vous utiliserez OpenCV, une bibliothèque de vision par ordinateur, PyTorch pour créer un réseau neuronal profond et onnx pour exporter votre réseau neuronal. Vous appliquerez également les concepts suivants lors de la création d’une application de vision par ordinateur :

• Vous utiliserez la même méthode en trois étapes qui est utilisée dans le tutoriel Comment appliquer la vision par ordinateur pour créer un filtre pour chiens basé sur les émotions : pré-traiter un ensemble de données, former un modèle et évaluer le modèle.
• Vous allez également aller plus loin dans chacune de ces étapes : utiliser l’augmentation des données pour traiter les aiguilles tournées ou non centrées, modifier les horaires de fréquence d’apprentissage pour améliorer la précision du modèle et exporter des modèles pour une vitesse d’inférence plus rapide.
• En cours de route, vous explorerez également les concepts liés à l’apprentissage automatique.

À la fin de ce tutoriel, vous aurez à la fois un traducteur de la langue des signes américaine et le savoir-faire fondamental sur l’apprentissage profond. Vous pouvez également accéder au code source complet de ce projet.

Conditions préalables

Pour terminer ce tutoriel, vous aurez besoin des éléments suivants :

• Un environnement de développement local pour Python 3 avec au moins 1 Go de RAM. Vous pouvez consulter Comment installer et configurer un environnement de programmation local pour Python 3 pour configurer tout ce dont vous avez besoin.
• Une webcam qui fonctionne pour la détection d’images en temps réel.
• (Recommandé) Créez un filtre pour chien basé sur les émotions. On n’utilise pas explicitement ce tutoriel mais les mêmes idées y sont renforcées et développées.

Étape 1 - Création du projet et installation des dépendances

Créons un espace de travail pour ce projet et installons les dépendances dont nous aurons besoin.

Sur les distributions Linux, commencez par préparer votre gestionnaire de packages système et installez le package virtualenv de Python3. Utilisez :

apt-get update
apt-get upgrade
apt-get install python3-venv

Nous allons appeler notre espace de travail SignLanguage :

mkdir ~/SignLanguage

Naviguez jusqu’au répertoire SignLanguage :

cd ~/SignLanguage

Ensuite, créez un nouvel environnement virtuel pour le projet :

python3 -m venv signlanguage

Activez votre environnement :

source signlanguage/bin/activate

Installez ensuite PyTorch, un framework d’apprentissage profond pour Python que nous utiliserons au cours de ce tutoriel.

Sous macOS, installez Pytorch avec la commande suivante :

python -m pip install torch==1.2.0 torchvision==0.4.0

Sous Linux et Windows, utilisez les commandes suivantes pour une construction du CPU uniquement :

pip install torch==1.2.0+cpu torchvision==0.4.0+cpu -f https://download.pytorch.org/whl/torch_stable.html
pip install torchvision

Installez maintenant les binaires préfilmés pour OpenCV, numpy et onnx, des bibliothèques destinée à la vision par ordinateur, l’algèbre linéaire, l’exportation de modèle AI et l’exécution de modèle AI, respectivement. OpenCV propose des utilitaires tels que les rotations d’images et numpy fournit des utilitaires d’algèbre linéaire comme l’inversion d’une matrice :

python -m pip install opencv-python==3.4.3.18 numpy==1.14.5 onnx==1.6.0 onnxruntime==1.0.0

Sur les distributions Linux, vous devrez installer libSM.so :

apt-get install libsm6 libxext6 libxrender-dev

Une fois les dépendances installées, construisons la première version de notre traducteur de la langue des signes : un système de classification de la langue des signes.

Étape 2 - Préparation de l’ensemble de données de classification de la langue des signes

Au cours des trois prochaines sections, vous allez construire un système de classification de la langue des signes à l’aide d’un réseau neuronal. Votre objectif est de produire un modèle qui accepte une image d’une main en entrée et génère une lettre.

Vous devez suivre les trois étapes suivantes pour créer un modèle de classification d’apprentissage automatique :

1. Pré-traitez les données : appliquez one-hot encoding​​​​​​ à vos étiquettes et sauvegardez vos données dans PyTorch Tensors. Entraînez votre modèle sur des données augmentées pour le préparer à une saisie “inhabituelle”, comme une main sur le côté ou tournée.
2. Spécifiez et entraînez le modèle : configurez un réseau neuronal à l’aide de PyTorch. Définissez les hyper-paramètres d’entraînement (comme la durée d’entraînement) et exécutez la descente de gradient stochastique. Vous modifierez également un hyper-paramètre d’entraînement spécifique, qui correspond au calendrier de fréquence d’apprentissage. Ils optimisent la précision du modèle.
3. Exécutez une prédiction à l’aide du modèle : évaluez le réseau neuronal sur vos données de validation pour comprendre sa précision. Ensuite, exportez le modèle dans un format appelé ONNX pour avoir des vitesses d’inférence plus rapides.

Dans cette section du tutoriel, vous allez effectuer l’étape 1 sur 3. Vous allez télécharger les données, créer un objet Dataset pour itérer sur vos données et enfin appliquer l’augmentation des données. À la fin de cette étape, vous aurez un moyen d’accéder par programme aux images et aux étiquettes de votre ensemble de données qui viendront alimenter votre modèle.

Tout d’abord, téléchargez l’ensemble de données dans votre répertoire de travail actuel :

wget https://assets.digitalocean.com/articles/signlanguage_data/sign-language-mnist.tar.gz

Décompressez le fichier zip, qui contient un répertoire data/ :

tar -xzf sign-language-mnist.tar.gz

Créez un nouveau fichier que vous nommerez step_2_dataset.py :

nano step_2_dataset.py

Comme précédemment, importez les utilitaires nécessaires et créez la classe qui contiendra vos données. Ici, pour le traitement des données, vous allez créer des ensembles de données d’entraînement et de test. Vous allez implémenter l’interface de Dataset de PyTorch, qui vous permettra de charger et d’utiliser le pipeline de données intégré de PyTorch pour votre ensemble de données de classification de la langue des signes :

from torch.utils.data import Dataset
from torch.autograd import Variable
import torch.nn as nn
import numpy as np
import torch

import csv


class SignLanguageMNIST(Dataset):
    """Sign Language classification dataset.

    Utility for loading Sign Language dataset into PyTorch. Dataset posted on
    Kaggle in 2017, by an unnamed author with username `tecperson`:
    https://www.kaggle.com/datamunge/sign-language-mnist

    Each sample is 1 x 1 x 28 x 28, and each label is a scalar.
    """
    pass

Supprimez l’espace réservé pass dans la catégorie SignLanguageMNIST. À sa place, ajoutez une méthode pour générer un mappage d’étiquette :

    @staticmethod
    def get_label_mapping():
        """
        We map all labels to [0, 23]. This mapping from dataset labels [0, 23]
        to letter indices [0, 25] is returned below.
        """
        mapping = list(range(25))
        mapping.pop(9)
        return mapping

Les étiquettes vont de 0 à 25. Cependant, les lettres J (9) et Z (25) sont exclues. Cela signifie qu’il n’existe que 24 valeurs d’étiquette valables. Pour que l’ensemble de toutes les valeurs d’étiquette à partir de 0 soit contigu, nous mappons toutes les étiquettes de [0 à 23]. Ce mappage des étiquettes de [0 à 23] et des indices de lettre de [0 à 25] de l’ensemble de données est fourni par cette méthode get_label_mapping.

Ensuite, ajoutez une méthode pour extraire les étiquettes et les échantillons d’un fichier CSV. Ce qui suit suppose que chaque ligne commence par l’étiquette, ensuite suivie des valeurs 784 pixels. Ces valeurs 784 pixels représentent une image 28x28 :

    @staticmethod
    def read_label_samples_from_csv(path: str):
        """
        Assumes first column in CSV is the label and subsequent 28^2 values
        are image pixel values 0-255.
        """
        mapping = SignLanguageMNIST.get_label_mapping()
        labels, samples = [], []
        with open(path) as f:
            _ = next(f)  # skip header
            for line in csv.reader(f):
                label = int(line[0])
                labels.append(mapping.index(label))
                samples.append(list(map(int, line[1:])))
        return labels, samples

Pour avoir une explication sur la façon dont ces 784 valeurs représentent une image, voir Créer un filtre pour chien basé sur les émotions, étape 4.

Notez que chaque ligne de l’itérable csv.reader est une liste de chaînes. Les invocations int et map (int, ...) transforment toutes les chaînes en entiers. Juste en dessous de notre méthode statique, ajoutez une fonction qui initialisera notre support de données :

    def __init__(self,
            path: str="data/sign_mnist_train.csv",
            mean: List[float]=[0.485],
            std: List[float]=[0.229]):
        """
        Args:
            path: Path to `.csv` file containing `label`, `pixel0`, `pixel1`...
        """
        labels, samples = SignLanguageMNIST.read_label_samples_from_csv(path)
        self._samples = np.array(samples, dtype=np.uint8).reshape((-1, 28, 28, 1))
        self._labels = np.array(labels, dtype=np.uint8).reshape((-1, 1))

        self._mean = mean
        self._std = std

Cette fonction commence par charger les échantillons et les étiquettes. Ensuite, elle sauvegarde les données dans des tableaux NumPy. Les informations sur l’écart moyen et l’écart-type seront expliquées sous peu, dans la section __getitem__ suivante.

Juste après la fonction __init__, ajoutez une fonction __len__ Le Dataset requiert cette méthode pour déterminer à quel moment arrêter l’itération sur les données :

...
    def __len__(self):
        return len(self._labels)

Enfin, ajoutez une méthode __getitem__, qui renvoie un dictionnaire qui contient l’échantillon et l’étiquette :

    def __getitem__(self, idx):
        transform = transforms.Compose([
            transforms.ToPILImage(),
            transforms.RandomResizedCrop(28, scale=(0.8, 1.2)),
            transforms.ToTensor(),
            transforms.Normalize(mean=self._mean, std=self._std)])

        return {
            'image': transform(self._samples[idx]).float(),
            'label': torch.from_numpy(self._labels[idx]).float()
        }

Vous utilisez la technique que l’on appelle data augmentation, dans laquelle les échantillons sont perturbés pendant l’entraînement, pour augmenter la robustesse du modèle face à ces perturbations. En particulier, zoomez de façon aléatoire sur l’image en variant les quantités et sur différents emplacements, via RandomResizedCrop. Notez que le zoom avant ne devrait pas affecter la catégorie finale de la langue des signes. Ainsi, l’étiquette n’est pas transformée. Vous normalisez encore plus les entrées de sorte que les valeurs d’image soient remises à l’échelle dans la plage [0 à 1] dans les valeurs attendues, au lieu de [0 à 25]5. Pour ce faire, utilisez l’ensemble de données _mean et _std lors de la normalisation.

La catégorie SignLanguageMNIST que vous venez de terminer ressemblera à ce qui suit :

from torch.utils.data import Dataset
from torch.autograd import Variable
import torchvision.transforms as transforms
import torch.nn as nn
import numpy as np
import torch

from typing import List

import csv


class SignLanguageMNIST(Dataset):
    """Sign Language classification dataset.

    Utility for loading Sign Language dataset into PyTorch. Dataset posted on
    Kaggle in 2017, by an unnamed author with username `tecperson`:
    https://www.kaggle.com/datamunge/sign-language-mnist

    Each sample is 1 x 1 x 28 x 28, and each label is a scalar.
    """

    @staticmethod
    def get_label_mapping():
        """
        We map all labels to [0, 23]. This mapping from dataset labels [0, 23]
        to letter indices [0, 25] is returned below.
        """
        mapping = list(range(25))
        mapping.pop(9)
        return mapping

    @staticmethod
    def read_label_samples_from_csv(path: str):
        """
        Assumes first column in CSV is the label and subsequent 28^2 values
        are image pixel values 0-255.
        """
        mapping = SignLanguageMNIST.get_label_mapping()
        labels, samples = [], []
        with open(path) as f:
            _ = next(f)  # skip header
            for line in csv.reader(f):
                label = int(line[0])
                labels.append(mapping.index(label))
                samples.append(list(map(int, line[1:])))
        return labels, samples

    def __init__(self,
            path: str="data/sign_mnist_train.csv",
            mean: List[float]=[0.485],
            std: List[float]=[0.229]):
        """
        Args:
            path: Path to `.csv` file containing `label`, `pixel0`, `pixel1`...
        """
        labels, samples = SignLanguageMNIST.read_label_samples_from_csv(path)
        self._samples = np.array(samples, dtype=np.uint8).reshape((-1, 28, 28, 1))
        self._labels = np.array(labels, dtype=np.uint8).reshape((-1, 1))

        self._mean = mean
        self._std = std

    def __len__(self):
        return len(self._labels)

    def __getitem__(self, idx):
        transform = transforms.Compose([
            transforms.ToPILImage(),
            transforms.RandomResizedCrop(28, scale=(0.8, 1.2)),
            transforms.ToTensor(),
            transforms.Normalize(mean=self._mean, std=self._std)])

        return {
            'image': transform(self._samples[idx]).float(),
            'label': torch.from_numpy(self._labels[idx]).float()
        }

Comme précédemment, vous allez maintenant vérifier les fonctions de notre utilitaire d’ensemble de données en chargeant l’ensemble de données SignLanguageMNIST. Ajoutez le code suivant à la fin de votre fichier après la catégorie SignLanguageMNIST :

def get_train_test_loaders(batch_size=32):
    trainset = SignLanguageMNIST('data/sign_mnist_train.csv')
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)

    testset = SignLanguageMNIST('data/sign_mnist_test.csv')
    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)
    return trainloader, testloader

Ce code initialise l’ensemble de données avec la catégorie SignLanguageMNIST. Ensuite, pour les ensembles d’entraînement et de validation, il sauvegarde l’ensemble de données dans un DataLoader. Cela traduira l’ensemble de données en un itérable à utiliser plus tard.

Vous allez maintenant vérifier que les utilitaires d’ensemble de données fonctionnent bien. Créez un exemple de chargeur de jeu de données à l’aide DataLoader et imprimez le premier élément de ce chargeur. Ajoutez ce qui suit à la fin de votre fichier :

if __name__ == '__main__':
    loader, _ = get_train_test_loaders(2)
    print(next(iter(loader)))

Vous pouvez vérifier si votre fichier correspond au fichier step_2_dataset dans ce (référentiel). Quittez votre éditeur et exécutez le script avec les éléments suivants :

python step_2_dataset.py

Cela génère la paire de vecteurs contravariants suivante. Notre pipeline de données génère deux échantillons et deux étiquettes. Cela indique que notre pipeline de données est opérationnel et prêt à être utilisé :

Output
{'image': tensor([[[[ 0.4337,  0.5022,  0.5707,  ...,  0.9988,  0.9646,  0.9646],
          [ 0.4851,  0.5536,  0.6049,  ...,  1.0502,  1.0159,  0.9988],
          [ 0.5364,  0.6049,  0.6392,  ...,  1.0844,  1.0844,  1.0673],
          ...,
          [-0.5253, -0.4739, -0.4054,  ...,  0.9474,  1.2557,  1.2385],
          [-0.3369, -0.3369, -0.3369,  ...,  0.0569,  1.3584,  1.3242],
          [-0.3712, -0.3369, -0.3198,  ...,  0.5364,  0.5364,  1.4783]]],


        [[[ 0.2111,  0.2796,  0.3481,  ...,  0.2453, -0.1314, -0.2342],
          [ 0.2624,  0.3309,  0.3652,  ..., -0.3883, -0.0629, -0.4568],
          [ 0.3309,  0.3823,  0.4337,  ..., -0.4054, -0.0458, -1.0048],
          ...,
          [ 1.3242,  1.3584,  1.3927,  ..., -0.4054, -0.4568,  0.0227],
          [ 1.3242,  1.3927,  1.4612,  ..., -0.1657, -0.6281, -0.0287],
          [ 1.3242,  1.3927,  1.4440,  ..., -0.4397, -0.6452, -0.2856]]]]), 'label': tensor([[24.],
        [11.]])}

Vous avez maintenant vérifié si votre pipeline de données fonctionne bien. Ceci conclut la première étape, le prétraitement de vos données, qui comprend désormais une augmentation des données pour un module plus robuste. Vous allez ensuite définir le réseau neuronal et l’optimiseur.

Étape 3 - Création et formation du un système de classification de la langue des signes à l’aide de l’apprentissage profond

Maintenant que vous avez un pipeline de données fonctionnel, vous allez définir un modèle et le former sur les données. Vous allez tout particulièrement construire un réseau neuronal à six couches, définir une perte, un optimiseur et enfin optimiser la fonction de perte pour les prédictions de votre réseau neuronal. À la fin de cette étape, vous disposerez d’un système de classification de la langue des signes fonctionnel.

Créez un nouveau fichier appelé step_3_train.py :

nano step_3_train.py

Importez les utilitaires dont vous avez besoin :

from torch.utils.data import Dataset
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch

from step_2_dataset import get_train_test_loaders

Définissez un réseau neuronal PyTorch comprenant trois couches convolutives, suivies de trois couches entièrement connectées. Ajoutez ce qui suit à la fin de votre script existant :

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 6, 3)
        self.conv3 = nn.Conv2d(6, 16, 3)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 48)
        self.fc3 = nn.Linear(48, 24)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

Maintenant, initialisez le réseau neuronal, définissez une fonction de perte et configurez les hyperparamètres d’optimisation en ajoutant le code suivant à la fin du script :

def main():
    net = Net().float()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

Enfin, vous vous entraînerez sur deux epochs :

def main():
    net = Net().float()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

    trainloader, _ = get_train_test_loaders()
    for epoch in range(2):  # loop over the dataset multiple times
        train(net, criterion, optimizer, trainloader, epoch)
    torch.save(net.state_dict(), "checkpoint.pth")

Vous configurez une epoch comme une itération de l’entraînement au cours de laquelle chaque échantillon d’entraînement a été utilisé exactement une fois. À la fin de la fonction principale, les paramètres du modèle seront enregistrés dans un fichier nommé "checkpoint.pth".

Ajoutez le code suivant à la fin de votre script pour extraire l’image et l'étiquette du chargeur d’ensemble de données, puis sauvegardez-les tous dans une variable PyTorch :

def train(net, criterion, optimizer, trainloader, epoch):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs = Variable(data['image'].float())
        labels = Variable(data['label'].long())
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels[:, 0])
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 100 == 0:
            print('[%d, %5d] loss: %.6f' % (epoch, i, running_loss / (i + 1)))

Ce code exécutera également la passe avant, puis la rétropropagera à travers le réseau de perte et neuronal.

À la fin de votre fichier, ajoutez ce qui suit pour appeler la fonction main :

if __name__ == '__main__':
    main()

Vérifiez que les éléments de votre fichier correspondent à ce qui suit :

from torch.utils.data import Dataset
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch

from step_2_dataset import get_train_test_loaders


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 6, 3)
        self.conv3 = nn.Conv2d(6, 16, 3)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 48)
        self.fc3 = nn.Linear(48, 25)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


def main():
    net = Net().float()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

    trainloader, _ = get_train_test_loaders()
    for epoch in range(2):  # loop over the dataset multiple times
        train(net, criterion, optimizer, trainloader, epoch)
    torch.save(net.state_dict(), "checkpoint.pth")


def train(net, criterion, optimizer, trainloader, epoch):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs = Variable(data['image'].float())
        labels = Variable(data['label'].long())
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels[:, 0])
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 100 == 0:
            print('[%d, %5d] loss: %.6f' % (epoch, i, running_loss / (i + 1)))


if __name__ == '__main__':
    main()

Sauvegardez et fermez. Ensuite, lancez notre entraînement de validation de concept en exécutant :

python step_3_train.py

Lorsque votre réseau neuronal s’entraîne, vous aurez un résultat semblable à ce qui suit :

Output
[0,     0] loss: 3.208171
[0,   100] loss: 3.211070
[0,   200] loss: 3.192235
[0,   300] loss: 2.943867
[0,   400] loss: 2.569440
[0,   500] loss: 2.243283
[0,   600] loss: 1.986425
[0,   700] loss: 1.768090
[0,   800] loss: 1.587308
[1,     0] loss: 0.254097
[1,   100] loss: 0.208116
[1,   200] loss: 0.196270
[1,   300] loss: 0.183676
[1,   400] loss: 0.169824
[1,   500] loss: 0.157704
[1,   600] loss: 0.151408
[1,   700] loss: 0.136470
[1,   800] loss: 0.123326

Pour obtenir une perte plus faible, vous pouvez augmenter le nombre d’époques de 5 à 10 ou même 20. Cependant, après une certaine période d’entraînement, la perte de réseau ne pourra plus diminuer avec l’augmentation du temps d’entraînement. Pour contourner ce problème, à mesure que le temps d’entraînement augmente, vous introduirez un calendrier de taux d’apprentissage, qui viendra faire baisser le taux d’apprentissage au fil du temps. Pour comprendre pourquoi cela fonctionne, voir la présentation de Distill “Pourquoi Momentum fonctionne réellement”

Modifiez votre fonction main avec les deux lignes suivantes, configurant un scheduler et invoquant scheduler.step. De plus, configurez le nombre d’époques sur 12 :

def main():
    net = Net().float()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

    trainloader, _ = get_train_test_loaders()
    for epoch in range(12):  # loop over the dataset multiple times
        train(net, criterion, optimizer, trainloader, epoch)
        scheduler.step()
    torch.save(net.state_dict(), "checkpoint.pth")

Vérifiez que votre fichier correspond au fichier de l’étape 3 dans ce référentiel. L’entraînement durera environ 5 minutes. Votre résultat ressemblera à ce qui suit:

Output
[0,     0] loss: 3.208171
[0,   100] loss: 3.211070
[0,   200] loss: 3.192235
[0,   300] loss: 2.943867
[0,   400] loss: 2.569440
[0,   500] loss: 2.243283
[0,   600] loss: 1.986425
[0,   700] loss: 1.768090
[0,   800] loss: 1.587308
...
[11,     0] loss: 0.000302
[11,   100] loss: 0.007548
[11,   200] loss: 0.009005
[11,   300] loss: 0.008193
[11,   400] loss: 0.007694
[11,   500] loss: 0.008509
[11,   600] loss: 0.008039
[11,   700] loss: 0.007524
[11,   800] loss: 0.007608

La perte finale obtenue est de 0.007608, soit 3 ordres de grandeur plus petite que la perte de départ de 3.20. Ceci conclut la deuxième étape de notre flux de travail, au cours duquel nous configurons et entraînons le réseau neuronal. Cela dit, aussi petite que soit cette valeur de perte, elle n’a que peu de sens. Pour mettre les performances du modèle en perspective, nous calculerons sa précision, c’est à dire le pourcentage d’images correctement classées par le modèle.

Étape 4 - Évaluation du système de classification de la langue des signes

Vous allez maintenant évaluer votre système de classification de la langue des signes en calculant sa précision sur le validation set, un ensemble d’images que le modèle n’a pas vu pendant l’entraînement. Cela vous donnera une meilleure idée des performances du modèle que la valeur de perte finale. De plus, vous ajouterez des utilitaires pour enregistrer notre modèle entraîné à la fin de l’entraînement et charger notre modèle pré-formé lors de l’inférence.

Créez un nouveau fichier que vous appellerez step_4_evaluate.py.

nano step_4_evaluate.py

Importez les utilitaires dont vous avez besoin :

from torch.utils.data import Dataset
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch
import numpy as np

import onnx
import onnxruntime as ort

from step_2_dataset import get_train_test_loaders
from step_3_train import Net

Ensuite, configurer un utilitaire pour évaluer les performances du réseau neuronal. La fonction suivante compare la lettre prédite par le réseau neuronal avec la vraie lettre, pour une seule image :

def evaluate(outputs: Variable, labels: Variable) -> float:
    """Evaluate neural network outputs against non-one-hotted labels."""
    Y = labels.numpy()
    Yhat = np.argmax(outputs, axis=1)
    return float(np.sum(Yhat == Y))

outputs liste les catégories probables pour chaque échantillon. Par exemple, les outputs pour un seul échantillon peuvent être [0.1, 0.3, 0.4, 0.2]. labels est une liste de catégories d’étiquettes. Par exemple, la catégorie d’étiquette peut être 3.

Y = ... convertit les étiquettes en un tableau NumPy. Ensuite, Yhat = np.argmax (...) convertit les catégories probables des outputs en prédictions de catégories. Par exemple, la liste de catégories probables [0.1, 0.3, 0.4, 0.2] donnerait la prédiction de catégorie 2 prédite, car la valeur d’indice 2 de 0,4 est la plus grande valeur.

Maintenant que Y et Yhat sont des catégories, vous pouvez les comparer. Yhat == Y vérifie si la prédiction de catégorie correspond à la catégorie d’étiquette, et np.sum (...) est une astuce qui calcule le nombre de valeurs de truth-y. En d’autres termes, np.sum affichera le nombre d’échantillons correctement classés.

Ajoutez la deuxième fonction batch_evaluate, qui applique la première fonction evaluate à toutes les images :

def batch_evaluate(
        net: Net,
        dataloader: torch.utils.data.DataLoader) -> float:
    """Evaluate neural network in batches, if dataset is too large."""
    score = n = 0.0
    for batch in dataloader:
        n += len(batch['image'])
        outputs = net(batch['image'])
        if isinstance(outputs, torch.Tensor):
            outputs = outputs.detach().numpy()
        score += evaluate(outputs, batch['label'][:, 0])
    return score / n

batch est un groupe d’images stockées comme un seul vecteur contravariant. Tout d’abord, vous devez augmenter le nombre total d’images à évaluer (n) en fonction du nombre d’images de ce lot. Ensuite, exécutez l’inférence sur le réseau neuronal avec ce lot d’images, outputs = net(...). La vérification type if isinstance (...) convertit les sorties dans un tableau NumPy au besoin. Enfin, utilisez evaluate pour calculer le nombre d’échantillons correctement classés. À la fin de la fonction, vous calculez le pourcentage d’échantillons que vous avez correctement classés, score / n.

Enfin, ajoutez le script suivant pour tirer parti des utilitaires précédents :

def validate():
    trainloader, testloader = get_train_test_loaders()
    net = Net().float()

    pretrained_model = torch.load("checkpoint.pth")
    net.load_state_dict(pretrained_model)

    print('=' * 10, 'PyTorch', '=' * 10)
    train_acc = batch_evaluate(net, trainloader) * 100.
    print('Training accuracy: %.1f' % train_acc)
    test_acc = batch_evaluate(net, testloader) * 100.
    print('Validation accuracy: %.1f' % test_acc)


if __name__ == '__main__':
    validate()

Cela charge un réseau neuronal pré-entraîné et évalue ses performances sur l’ensemble de données en langue des signes fourni. Plus précisément, le script donne ici une précision sur les images que vous avez utilisées pour la formation et un ensemble distinct d’images que vous mettez de côté à des fins de test, appelé validation set.

Vous allez ensuite exporter le modèle PyTorch vers un fichier binaire ONNX. Ce fichier binaire peut ensuite être utilisé en production pour exécuter l’inférence avec votre modèle. Plus important encore, le code exécutant ce binaire n’a pas besoin d’une copie de la configuration du réseau d’origine. À la fin de la fonction de valide, ajoutez ce qui suit :

    trainloader, testloader = get_train_test_loaders(1)

    # export to onnx
    fname = "signlanguage.onnx"
    dummy = torch.randn(1, 1, 28, 28)
    torch.onnx.export(net, dummy, fname, input_names=['input'])

    # check exported model
    model = onnx.load(fname)
    onnx.checker.check_model(model)  # check model is well-formed

    # create runnable session with exported model
    ort_session = ort.InferenceSession(fname)
    net = lambda inp: ort_session.run(None, {'input': inp.data.numpy()})[0]

    print('=' * 10, 'ONNX', '=' * 10)
    train_acc = batch_evaluate(net, trainloader) * 100.
    print('Training accuracy: %.1f' % train_acc)
    test_acc = batch_evaluate(net, testloader) * 100.
    print('Validation accuracy: %.1f' % test_acc)

Cela exporte le modèle ONNX, vérifie le modèle exporté, puis exécute l’inférence avec le modèle exporté. Vérifiez que votre fichier correspond au fichier de l’étape 4 dans ce référentiel :

from torch.utils.data import Dataset
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch
import numpy as np

import onnx
import onnxruntime as ort

from step_2_dataset import get_train_test_loaders
from step_3_train import Net


def evaluate(outputs: Variable, labels: Variable) -> float:
    """Evaluate neural network outputs against non-one-hotted labels."""
    Y = labels.numpy()
    Yhat = np.argmax(outputs, axis=1)
    return float(np.sum(Yhat == Y))


def batch_evaluate(
        net: Net,
        dataloader: torch.utils.data.DataLoader) -> float:
    """Evaluate neural network in batches, if dataset is too large."""
    score = n = 0.0
    for batch in dataloader:
        n += len(batch['image'])
        outputs = net(batch['image'])
        if isinstance(outputs, torch.Tensor):
            outputs = outputs.detach().numpy()
        score += evaluate(outputs, batch['label'][:, 0])
    return score / n


def validate():
    trainloader, testloader = get_train_test_loaders()
    net = Net().float().eval()

    pretrained_model = torch.load("checkpoint.pth")
    net.load_state_dict(pretrained_model)

    print('=' * 10, 'PyTorch', '=' * 10)
    train_acc = batch_evaluate(net, trainloader) * 100.
    print('Training accuracy: %.1f' % train_acc)
    test_acc = batch_evaluate(net, testloader) * 100.
    print('Validation accuracy: %.1f' % test_acc)

    trainloader, testloader = get_train_test_loaders(1)

    # export to onnx
    fname = "signlanguage.onnx"
    dummy = torch.randn(1, 1, 28, 28)
    torch.onnx.export(net, dummy, fname, input_names=['input'])

    # check exported model
    model = onnx.load(fname)
    onnx.checker.check_model(model)  # check model is well-formed

    # create runnable session with exported model
    ort_session = ort.InferenceSession(fname)
    net = lambda inp: ort_session.run(None, {'input': inp.data.numpy()})[0]

    print('=' * 10, 'ONNX', '=' * 10)
    train_acc = batch_evaluate(net, trainloader) * 100.
    print('Training accuracy: %.1f' % train_acc)
    test_acc = batch_evaluate(net, testloader) * 100.
    print('Validation accuracy: %.1f' % test_acc)


if __name__ == '__main__':
    validate()

Pour utiliser et évaluer le point de contrôle de la dernière étape, exécutez ce qui suit :

python step_4_evaluate.py

Cela générera une sortie similaire à la suivante, affirmant que votre modèle exporté non seulement fonctionne, mais le fait également en accord avec votre modèle PyTorch d’origine :

Output
========== PyTorch ==========
Training accuracy: 99.9
Validation accuracy: 97.4
========== ONNX ==========
Training accuracy: 99.9
Validation accuracy: 97.4

Votre réseau neuronal atteint une précision d’entraînement de 99,9 % et une précision de validation de 97,4 %. Cet écart entre la précision d’entraînement et de la validation indique que votre modèle souffre d’un ajustement excessif. Cela signifie qu’au lieu d’apprendre des modèles généralisables, votre modèle a mémorisé les données d’entraînement. Pour comprendre les implications et les causes du sur-ajustement, consultez Comprendre les compromis entre le biais et la variance.

À ce stade, nous avons terminé de concevoir un système de classification de la langue des signes En substance, notre modèle peut correctement lever une ambiguïté entre les signes presque tout le temps. Nous avons un modèle plutôt acceptable, nous pouvons donc passer à l’étape finale de notre application. Nous utiliserons ce système de classification de la langue des signes dans une application webcam en temps réel.

Étape 5 - Liaison du flux de la caméra

Votre prochain objectif est de relier l’appareil photo de l’ordinateur à votre système de classification de la langue des signes. Vous allez collecter les entrées de la caméra, classer la langue des signes affichée, puis signaler le signe classifié à l’utilisateur.

Créez maintenant un script Python pour le détecteur de visages. Créez le fichier step_6_camera.py en utilisant nano ou votre éditeur de texte favori :

nano step_5_camera.py

Ajoutez le code suivant dans le fichier :

"""Test for sign language classification"""
import cv2
import numpy as np
import onnxruntime as ort

def main():
    pass

if __name__ == '__main__':
    main()

Ce code importe OpenCV, qui contient vos utilitaires d’image, et le runtime ONNX, tout ce dont vous avez besoin pour exécuter l’inférence avec votre modèle. Le reste du code est un texte standard type du programme Python.

Remplacez maintenant pass dans la fonction main par le code suivant, qui initialise un système de classification de la langue des signes en utilisant les paramètres que vous avez précédemment entraînés. Ajoutez également un mappage des index aux lettres et aux statistiques d’images :

def main():
    # constants
    index_to_letter = list('ABCDEFGHIKLMNOPQRSTUVWXY')
    mean = 0.485 * 255.
    std = 0.229 * 255.

    # create runnable session with exported model
    ort_session = ort.InferenceSession("signlanguage.onnx")

Vous utiliserez des éléments de ce test script de la documentation officielle d’OpenCV. Plus précisément, vous mettrez à jour le corps de la fonction main. Commencez par initialiser un objet VideoCapture configuré pour capturer le flux en direct à partir de la caméra de votre ordinateur. Placez-le à la fin de la fonction main :

def main():
    ...
    # create runnable session with exported model
    ort_session = ort.InferenceSession("signlanguage.onnx")

    cap = cv2.VideoCapture(0)

Ajoutez ensuite une boucle while pour que la lecture se fasse à partir de la caméra à chaque intervalle de temps :

def main():
    ...
    cap = cv2.VideoCapture(0)
    while True:
        # Capture frame-by-frame
        ret, frame = cap.read()

Écrivez une fonction utilitaire qui prend le recadrage central comme cadre de caméra. Placez cette fonction avant main :

def center_crop(frame):
    h, w, _ = frame.shape
    start = abs(h - w) // 2
    if h > w:
        frame = frame[start: start + w]
    else:
        frame = frame[:, start: start + h]
    return frame

Ensuite, prenez le recadrage central comme cadre de la caméra, convertissez-le en niveaux de gris, normalisez -le et redimensionnez-le en 28x28. Placez-le dans la boucle while de la fonction main :

def main():
    ...
    while True:
        # Capture frame-by-frame
        ret, frame = cap.read()

        # preprocess data
        frame = center_crop(frame)
        frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
        x = cv2.resize(frame, (28, 28))
        x = (frame - mean) / std

Toujours dans la boucle while, exécutez l’inférence avec le runtime ONNX. Convertissez les sorties en un index de catégorie, puis en une lettre :

        ...
        x = (frame - mean) / std

        x = x.reshape(1, 1, 28, 28).astype(np.float32)
        y = ort_session.run(None, {'input': x})[0]

        index = np.argmax(y, axis=1)
        letter = index_to_letter[int(index)]

Affichez la lettre prédite à l’intérieur du cadre et affichez le cadre à l’utilisateur :

        ...
        letter = index_to_letter[int(index)]

        cv2.putText(frame, letter, (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 2.0, (0, 255, 0), thickness=2)
        cv2.imshow("Sign Language Translator", frame)

À la fin de la boucle while, ajoutez ce code pour vérifier si lorsque l’utilisateur frappe le caractère q il quitte bien l’application. Cette ligne arrête le programme pendant 1 milliseconde. Ajoutez ce qui suit :

        ...
        cv2.imshow("Sign Language Translator", frame)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

Enfin, relâchez la capture et fermez toutes les fenêtres. Placez-la en dehors de la boucle while pour terminer la fonction main.

...

    while True:
        ...
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break


    cap.release()
    cv2.destroyAllWindows()

Vérifiez que votre fichier correspond à ce qui suit ou à ce référentiel :

import cv2
import numpy as np
import onnxruntime as ort


def center_crop(frame):
    h, w, _ = frame.shape
    start = abs(h - w) // 2
    if h > w:
        return frame[start: start + w]
    return frame[:, start: start + h]


def main():
    # constants
    index_to_letter = list('ABCDEFGHIKLMNOPQRSTUVWXY')
    mean = 0.485 * 255.
    std = 0.229 * 255.

    # create runnable session with exported model
    ort_session = ort.InferenceSession("signlanguage.onnx")

    cap = cv2.VideoCapture(0)
    while True:
        # Capture frame-by-frame
        ret, frame = cap.read()

        # preprocess data
        frame = center_crop(frame)
        frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
        x = cv2.resize(frame, (28, 28))
        x = (x - mean) / std

        x = x.reshape(1, 1, 28, 28).astype(np.float32)
        y = ort_session.run(None, {'input': x})[0]

        index = np.argmax(y, axis=1)
        letter = index_to_letter[int(index)]

        cv2.putText(frame, letter, (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 2.0, (0, 255, 0), thickness=2)
        cv2.imshow("Sign Language Translator", frame)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Quittez votre fichier et exécutez le script.

python step_5_camera.py

Une fois le script exécuté, une fenêtre apparaîtra avec votre flux de webcam en direct. La lettre de la langue des signes prédite s’affichera en haut à gauche. Levez la main et faites votre signe favori pour voir votre classeur en action. Voici quelques exemples de résultats avec la lettre L et D.

 

Lorsque vous réalisez les tests, notez que l’arrière-plan doit être assez clair pour que ce traducteur fonctionne. C’est une conséquence malheureuse de la propreté de l’ensemble de données. Si l’ensemble de données comprenait des images de signes de la main avec des arrière-plans divers, le réseau pourrait résister aux arrière-plans bruyants. Cependant, dans cet ensemble de données, les arrière-plans sont vierges et les mains bien centrées. Par conséquent, ce traducteur de webcam fonctionne mieux lorsque vous centrez votre main et la placez sur un fond vierge.

Ceci conclut l’application du traducteur de la langue des signes.

Conclusion

Dans ce tutoriel, vous avez créé un traducteur de la langue des signes américaine à l’aide de la vision par ordinateur et d’un modèle d’apprentissage automatique. Vous avez tout particulièrement abordé de nouveaux aspects de l’entraînement d’un modèle d’apprentissage automatique, notamment l’augmentation des données pour veiller à la robustesse du modèle, les calendriers de fréquence d’apprentissage pour réduire les pertes et l’exportation de modèles d’IA à l’aide d’ONNX pour la production. Vous avez ensuite obtenu une application de vision par ordinateur en temps réel, qui traduit le langage des signes en lettres à l’aide d’un pipeline que vous avez créé. Il convient de noter vous pouvez lutter contre la fragilité du classificateur final en utilisant l’une des méthodes suivantes (ou l’ensemble d’entre elles). Pour explorer le sujet plus profondément, essayez les rubriques suivantes pour améliorer votre application :

• Généralisation : il ne s’agit d’un sous-thème de la vision par ordinateur, mais plutôt d’un problème constant tout au long de l’apprentissage automatique. Voir Comprendre les compromis entre le biais et la variance.
• Adaptation du domaine : supposons que votre modèle soit formé dans le domaine A (par exemple, des environnements ensoleillés). Pouvez-vous rapidement adapter le modèle au domaine B (par exemple, des environnements nuageux) ?
• Exemples contradictoires : Supposons qu’un adversaire conçoit intentionnellement des images pour tromper votre modèle. Comment pouvez-vous concevoir de telles images ? Que pouvez-vous faire pour combattre de telles images ?