Bibliothèques GAN pour l'apprentissage en profondeur

Vue d'ensemble

• Les GAN sont des modèles génératifs, croyez ce que vous les nourrissez.
• nous avons répertorié 4 bibliothèques GAN en vedette

introduction

Actuellement, Le GAN est considéré comme l'un des domaines de recherche les plus intéressants en vision par ordinateur. Ses prouesses de traitement d'image sont inégalées et, être un scientifique des données, ne pas explorer ce serait une erreur. Même des personnes éminentes comme Yann LeCun ont décrit les GAN comme “l'idée la plus intéressante en apprentissage automatique ces derniers temps 10 ans”.

Quand j'ai travaillé pour la première fois avec GAN, Je l'ai développé à partir de zéro en utilisant PyTorch et c'était une tâche fastidieuse. Cela devient encore plus difficile lorsque le résultat n'est pas satisfaisant et que vous souhaitez essayer une autre architecture, car maintenant il faut réécrire le code. Mais heureusement, Des chercheurs travaillant dans divers géants techniques ont développé diverses bibliothèques GAN pour vous aider à explorer et développer des applications basées sur GAN.

Dans cet article, nous verrons 4 Bibliothèques GAN intéressantes que vous devez absolument connaître. En outre, Je vais vous donner un aperçu du GAN, pour commencer.

Je vous recommande de consulter notre Programme de vision artificielle commencer dans ce domaine.

Table des matières

• Un aperçu rapide des GAN
• Bibliothèques GAN
• TF-GAN
• Torche-GAN
• Mimétisme
• Boîte à outils IBM- GAN

Un aperçu rapide des GAN

Ian Good Fellow a présenté les GAN dans 2014 et c'est une méthode d'apprentissage en profondeur à la pointe de la technologie. C'est un membre de la famille des modèles génératifs qui passe par l'entraînement de l'adversaire.

La modélisation générative est une méthode puissante dans laquelle le réseau apprend la distribution des données d'entrée et essaie de générer le nouveau point de données sur la base d'une distribution similaire.. Si nous regardons les exemples de modèles génératifs, nous avons des encodeurs automatiques, Machines Boltzmann, réseaux génératifs contradictoires, redes bayesianas, etc.

Architecture GAN

Les GAN sont constitués de deux réseaux de neurones, un générateur GRAMME et un discriminateur ré. En outre, ces deux modèles sont impliqués dans un jeu à somme nulle pendant l'entraînement.

Le réseau de générateurs apprend la distribution des données d'entraînement. Et quand nous fournissons du bruit aléatoire en entrée, génère des données synthétiques qui tentent d'imiter les échantillons d'apprentissage.

Voici maintenant le modèle discriminateur (ré). Désigne une étiquette: Vrai ou Faux aux données générées par GRAMME basé sur la distribution des données. Cela signifie que la nouvelle image provient des images d'apprentissage ou est une image générée artificiellement..

Le cas où ré reconnaître avec succès l'image comme réelle ou fausse conduit à une perte de générateur accrue. De la même manière, lorsque GRAMME parvient à créer des images de bonne qualité similaires aux vraies et trompe le ré, la perte de discriminateur augmente. En outre, le générateur apprend du processus et génère des images meilleures et plus réalistes à l'itération suivante.

Essentiellement, peut être considéré comme un jeu MIN-MAX à deux joueurs. Ici, les performances des deux réseaux s'améliorent avec le temps. Les deux réseaux passent par plusieurs itérations de formation. Au fil du temps et diverses mises à jour des paramètres du modèle tels que les poids et les biais, atteindre l'état d'équilibre également connu sous le nom équilibre de Nash.

Quel est l'équilibre de Nash?

L'équilibre de Nash est un état stable d'un système qui implique l'interaction de différents participants, dans lequel aucun participant ne peut gagner par un changement unilatéral de stratégie si les stratégies des autres restent inchangées.

En dernier recours, dans ce jeu à somme nulle, nous pouvons générer avec succès des images artificielles ou fausses qui ressemblent pour la plupart à l'ensemble de données d'entraînement réel.

Exemple-

Voyons à quel point les GAN peuvent être utiles.

Par exemple, pendant le confinement, eu la chance de revoir son ancien album photo. Dans une période si stressante, est une bonne critique pour revivre vos souvenirs. Mais comment cet album était dans ton placard pendant des années, intact, certaines photographies ont été abîmées et cela vous a rendu triste. Et c'est précisément à ce moment-là que vous avez décidé d'utiliser GAN.

L'image ci-dessous a été restaurée avec succès avec l'aide de GAN, en utilisant une méthode appelée Image Inpainting.

Source de l'image: Bertalmio et al., 2000.

Image Inpainting est l'art de restaurer des images endommagées en reconstruisant les parties manquantes en utilisant les informations de fond disponibles.. Cette technique est également utilisée pour supprimer les objets indésirables des images données.

Ce n'était qu'un rapide examen du GAN. Si vous voulez en savoir plus, Je vous suggère de lire les articles suivants.

Nous allons maintenant voir quelques bibliothèques GAN intéressantes.

TF-GAN

Tensorflow GAN, également connu sous le nom de TF-GAN, est une bibliothèque python légère et open source. Il a été développé par les chercheurs de Google AI pour une mise en œuvre facile et efficace du GAN.

TF-GAN fournit une infrastructure bien développée pour former et évaluer le réseau contradictoire génératif ainsi que des fonctions de perte et des mesures d'évaluation éprouvées.. La bibliothèque se compose de plusieurs modules pour implémenter le modèle. Fournit des appels de fonction simples qu'un utilisateur peut appliquer sur ses propres données sans écrire le code à partir de zéro.

Il est facile à installer et à utiliser comme d'autres packages comme NumPy et pandas, car il fournit le package PyPi. Utilisez le code suivant

#Installation de la bibliothèque
pip installer tensorflow-gan
#importation de la bibliothèque
importer tenorflow_gan en tant que tfgan

Ce qui suit est un code pour générer des images à partir de l'ensemble de données MNIST à l'aide de TF-Gan-

# Configurer l'entrée.
images = mnist_data_provider.provide_data(DRAPEAUX.taille du lot)
bruit = tf.random_normal([DRAPEAUX.taille du lot, DRAPEAUX.noise_dims])

# Construire le générateur et le discriminateur.
modèle_gan = tfgan.gan_model(
    générateur_fn=mnist.unconditional_generator,  # tu définis
    discriminateur_fn=mnist.unconditional_discriminator,  # tu définis
    données_réelles=images,
    générateur_entrées=bruit)

# Construire la perte du GAN.
gan_loss = tfgan.gan_loss(
    modèle_gan,
    generator_loss_fn=tfgan_losses.wasserstein_generator_loss,
    discriminateur_perte_fn=tfgan_losses.wasserstein_discriminator_loss)

# Créer les opérations de train, qui calculent les gradients et appliquent les mises à jour aux poids.
train_ops = tfgan.gan_train_ops(
    modèle_gan,
    gan_loss,
    générateur_optimiseur=tf.train.AdamOptimizer(gen_lr, 0.5),
    discriminateur_optimiseur=tf.train.AdamOptimizer(dis_lr, 0.5))

# Exécuter les opérations de train dans le programme de formation en alternance.
tfgan.gan_train(
    train_ops,
    crochets=[tf.train.StopAtStepHook(nombre_étapes=DRAPEAUX.nombre_max_de_pas)],
    rép_log=DRAPEAUX.train_log_dir)

Ce que j'aime dans la bibliothèque

1. Une chose importante à propos de la bibliothèque est que TF-GAN prend actuellement en charge Tensorflow-2.0, c'est-à-dire, la dernière version de TensorFlow. En outre, vous pouvez l'utiliser efficacement avec d'autres frameworks.
2. L'entraînement d'un modèle d'adversaire génératif est une tâche de traitement lourde, cela prenait des semaines. TF-GAN prend en charge Cloud TPU. Ainsi, le processus de formation est terminé en quelques heures. Pour en savoir plus sur l'utilisation de TF-GAN en TPU, peut voir est didacticiel des auteurs de bibliothèque.
3. Au cas où vous auriez besoin de comparer les résultats de plusieurs articles, TF-GAN vous fournit des métriques standard qui permettent à l'utilisateur de comparer facilement et efficacement différents articles de recherche sans aucun biais statistique..

Voici quelques projets mis en œuvre avec TF-GAN-

En outre, pour en savoir plus sur cette intéressante bibliothèque GAN utilisée par les chercheurs de Google, lis le document officiel.

Torche-GAN

Torch-GAN est un framework basé sur PyTorch pour écrire des codes courts et faciles à comprendre pour développer GAN. Ce package se compose de plusieurs réseaux d'adversaires génératifs ainsi que des utilitaires nécessaires à leur mise en œuvre..

Généralement, Les GAN partagent une conception standard comportant plusieurs composants tels que le modèle de générateur, le modèle discriminateur, la fonction de perte et les métriques d'évaluation. Tandis que Torch GAN imite la conception des GAN via une API simple et permet aux composants d'être personnalisés en cas de besoin.

La source

Cette bibliothèque GAN facilite l'interaction entre les composants GAN grâce à un entraîneur très polyvalent qui s'adapte automatiquement aux modèles et aux pertes définis par l'utilisateur..

L'installation de la bibliothèque est simple à l'aide de pip. Vous avez juste besoin d'utiliser la commande ci-dessous ci-dessous et le tour est joué.

pip3 installer torchgan

Implémentation des modèles Torch-GAN

Au cœur de la conception, nous avons un module formateur responsable de la flexibilité et de la facilité d'utilisation. L'utilisateur doit fournir les spécifications requises, c'est-à-dire, l'architecture des modèles générateur et discriminateur, avec l'optimiseur associé. L'utilisateur doit également fournir les fonctions de perte et les métriques d'évaluation.

La bibliothèque offre la liberté de choisir vos spécifications parmi la large gamme disponible ou vos propres variantes personnalisées. Dans l'image suivante, nous pouvons voir la mise en œuvre de DC-GAN en seulement 10 lignes de code, ce n'est pas surprenant?

La source

Qu'est-ce que j'aime dans cette bibliothèque GAN?

1. 1. La large gamme d'architecture GAN qui prend en charge. Vous nommez l'architecture et vous en trouverez l'implémentation TorchGAN. Par exemple, Vanille GAN, DCGAN, CycleGan, GAN conditionnel, Réseau multi-accusatoire génératif et bien d'autres.
   2. Une autre caractéristique importante du cadre est son extensibilité et sa flexibilité.. Torch-GAN est un package compréhensible. Nous pouvons l'utiliser efficacement avec des fonctionnalités intégrées ou définies par l'utilisateur.
   3. En outre, fournit un affichage efficace des performances via un objet Logger. Prend en charge la journalisation de la console et l'affichage des performances à l'aide de TensorBoard et Vizdom.

Si tu veux aller plus loin, n'oubliez pas de lire le documents officiels de TorchGAN.

Mimétisme

Avec l'augmentation de la recherche dans le domaine, nous pouvons voir diverses implémentations GAN. Difficile de comparer plusieurs implémentations développées à l'aide de différents frameworks, entraînés dans différentes conditions et évalués à l'aide de différentes métriques. Cette comparaison est une tâche incontournable pour les chercheurs. Donc, c'était la principale motivation derrière le développement de Mimicry.

la source

Mimicry est une bibliothèque PyTorch légère pour la reproductibilité du GAN. Fournit les fonctionnalités communes nécessaires pour former et évaluer un modèle Gan. Cela permet aux chercheurs de se concentrer sur la mise en œuvre du modèle plutôt que d'écrire le même code passe-partout encore et encore..

Cette bibliothèque GAN fournit l'implémentation standard de diverses architectures GAN telles que DCGAN, Wasserstein GAN avec pénalité de gradient (WGAN-GP), GAN auto-surveillé (SSGAN), etc. même taille de modèle, formé dans des conditions similaires.

Comme les deux autres bibliothèques, nous pouvons facilement installer Mimicry en utilisant pip et il est prêt à l'emploi.

pip installer torche-mimétisme

Voici la mise en place rapide de SNGAN en utilisant le mimétisme

importer torche
importer torche.optim comme optimum
importer torche_mimétisme comme mmc
de torch_mimicry.nets importer sngan


# Objets de traitement de données
dispositif = torche.dispositif('miracles:0' si torche.miracle.est disponible() autre "CPU")
base de données = mmc.ensembles de données.load_dataset(racine='./ensembles de données', Nom='cifar10')
chargeur de données = torche.utilitaires.Les données.DataLoader(
        base de données, taille du lot=64, mélanger=Vrai, nombre_travailleurs=4)

# Définir des modèles et des optimiseurs
netG = sngan.SNGANGenerator32().à(dispositif)
netD = sngan.SNGANDdiscriminateur32().à(dispositif)
optD = optimum.Adam(netD.paramètres(), 2e-4, bêta=(0.0, 0.9))
optG = optimum.Adam(netG.paramètres(), 2e-4, bêta=(0.0, 0.9))

# Commence l'entraînement
entraîneur = mmc.entraînement.Entraîneur(
    netD=netD,
    netG=netG,
    optD=optD,
    optG=optG,
    n_dis=5,
    nombre_étapes=100000,
    lr_decay='linéaire',
    chargeur de données=chargeur de données,
    log_dir='./log/exemple',
    dispositif=dispositif)
entraîneur.former()

Une autre caractéristique importante du mimétisme est qu'il fournit un support Tensorboard pour la visualisation des performances. Donc, vous pouvez créer une courbe de perte et de probabilité pour surveiller l'entraînement. Peut afficher des images générées aléatoirement pour vérifier la variété.

Le mimétisme est un développement intéressant destiné à aider les chercheurs. Je vous suggère personnellement de lire le Papier d'imitation.

Boîte à outils IBM GAN

Jusqu'à maintenant, nous avons vu des bibliothèques GAN très efficaces et à la pointe de la technologie. Il existe de nombreuses autres bibliothèques GAN comme Keras-GAN, PyTorch-GAN, PyGAN, etc. Quand on regarde de près, nous voyons des points communs entre ces bibliothèques GAN. Ils sont gourmands en code. Si vous voulez utiliser l'un d'eux, il faut bien connaître

• La connaissance et la mise en œuvre du GAN.
• Courant en Python
• Comment utiliser le cadre particulier

C'est un peu difficile de tout savoir pour un programmeur de logiciels. Résoudre le problème, nous avons ici un outil GAN ​​facile à utiliser: IBM GAN-Toolkit.

La boîte à outils GAN fournit une variante très flexible, sans code, mettre en œuvre des modèles GAN. En outre, fournit un haut niveau d'abstraction pour implémenter le modèle GAN. Ici, l'utilisateur n'a qu'à donner les détails du modèle en utilisant le fichier de configuration ou l'argument de ligne de commande. Ensuite, le cadre s'occupera de tout le reste. personnellement je l'ai trouvé très intéressant.

Les étapes suivantes vous aideront avec l'installation:

1. En premier lieu, on clone le code

   $ git clone https://github.com/IBM/gan-toolkit
   $ CD gan-boîte à outils

2. Ensuite, installez toutes les exigences

   $ pip install -r requirements.txt

   Vous êtes maintenant prêt à utiliser. Finalement, pour former le réseau nous devons lui donner un fichier de configuration au format JSON comme suit

   { 
           "Générateur":{
               "choix":"gan"
           },
           "discriminateur":{
               "choix":"gan"
           },
           "Chemin de données":"jeux de données/jeu de données1.p",
           "metric_evaluate":"MMD"
       }

   $ python main.py --config my_gan.json

La boîte à outils implémente plusieurs architectures GAN comme la vanille GAN, DC-GAN, GAN conditionnel et plus.

Avantages de la boîte à outils GAN

1. Fournit un moyen sans code de mettre en œuvre la technologie de vision par ordinateur de nouvelle génération. Seul un simple fichier JSON est nécessaire pour définir une architecture GAN. Il n'est pas nécessaire d'écrire le code de formation puisque le framework s'en chargera.
2. Prend en charge plusieurs bibliothèques, c'est-à-dire, PyTorche, Keras et TensorFlow aussi.
3. En outre, dans la boîte à outils du GAN, nous avons la liberté de mélanger et d'assortir facilement les composants de différents modèles. Par exemple, peut utiliser le modèle de générateur DC-GAN, le discriminateur C-GAN et le processus de formation du gan vanille.

Maintenant, il suffit de lire le document et jouez aux GAN à votre façon.

Remarques finales

Les GAN sont un domaine de recherche actif. Nous voyons des mises à jour régulières presque hebdomadaires sur la prochaine version de GAN. Vous pouvez vérifier le travail que les chercheurs ont fait ici.

Compléter, Dans cet article, nous discutons de la 4 Bibliothèques GAN les plus importantes pouvant être facilement implémentées en Python. du quotidien, nous voyons des développements énormes et nous voyons de nouvelles applications de GAN. L'article suivant explique certaines de ces applications étonnantes:

Quelles sont les bibliothèques GAN que vous utilisez? Pensez-vous que j'aurais dû inclure une autre bibliothèque? Faites-nous savoir dans les commentaires ci-dessous!.

En rapport