自动编码器实际上是一种人工神经网络，用于对以无监督方式提供的输入数据进行解压缩和压缩。解压缩和压缩操作是有损的且特定于数据的。

数据特定意味着自动编码器将只能实际压缩已经训练过的数据。例如，如果你用狗的图像训练一个自动编码器，那么它会给猫带来糟糕的表现。自动编码器计划学习表示对整个数据集的编码。这可能会导致训练网络降低维数。重构部分也是通过这个学习的。

有损操作意味着重建图像的质量通常不如原始图像清晰或高分辨率，并且对于具有更大损失的重建，差异更大，这被称为有损操作。下图显示了如何使用特定损失因子对图像进行编码和解码。

自动编码器是一种特殊类型的前馈神经网络，输入应该与输出相似。因此，我们需要一种编码方法、损失函数和解码方法。最终目标是以最小的损失完美地复制输入。

输入将通过一层编码器，它实际上是一个完全连接的神经网络，它也构成代码解码器，因此像 ANN 一样使用相同的代码进行编码和解码。

通过反向传播训练的 ANN 的工作方式与自动编码器相同。在本文中，我们将讨论 3 种类型的自动编码器，如下所示：

• 简单的自动编码器

• 深度 CNN 自动编码器

• 去噪自动编码器

对于自动编码器的实现部分，我们将使用流行的 MNIST 数字数据集。

1. 简单的自动编码器

我们首先导入所有必要的库：

import all the dependencies
from keras.layers import Dense,Conv2D,MaxPooling2D,UpSampling2D
from keras import Input, Model
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt
 
然后我们将构建我们的模型，我们将提供决定输入将被压缩多少的维度数。维度越小，压缩越大。
 
 
encoding_dim = 15 
input_img = Input(shape=(784,))
# encoded representation of input
encoded = Dense(encoding_dim, activation='relu')(input_img)
# decoded representation of code 
decoded = Dense(784, activation='sigmoid')(encoded)
# Model which take input image and shows decoded images
autoencoder = Model(input_img, decoded)
 
然后我们需要分别构建编码器模型和解码器模型，以便我们可以轻松区分输入和输出。
 
 
# This model shows encoded images
encoder = Model(input_img, encoded)
# Creating a decoder model
encoded_input = Input(shape=(encoding_dim,))
# last layer of the autoencoder model
decoder_layer = autoencoder.layers[-1]
# decoder model
decoder = Model(encoded_input, decoder_layer(encoded_input))
 
然后我们需要用ADAM优化器和交叉熵损失函数拟合来编译模型。
 
 
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
 
然后你需要加载数据：
 
 
(x_train, y_train), (x_test, y_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:])))
print(x_train.shape)
print(x_test.shape)
 
(60000, 784)
(10000, 784)
 
如果你想查看数据的实际情况，可以使用以下代码行：
 
 
plt.imshow(x_train[0].reshape(28,28))
 
然后你需要训练你的模型：
 
 
autoencoder.fit(x_train, x_train,
                epochs=15,
                batch_size=256,
                validation_data=(x_test, x_test))
 
Epoch 1/15
235/235 [==============================] - 14s 5ms/step - loss: 0.4200 - val_loss: 0.2263
Epoch 2/15
235/235 [==============================] - 1s 3ms/step - loss: 0.2129 - val_loss: 0.1830
Epoch 3/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1799 - val_loss: 0.1656
Epoch 4/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1632 - val_loss: 0.1537
Epoch 5/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1533 - val_loss: 0.1481
Epoch 6/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1488 - val_loss: 0.1447
Epoch 7/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1457 - val_loss: 0.1424
Epoch 8/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1434 - val_loss: 0.1405
Epoch 9/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1415 - val_loss: 0.1388
Epoch 10/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1398 - val_loss: 0.1374
Epoch 11/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1386 - val_loss: 0.1360
Epoch 12/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1373 - val_loss: 0.1350
Epoch 13/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1362 - val_loss: 0.1341
Epoch 14/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1355 - val_loss: 0.1334
Epoch 15/15
235/235 [==============================] - 1s 3ms/step - loss: 0.1348 - val_loss: 0.1328
 
训练后，你需要提供输入，你可以使用以下代码绘制结果：
 
 
encoded_img = encoder.predict(x_test)
decoded_img = decoder.predict(encoded_img)
plt.figure(figsize=(20, 4))
for i in range(5):
    # Display original
    ax = plt.subplot(2, 5, i + 1)
    plt.imshow(x_test[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
    # Display reconstruction
    ax = plt.subplot(2, 5, i + 1 + 5)
    plt.imshow(decoded_img[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()
 
你可以分别清楚地看到编码和解码图像的输出，如下所示。
 
 
2. 深度 CNN 自动编码器
 
 
由于这里的输入是图像，因此使用卷积神经网络或 CNN 确实更有意义。编码器将由一堆 Conv2D 和最大池化层组成，解码器将由一堆 Conv2D 和上采样层组成。
 
 
model = Sequential()
# encoder network
model.add(Conv2D(30, 3, activation= 'relu', padding='same', input_shape = (28,28,1)))
model.add(MaxPooling2D(2, padding= 'same'))
model.add(Conv2D(15, 3, activation= 'relu', padding='same'))
model.add(MaxPooling2D(2, padding= 'same'))
#decoder network
model.add(Conv2D(15, 3, activation= 'relu', padding='same'))
model.add(UpSampling2D(2))
model.add(Conv2D(30, 3, activation= 'relu', padding='same'))
model.add(UpSampling2D(2))
model.add(Conv2D(1,3,activation='sigmoid', padding= 'same')) # output layer
model.compile(optimizer= 'adam', loss = 'binary_crossentropy')
model.summary()
 
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 28, 28, 30)        300       
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 14, 14, 30)        0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 14, 14, 15)        4065      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 7, 7, 15)          0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 7, 7, 15)          2040      
_________________________________________________________________
up_sampling2d (UpSampling2D) (None, 14, 14, 15)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 14, 14, 30)        4080      
_________________________________________________________________
up_sampling2d_1 (UpSampling2 (None, 28, 28, 30)        0         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 28, 28, 1)         271       
=================================================================
Total params: 10,756
Trainable params: 10,756
Non-trainable params: 0
_________________________________________________________________
 
现在你需要加载数据并训练模型
 
 
(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
model.fit(x_train, x_train,
                epochs=15,
                batch_size=128,
                validation_data=(x_test, x_test))
 
Epoch 1/15
469/469 [==============================] - 34s 8ms/step - loss: 0.2310 - val_loss: 0.0818
Epoch 2/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0811 - val_loss: 0.0764
Epoch 3/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0764 - val_loss: 0.0739
Epoch 4/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0743 - val_loss: 0.0725
Epoch 5/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0729 - val_loss: 0.0718
Epoch 6/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0722 - val_loss: 0.0709
Epoch 7/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0715 - val_loss: 0.0703
Epoch 8/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0709 - val_loss: 0.0698
Epoch 9/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0700 - val_loss: 0.0693
Epoch 10/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0698 - val_loss: 0.0689
Epoch 11/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0694 - val_loss: 0.0687
Epoch 12/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0691 - val_loss: 0.0684
Epoch 13/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0688 - val_loss: 0.0680
Epoch 14/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0685 - val_loss: 0.0680
Epoch 15/15
469/469 [==============================] - 3s 7ms/step - loss: 0.0683 - val_loss: 0.0676
 
现在你需要提供输入并绘制以下结果的输出
 
 
pred = model.predict(x_test)
plt.figure(figsize=(20, 4))
for i in range(5):
    # Display original
    ax = plt.subplot(2, 5, i + 1)
    plt.imshow(x_test[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
    # Display reconstruction
    ax = plt.subplot(2, 5, i + 1 + 5)
    plt.imshow(pred[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()
 
3. 去噪自动编码器
 
 
现在我们将看到模型如何处理图像中的噪声。我们所说的噪声是指模糊的图像、改变图像的颜色，甚至是图像上的白色标记。
 
 
noise_factor = 0.7
x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape) 
x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape) 
x_train_noisy = np.clip(x_train_noisy, 0., 1.)
x_test_noisy = np.clip(x_test_noisy, 0., 1.)
Here is how the noisy images look right now.
plt.figure(figsize=(20, 2))
for i in range(1, 5 + 1):
    ax = plt.subplot(1, 5, i)
    plt.imshow(x_test_noisy[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()
 
现在图像几乎无法识别，为了增加自动编码器的范围，我们将修改定义模型的层以增加过滤器，使模型性能更好，然后拟合模型。
 
 
model = Sequential()
# encoder network
model.add(Conv2D(35, 3, activation= 'relu', padding='same', input_shape = (28,28,1)))
model.add(MaxPooling2D(2, padding= 'same'))
model.add(Conv2D(25, 3, activation= 'relu', padding='same'))
model.add(MaxPooling2D(2, padding= 'same'))
#decoder network
model.add(Conv2D(25, 3, activation= 'relu', padding='same'))
model.add(UpSampling2D(2))
model.add(Conv2D(35, 3, activation= 'relu', padding='same'))
model.add(UpSampling2D(2))
model.add(Conv2D(1,3,activation='sigmoid', padding= 'same')) # output layer
model.compile(optimizer= 'adam', loss = 'binary_crossentropy')
model.fit(x_train_noisy, x_train,
                epochs=15,
                batch_size=128,
                validation_data=(x_test_noisy, x_test))
 
Epoch 1/15
469/469 [==============================] - 5s 9ms/step - loss: 0.2643 - val_loss: 0.1456
Epoch 2/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1440 - val_loss: 0.1378
Epoch 3/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1373 - val_loss: 0.1329
Epoch 4/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1336 - val_loss: 0.1305
Epoch 5/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1313 - val_loss: 0.1283
Epoch 6/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1294 - val_loss: 0.1268
Epoch 7/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1278 - val_loss: 0.1257
Epoch 8/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1267 - val_loss: 0.1251
Epoch 9/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1259 - val_loss: 0.1244
Epoch 10/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1251 - val_loss: 0.1234
Epoch 11/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1241 - val_loss: 0.1234
Epoch 12/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1239 - val_loss: 0.1222
Epoch 13/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1232 - val_loss: 0.1223
Epoch 14/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1226 - val_loss: 0.1215
Epoch 15/15
469/469 [==============================] - 4s 8ms/step - loss: 0.1221 - val_loss: 0.1211
 
训练结束后，我们将提供输入并编写绘图函数以查看最终结果。
 
 
pred = model.predict(x_test_noisy)
plt.figure(figsize=(20, 4))
for i in range(5):
    # Display original
    ax = plt.subplot(2, 5, i + 1)
    plt.imshow(x_test_noisy[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
    # Display reconstruction
    ax = plt.subplot(2, 5, i + 1 + 5)
    plt.imshow(pred[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()
 
我们已经了解了自动编码器工作的结构，并使用了 3 种类型的自动编码器。自动编码器有多种用途，如降维图像压缩、电影和歌曲推荐系统等。模型的性能可以通过训练更多的 epoch 或增加我们网络的维度来提高。
 
 
☆ END ☆
 
 
如果看到这里，说明你喜欢这篇文章，请转发、点赞。微信搜索「uncle_pn」，欢迎添加小编微信「 woshicver」，每日朋友圈更新一篇高质量博文。
 
 
↓扫描二维码添加小编↓
 
                    介绍自动编码器实际上是一种人工神经网络，用于对以无监督方式提供的输入数据进行解压缩和压缩。解压缩和压缩操作是有损的且特定于数据的。数据特定意味着自动编码器将只能实际压缩已经训练过的数据。例...
 我强烈建议您在培训期间使用GPU。
 tf.nn.sigmoid_cross_entropy_with_logits具有一个targets参数，该参数已更改为tensorflow版本> r0.12的labels 。
自编码器是一种非常通用的神经网络工具。主要思想是通过一个编码器，将原始信息编码为一组向量，然后通过一个解码器，将向量解码为原始数据。通过衡量输入与输出的差别，来对网络参数进行训练。主要可以用来进行信息压缩。
最进在了解GAN方向的应用，发现很多GANs类似与自编码器的思想，在条件GAN中，生成器类似于自编码器中的解码器。都是通过给定一组输入，来得到相应的图片。我比较好奇自编码器产生的编码...
				
目录一.原理二.为什么要使用自编码器三.代码实现1.原始自编码器2.多层（堆叠）自编码器3.卷积自编码器4.正则自编码器4.1稀疏自编码器四.降噪自编码器五. 逐层贪婪训练堆叠自编码器参考
自编码器由两部分组成：
编码器（encoder）:这部分能将输入压缩成潜在空间表征，可以用编码函数h=f(x)表示。
解码器（decoder）:这部分重构来自潜在空间表征的输入，可以用解码函数r=g(h)表示。
因此，整个自编码器可以用函数g(f(x)) = r 来描述，其中输出r与原始输入x相近。
自编码器(
最近在实现对抗自编码器的代码，想法是从最简单的模板开始。同时为了能够先找到点感觉，先看看怎么处理MNIST数据。
1. 代码示例
针对对抗自编码器的代码，找到了两份代码，分别是tensorflow实现和keras实现。其实最开始是弄的keras版本，但是判别器的判别准确率基本上一直稳定在100%，就挺奇怪的。所以，就有弄了个tensorflow来看看，不过这个问题还是没有解答。先把整理代码的过程来记录下，因为代码并不能直接跑。代码地址分别位于[1]和[2]。
1.1 Ker
				
如果您是在 Python 中指的是某个具体的东西，比如库、框架、工具等，请提供更具体的信息。如果您指的是某个编程概念或技术，我可以帮您提供一些基本的信息。
Python 是一种流行的高级编程语言，可以用于各种目的，包括 Web 开发、数据科学、机器学习、人工智能等。以下是一些 Python 中常用的编程概念和技术：
1. 变量和数据类型：在 Python 中，您可以使用变量来存储和操作数据。Python 支持多种数据类型，包括整数、浮点数、字符串、列表、元组、字典等。
2. 条件语句和循环语句：Python 中有多种条件语句和循环语句，可以帮助您编写更加灵活和复杂的程序。例如，if/else 条件语句、for/while 循环语句等。
3. 函数和模块：Python 中支持定义函数和模块，以便重复使用代码，并提高代码的可读性和可维护性。
4. 异常处理：Python 中的异常处理机制可以帮助您处理程序中的错误和异常情况，使程序更加健壮和稳定。
5. 文件操作：Python 中提供了多种文件操作函数，可以读取和写入文件，以及对文件进行其他操作。
6. 库和框架：Python 中有许多流行的库和框架，可以帮助您完成各种任务，例如 NumPy、Pandas、Matplotlib、Django、Flask、TensorFlow 等。
希望这些信息能够帮助您更好地了解 Python。如果您有任何具体问题或需要更多帮助，请告诉我。
                    Maybe_fzzf: 
                    你好想问一下为什么每次我都报这样的错
DuplicateWidgetID: There are multiple identical st.file_uploader widgets with the same generated key.
When a widget is created, it's assigned an internal key based on its structure. Multiple widgets with an identical structure will result in the same internal key, which causes this error.
To fix this error, please pass a unique key argument to st.file_uploader.
                使用Google Vision API进行计算机视觉图像创意分析
                    reaishenghuo5500: 
                    千辛万苦配置完,发现不是免费项目哈哈哈
                【最新】整理了CVPR 2023论文代码合集！
                    梦想天空分外蓝-: 
                    怎么领取啊