Python 在构建编码器/解码器模型之前，对自动编码器进行培训是否有效？

我正在按照教程构建我的自动编码器。为此，我有两种策略：

A） 步骤1：构建自动编码器；第二步：构建编码器；步骤3：构建解码器；第四步：编译自动编码器；步骤5：列车自动编码器

B） 步骤1：构建自动编码器；第二步：编译自动编码器；步骤3：列车自动编码器；第四步：构建编码器；步骤5：构建解码器

对于这两种情况，模型收敛到损失0.100。然而，对于教程中所述的策略A，重建效果非常差。在战略B的情况下，重建要好得多

在我看来，这是有意义的，因为在策略A中，编码器和解码器模型的权重是在未经训练的层上构建的，结果是随机的。另一方面，在策略B中，我在训练后更好地定义了权重，因此重建效果更好

我的问题是，策略B是有效的还是我在重建中作弊？在策略A的情况下，由于编码器和解码器模型是基于自动编码器层构建的，KERA是否应该自动更新编码器和解码器模型的权重

###### Code for Strategy A

# Step 1
features = Input(shape=(x_train.shape[1],))

encoded = Dense(1426, activation='relu')(features)
encoded = Dense(732, activation='relu')(encoded)
encoded = Dense(328, activation='relu')(encoded)

encoded = Dense(encoding_dim, activation='relu')(encoded)

decoded = Dense(328, activation='relu')(encoded)
decoded = Dense(732, activation='relu')(decoded)
decoded = Dense(1426, activation='relu')(decoded)
decoded = Dense(x_train.shape[1], activation='relu')(decoded)

autoencoder = Model(inputs=features, outputs=decoded)

# Step 2
encoder = Model(features, encoded)

# Step 3
encoded_input = Input(shape=(encoding_dim,))
decoder_layer = autoencoder.layers[-4](encoded_input)
decoder_layer = autoencoder.layers[-3](decoder_layer)
decoder_layer = autoencoder.layers[-2](decoder_layer)
decoder_layer = autoencoder.layers[-1](decoder_layer)

decoder = Model(encoded_input, decoder_layer)

# Step 4
autoencoder.compile(optimizer='adam', loss='mse')

# Step 5
history = autoencoder.fit(x_train, 
                         x_train,
                         epochs=150,
                         batch_size=256,
                         shuffle=True,
                         verbose=1,
                         validation_split=0.2)

# Testing encoding
encoded_fts = encoder.predict(x_test)
decoded_fts = decoder.predict(encoded_fts)

###### Code for Strategy B

# Step 1
features = Input(shape=(x_train.shape[1],))

encoded = Dense(1426, activation='relu')(features)
encoded = Dense(732, activation='relu')(encoded)
encoded = Dense(328, activation='relu')(encoded)

encoded = Dense(encoding_dim, activation='relu')(encoded)

decoded = Dense(328, activation='relu')(encoded)
decoded = Dense(732, activation='relu')(decoded)
decoded = Dense(1426, activation='relu')(decoded)
decoded = Dense(x_train.shape[1], activation='relu')(decoded)

autoencoder = Model(inputs=features, outputs=decoded)

# Step 2
autoencoder.compile(optimizer='adam', loss='mse')

# Step 3
history = autoencoder.fit(x_train, 
                         x_train,
                         epochs=150,
                         batch_size=256,
                         shuffle=True,
                         verbose=1,
                         validation_split=0.2)
# Step 4
encoder = Model(features, encoded)

# Step 5
encoded_input = Input(shape=(encoding_dim,))
decoder_layer = autoencoder.layers[-4](encoded_input)
decoder_layer = autoencoder.layers[-3](decoder_layer)
decoder_layer = autoencoder.layers[-2](decoder_layer)
decoder_layer = autoencoder.layers[-1](decoder_layer)

decoder = Model(encoded_input, decoder_layer)

# Testing encoding
encoded_fts = encoder.predict(x_test)
decoded_fts = decoder.predict(encoded_fts)

我的问题是，策略B是有效的还是我在重建中作弊

A

和

B

是等效的；不，你没有作弊

在策略A的情况下，由于编码器和解码器模型是基于自动编码器层构建的，KERA是否应该自动更新编码器和解码器模型的权重

###### Code for Strategy A

# Step 1
features = Input(shape=(x_train.shape[1],))

encoded = Dense(1426, activation='relu')(features)
encoded = Dense(732, activation='relu')(encoded)
encoded = Dense(328, activation='relu')(encoded)

encoded = Dense(encoding_dim, activation='relu')(encoded)

decoded = Dense(328, activation='relu')(encoded)
decoded = Dense(732, activation='relu')(decoded)
decoded = Dense(1426, activation='relu')(decoded)
decoded = Dense(x_train.shape[1], activation='relu')(decoded)

autoencoder = Model(inputs=features, outputs=decoded)

# Step 2
encoder = Model(features, encoded)

# Step 3
encoded_input = Input(shape=(encoding_dim,))
decoder_layer = autoencoder.layers[-4](encoded_input)
decoder_layer = autoencoder.layers[-3](decoder_layer)
decoder_layer = autoencoder.layers[-2](decoder_layer)
decoder_layer = autoencoder.layers[-1](decoder_layer)

decoder = Model(encoded_input, decoder_layer)

# Step 4
autoencoder.compile(optimizer='adam', loss='mse')

# Step 5
history = autoencoder.fit(x_train, 
                         x_train,
                         epochs=150,
                         batch_size=256,
                         shuffle=True,
                         verbose=1,
                         validation_split=0.2)

# Testing encoding
encoded_fts = encoder.predict(x_test)
decoded_fts = decoder.predict(encoded_fts)

###### Code for Strategy B

# Step 1
features = Input(shape=(x_train.shape[1],))

encoded = Dense(1426, activation='relu')(features)
encoded = Dense(732, activation='relu')(encoded)
encoded = Dense(328, activation='relu')(encoded)

encoded = Dense(encoding_dim, activation='relu')(encoded)

decoded = Dense(328, activation='relu')(encoded)
decoded = Dense(732, activation='relu')(decoded)
decoded = Dense(1426, activation='relu')(decoded)
decoded = Dense(x_train.shape[1], activation='relu')(decoded)

autoencoder = Model(inputs=features, outputs=decoded)

# Step 2
autoencoder.compile(optimizer='adam', loss='mse')

# Step 3
history = autoencoder.fit(x_train, 
                         x_train,
                         epochs=150,
                         batch_size=256,
                         shuffle=True,
                         verbose=1,
                         validation_split=0.2)
# Step 4
encoder = Model(features, encoded)

# Step 5
encoded_input = Input(shape=(encoding_dim,))
decoder_layer = autoencoder.layers[-4](encoded_input)
decoder_layer = autoencoder.layers[-3](decoder_layer)
decoder_layer = autoencoder.layers[-2](decoder_layer)
decoder_layer = autoencoder.layers[-1](decoder_layer)

decoder = Model(encoded_input, decoder_layer)

# Testing encoding
encoded_fts = encoder.predict(x_test)
decoded_fts = decoder.predict(encoded_fts)

解码器模型只使用自动编码器层。如果

A

：

decoder.layers
Out:
[<keras.engine.input_layer.InputLayer at 0x7f8a44d805c0>,
 <keras.layers.core.Dense at 0x7f8a44e58400>,
 <keras.layers.core.Dense at 0x7f8a44e746d8>,
 <keras.layers.core.Dense at 0x7f8a44e14940>,
 <keras.layers.core.Dense at 0x7f8a44e2dba8>]

autoencoder.layers
Out:[<keras.engine.input_layer.InputLayer at 0x7f8a44e91c18>,
 <keras.layers.core.Dense at 0x7f8a44e91c50>,
 <keras.layers.core.Dense at 0x7f8a44e91ef0>,
 <keras.layers.core.Dense at 0x7f8a44e89080>,
 <keras.layers.core.Dense at 0x7f8a44e89da0>,
 <keras.layers.core.Dense at 0x7f8a44e58400>,
 <keras.layers.core.Dense at 0x7f8a44e746d8>,
 <keras.layers.core.Dense at 0x7f8a44e14940>,
 <keras.layers.core.Dense at 0x7f8a44e2dba8>]

-各层都是一样的

因此，

A

和

B

的训练顺序是相等的。更一般地说，如果共享层（以及权重），那么在大多数情况下，构建、编译和训练的顺序并不重要，因为它们位于同一张tensorflow图中

我在

mnist

dataset上运行了这个示例，它们显示了相同的性能，并且可以很好地重建图像。我想，如果您遇到case

A

的问题，您可能会错过其他事情（idk how，因为我复制粘贴了您的代码，一切都正常）

如果您使用jupyter，有时会重新启动并从上到下运行帮助

我的问题是，策略B是有效的还是我在重建中作弊

A

和

B

是等效的；不，你没有作弊

在策略A的情况下，由于编码器和解码器模型是基于自动编码器层构建的，KERA是否应该自动更新编码器和解码器模型的权重

###### Code for Strategy A

# Step 1
features = Input(shape=(x_train.shape[1],))

encoded = Dense(1426, activation='relu')(features)
encoded = Dense(732, activation='relu')(encoded)
encoded = Dense(328, activation='relu')(encoded)

encoded = Dense(encoding_dim, activation='relu')(encoded)

decoded = Dense(328, activation='relu')(encoded)
decoded = Dense(732, activation='relu')(decoded)
decoded = Dense(1426, activation='relu')(decoded)
decoded = Dense(x_train.shape[1], activation='relu')(decoded)

autoencoder = Model(inputs=features, outputs=decoded)

# Step 2
encoder = Model(features, encoded)

# Step 3
encoded_input = Input(shape=(encoding_dim,))
decoder_layer = autoencoder.layers[-4](encoded_input)
decoder_layer = autoencoder.layers[-3](decoder_layer)
decoder_layer = autoencoder.layers[-2](decoder_layer)
decoder_layer = autoencoder.layers[-1](decoder_layer)

decoder = Model(encoded_input, decoder_layer)

# Step 4
autoencoder.compile(optimizer='adam', loss='mse')

# Step 5
history = autoencoder.fit(x_train, 
                         x_train,
                         epochs=150,
                         batch_size=256,
                         shuffle=True,
                         verbose=1,
                         validation_split=0.2)

# Testing encoding
encoded_fts = encoder.predict(x_test)
decoded_fts = decoder.predict(encoded_fts)

###### Code for Strategy B

# Step 1
features = Input(shape=(x_train.shape[1],))

encoded = Dense(1426, activation='relu')(features)
encoded = Dense(732, activation='relu')(encoded)
encoded = Dense(328, activation='relu')(encoded)

encoded = Dense(encoding_dim, activation='relu')(encoded)

decoded = Dense(328, activation='relu')(encoded)
decoded = Dense(732, activation='relu')(decoded)
decoded = Dense(1426, activation='relu')(decoded)
decoded = Dense(x_train.shape[1], activation='relu')(decoded)

autoencoder = Model(inputs=features, outputs=decoded)

# Step 2
autoencoder.compile(optimizer='adam', loss='mse')

# Step 3
history = autoencoder.fit(x_train, 
                         x_train,
                         epochs=150,
                         batch_size=256,
                         shuffle=True,
                         verbose=1,
                         validation_split=0.2)
# Step 4
encoder = Model(features, encoded)

# Step 5
encoded_input = Input(shape=(encoding_dim,))
decoder_layer = autoencoder.layers[-4](encoded_input)
decoder_layer = autoencoder.layers[-3](decoder_layer)
decoder_layer = autoencoder.layers[-2](decoder_layer)
decoder_layer = autoencoder.layers[-1](decoder_layer)

decoder = Model(encoded_input, decoder_layer)

# Testing encoding
encoded_fts = encoder.predict(x_test)
decoded_fts = decoder.predict(encoded_fts)

解码器模型只使用自动编码器层。如果

A

：

decoder.layers
Out:
[<keras.engine.input_layer.InputLayer at 0x7f8a44d805c0>,
 <keras.layers.core.Dense at 0x7f8a44e58400>,
 <keras.layers.core.Dense at 0x7f8a44e746d8>,
 <keras.layers.core.Dense at 0x7f8a44e14940>,
 <keras.layers.core.Dense at 0x7f8a44e2dba8>]

autoencoder.layers
Out:[<keras.engine.input_layer.InputLayer at 0x7f8a44e91c18>,
 <keras.layers.core.Dense at 0x7f8a44e91c50>,
 <keras.layers.core.Dense at 0x7f8a44e91ef0>,
 <keras.layers.core.Dense at 0x7f8a44e89080>,
 <keras.layers.core.Dense at 0x7f8a44e89da0>,
 <keras.layers.core.Dense at 0x7f8a44e58400>,
 <keras.layers.core.Dense at 0x7f8a44e746d8>,
 <keras.layers.core.Dense at 0x7f8a44e14940>,
 <keras.layers.core.Dense at 0x7f8a44e2dba8>]

-各层都是一样的

因此，

A

和

B

的训练顺序是相等的。更一般地说，如果共享层（以及权重），那么在大多数情况下，构建、编译和训练的顺序并不重要，因为它们位于同一张tensorflow图中

我在

mnist

dataset上运行了这个示例，它们显示了相同的性能，并且可以很好地重建图像。我想，如果您遇到case

A

的问题，您可能会错过其他事情（idk how，因为我复制粘贴了您的代码，一切都正常）

---

如果您使用jupyter，有时重新启动并自上而下运行会有帮助。

这不是一个编程问题，因此可以说是离题了；关于ML理论和方法的问题请发到。谢谢！我也把我的问题贴在那里。它与理论和编码都相关，因为它取决于Keras如何构建其模型以及我如何编码我的层。因此，我将它保留在两个社区中；）我恐怕你不能这样做-看，请选择一个，然后删除另一个（就我个人而言，我在这里没有看到任何特定的内容，所以我仍然认为你应该删除这个）。嗯，好的。我删除了关于交叉验证的问题。谢谢你，诺特！这不是一个编程问题，因此可以说是离题的；关于ML理论和方法的问题请发到。谢谢！我也把我的问题贴在那里。它与理论和编码都相关，因为它取决于Keras如何构建其模型以及我如何编码我的层。因此，我将它保留在两个社区中；）我恐怕你不能这样做-看，请选择一个，然后删除另一个（就我个人而言，我在这里没有看到任何特定的内容，所以我仍然认为你应该删除这个）。嗯，好的。我删除了关于交叉验证的问题。谢谢你，诺特！我懂了。谢谢你，米哈伊尔！我懂了。谢谢你，米哈伊尔！