def test_autoencoder_advanced():
encoder = containers.Sequential([core.Dense(5, input_shape=(10,))])
decoder = containers.Sequential([core.Dense(10, input_shape=(5,))])
X_train = np.random.random((100, 10))
X_test = np.random.random((100, 10))
model = Sequential()
model.add(core.Dense(output_dim=10, input_dim=10))
autoencoder = core.AutoEncoder(encoder=encoder, decoder=decoder,
output_reconstruction=True)
model.add(autoencoder)
# training the autoencoder:
model.compile(optimizer='sgd', loss='mse')
assert autoencoder.output_reconstruction
model.fit(X_train, X_train, nb_epoch=1, batch_size=32)
# predicting compressed representations of inputs:
autoencoder.output_reconstruction = False # the autoencoder has to be recompiled after modifying this property
assert not autoencoder.output_reconstruction
model.compile(optimizer='sgd', loss='mse')
representations = model.predict(X_test)
assert representations.shape == (100, 5)
# the model is still trainable, although it now expects compressed representations as targets:
model.fit(X_test, representations, nb_epoch=1, batch_size=32)
# to keep training against the original inputs, just switch back output_reconstruction to True:
autoencoder.output_reconstruction = True
model.compile(optimizer='sgd', loss='mse')
model.fit(X_train, X_train, nb_epoch=1)
reconstructions = model.predict(X_test)
assert reconstructions.shape == (100, 10)
def test_autoencoder_second_layer():
# regression test for issue #1275
encoder = core.Dense(input_dim=10, output_dim=2)
decoder = core.Dense(input_dim=2, output_dim=10)
model = Sequential()
model.add(core.Dense(input_dim=20, output_dim=10))
model.add(core.AutoEncoder(encoder=encoder, decoder=decoder,
output_reconstruction=False))
model.compile(loss='mse', optimizer='sgd')
def _pre_train(self, X):
logger.info(u"Pre-training the network")
encoders = []
layers = self._hidden_layers[:] # Copy the hidden layers list
layers.insert(0, self.input_dim)
for i, (n_in, n_out) in enumerate(zip(layers[:-1], layers[1:]),
start=1):
logger.info(u"Training layer {}: Input {} -> Output {}".format(
i, n_in, n_out))
autoencoder = models.Sequential()
encoder = containers.Sequential()
encoder.add(core.Dropout(self._dropout_ratio,
input_shape=(n_in, )))
encoder.add(
core.Dense(input_dim=n_in,
output_dim=n_out,
activation=self._activation,
init=self._weight_init))
decoder = containers.Sequential()
decoder.add(
core.Dense(input_dim=n_out,
output_dim=n_in,
activation=self._activation,
init=self._weight_init))
autoencoder.add(
core.AutoEncoder(encoder=encoder,
decoder=decoder,
output_reconstruction=False))
logger.info(u"Compiling the autoencoder")
autoencoder.compile(optimizer=self._optimizer,
loss='mean_squared_error')
logger.info(u"Fitting the data")
autoencoder.fit(X,
X,
batch_size=self._batch_size,
nb_epoch=self._pre_train_epochs)
# Store trained weight and update training data
encoders.append(autoencoder.layers[0].encoder)
X = autoencoder.predict(X)
pass
return encoders
def new_encdecs(self, compile=True, use_dropout=None, use_noise=None):
self.enc_decs = []
if not use_dropout is None:
self.enc_use_drop = self.drop_rate > 0 and use_dropout
if not use_noise is None:
self.enc_use_noise = self.sigma_base > 0 and use_noise
if self.l1 != 0 or self.l2 != 0:
regularizer = WeightRegularizer(l1=self.l1, l2=self.l2)
else:
regularizer = None
for (i, (n_in, n_out)) in enumerate(
zip(self.layer_sizes[:-1], self.layer_sizes[1:])):
ae = Sequential()
enc_l = []
if self.enc_use_noise:
enc_l.append(
noise.GaussianNoise(self.sigma_base *
(self.sigma_fact**-i),
input_shape=(n_in, )))
enc_l.append(
core.Dense(input_dim=n_in,
output_dim=n_out,
activation='sigmoid',
W_regularizer=regularizer))
if self.enc_use_drop:
enc_l.append(core.Dropout(self.drop_rate))
enc = containers.Sequential(enc_l)
dec = containers.Sequential([
core.Dense(input_dim=n_out,
output_dim=n_in,
activation='sigmoid')
])
ae.add(
core.AutoEncoder(encoder=enc,
decoder=dec,
output_reconstruction=True))
if compile:
ae.compile(loss='mse', optimizer=self.enc_opt)
self.enc_decs.append(ae)
def test_autoencoder():
layer_1 = core.Layer()
layer_2 = core.Layer()
layer = core.AutoEncoder(layer_1, layer_2)
_runner(layer)
