Question

目前，我正在尝试使用Keras来实现多层自动编码器，以处理Mnist数据集（手写数字）。我的代码如下所示：

from keras.layers import Input, Dense, initializers
from keras.models import Model
import numpy as np
from Dataset import Dataset
import matplotlib.pyplot as plt
from keras import optimizers, losses
from keras import backend as K
import tensorflow as tf
from keras.callbacks import TensorBoard
from keras.layers import Dropout
from keras.models import Sequential
from keras import models
from keras import layers
import keras
from keras.optimizers import Adam


#global variables
d = Dataset()
num_features = d.X_train.shape[1]
low_dim = 32


def autoencoder(epochs):
    w = initializers.RandomNormal(mean=0.0, stddev=0.05, seed=None)
    model = Sequential()
    #First autoencoder
    model.add(Dense(400, activation='relu', kernel_initializer=w, input_dim=num_features, name='hidden'))
    model.add(Dropout(0.2))
    model.add(Dense(num_features, activation='sigmoid', input_dim = 400, name = 'output'))
    #Second autoencoder
    model.add(Dense(100, activation='relu', kernel_initializer=w, input_dim=num_features, name='hidden2'))
    model.add(Dropout(0.2))
    model.add(Dense(num_features, activation = 'sigmoid', input_dim = 100, name='output2'))
    #Third autoencoder
    model.add(Dense(50, activation='relu', kernel_initializer=w, input_dim=num_features, name='hidden3'))
    model.add(Dropout(0.2))
    model.add(Dense(num_features, activation='sigmoid', input_dim=10, name='output3'))
    model.compile(optimizer=Adam(lr=0.01), loss='binary_crossentropy', metrics=['accuracy'])
    history = model.fit(d.X_train, d.X_train,
                        epochs=epochs,
                        batch_size=64,
                        shuffle=True,
                        validation_data=(d.X_test, d.X_test))
    model.test_on_batch(d.X_test, d.X_test)
    print(history.history.keys())
    plt.plot(history.history['acc'])
    print(history.history['acc'])
    plt.show()
    return model

def finding_index():
    elements, index = np.unique(d.Y_test, return_index = True)
    return elements, index

def plotting():
    ae = autoencoder(2)
    elements, index = finding_index()
    y_proba = ae.predict(d.X_test)
    plt.figure(figsize=(20, 4))
    #size = 20
    for i in range(len(index)):
        ax = plt.subplot(2, len(index), i + 1)
        plt.imshow(d.X_test[index[i]].reshape(28, 28))
        plt.gray()
        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)

        ax = plt.subplot(2, len(index), i + 1 + len(index))
        plt.imshow(y_proba[index[i]].reshape(28, 28))
        plt.gray()
        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)
    plt.show()

plotting()

我有两个问题，当您堆叠自动编码器时应该是这样吗？还是我应该让一层缩小尺寸，比如说400，然后再缩小到100，依此类推，或者是我这样做的方式？第二个问题是，您可以针对不同的层使用不同的优化器（在我的情况下为Adam）吗？我想在最后一层使用SGD（随机梯度下降）。预先感谢！

Answer 1

您不应按照自己的方式进行操作，而应按问题中的描述方式进行操作。另外，您应该先下降然后再上升（例如400、100、50、25、10、25、50、100、400）。

第二个问题是答案。您可以先与Adam一起训练模型，然后冻结除最后一层以外的所有图层，以使用SGD进一步训练模型。但是您不能告诉Keras在不同的图层上使用不同的分类器。

使用keras的多层自动编码器，指定了不同的优化器

1 个答案: