One place for hosting & domains

      réseau

      Comment tromper un réseau de neurones en Python 3


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

      Un réseau de neurones pour la classification des animaux pourrait-il être trompé ? Tromper un classificateur d’animaux peut avoir peu de conséquences, mais que se passerait-il si notre authentificateur de visage pouvait être trompé ? Ou encore le logiciel de notre prototype de voiture qui se conduit toute seule ? Heureusement, une foule d’ingénieurs et de chercheurs se tiennent entre un prototype de modèle de vision par ordinateur et des modèles de qualité production sur nos appareils mobiles ou nos voitures. Néanmoins, ces risques ont des implications importantes et il est important, en tant que professionnel de l’apprentissage automatique, de les prendre en considération.

      Dans ce tutoriel, vous allez essayer de « tromper » ou de duper un classificateur d’animaux. Au fur et à mesure que vous avancez dans le tutoriel, vous utiliserez OpenCV, une bibliothèque de vision par ordinateur, et PyTorch,une bibliothèque de Deep Learning (apprentissage approfondi). Vous aborderez les sujets suivants dans le domaine associé à l’apprentissage automatique contradictoire:

      • Créez un exemple contradictoire ciblé. Choisissez une image, disons, d’un chien. Choisissez une classe cible, disons un chat. Votre objectif est de faire croire au réseau de neurones que le chien représenté est un chat.
      • Créer une défense contradictoire. En bref, protégez votre réseau neuronal contre ces images piégées, sans savoir quelle est le piège.

      À la fin du tutoriel, vous disposerez d’un outil permettant de piéger les réseaux neuronaux et vous comprendrez comment vous défendre contre les pièges.

      Conditions préalables

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

      Étape 1 – Création de votre projet et installation des dépendances

      Créons un espace de travail pour ce projet et installons les dépendances dont vous aurez besoin. Vous appellerez votre espace de travail AdversarialML :

      Naviguez vers le répertoire AdversarialML :

      Faites un répertoire pour conserver tous vos éléments :

      • mkdir ~/AdversarialML/assets

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

      • python3 -m venv adversarialml

      Activez votre environnement :

      • source adversarialml/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é-packagés pour OpenCV et numpyqui sont respectivement des bibliothèques pour la vision par ordinateur et l’algèbre linéaire. 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

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

      • sudo apt-get install libsm6 libxext6 libxrender-dev

      Une fois les dépendances installées, faisons fonctionner un classificateur d’animaux appelé ResNet18, que nous décrivons ensuite.

      Étape 2 – Faire fonctionner un classificateur d’animaux préformés

      La bibliothèque torchvision, la bibliothèque officielle de vision par ordinateur pour PyTorch, contient des versions préformées de réseaux neuronaux de vision par ordinateur couramment utilisés. Ces réseaux neuronaux sont tous formés sur ImageNet 2012, un ensemble de données de 1,2 million d’images de formation avec 1000 classes. Ces classes comprennent les véhicules, les lieux et, surtout, les animaux. Dans cette étape, vous ferez fonctionner l’un de ces réseaux neuronaux préformés, appelé ResNet18. Nous parlerons de ResNet18 formé sur ImageNet comme d’un « classificateur d’animaux ».

      Qu’est-ce que ResNet18 ? ResNet18 est le plus petit réseau neuronal d’une famille de réseaux neuronaux appelés réseaux neuronaux résiduels, développé par MSR (He et al.). En bref, il a découvert qu’un réseau neuronal (désigné comme une fonction f, avec l’entrée x, et la sortie f(x)) serait plus performant avec une « connexion résiduelle » x + f(x). Cette connexion résiduelle est utilisée de façon prolifique dans les réseaux neuronaux de pointe, même aujourd’hui. Par exemple, FBNetV2, FBNetV3.

      Téléchargez cette image d’un chien avec la commande suivante :

      • wget -O assets/dog.jpg https://www.xpresservers.com/wp-content/uploads/2020/06/How-To-Trick-a-Neural-Network-in-Python-3.png

      Image de corgi courant près d'un étang 

      Ensuite, téléchargez un fichier JSON pour convertir la sortie du réseau neuronal en un nom de classe lisible par l’homme :

      • wget -O assets/imagenet_idx_to_label.json https://raw.githubusercontent.com/do-community/tricking-neural-networks/master/utils/imagenet_idx_to_label.json

      Ensuite, créez un script pour faire fonctionner votre modèle prédéfini sur l’image du chien. Créez un nouveau fichier appelé step_2_pretrained.py :

      • nano step_2_pretrained.py

      Tout d’abord, ajoutez le passe-partout Python en important les packages nécessaires et en déclarant une fonction principale:

      step_2_pretrained.py

      from PIL import Image
      import json
      import torchvision.models as models
      import torchvision.transforms as transforms
      import torch
      import sys
      
      def main():
          pass
      
      if __name__ == '__main__':
          main()
      

      Ensuite, chargez le mappage de la sortie du réseau neuronal en noms de classe lisibles à l’oeil humain. Ajoutez-le directement après vos déclarations d’importation et avant votre fonction principale : 

      step_2_pretrained.py

      . . .
      def get_idx_to_label():
          with open("assets/imagenet_idx_to_label.json") as f:
              return json.load(f)
      . . .
      

      Créez une fonction de transformation d’image qui garantira tout d’abord que votre image d’entrée a les bonnes dimensions, et ensuite qu’elle est correctement normalisée. Ajoutez la fonction suivante directement après la dernière :

      step_2_pretrained.py

      . . .
      def get_image_transform():
          transform = transforms.Compose([
            transforms.Resize(224),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                 std=[0.229, 0.224, 0.225])
          ])
          return transform
      . . .
      

      Dans get_image_transform, vous définissez un certain nombre de transformations différentes à appliquer aux images qui sont transmises à votre réseau de neurones :

      • transforms. Resize(224) : Redimensionne le petit côté de l’image à 224. Par exemple, si votre image est de 448 x 672, cette opération réduira l’image à 224 x 336.
      • transforme.CenterCrop(224): Prend un recadrage du centre de l’image, de taille 224 x 224. 
      • transforms.ToTensor() : Convertit l’image en un tenseur PyTorch. Tous les modèles PyTorch nécessitent des tenseurs PyTorch comme entrée.
      • transforms.Normalize(mean=..., std=...): Normalise votre entrée en soustrayant la moyenne, puis en divisant par l’écart type. Ceci est décrit plus précisément dans la documentation de la torchvision.

      Ajouter un utilitaire pour prédire la classe de l’animal, compte tenu de l’image. Cette méthode utilise les deux utilitaires précédents pour effectuer la classification des animaux :

      step_2_pretrained.py

      . . .
      def predict(image):
          model = models.resnet18(pretrained=True)
          model.eval()
      
          out = model(image)
      
          _, pred = torch.max(out, 1)  
          idx_to_label = get_idx_to_label()  
          cls = idx_to_label[str(int(pred))]  
          return cls
      . . .
      

      Ici, la fonction de prédiction classifie l’image fournie en utilisant un réseau neuronal préformé :

      • models.resnet18(pretrained=True): Charge un réseau neuronal préformé appelé ResNet18. 
      • model.eval(): modifie le modèle en place pour qu’il fonctionne en mode « evaluation ». Le seul autre mode est le mode « training », mais le mode « training » n’est pas nécessaire, car vous n’êtes pas en train de former le modèle (c’est-à-dire de mettre à jour les paramètres du modèle) dans ce tutoriel.
      • out = model(image) : fait fonctionner le réseau de neurones sur l’image transformée fournie.
      • _, pred = torch.max(out, 1) : Le réseau de neurones produit une probabilité pour chaque classe possible.  Cette étape permet de calculer l’indice de la classe ayant la plus grande probabilité. Par exemple, si out = [0,4, 0,1, 0,2], alors pred = 0.
      • idx_to_label = get_idx_to_label(): Obtient une correspondance entre l’index des classes et les noms de classe lisibles à l’oeil humain. Par exemple, le mappage pourrait être {0 : chat, 1 : chien, 2 : poisson}. 
      • cls = idx_to_label [str(int(pred))]: Convertit l’indice de classe prévu en un nom de classe. Les exemples fournis dans les deux derniers points permettraient de donner cls = idx_to_label[0] = 'chat'. 

      Ensuite, après la dernière fonction, ajoutez un utilitaire pour charger les images :

      step_2_pretrained.py

      . . .
      def load_image():
          assert len(sys.argv) > 1, 'Need to pass path to image'
          image = Image.open(sys.argv[1])
      
          transform = get_image_transform()
          image = transform(image)[None]
          return image
      . . .
      

      Cela va charger une image à partir du chemin fourni dans le premier argument du script. transform(image) [None] applique la séquence de transformations d’images définie dans les lignes précédentes.

      Enfin, remplissez votre fonction principale avec ce qui suit, pour charger votre image et classer l’animal dans l’image :

      step_2_pretrained.py

      def main():
          x = load_image()
          print(f'Prediction: {predict(x)}')
      

      Vérifiez que votre fichier correspond à notre script final de l’étape 2 à step_2_pretrained.py sur GitHub. Sauvegardez et quittez votre script, et lancez le classificateur d’animaux :

      • python step_2_pretrained.py assets/dog.jpg

      Cela produira le résultat suivant, montrant que votre classificateur d’animaux fonctionne comme prévu :

      Output

      Prediction: Pembroke, Pembroke Welsh corgi

      Cela conclut l’inférence courante avec votre modèle préformé. Ensuite, vous verrez un exemple contradictoire en action en trompant un réseau de neurones avec des différences imperceptibles dans l’image.

      Étape 3 – Essai d’un exemple contradictoire

      Maintenant, vous allez synthétiser un exemple contradictoire et tester le réseau neuronal sur cet exemple. Pour ce tutoriel, vous construirez des exemples contradictoires de la forme x + rx est l’image originale et r est une « perturbation ». Vous finirez par créer la perturbation r vous-même, mais dans cette étape, vous téléchargerez une perturbation que nous avons créée pour vous au préalable. Commencez par télécharger la perturbation r : 

      • wget -O assets/adversarial_r.npy https://github.com/do-community/tricking-neural-networks/blob/master/outputs/adversarial_r.npy?raw=true

      Composez maintenant l’image avec la perturbation. Créez un nouveau fichier appelé step_3_adversarial.py​​​​​ :

      • nano step_3_adversarial.py

      Dans ce fichier, vous effectuerez le processus en trois étapes suivant, afin de produire un exemple contradictoire :

      1. Transformez une image
      2. Appliquez la perturbation r
      3. Transformez à l’inverse l’image perturbée

      À la fin de l’étape 3, vous aurez une image contradictoire. Tout d’abord, il faut importer les packages nécessaires et déclarer une fonction principale :

      step_3_adversarial.py

      from PIL import Image
      import torchvision.transforms as transforms
      import torch
      import numpy as np
      import os
      import sys
      
      from step_2_pretrained import get_idx_to_label, get_image_transform, predict, load_image
      
      
      def main():
          pass
      
      
      if __name__ == '__main__':
          main()
      

      Ensuite, créez une « transformation d’image » qui inverse la transformation d’image précédente. Placez ceci après vos importations, avant la fonction principale :

      step_3_adversarial.py

      . . .
      def get_inverse_transform():
          return transforms.Normalize(
              mean=[-0.485/0.229, -0.456/0.224, -0.406/0.255],  # INVERSE normalize images, according to https://pytorch.org/docs/stable/torchvision/models.html
              std=[1/0.229, 1/0.224, 1/0.255])
      . . .
      

      Comme précédemment, l’opération transforms.Normalize soustrait la moyenne et divise par l’écart type (c’est-à-dire, pour l’image originale x, y = transforms.Normalize(moyenne=u, std=o) = (x - u) / o). Vous faites un peu d’algèbre et vous définissez une nouvelle opération qui inverse cette fonction de normalisation (transforms.Normalize(mean=-u/o, std=1/o) = (y - -u/o) / 1/o = (y + u/o) o = yo + u = x).

      Dans le cadre de la transformation inverse, ajoutez une méthode qui transforme un tenseur PyTorch en une image PIL. Ajoutez ceci à la suite de la dernière fonction :

      step_3_adversarial.py

      . . .
      def tensor_to_image(tensor):
          x = tensor.data.numpy().transpose(1, 2, 0) * 255.  
          x = np.clip(x, 0, 255)
          return Image.fromarray(x.astype(np.uint8))
      . . .
      
      • tensor.data.numpy() convertit le tenseur PyTorch en un tableau NumPy. .transpose(1, 2, 0) réorganise (canaux, largeur, hauteur) en (hauteur, largeur, canaux). Ce tableau NumPy se situe approximativement dans la fourchette (0, 1). Enfin, multipliez par 255 pour vous assurer que l’image est maintenant dans la fourchette (0, 255). 
      • np.clip s’assure que toutes les valeurs de l’image se situent entre (0, 255). 
      • x.astype(np.uint8) garantit que toutes les valeurs des images sont des entiers.  Enfin, Image.fromarray(...) crée un objet image PIL à partir du tableau NumPy.

      Ensuite, utilisez ces services pour créer l’exemple contradictoire suivant :

      step_3_adversarial.py

      . . .
      def get_adversarial_example(x, r):
          y = x + r
          y = get_inverse_transform()(y[0])
          image = tensor_to_image(y)
          return image
      . . .
      

      Cette fonction génère l’exemple contradictoire décrit au début de la section :

      1. y = x + r. Prenez votre perturbation r et ajoutez-la à l’image originale x. 
      2. get_inverse_transform : Obtenez et appliquez la transformation inverse de l’image que vous avez définie plusieurs lignes plus tôt.
      3. tensor_to_image: Enfin, reconvertissez le tenseur PyTorch en objet image. 

      Enfin, modifiez votre fonction principale pour charger l’image, charger la perturbation contradictoire r, appliquer la perturbation, enregistrer l’exemple contradictoire sur le disque et exécuter la prédiction sur l’exemple contradictoire :

      step_3_adversarial.py

      def main():
          x = load_image()
          r = torch.Tensor(np.load('assets/adversarial_r.npy'))
      
          # save perturbed image
          os.makedirs('outputs', exist_ok=True)
          adversarial = get_adversarial_example(x, r)
          adversarial.save('outputs/adversarial.png')
      
          # check prediction is new class
          print(f'Old prediction: {predict(x)}')
          print(f'New prediction: {predict(x + r)}')
      

      Votre dossier complété doit correspondre à step_3_adversarial.py sur GitHub. Enregistrez le fichier, quittez l’éditeur et lancez votre script avec :

      • python step_3_adversarial.py assets/dog.jpg

      Vous verrez la sortie suivante :

      Output

      Old prediction: Pembroke, Pembroke Welsh corgi New prediction: goldfish, Carassius auratus

      Vous avez maintenant créé un exemple contradictoire : faire croire au réseau neuronal qu’un corgi est un poisson rouge. Dans l’étape suivante, vous allez en fait créer la perturbation r que vous avez utilisée ici.

      Étape 4 – Comprendre un exemple de procédure contradictoire

      Pour une introduction à la classification, voir « Comment construire un filtre pour chien basé sur les émotions ».. 

      En prenant du recul, rappelez-vous que votre modèle de classification produit une probabilité pour chaque classe. Lors de l’inférence, le modèle prédit la classe avec la plus grande probabilité. Pendant la formation, vous mettez à jour les paramètres du modèle t pour maximiser la probabilité d’avoir la bonne classe y, compte tenu de vos données x.

      argmax_y P(y|x,t)
      

      Cependant, pour générer des exemples contradictoires, vous modifiez maintenant votre objectif. Au lieu de trouver une classe, votre objectif est maintenant de trouver une nouvelle image, x. Prenez n’importe quelle classe autre que la classe correcte. Appelons cette nouvelle classe w. Votre nouvel objectif est de maximiser la probabilité de la mauvaise classe.

      argmax_x P(w|x)
      

      Notez que les poids du réseau neuronal t sont absents de l’expression ci-dessus. C’est parce que vous assumez maintenant le rôle de l’adversaire : Quelqu’un d’autre a formé et déployé un modèle. Vous êtes seulement autorisé à créer des contributions contradictoires et n’êtes pas autorisé à modifier le modèle déployé. Pour générer l’exemple contradictoire x, vous pouvez exécuter « training », sauf qu’au lieu de mettre à jour les poids du réseau neuronal, vous mettez à jour l’image d’entrée avec le nouvel objectif.

      Pour rappel, concernant ce tutoriel, vous supposez que l’exemple contradictoire est une transformation affine de x. En d’autres termes, votre exemple contradictoire prend la forme x + r pour un certain r. Dans l’étape suivante, vous allez écrire un script pour générer ce r.

      Étape 5 – Création d’un exemple de procédure contradictoire

      Dans cette étape, vous apprendrez une perturbation r, de sorte que votre corgi soit classé à tort comme un poisson rouge. Créez un nouveau fichier appelé step_5_perturb.py​​​​​ :

      Tout d’abord, il faut importer les packages nécessaires et déclarer une fonction main :

      step_5_perturb.py

      from torch.autograd import Variable
      import torchvision.models as models
      import torch.nn as nn
      import torch.optim as optim
      import numpy as np
      import torch
      import os
      
      from step_2_pretrained import get_idx_to_label, get_image_transform, predict, load_image
      from step_3_adversarial import get_adversarial_example
      
      
      def main():
          pass
      
      
      if __name__ == '__main__':
          main()
      

      Directement après vos importations et avant la fonction main, définissez deux constantes :

      step_5_perturb.py

      . . .
      TARGET_LABEL = 1
      EPSILON = 10 / 255.
      . . .
      

      La première constante TARGET_LABEL est la classe dans laquelle il faut confondre le corgi. Dans ce cas, l’indice 1 correspond à « poisson rouge ». La deuxième constante EPSILON est la quantité maximale de perturbation autorisée pour chaque valeur d’image. Cette limite est introduite de manière à ce que l’image soit imperceptiblement altérée.

      En suivant vos deux constantes, ajoutez une fonction d’aide pour définir un réseau de neurones et le paramètre de perturbation r: 

      step_5_perturb.py

      . . .
      def get_model():
          net = models.resnet18(pretrained=True).eval()
          r = nn.Parameter(data=torch.zeros(1, 3, 224, 224), requires_grad=True)
          return net, r
      . . .
      
      • model.resnet18(pretrained=True) charge un réseau neuronal préformé appelé ResNet18, comme auparavant.  Comme auparavant, vous mettez le modèle en mode évaluation en utilisant .eval. 
      • nn.Parameter(...) définit une nouvelle perturbation r, la taille de l’image d’entrée. L’image d’entrée est également de la taille (1, 3, 224, 224).  L’argument du mot-clé require_grad=True assure que vous pouvez mettre à jour cette perturbation r dans les lignes suivantes, dans ce fichier.

      Ensuite, commencez à modifier votre fonction main. Commencez par charger le réseau modèle, charger les entrées x, et définir l’étiquette label :

      step_5_perturb.py

      . . .
      def main():
          print(f'Target class: {get_idx_to_label()[str(TARGET_LABEL)]}')
          net, r = get_model()
          x = load_image()
          labels = Variable(torch.Tensor([TARGET_LABEL])).long()
        . . .
      

      Ensuite, définissez à la fois le critère et l’optimiseur dans votre fonction. Le premier dit à PyTorch quel est l’objectif, c’est-à-dire quelles sont les pertes à minimiser. Ce dernier indique à PyTorch comment entraîner votre paramètre r :

      step_5_perturb.py

      . . .
          criterion = nn.CrossEntropyLoss()
          optimizer = optim.SGD([r], lr=0.1, momentum=0.1)
      . . .
      

      Directement après, ajoutez la boucle de formation principale pour votre paramètre r: 

      step_5_perturb.py

      . . .
          for i in range(30):
              r.data.clamp_(-EPSILON, EPSILON)
              optimizer.zero_grad()
      
              outputs = net(x + r)
              loss = criterion(outputs, labels)
              loss.backward()
              optimizer.step()
      
              _, pred = torch.max(outputs, 1)
              if i % 5 == 0:
                  print(f'Loss: {loss.item():.2f} / Class: {get_idx_to_label()[str(int(pred))]}')
      . . .
      

      À chaque itération de cette boucle de formation, vous devez :

      • r.data.clamp_(...) : Vous assurer que le paramètre r est petit, dans EPSILON de 0.
      • optimizer.zero_grad(): Effacez tous les gradients que vous avez calculés lors de l’itération précédente.
      • model(x + r): Faire une inférence sur l’image modifiée x + r.
      • Calculez la perte. 
      • Calculez le gradient perte.backward. 
      • Prenez une étape de descente en gradient optimizer.step.
      • Calculer la prédiction pred. 
      • Enfin, signalez la perte et la classe print(...).

      Ensuite, sauvegardez la dernière perturbation r :

      step_5_perturb.py

      def main():
          . . .
          for i in range(30):
              . . .
          . . .
          np.save('outputs/adversarial_r.npy', r.data.numpy())
      

      Directement à la suite, toujours dans la fonction main, sauvegardez l’image perturbée :

      step_5_perturb.py

      . . .
          os.makedirs('outputs', exist_ok=True)
          adversarial = get_adversarial_example(x, r)
      

      Enfin, faites des prédictions à la fois sur l’image originale et sur l’exemple contradictoire :

      step_5_perturb.py

          print(f'Old prediction: {predict(x)}')
          print(f'New prediction: {predict(x + r)}')
      

      Vérifiez que votre script correspond à step_5_perturb.py sur GitHub. Sauvegardez, quittez et lancez le script :

      • python step_5_perturb.py assets/dog.jpg

      Votre script donnera les résultats suivants.

      Output

      Target class: goldfish, Carassius auratus Loss: 17.03 / Class: Pembroke, Pembroke Welsh corgi Loss: 8.19 / Class: Pembroke, Pembroke Welsh corgi Loss: 5.56 / Class: Pembroke, Pembroke Welsh corgi Loss: 3.53 / Class: Pembroke, Pembroke Welsh corgi Loss: 1.99 / Class: Pembroke, Pembroke Welsh corgi Loss: 1.00 / Class: goldfish, Carassius auratus Old prediction: Pembroke, Pembroke Welsh corgi New prediction: goldfish, Carassius auratus

      Les deux dernières lignes indiquent que vous avez maintenant terminé la construction d’un exemple contradictoire à partir de zéro. Votre réseau neuronal classe maintenant une image de corgi parfaite comme un poisson rouge.

      Vous avez maintenant montré que les réseaux neuronaux peuvent être facilement dupés, qui plus est, le manque de robustesse aux exemples contradictoires a des conséquences importantes. La question suivante est tout à fait naturelle : Comment pouvez-vous lutter contre les exemples contradictoires ? De nombreuses recherches ont été menées par différentes organisations, dont OpenAI. Dans la section suivante, vous présenterez une défense pour contrecarrer cet exemple de confrontation.

      Étape 6 – Se défendre contre des exemples contradictoires

      Au cours de cette étape, vous mettrez en œuvre une défense contre des exemples contradictoires. L’idée est la suivante : vous êtes maintenant le propriétaire du classificateur d’animaux en cours de déploiement en phase de production. Vous ne savez pas quels exemples contradictoires peuvent être générés, mais vous pouvez modifier l’image ou le modèle pour vous protéger contre les attaques.

      Avant de vous défendre, vous devriez voir par vous-même combien la manipulation de l’image est imperceptible. Ouvrez les deux images suivantes :

      1. assets/dog.jpg
      2. outputs/adversarial.png

      Ici, vous montrez les deux côte à côte. Votre image originale aura un rapport d’aspect différent. Pouvez-vous dire quel est l’exemple de la procédure contradictoire ?

      (gauche) Corgi en poisson rouge, contradictoire, (droite) Corgi en lui-même, non contradictoire

      Remarquez que la nouvelle image semble identique à l’originale. Il s’avère que l’image de gauche est l’image contradictoire. Pour en être certain, téléchargez l’image et lancez votre script d’évaluation :

      • wget -O assets/adversarial.png https://github.com/alvinwan/fooling-neural-network/blob/master/outputs/adversarial.png?raw=true
      • python step_2_pretrained.py assets/adversarial.png

      Cela donnera naissance à la classe des poissons rouges, pour prouver son caractère contradictoire :

      Output

      Prediction: goldfish, Carassius auratus

      Vous dirigerez une défense assez naïve, mais efficace : Comprimer l’image en écrivant dans un format JPEG avec perte. Ouvrez l’invite interactive Python :

      Ensuite, chargez l’image contradictoire au format PNG, et enregistrez-la à nouveau au format JPEG.

      • from PIL import Image
      • image = Image.open('assets/adversarial.png')
      • image.save('outputs/adversarial.jpg')

      Tapez CTRL + D pour quitter l’invite interactive Python. Ensuite, faites des inférences avec votre modèle sur l’exemple contradictoire compressé :

      • python step_2_pretrained.py outputs/adversarial.jpg

      Cela va maintenant produire la classe corgi, prouvant l’efficacité de votre défense naïve.

      Output

      Prediction: Pembroke, Pembroke Welsh corgi

      Vous avez maintenant terminé votre toute première défense contradictoire. Notez que cette défense n’exige pas de savoir comment l’exemple contradictoire a été généré. C’est ce qui fait une défense efficace. Il existe également de nombreuses autres formes de défense, dont beaucoup impliquent le recyclage du réseau neuronal. Toutefois, ces procédures de recyclage sont un sujet à part entière et dépassent le cadre de ce tutoriel. Ceci conclut votre guide sur l’apprentissage automatique contradictoire.

      Conclusion

      Pour comprendre les implications de votre travail dans ce tutoriel, revisitez les deux images côte à côte l’original et l’exemple contradictoire.

      (gauche) Corgi en poisson rouge, contradictoire, (droite) Corgi en lui-même, non contradictoire

      Malgré le fait que les deux images semblent identiques à l’œil humain, la première a été manipulée pour tromper votre modèle. Les deux images montrent clairement un corgi, et pourtant le modèle est tout à fait sûr que le second modèle contient un poisson rouge. Cela devrait vous préoccuper et, en terminant ce tutoriel, gardez à l’esprit la fragilité de votre modèle. Il suffit d’appliquer une simple transformation pour la tromper. Ce sont là des dangers réels et plausibles qui échappent même à la recherche de pointe. La recherche qui va au-delà de la sécurité de l’apprentissage automatique est tout aussi sensible à ces défauts, et, en tant que professionnel, il vous appartient d’appliquer l’apprentissage automatique en toute sécurité. Pour plus de lectures, consultez les liens suivants :

      Pour plus de contenu et de tutoriels sur l’apprentissage automatique, vous pouvez visiter notre Page thématique sur l’apprentissage automatique. 



      Source link

      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 :

      É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 :

      Naviguez jusqu’au répertoire 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 :

      Note : sous macOS, par défaut, wget n’est pas disponible. Pour qu’il le soit, installez Homebrew en suivant ce tutoriel de DigitalOcean. Ensuite, exécutez brew install wget.

      • 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 :

      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 :

      step_2_dataset.py

      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 :

      step_2_dataset.py

          @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 :

      step_2_dataset.py

          @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 :

      step_2_dataset.py

          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 :

      step_2_dataset.py

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

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

      step_2_dataset.py

          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 :

      step_2_dataset.py

      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 :

      step_2_dataset.py

      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 :

      step_2_dataset.py

      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 :

      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 :

      Importez les utilitaires dont vous avez besoin :

      step_3_train.py

      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 :

      step_3_train.py

      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 :

      step_3_train.py

      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 :

      step_3_train.py

      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 :

      step_3_train.py

      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 :

      step_3_train.py

      if __name__ == '__main__':
          main()
      

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

      step_3_train.py

      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 :

      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 :

      step_3_train.py

      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.

      Importez les utilitaires dont vous avez besoin :

      step_4_evaluate.py

      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 :

      step_4_evaluate.py

      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 :

      step_4_evaluate.py

      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 :

      step_4_evaluate.py

      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 :

      step_4_evaluate.py

          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 :

      step_4_evaluate.py

      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 :

      Ajoutez le code suivant dans le fichier :

      step_5_camera.py

      """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 :

      step_5_camera.py

      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 :

      step_5_camera.py

      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 :

      step_5_camera.py

      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 :

      step_5_camera.py

      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 :

      step_5_camera.py

      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 :

      step_5_camera.py

              ...
              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 :

      step_5_camera.py

              ...
              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 :

      step_5_camera.py

              ...
              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.

      step_5_camera.py

      ...
      
          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 :

      step_5_camera.py

      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.

      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.

      Capture d'écran de votre programme OpenCV échantillon, pour la langue des signes « L » 
       Capture d'écran de votre programme OpenCV échantillon, pour la langue des signes « 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 ?



      Source link