Que sont les encodeurs automatiques en Python ?

Autoencoder est un algorithme d'apprentissage non supervisé qui peut apprendre l'expression des caractéristiques des données d'entrée et est largement utilisé dans l'apprentissage en profondeur. Cet article présentera les encodeurs automatiques en Python.

1. Introduction à l'Autoencoder

Un Autoencoder est un réseau neuronal qui contient un encodeur et un décodeur. L'encodeur compresse les données d'entrée (telles que les images, le texte) dans un petit vecteur et le décodeur reconstruit les données d'entrée originales sur la base de ce vecteur. Grâce à ce processus de compression-reconstruction, l'auto-encodeur peut apprendre une représentation de faible dimension des données d'entrée, c'est-à-dire une expression de caractéristique.

Le processus de formation de l'auto-encodeur n'est pas supervisé et ne nécessite pas de données étiquetées. Le principe est de minimiser l'erreur de reconstruction entre l'entrée et la sortie, afin que l'encodeur et le décodeur apprennent conjointement la représentation caractéristique des données d'entrée. La structure des auto-encodeurs peut être diversifiée, comme les auto-encodeurs ordinaires, les auto-encodeurs convolutifs, les auto-encodeurs cycliques, etc.

2. Implémentation d'encodeurs automatiques en Python

L'implémentation d'encodeurs automatiques en Python utilise généralement des frameworks d'apprentissage en profondeur, tels que TensorFlow, Keras, PyTorch, etc. Voici un exemple d'auto-encodeur de base, implémenté à l'aide de Keras :

from keras.layers import Input, Dense
from keras.models import Model

# 定义编码器
input_img = Input(shape=(784,))
encoded = Dense(128, activation='relu')(input_img)
encoded = Dense(64, activation='relu')(encoded)
encoded_output = Dense(32, activation='relu')(encoded)

# 定义解码器
decoded = Dense(64, activation='relu')(encoded_output)
decoded = Dense(128, activation='relu')(decoded)
decoded_output = Dense(784, activation='sigmoid')(decoded)

# 定义自动编码器模型
autoencoder = Model(inputs=input_img, outputs=decoded_output)

# 编译模型
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')

# 加载数据
from keras.datasets import mnist
import numpy as np

(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))

# 训练模型
autoencoder.fit(x_train, x_train,
                epochs=50,
                batch_size=256,
                shuffle=True,
                validation_data=(x_test, x_test))

Dans cet exemple, une couche Dense est utilisée pour définir l'encodeur et le décodeur, et les fonctions d'activation sont relu et sigmoïde. En prenant comme exemple l'ensemble de données de chiffres manuscrits du MNIST, le modèle est formé pendant 50 époques. Grâce au modèle établi grâce à la formation, la représentation des caractéristiques de faible dimension des données peut être obtenue via l'encodeur.

3. Application des encodeurs automatiques

Les encodeurs automatiques sont largement utilisés dans l'apprentissage des fonctionnalités, la réduction de la dimensionnalité des données, la compression d'images et d'autres domaines. Voici un exemple d'application des encodeurs automatiques dans la compression d'images :

# 压缩图像
encoded_imgs = encoder.predict(x_test)
# 解压缩图像
decoded_imgs = decoder.predict(encoded_imgs)

# 可视化图像
import matplotlib.pyplot as plt
n = 10  # 选择要可视化的图像数量
plt.figure(figsize=(20, 4))
for i in range(n):
    # 原始图像
    ax = plt.subplot(2, n, i + 1)
    plt.imshow(x_test[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    # 压缩后的图像
    ax = plt.subplot(2, n, i + 1 + n)
    plt.imshow(decoded_imgs[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()

Dans l'exemple ci-dessus, l'encodeur automatique formé est utilisé pour effectuer une compression d'image sur l'ensemble de données de chiffres manuscrits MNIST. Le bruit est supprimé pendant le processus de compression et de décompression, et. Grâce à la visualisation, nous pouvons voir que l'image compressée est assez bien restituée.

4. Conclusion

L'autoencoder est l'un des modèles les plus basiques du deep learning et constitue une étape essentielle dans la compréhension du deep learning. Il est très pratique d'implémenter des encodeurs automatiques en Python. Il vous suffit de choisir un framework d'apprentissage en profondeur approprié, tel que Keras, PyTorch, etc. Grâce aux encodeurs automatiques, nous pouvons apprendre des fonctionnalités importantes des données d'entrée et mettre en œuvre des applications telles que la compression d'images et l'apprentissage de fonctionnalités.

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!