Introduction

Bienvenue dans cet article, dans lequel nous explorerons le monde passionnant de l'IA générative. Nous nous concentrerons principalement sur les auto-encodeurs variationnels conditionnels ou CVAE, qui sont comme le prochain niveau de talent artistique de l'IA, fusionnant les points forts des auto-encodeurs variationnels (VAE) avec la capacité de suivre des instructions spécifiques, nous donnant un contrôle précis sur la création d'images. Tout au long de cet article, nous approfondirons les CVAE et verrons comment et pourquoi elles peuvent être utilisées dans divers scénarios du monde réel, et nous vous fournirons même des exemples de code faciles à comprendre pour mettre en valeur leur potentiel.

Cet article a été publié dans le cadre du Blogathon sur la science des données.

Comprendre les auto-encodeurs variationnels (VAE)

Avant de plonger dans les CVAE, concentrons-nous sur les fondamentaux des VAE. Les VAE sont un type de modèle génératif qui combine un réseau d'encodeur et de décodeur. Ils sont utilisés pour apprendre la structure sous-jacente des données et générer de nouveaux échantillons.

Bien sûr, utilisons un exemple simple impliquant les préférences de café pour expliquer les auto-encodeurs variationnels (VAE)

Imaginez que vous souhaitiez représenter les préférences de chacun en matière de café dans votre bureau :

• Codeur: Chaque personne résume son choix de café (noir, latté, cappuccino) en quelques mots (ex. : ferme, crémeux, doux).
• Variante: Comprend que même au sein d'un même choix (par exemple, latté), il existe des variations dans le lait, la douceur, etc.
• Espace latent : Crée un espace flexible où les préférences en matière de café peuvent varier.
• Décodeur: Utilise ces résumés pour préparer le café de ses collègues, avec de légères variations, en respectant leurs préférences.
• Puissance générative : Peut créer de nouveaux styles de café qui conviennent aux goûts individuels mais ne sont pas des répliques exactes.

Les VAE fonctionnent de la même manière, apprenant les fonctionnalités principales et les variations des données pour générer de nouvelles données similaires avec de légères différences.

Voici une implémentation simple d'un auto-encodeur variationnel (VAE) utilisant Python et TensorFlow/Keras. Cet exemple utilise l'ensemble de données MNIST pour plus de simplicité, mais vous pouvez l'adapter à d'autres types de données.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np # Load and preprocess the MNIST dataset
(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0 # Define the VAE model
latent_dim = 2 # Encoder
encoder_inputs = keras.Input(shape=(28, 28))
x = layers.Flatten()(encoder_inputs)
x = layers.Dense(256, activation='relu')(x)
z_mean = layers.Dense(latent_dim)(x)
z_log_var = layers.Dense(latent_dim)(x) # Reparameterization trick
def sampling(args): z_mean, z_log_var = args epsilon = tf.keras.backend.random_normal(shape=(tf.shape(z_mean)[0], latent_dim)) return z_mean + tf.exp(0.5 * z_log_var) * epsilon z = layers.Lambda(sampling)([z_mean, z_log_var]) # Decoder
decoder_inputs = keras.Input(shape=(latent_dim,))
x = layers.Dense(256, activation='relu')(decoder_inputs)
x = layers.Dense(28 * 28, activation='sigmoid')(x)
decoder_outputs = layers.Reshape((28, 28))(x) # Define the VAE model
encoder = keras.Model(encoder_inputs, [z_mean, z_log_var, z], name='encoder')
decoder = keras.Model(decoder_inputs, decoder_outputs, name='decoder')
vae_outputs = decoder(encoder(encoder_inputs)[2])
vae = keras.Model(encoder_inputs, vae_outputs, name='vae') # Loss function
def vae_loss(x, x_decoded_mean, z_log_var, z_mean): x = tf.keras.backend.flatten(x) x_decoded_mean = tf.keras.backend.flatten(x_decoded_mean) xent_loss = keras.losses.binary_crossentropy(x, x_decoded_mean) kl_loss = -0.5 * tf.reduce_mean(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var)) return xent_loss + kl_loss vae.compile(optimizer='adam', loss=vae_loss)
vae.fit(x_train, x_train, epochs=10, batch_size=32, validation_data=(x_test, x_test))

Explication des auto-encodeurs variationnels conditionnels (CVAE)

Les CVAE étendent les capacités des VAE en introduisant des entrées conditionnelles. Les CVAE peuvent générer des échantillons de données basés sur des conditions ou des informations spécifiques. Par exemple, vous pouvez générer conditionnellement des images de chats ou de chiens en fournissant au modèle l'étiquette de classe souhaitée en entrée.

Comprenons en utilisant un exemple en temps réel.

Achats en ligne avec les CVAE Imaginez que vous achetez des baskets en ligne :

• VAE de base (sans condition) : Le site Web vous montre des baskets aléatoires.
• CVAE (sous conditions) : Vous sélectionnez vos préférences – couleur (rouge), taille (10) et style (course à pied).
• Codeur: Le site Web comprend vos choix et filtre les baskets en fonction de ces conditions.
• Variante: Reconnaissant que même dans vos conditions, il existe des variations (différentes nuances de rouge, styles de chaussures de course), il les prend en compte.
• Espace latent : Cela crée un « espace de personnalisation des baskets » où les variations sont autorisées.
• Décodeur: À l’aide de vos conditions personnalisées, il vous montre des baskets qui correspondent étroitement à vos préférences.

Les CVAE, comme les sites d'achat en ligne, utilisent des conditions spécifiques (vos préférences) pour générer des données personnalisées (options de baskets) qui correspondent étroitement à vos choix.

En continuant à partir de l’exemple de l’encodeur automatique variationnel (VAE), vous pouvez implémenter un encodeur automatique variationnel conditionnel (CVAE). Dans cet exemple, nous considérerons l'ensemble de données MNIST et générerons des chiffres de manière conditionnelle en fonction d'une étiquette de classe.

# Define the CVAE model
encoder = keras.Model([encoder_inputs, label], [z_mean, z_log_var, z], name='encoder')
decoder = keras.Model([decoder_inputs, label], decoder_outputs, name='decoder')
cvae_outputs = decoder([encoder([encoder_inputs, label])[2], label])
cvae = keras.Model([encoder_inputs, label], cvae_outputs, name='cvae')

Différence entre VAE et CVAE

VAE

• Les VAE sont comme des artistes qui créent de l'art mais avec un peu d'aléatoire.
• Ils apprennent à créer diverses variations de données sans aucune instruction spécifique.
• Utile pour générer de nouveaux échantillons de données sans conditions, comme l'art aléatoire.

CVAE

• Les CVAE sont comme des artistes qui peuvent répondre à des demandes précises
• Ils génèrent des données en fonction de conditions ou d'instructions données
• Utile pour les tâches où vous souhaitez un contrôle précis sur ce qui est généré, comme transformer un cheval en zèbre tout en préservant les principales caractéristiques

Implémentation de CVAE : exemples de code

Explorons un exemple de code Python simple utilisant TensorFlow et Keras pour implémenter un CVAE permettant de générer des chiffres manuscrits

# Import necessary libraries
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Model # Define the CVAE model architecture
latent_dim = 2
input_shape = (28, 28, 1)
num_classes = 10 # Encoder network
encoder_inputs = keras.Input(shape=input_shape)
x = layers.Conv2D(32, 3, padding='same', activation='relu')(encoder_inputs)
x = layers.Flatten()(x)
x = layers.Dense(64, activation='relu')(x) # Conditional input
label = keras.Input(shape=(num_classes,))
x = layers.concatenate([x, label]) # Variational layers
z_mean = layers.Dense(latent_dim)(x)
z_log_var = layers.Dense(latent_dim)(x) # Reparameterization trick
def sampling(args): z_mean, z_log_var = args epsilon = tf.keras.backend.random_normal(shape=(tf.shape(z_mean)[0], latent_dim)) return z_mean + tf.exp(0.5 * z_log_var) * epsilon z = layers.Lambda(sampling)([z_mean, z_log_var]) # Decoder network
decoder_inputs = layers.Input(shape=(latent_dim,))
x = layers.concatenate([decoder_inputs, label])
x = layers.Dense(64, activation='relu')(x)
x = layers.Dense(28 * 28 * 1, activation='sigmoid')(x)
x = layers.Reshape((28, 28, 1))(x) # Create the models
encoder = Model([encoder_inputs, label], [z_mean, z_log_var, z], name='encoder')
decoder = Model([decoder_inputs, label], x, name='decoder')
cvae = Model([encoder_inputs, label], decoder([z, label]), name='cvae')
#import csv

Ce code fournit une structure de base pour un modèle CVAE. Pour entraîner et générer des images, vous aurez besoin d’un ensemble de données approprié et de réglages supplémentaires.

Applications des CVAE

Les CVAE ont des applications dans divers domaines, notamment :

Traduction image à image :  Ils peuvent être utilisés pour traduire des images d'un domaine à un autre tout en préservant le contenu. Imaginez que vous ayez une photo d'un cheval et que vous souhaitiez le transformer en zèbre tout en conservant les principales caractéristiques. Les CVAE peuvent faire ça :

#import csv# Translate horse image to a zebra image
translated_image = cvae_generate(horse_image, target="zebra")

Transfert de styles : Les CVAE permettent le transfert de styles artistiques entre les images. Supposons que vous ayez une image et que vous vouliez qu'elle ressemble à un tableau célèbre, par exemple La Nuit étoilée de Van Gogh. Les CVAE peuvent appliquer ce style :

#import csv
# Apply "Starry Night" style to your photo
styled_image = cvae_apply_style(your_photo, style="Starry Night")

• Détection d'une anomalie : Ils sont efficaces pour détecter les anomalies dans les données. Vous disposez d’un ensemble de données de battements cardiaques normaux et vous souhaitez détecter les battements cardiaques irréguliers. Les CVAE peuvent repérer des anomalies :

# Detect irregular heartbeats
is_anomaly = cvae_detect_anomaly(heartbeat_data)

• Découverte de médicament : Les CVAE aident à générer des structures moléculaires pour la découverte de médicaments. Disons que vous devez trouver de nouvelles molécules pour un médicament qui sauve des vies. Les CVAE peuvent aider à concevoir des structures moléculaires :

#import csv# Generate potential drug molecules
drug_molecule = cvae_generate_molecule("anti-cancer")

Ces applications montrent comment les CVAE peuvent transformer des images, appliquer des styles artistiques, détecter des anomalies et faciliter des tâches cruciales telles que la découverte de médicaments, tout en gardant les données sous-jacentes significatives et utiles.

Défis et orientations futures

Défis

• Réduire le mode : Pensez aux CVAE comme à un peintre qui oublie parfois d’utiliser toutes ses couleurs. L'effondrement du mode se produit lorsque les CVAE continuent d'utiliser les mêmes couleurs (représentations) pour différentes choses. Ainsi, ils pourraient peindre tous les animaux d’une seule couleur, perdant ainsi leur diversité.
• Génération d'images haute résolution : Imaginez demander à un artiste de peindre une grande fresque détaillée sur une petite toile. C'est un défi. Les CVAE sont confrontés à un défi similaire lorsqu’ils tentent de créer de grandes images très détaillées.

Objectifs futurs

Les chercheurs veulent améliorer les CVAE :

• Éviter l'effondrement du mode : Ils s'efforcent de s'assurer que l'artiste (CVAE) utilise toutes les couleurs (représentations) dont il dispose, créant ainsi des résultats plus diversifiés et plus précis.
• Art haute résolution : Ils visent à aider l'artiste (CVAE) à peindre des peintures murales (images) plus grandes et plus détaillées en améliorant les techniques utilisées. De cette façon, nous pouvons obtenir des œuvres d’art impressionnantes et de haute qualité provenant des CVAE.

Conclusion

Les auto-encodeurs variationnels conditionnels représentent un développement révolutionnaire dans le domaine de l’IA générative. Leur capacité à générer des données basées sur des conditions spécifiques ouvre un monde de possibilités dans diverses applications. En comprenant leurs principes sous-jacents et en les mettant en œuvre efficacement, nous pouvons exploiter le potentiel des CVAE pour la génération d’images avancées et au-delà.

Faits marquants

1. Avancement de l’IA générative : Activation de la génération d'images avec des entrées conditionnelles.
2. Analogie simple avec le café : Pensez aux VAE comme à une synthèse des préférences en matière de café, permettant des variations tout en préservant l'essence.
3. Code VAE de base : Un exemple de code Python convivial pour un VAE est fourni, utilisant l'ensemble de données MNIST.
4. Mise en œuvre de la CVAE : L'article comprend un extrait de code pour implémenter un CVAE pour la génération d'images conditionnelles.
5. Exemple d'achat en ligne : Une analogie avec l'achat de baskets en ligne illustre la capacité des CVAE à personnaliser les données en fonction des conditions.

Foire aux Questions

Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur.

Services Connexes

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Automobile / VE, Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• GraphiquePrime. Élevez votre jeu de trading avec ChartPrime. Accéder ici.
• Décalages de bloc. Modernisation de la propriété des compensations environnementales. Accéder ici.
• La source: https://www.analyticsvidhya.com/blog/2023/09/generative-ai-conditional-vaes/