Maison > Article > Périphériques technologiques > Réseau contradictoire génératif à convolution profonde en pratique
Traducteur | Zhu Xianzhong
Critique | Sun Shujuan
Red Vineyard (Auteur : Vincent van Gogh)
Selon le rapport du « New York Times », 90 % de l'énergie des centres de données est gaspillée. c'est parce que l'entreprise La plupart des données collectées ne sont jamais analysées ou utilisées sous quelque forme que ce soit. Plus précisément, cela s’appelle « Dark Data ».
Les « données sombres » font référence aux données obtenues via diverses opérations de réseau informatique mais qui ne sont en aucun cas utilisées pour obtenir des informations ou prendre des décisions. La capacité d'une organisation à collecter des données peut dépasser son débit d'analyse. Dans certains cas, les organisations peuvent même ne pas savoir que des données sont collectées. IBM estime qu'environ 90 % des données générées par les capteurs et la conversion analogique-numérique ne sont jamais utilisées. — Définition Wikipédia des « données sombres »
Du point de vue de l'apprentissage automatique, l'une des principales raisons pour lesquelles ces données ne sont pas utiles pour tirer des informations est le manque d'étiquettes. Cela rend les algorithmes d’apprentissage non supervisés très attractifs pour exploiter le potentiel de ces données.
En 2014, Ian Goodfello et al. ont proposé une nouvelle méthode pour estimer les modèles génératifs à travers un processus contradictoire. Cela implique la formation simultanée de deux modèles indépendants : un modèle générateur qui tente de modéliser la distribution des données et un discriminateur qui tente de classer l'entrée comme données d'entraînement ou fausses données via le générateur.
Cet article pose une étape très importante dans le domaine de l'apprentissage automatique moderne et ouvre une nouvelle voie pour l'apprentissage non supervisé. En 2015, l'article GAN à convolution profonde publié par Radford et al a réussi à générer des images 2D en appliquant les principes des réseaux convolutifs, continuant ainsi à s'appuyer sur cette idée dans l'article. À travers cet article, j'ai essayé d'expliquer les composants clés abordés dans l'article ci-dessus et de les implémenter à l'aide du framework PyTorch.
Quels sont les aspects accrocheurs du GAN ?
1. Étant donné que la plupart des données réelles ne sont pas étiquetées, les propriétés d'apprentissage non supervisées des GAN les rendent idéales pour de tels cas d'utilisation.
2. Les générateurs et les discriminateurs agissent comme de très bons extracteurs de fonctionnalités pour les cas d'utilisation avec des données étiquetées limitées, ou génèrent des données supplémentaires pour améliorer la formation du modèle quadratique, car ils peuvent générer de faux échantillons au lieu d'utiliser des techniques d'augmentation.
3. Les GAN offrent une alternative aux techniques du maximum de vraisemblance. Leur processus d’apprentissage contradictoire et leur fonction de coût non heuristique les rendent très attractifs pour l’apprentissage par renforcement.
4. La recherche sur le GAN est très attractive et ses résultats ont suscité un large débat sur l'impact du ML/DL. Par exemple, Deepfake est une application du GAN qui superpose le visage d'une personne sur une personne cible, ce qui est de nature très controversée car elle a le potentiel d'être utilisée à des fins néfastes.
5. Enfin et surtout, travailler avec ce genre de réseau est cool et toutes les nouvelles recherches dans ce domaine sont fascinantes.
Architecture globale
Architecture du GAN à convolution profonde
Comme nous en avons discuté plus tôt, nous travaillerons via DCGAN, qui tente de mettre en œuvre l'idée de base du GAN, un réseau convolutif pour générer des images réalistes.
DCGAN se compose de deux modèles indépendants : un générateur (G) qui essaie de modéliser des vecteurs de bruit aléatoires en entrée et essaie d'apprendre la distribution des données pour générer de faux échantillons, et un autre discriminateur (D) qui récupère les données d'entraînement (échantillons réels) et les données générées (faux échantillons) et essayez de les classer. La lutte entre ces deux modèles est ce que nous appelons un processus d’entraînement contradictoire, dans lequel la perte de l’une des parties est le gain de l’autre.
Générateur
Schéma d'architecture du générateur
Le générateur est la partie qui nous intéresse le plus car c'est un générateur qui génère de fausses images pour tenter de tromper le discriminateur.
Maintenant, regardons l'architecture du générateur plus en détail.
Parmi eux, les couches 2 à 5 constituent le bloc générateur de base, qui peut être répété N fois pour obtenir la forme d'image de sortie souhaitée.
Ce qui suit est le code clé de la façon dont nous l'implémentons dans PyTorch (pour le code source complet, voir l'adresse https://github.com/akash-agni/ReadThePaper/blob/main/DCGAN/dcgan.py).
Utilisez le générateur du framework PyTorch pour implémenter le code clé
Schéma d'architecture du discriminateur
Il est facile de voir sur la figure que le discriminateur ressemble plus à un réseau de classification d'images, juste faire quelques petits ajustements. Par exemple, au lieu d'utiliser des couches de regroupement pour le sous-échantillonnage, il utilise une couche convolutive spéciale appelée couche convolutive stride, qui lui permet d'apprendre son propre sous-échantillonnage.
Maintenant, examinons de plus près l'architecture du discriminateur.
Dans cette architecture, les couches 2 à 5 forment le bloc de base du discriminateur, et le calcul peut être répété N fois pour rendre le modèle plus complexe pour chaque donnée d'entraînement.
Voici comment nous l'implémentons dans PyTorch (pour le code source complet, voir l'adresse https://github.com/akash-agni/ReadThePaper/blob/main/DCGAN/dcgan.py).
Section de code clé du discriminateur implémentée dans PyTorch
Nous formons le discriminateur (D) pour maximiser la probabilité d'attribuer la bonne étiquette aux échantillons d'entraînement et aux échantillons du générateur (G), qui peut être fait en minimisant log(D(x)). Nous entraînons simultanément G à minimiser log(1 − D(G(z))), où z représente le vecteur de bruit. En d'autres termes, D et G utilisent tous deux la fonction de valeur V (G, D) pour jouer au jeu minimax à deux joueurs suivant :
Formule de calcul de la fonction de coût contradictoire
Dans un environnement d'application pratique, l'équation ci-dessus peut ne pas fournir suffisamment de gradients pour que G puisse bien apprendre. Dans les premiers stades de l’apprentissage, lorsque G est médiocre, D peut rejeter les échantillons avec une grande confiance car ils sont significativement différents des données d’entraînement. Dans ce cas, la fonction log(1 − D(G(z))) atteint la saturation. Au lieu d'entraîner G pour minimiser log(1 − D(G(z))), nous entraînons G pour maximiser logD(G(z)). Cette fonction objectif génère les mêmes points fixes pour G et D dynamiques, mais fournit des calculs de gradient plus solides au début de l'apprentissage. ——article arxiv
Étant donné que nous entraînons deux modèles en même temps, cela peut être délicat, et les GAN sont notoirement difficiles à entraîner, l'un des problèmes connus dont nous discuterons plus tard est appelé effondrement du mode modèles .
Le document recommande d'utiliser l'optimiseur Adam avec un taux d'apprentissage de 0,0002. Un taux d'apprentissage aussi faible indique que les GAN ont tendance à diverger très rapidement. Il utilise également un élan de premier et deuxième ordre avec des valeurs de 0,5 et 0,999 pour accélérer davantage l'entraînement. Le modèle est initialisé avec une distribution pondérée normale avec une moyenne de zéro et un écart type de 0,02.
Ce qui suit montre comment nous implémentons une boucle de formation pour cela (le code source complet est disponible sur https://github.com/akash-agni/ReadThePaper/blob/main/DCGAN/dcgan.py).
Boucle de formation du DCGAN
Idéalement, nous voulons que le générateur produise une variété de sorties. Par exemple, s'il génère des visages, il doit générer un nouveau visage pour chaque entrée aléatoire. Cependant, si le générateur produit une sortie suffisamment plausible pour tromper le discriminateur, il peut produire la même sortie encore et encore.
Finalement, le générateur suroptimisera un seul discriminateur et effectuera une rotation entre un petit ensemble de sorties, une situation appelée « effondrement de mode ».
Les méthodes suivantes peuvent être utilisées pour corriger la situation.
En bref, l'article sur le GAN et le DCGAN mentionné ci-dessus est tout simplement un article historique, car il ouvre une nouvelle voie dans l'apprentissage non supervisé. La méthode de formation contradictoire qui y est proposée fournit une nouvelle méthode pour former des modèles qui simulent étroitement le processus d'apprentissage du monde réel. Il sera donc très intéressant de voir comment ce domaine évolue.
Enfin, vous pouvez trouver le code source complet d'implémentation de l'exemple de projet dans cet article sur mon Dépôt de code source GitHub.
Zhu Xianzhong, rédacteur en chef de la communauté 51CTO, professeur d'informatique dans une université de Weifang et vétéran de l'industrie de la programmation indépendante.
Titre original : Implementing Deep Convolutional GAN, auteur : Akash Agnihotri
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!