Exemple d'algorithme VAE en Python

VAE est un modèle génératif, son nom complet est Variational Autoencoder et sa traduction chinoise est variational autoencoder. Il s'agit d'un algorithme d'apprentissage non supervisé qui peut être utilisé pour générer de nouvelles données, telles que des images, de l'audio, du texte, etc. Comparés aux auto-encodeurs ordinaires, les VAE sont plus flexibles et plus puissants et peuvent générer des données plus complexes et plus réalistes.

Python est l'un des langages de programmation les plus utilisés et l'un des principaux outils d'apprentissage en profondeur. En Python, il existe de nombreux excellents frameworks d'apprentissage automatique et d'apprentissage profond, tels que TensorFlow, PyTorch, Keras, etc., qui ont tous des implémentations VAE.

Cet article utilisera un exemple de code Python pour présenter comment utiliser TensorFlow pour implémenter l'algorithme VAE et générer de nouvelles images de chiffres manuscrites.

Principe du modèle VAE

VAE est une méthode d'apprentissage non supervisée qui peut extraire des fonctionnalités potentielles des données et utiliser ces fonctionnalités pour générer de nouvelles données. VAE apprend la distribution des données en considérant la distribution de probabilité des variables latentes. Il mappe les données originales dans un espace latent et convertit l'espace latent en données reconstruites via un décodeur.

La structure du modèle de VAE comprend deux parties : l'encodeur et le décodeur. L'encodeur compresse les données d'origine dans l'espace de variables latentes et le décodeur mappe les variables latentes à l'espace de données d'origine. Entre l'encodeur et le décodeur, il existe également une couche de reparamétrage pour garantir que l'échantillonnage des variables latentes est différentiable.

La fonction de perte de VAE se compose de deux parties. L'une est l'erreur de reconstruction, qui est la distance entre les données d'origine et les données générées par le décodeur. L'autre partie est le terme de régularisation, qui est utilisé pour limiter la distribution. des variables latentes.

Ensemble de données

Nous utiliserons l'ensemble de données MNIST pour entraîner le modèle VAE et générer de nouvelles images de chiffres manuscrits. L'ensemble de données MNIST contient un ensemble d'images de chiffres manuscrites, chaque image est une image en niveaux de gris 28 × 28.

Nous pouvons utiliser l'API fournie par TensorFlow pour charger l'ensemble de données MNIST et convertir l'image sous forme vectorielle. Le code est le suivant :

import tensorflow as tf
import numpy as np

# 加载MNIST数据集
mnist = tf.keras.datasets.mnist

# 加载训练集和测试集
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 将图像转换为向量形式
x_train = x_train.astype(np.float32) / 255.
x_test = x_test.astype(np.float32) / 255.
x_train = x_train.reshape((-1, 28 * 28))
x_test = x_test.reshape((-1, 28 * 28))

Implémentation du modèle VAE

Nous pouvons utiliser TensorFlow pour implémenter le modèle VAE. Le codeur et le décodeur sont tous deux des réseaux neuronaux multicouches et la couche de reparamétrage est une couche aléatoire.

Le code d'implémentation du modèle VAE est le suivant :

import tensorflow_probability as tfp

# 定义编码器
encoder_inputs = tf.keras.layers.Input(shape=(784,))
x = tf.keras.layers.Dense(256, activation='relu')(encoder_inputs)
x = tf.keras.layers.Dense(128, activation='relu')(x)
mean = tf.keras.layers.Dense(10)(x)
logvar = tf.keras.layers.Dense(10)(x)

# 定义重参数化层
def sampling(args):
    mean, logvar = args
    epsilon = tfp.distributions.Normal(0., 1.).sample(tf.shape(mean))
    return mean + tf.exp(logvar / 2) * epsilon

z = tf.keras.layers.Lambda(sampling)([mean, logvar])

# 定义解码器
decoder_inputs = tf.keras.layers.Input(shape=(10,))
x = tf.keras.layers.Dense(128, activation='relu')(decoder_inputs)
x = tf.keras.layers.Dense(256, activation='relu')(x)
decoder_outputs = tf.keras.layers.Dense(784, activation='sigmoid')(x)

# 构建模型
vae = tf.keras.models.Model(encoder_inputs, decoder_outputs)

# 定义损失函数
reconstruction = -tf.reduce_sum(encoder_inputs * tf.math.log(1e-10 + decoder_outputs) + 
                                (1 - encoder_inputs) * tf.math.log(1e-10 + 1 - decoder_outputs), axis=1)
kl_divergence = -0.5 * tf.reduce_sum(1 + logvar - tf.square(mean) - tf.exp(logvar), axis=-1)
vae_loss = tf.reduce_mean(reconstruction + kl_divergence)

vae.add_loss(vae_loss)
vae.compile(optimizer='rmsprop')
vae.summary()

Lors de l'écriture du code, vous devez faire attention aux points suivants :

• Utilisez la couche Lambda pour implémenter des opérations de paramétrage lourdes
• La fonction de perte inclut la reconstruction termes d'erreur et de régularisation
• Ajoutez la fonction de perte au modèle, il n'est pas nécessaire de calculer manuellement le gradient, vous pouvez directement utiliser l'optimiseur pour la formation

Formation du modèle VAE

Nous pouvons utiliser l'ensemble de données MNIST pour former le Modèle VAE. Le code pour entraîner le modèle est le suivant :

vae.fit(x_train, x_train,
        epochs=50,
        batch_size=128,
        validation_data=(x_test, x_test))

Pendant l'entraînement, nous pouvons utiliser plusieurs époques et des lots plus grands pour améliorer l'effet d'entraînement.

Générer de nouvelles images de chiffres manuscrits

Une fois la formation terminée, nous pouvons utiliser le modèle VAE pour générer de nouvelles images de chiffres manuscrits. Le code pour générer l'image est le suivant :

import matplotlib.pyplot as plt

# 随机生成潜在变量
z = np.random.normal(size=(1, 10))

# 将潜在变量解码为图像
generated = vae.predict(z)

# 将图像转换为灰度图像
generated = generated.reshape((28, 28))
plt.imshow(generated, cmap='gray')
plt.show()

Nous pouvons générer différentes images de chiffres manuscrits en exécutant le code plusieurs fois. Ces images sont générées sur la base de la distribution des données apprises par VAE, avec diversité et créativité.

Résumé

Cet article présente comment implémenter l'algorithme VAE à l'aide de TensorFlow en Python, et démontre son application via l'ensemble de données MNIST et la génération de nouvelles images de chiffres manuscrites. En apprenant l’algorithme VAE, non seulement de nouvelles données peuvent être générées, mais également des caractéristiques potentielles des données peuvent être extraites, offrant ainsi une nouvelle idée pour l’analyse des données et la reconnaissance de formes.

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!