compression-format.jpg

卷积自编码

输入是表示图像的数据，因此使用卷积自动编码器是不错选择，因为卷积适合处理空间上数据。卷积自动编码器就是由卷积层堆叠在一起结构，您用卷积层替换全连接层。卷积层与最大池层一起，将输入从宽（28×28图像）和深度为（单通道）通过一系列非线性变换为（稀疏空间为7×7图像）和深度（128通道）的矩阵。

我们之前通常是使用 PCA ，而今天在深度学习中通常使用 auto-encoder 来进行降维。传统 PCA 通过线性变换将高维数据在保持主要特征前提进行 。

即使对上面思想能还有疑惑，没有关系，随后我们将只关注如何实现一个自动编码器。通过具体实例希望对你理解会有所帮助。

编码器主要用于压缩输入，主要压缩输入图片，例如图片是 (~30976) 编码为 ，在瓶颈处进行压缩 输入图片经过一些列卷积层和 3 池化层，但是通道从 1 增加 512。通过一些列非线性变换输入从 宽度为 深度 (1) 矩阵变为宽度 深度为 (512) 的矩阵。

依赖

主要使用 keras 完成整个自编码器的任务

import keras
from matplotlib import pyplot as plt
import numpy as np
import gzip

from keras.layers import Input,Conv2D,MaxPooling2D,UpSampling2D
from keras.models import Model
from keras.optimizers import RMSprop
from sklearn.model_selection import train_test_split

准备数据集

def extract_data(filename, num_images):
    with gzip.open(filename) as bytestream:
        bytestream.read(16)
        buf = bytestream.read(28 * 28 * num_images)
        data = np.frombuffer(buf, dtype=np.uint8).astype(np.float32)
        data = data.reshape(num_images, 28,28)
        return data

train_data = extract_data('data/train-images-idx3-ubyte.gz', 60000)
test_data = extract_data('data/t10k-images-idx3-ubyte.gz', 10000)

print(train_data,test_data)
((60000, 28, 28, 1), (10000, 28, 28, 1))

从数据集中提取标签。

def extract_labels(filename, num_images):
    with gzip.open(filename) as bytestream:
        bytestream.read(8)
        buf = bytestream.read(1 * num_images)
        labels = np.frombuffer(buf, dtype=np.uint8).astype(np.int64)
        return labels
train_labels = extract_labels('data/train-labels-idx1-ubyte.gz',60000)
test_labels = extract_labels('data/t10k-labels-idx1-ubyte.gz',10000)

在数据集中我们是用 0 到 9 数字作为图片标签，为了便于观察可以将这些数字表示从 A 到 J 字母。

label_dict = {
 0: 'A',
 1: 'B',
 2: 'C',
 3: 'D',
 4: 'E',
 5: 'F',
 6: 'G',
 7: 'H',
 8: 'I',
 9: 'J',
}

print(train_data[0].shape)

下面函数 show_train_labels 显示数据集中图片

def show_train_labels():
    plt.figure(figsize=[5,5])

    # Display the first image in training data
    plt.subplot(121)
    curr_img = np.reshape(train_data[0], (28,28))
    curr_lbl = train_labels[0]
    plt.imshow(curr_img, cmap='gray')
    plt.title("(Label: " + str(label_dict[curr_lbl]) + ")")

    # Display the first image in testing data
    plt.subplot(122)
    curr_img = np.reshape(test_data[0], (28,28))
    curr_lbl = test_labels[0]
    plt.imshow(curr_img, cmap='gray')
    plt.title("(Label: " + str(label_dict[curr_lbl]) + ")")

    plt.show()

在输入数据之前，需要对数据形状进行一次变换，将图片从 通道变换为 的形状后在输入网络

train_data = train_data.reshape(-1, 28,28, 1)
test_data = test_data.reshape(-1, 28,28, 1)

print(train_data.shape, test_data.shape)

print(train_data.dtype, test_data.dtype)
np.max(train_data), np.max(test_data)

这里使用 sklearn 的 train_test_split 方法对数据集进行拆分。

train_data = train_data / np.max(train_data)
test_data = test_data / np.max(test_data)

```d     
接下来，需要对数进行处理，训练和测试数据类型都是 NumPy 数组的，它应该是float32格式，如果不是，则需要将其转换为此格式，但由于您在读取数据时已经转换了它，因此不再需要再次执行此操作。您还必须在0-1范围内（包括0-1）重新缩放像素值。所以让我们这么做吧！

```python
train_X,valid_X,train_ground,valid_ground = train_test_split(train_data,
                                                            train_data, 
                                                            test_size=0.2, 
                                                            random_state=13)

batch_size = 128
epochs = 1
inChannel = 1
x, y = 28, 28
input_img = Input(shape = (x, y, inChannel))

定义编码器

定义超参数，开始没有弄明白什么是超参数，现在我所理解的超参数就是可以学习的参数，例如定义卷积核大小、卷积通道数、卷积层数。不过为了得到好训练效果，我们也需要调整这些参数来训练出好的模型，这就是看经验了。

def autoencoder(input_img):
    #encoder
    #input = 28 x 28 x 1 (wide and thin)
    conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img) #28 x 28 x 32
    pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) #14 x 14 x 32
    conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1) #14 x 14 x 64
    pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) #7 x 7 x 64
    conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2) #7 x 7 x 128 (small and thick)
    #decoder
    conv4 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3) #7 x 7 x 128
    up1 = UpSampling2D((2,2))(conv4) # 14 x 14 x 128
    conv5 = Conv2D(64, (3, 3), activation='relu', padding='same')(up1) # 14 x 14 x 64
    up2 = UpSampling2D((2,2))(conv5) # 28 x 28 x 64
    decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(up2) # 28 x 28 x 1
    return decoded

编码器

• 第1 层是经过 32 个 的卷积层，然后进行一个最大池化输出为( )
• 第 2 层是经过 64 个 的卷积层，然后进行一个最大池化输出为( )
• 第 3 层是经过 128 个 的卷积层

解码器

• 第 1 层是经过 128 个 的卷积层，随后是一个上采用输出变为
• 第 2 层是经过 64 个 的卷积层，随后还是进行一次上采样，输出为( )
• 第 3 层是经过 32 个 的卷积层，然后进行一个最大池化输出为( )

autoencoder = Model(input_img, autoencoder(input_img))
autoencoder.compile(loss='mean_squared_error', optimizer = RMSprop())
autoencoder.summary()

autoencoder_train = autoencoder.fit(train_X, train_ground, batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(valid_X, valid_ground))

letters01 (2).png letters01 (1).png letters01.png

最后希望大家关注我们微信公众号

wechat.jpeg