Contoh algoritma VAE dalam Python

VAE ialah model generatif, nama penuhnya ialah Variational Autoencoder, dan terjemahan bahasa Cinanya ialah variational autoencoder. Ia adalah algoritma pembelajaran tanpa pengawasan yang boleh digunakan untuk menjana data baharu, seperti imej, audio, teks, dsb. Berbanding dengan pengekod auto biasa, VAE lebih fleksibel dan berkuasa serta boleh menjana data yang lebih kompleks dan realistik.

Python ialah salah satu bahasa pengaturcaraan yang paling banyak digunakan dan salah satu alat utama untuk pembelajaran mendalam. Dalam Python, terdapat banyak pembelajaran mesin yang sangat baik dan rangka kerja pembelajaran mendalam, seperti TensorFlow, PyTorch, Keras, dll., semuanya mempunyai pelaksanaan VAE.

Artikel ini akan menggunakan contoh kod Python untuk memperkenalkan cara menggunakan TensorFlow untuk melaksanakan algoritma VAE dan menjana imej digit tulisan tangan baharu.

Prinsip model VAE

VAE ialah kaedah pembelajaran tanpa pengawasan yang boleh mengekstrak ciri berpotensi daripada data dan menggunakan ciri ini untuk menjana data baharu. VAE mempelajari taburan data dengan mempertimbangkan taburan kebarangkalian pembolehubah pendam. Ia memetakan data asal ke dalam ruang terpendam dan menukar ruang terpendam kepada data yang dibina semula melalui penyahkod.

Struktur model VAE merangkumi dua bahagian: pengekod dan penyahkod. Pengekod memampatkan data asal ke dalam ruang pembolehubah pendam, dan penyahkod memetakan pembolehubah pendam kembali ke ruang data asal. Di antara pengekod dan penyahkod, terdapat juga lapisan penyusunan semula untuk memastikan pensampelan pembolehubah terpendam boleh dibezakan.

Fungsi kehilangan VAE terdiri daripada dua bahagian Satu bahagian ialah ralat pembinaan semula, iaitu jarak antara data asal dan data yang dijana oleh penyahkod, yang digunakan untuk mengehadkan taburan pembolehubah terpendam.

Set Data

Kami akan menggunakan set data MNIST untuk melatih model VAE dan menjana imej digit tulisan tangan baharu. Set data MNIST mengandungi set imej digit tulisan tangan, setiap imej ialah imej skala kelabu 28×28.

Kami boleh menggunakan API yang disediakan oleh TensorFlow untuk memuatkan set data MNIST dan menukar imej kepada bentuk vektor. Kodnya adalah seperti berikut:

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

Pelaksanaan model VAE

Kita boleh menggunakan TensorFlow untuk melaksanakan model VAE. Pengekod dan penyahkod ialah kedua-dua rangkaian saraf berbilang lapisan, dan lapisan penyusunan semula ialah lapisan rawak.

Kod pelaksanaan model VAE adalah seperti berikut:

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()

Apabila menulis kod, anda perlu memberi perhatian kepada perkara berikut:

• Gunakan lapisan Lambda untuk melaksanakan operasi parameterisasi berat
• Fungsi kehilangan termasuk ralat pembinaan semula dan terma regularisasi
• Tambah fungsi kehilangan pada model Anda tidak perlu mengira kecerunan secara langsung latihan

latihan model VAE

Kita boleh menggunakan set data MNIST untuk melatih model VAE. Kod untuk melatih model adalah seperti berikut:

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

Semasa latihan, kita boleh menggunakan berbilang zaman dan saiz kelompok yang lebih besar untuk meningkatkan kesan latihan.

Jana imej digit tulisan tangan baharu

Selepas latihan selesai, kita boleh menggunakan model VAE untuk menjana imej digit tulisan tangan baharu. Kod untuk menjana imej adalah seperti berikut:

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()

Kami boleh menjana imej digit tulisan tangan yang berbeza dengan menjalankan kod beberapa kali Imej ini dijana berdasarkan pengedaran data yang dipelajari oleh VAE, dengan kepelbagaian dan kreativiti.

Ringkasan

Artikel ini memperkenalkan cara melaksanakan algoritma VAE menggunakan TensorFlow dalam Python, dan menunjukkan aplikasinya melalui set data MNIST dan menjana imej digit tulisan tangan baharu. Dengan mempelajari algoritma VAE, bukan sahaja data baharu boleh dijana, tetapi juga ciri berpotensi dalam data boleh diekstrak, memberikan idea baharu untuk analisis data dan pengecaman corak.

Atas ialah kandungan terperinci Contoh algoritma VAE dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!