def example_gan(adversarial_optimizer, path, opt_g, opt_d, nb_epoch, generator, discriminator, latent_dim, targets=gan_targets, loss="binary_crossentropy"):
csvpath = os.path.join(path, "history.csv")
if os.path.exists(csvpath):
print("Already exists: {}".format(csvpath))
return
print("Training: {}".format(csvpath))
# gan (x -> yfake, yreal), z is gaussian generated on GPU
# can also experiment with uniform_latent_sampling
d_g = discriminator(0)
d_d = discriminator(0.5)
generator.summary()
d_d.summary()
gan_g = simple_gan(generator, d_g, None)
gan_d = simple_gan(generator, d_d, None)
x = gan_g.inputs[1]
z = normal_latent_sampling((latent_dim,))(x)
# eliminate z from inputs
gan_g = Model([x], fix_names(gan_g([z, x]), gan_g.output_names))
gan_d = Model([x], fix_names(gan_d([z, x]), gan_d.output_names))
# build adversarial model
model = AdversarialModel(player_models=[gan_g, gan_d],
player_params=[generator.trainable_weights,
d_d.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=[opt_g, opt_d],
loss=loss)
# create callback to generate images
zsamples = np.random.normal(size=(10 * 10, latent_dim))
def generator_sampler():
xpred = generator.predict(zsamples)
xpred = dim_ordering_unfix(xpred.transpose((0, 2, 3, 1)))
return xpred.reshape((10, 10) + xpred.shape[1:])
generator_cb = ImageGridCallback(
os.path.join(path, "epoch-{:03d}.png"),
generator_sampler, cmap=None
)
callbacks = [generator_cb]
if K.backend() == "tensorflow":
callbacks.append(TensorBoard(log_dir=os.path.join(path, "logs"), histogram_freq=0, write_graph=True, write_images=True))
# train model
x_train, x_test = cifar10_data()
y = targets(x_train.shape[0])
y_test = targets(x_test.shape[0])
history = model.fit(x=x_train, y=y, validation_data=(x_test, y_test), callbacks=callbacks, epochs=nb_epoch, batch_size=32)
# save history to CSV
df = pd.DataFrame(history.history)
df.to_csv(csvpath)
# save models
generator.save(os.path.join(path, "generator.h5"))
d_d.save(os.path.join(path, "discriminator.h5"))
def aae_model(path, adversarial_optimizer,xtrain,encoded_dim=100,img_dim=25, nb_epoch=20):
# z \in R^100
latent_dim = encoded_dim
# x \in R^{28x28}
input_shape = (img_dim,)
# generator (z -> x)
generator = model_generator(latent_dim, input_shape)
# encoder (x ->z)
encoder = model_encoder(latent_dim, input_shape)
# autoencoder (x -> x')
autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)), name="autoencoder")
# discriminator (z -> y)
discriminator = model_discriminator(input_shape)
# assemple AAE
x = encoder.inputs[0]
z = encoder(x)
xpred = generator(z)
yreal = discriminator(x)
yfake = discriminator(xpred)
aae = Model(x, fix_names([xpred, yfake, yreal], ["xpred", "yfake", "yreal"]))
# print summary of models
encoder.summary()
generator.summary()
discriminator.summary()
#autoencoder.summary()
# build adversarial model
generative_params = generator.trainable_weights + encoder.trainable_weights
model = AdversarialModel(base_model=aae,
player_params=[generative_params, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
#parallel_model = multi_gpu_model(model, gpus=4)
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=[Adadelta(),Adadelta()],
loss={"yfake": "binary_crossentropy", "yreal": "binary_crossentropy",
"xpred": "binary_crossentropy"},
player_compile_kwargs=[{"loss_weights": {"yfake": 1e-4, "yreal": 1e-4, "xpred": 1e1}}]*2)
# train network
n = xtrain.shape[0]
y = [xtrain, np.ones((n, 1)), np.zeros((n, 1)), xtrain, np.zeros((n, 1)), np.ones((n, 1))]
ntest = xtest.shape[0]
#ytest = [xtest, np.ones((ntest, 1)), np.zeros((ntest, 1)), xtest, np.zeros((ntest, 1)), np.ones((ntest, 1))]
history = model.fit(x=xtrain, y=y, epochs=nb_epoch, batch_size=128, shuffle=False)
# save history
df = pd.DataFrame(history.history)
df.to_csv(os.path.join(path, "aae_history.csv"))
# save model
encoder.save(os.path.join(path, "aae_encoder.h5"))
generator.save(os.path.join(path, "aae_decoder.h5"))
discriminator.save(os.path.join(path, "aae_discriminator.h5"))
K.clear_session()
def __build_connected_network_train(self, main=True):
x = self.encoder.inputs[0]
e1, e2 = self.encoder(x)
noisy_e1 = self.noisy_transformer(e1)
y = self.predictor(e1)
x_pred = self.decoder([noisy_e1, e2])
e1_dim = int(self.encoder.outputs[0].shape[-1])
e2_dim = int(self.encoder.outputs[1].shape[-1])
output_vars = [y, x_pred]
output_names = ['y', 'x_pred']
e1_target = e1
e2_target = e2
e2_pred = self.disentangler1(e1)
e1_pred = self.disentangler2(e2)
if main:
embedding_activation = self.model_config.embedding_activation
e2_target = self.__random_target(x, e2_dim, embedding_activation)
e1_target = self.__random_target(x, e1_dim, embedding_activation)
e1_e1_pred = Concatenate()([e1_target, e1_pred])
output_vars.append(e1_e1_pred)
output_names.append('e1pred')
e2_e2_pred = Concatenate()([e2_target, e2_pred])
output_vars.append(e2_e2_pred)
output_names.append('e2pred')
if self.z_discriminator is not None:
z = self.z_discriminator(e1)
output_vars.append(z)
output_names.append('z')
outputs = fix_names(output_vars, output_names)
network = Model(inputs=[x], outputs=outputs)
return network
def example_aae(path, adversarial_optimizer):
# z \in R^100
latent_dim = 100
# x \in R^{28x28}
input_shape = (28, 28)
# generator (z -> x)
generator = model_generator(latent_dim, input_shape)
# encoder (x ->z)
encoder = model_encoder(latent_dim, input_shape)
# autoencoder (x -> x')
autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
# discriminator (z -> y)
discriminator = model_discriminator(latent_dim)
# assemple AAE
x = encoder.inputs[0]
z = encoder(x)
xpred = generator(z)
zreal = normal_latent_sampling((latent_dim, ))(x)
yreal = discriminator(zreal)
yfake = discriminator(z)
aae = Model(x, fix_names([xpred, yfake, yreal],
["xpred", "yfake", "yreal"]))
# print summary of models
generator.summary()
encoder.summary()
discriminator.summary()
autoencoder.summary()
# build adversarial model
generative_params = generator.trainable_weights + encoder.trainable_weights
model = AdversarialModel(
base_model=aae,
player_params=[generative_params, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(
adversarial_optimizer=adversarial_optimizer,
player_optimizers=[Adam(1e-4, decay=1e-4),
Adam(1e-3, decay=1e-4)],
loss={
"yfake": "binary_crossentropy",
"yreal": "binary_crossentropy",
"xpred": "mean_squared_error"
},
compile_kwargs={
"loss_weights": {
"yfake": 1e-2,
"yreal": 1e-2,
"xpred": 1
}
})
# load mnist data
xtrain, xtest = mnist_data()
# callback for image grid of generated samples
def generator_sampler():
zsamples = np.random.normal(size=(10 * 10, latent_dim))
return generator.predict(zsamples).reshape((10, 10, 28, 28))
generator_cb = ImageGridCallback(
os.path.join(path, "generated-epoch-{:03d}.png"), generator_sampler)
# callback for image grid of autoencoded samples
def autoencoder_sampler():
xsamples = n_choice(xtest, 10)
xrep = np.repeat(xsamples, 9, axis=0)
xgen = autoencoder.predict(xrep).reshape((10, 9, 28, 28))
xsamples = xsamples.reshape((10, 1, 28, 28))
samples = np.concatenate((xsamples, xgen), axis=1)
return samples
autoencoder_cb = ImageGridCallback(
os.path.join(path, "autoencoded-epoch-{:03d}.png"),
autoencoder_sampler)
# train network
# generator, discriminator; pred, yfake, yreal
n = xtrain.shape[0]
y = [
xtrain,
np.ones((n, 1)),
np.zeros((n, 1)), xtrain,
np.zeros((n, 1)),
np.ones((n, 1))
]
ntest = xtest.shape[0]
ytest = [
xtest,
np.ones((ntest, 1)),
np.zeros((ntest, 1)), xtest,
np.zeros((ntest, 1)),
np.ones((ntest, 1))
]
history = model.fit(x=xtrain,
y=y,
validation_data=(xtest, ytest),
callbacks=[generator_cb, autoencoder_cb],
nb_epoch=100,
batch_size=32)
# save history
df = pd.DataFrame(history.history)
df.to_csv(os.path.join(path, "history.csv"))
# save model
encoder.save(os.path.join(path, "encoder.h5"))
generator.save(os.path.join(path, "generator.h5"))
discriminator.save(os.path.join(path, "discriminator.h5"))
def example_bigan(path, adversarial_optimizer):
# z \in R^100
latent_dim = 25
# x \in R^{28x28}
input_shape = (28, 28)
# generator (z -> x)
generator = model_generator(latent_dim, input_shape)
# encoder (x ->z)
encoder = model_encoder(latent_dim, input_shape)
# autoencoder (x -> x')
autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
# discriminator (x -> y)
discriminator_train, discriminator_test = model_discriminator(
latent_dim, input_shape)
# bigan (z, x - > yfake, yreal)
bigan_generator = simple_bigan(generator, encoder, discriminator_test)
bigan_discriminator = simple_bigan(generator, encoder, discriminator_train)
# z generated on GPU based on batch dimension of x
x = bigan_generator.inputs[1]
z = normal_latent_sampling((latent_dim, ))(x)
# eliminate z from inputs
bigan_generator = Model([x],
fix_names(bigan_generator([z, x]),
bigan_generator.output_names))
bigan_discriminator = Model([x],
fix_names(bigan_discriminator([z, x]),
bigan_discriminator.output_names))
generative_params = generator.trainable_weights + encoder.trainable_weights
# print summary of models
generator.summary()
encoder.summary()
discriminator_train.summary()
bigan_discriminator.summary()
autoencoder.summary()
# build adversarial model
model = AdversarialModel(
player_models=[bigan_generator, bigan_discriminator],
player_params=[
generative_params, discriminator_train.trainable_weights
],
player_names=["generator", "discriminator"])
model.adversarial_compile(
adversarial_optimizer=adversarial_optimizer,
player_optimizers=[Adam(1e-4, decay=1e-4),
Adam(1e-3, decay=1e-4)],
loss='binary_crossentropy')
# load mnist data
xtrain, xtest = mnist_data()
# callback for image grid of generated samples
def generator_sampler():
zsamples = np.random.normal(size=(10 * 10, latent_dim))
return generator.predict(zsamples).reshape((10, 10, 28, 28))
generator_cb = ImageGridCallback(
os.path.join(path, "generated-epoch-{:03d}.png"), generator_sampler)
# callback for image grid of autoencoded samples
def autoencoder_sampler():
xsamples = n_choice(xtest, 10)
xrep = np.repeat(xsamples, 9, axis=0)
xgen = autoencoder.predict(xrep).reshape((10, 9, 28, 28))
xsamples = xsamples.reshape((10, 1, 28, 28))
x = np.concatenate((xsamples, xgen), axis=1)
return x
autoencoder_cb = ImageGridCallback(
os.path.join(path, "autoencoded-epoch-{:03d}.png"),
autoencoder_sampler)
# train network
y = gan_targets(xtrain.shape[0])
ytest = gan_targets(xtest.shape[0])
history = model.fit(x=xtrain,
y=y,
validation_data=(xtest, ytest),
callbacks=[generator_cb, autoencoder_cb],
nb_epoch=100,
batch_size=32)
# save history
df = pd.DataFrame(history.history)
df.to_csv(os.path.join(path, "history.csv"))
# save model
encoder.save(os.path.join(path, "encoder.h5"))
generator.save(os.path.join(path, "generator.h5"))
discriminator_train.save(os.path.join(path, "discriminator.h5"))
def __init__(self, uNum, iNum, dim, weight, pop_percent):
self.uNum = uNum
self.iNum = iNum
self.dim = dim
self.weight = weight
self.pop_percent = pop_percent
# Define user input -- user index (an integer)
userInput = Input(shape=(1,), dtype="int32")
itemInput = Input(shape=(1,), dtype="int32")
userAdvInput = Input(shape=(1,), dtype="int32")
itemAdvInput = Input(shape=(1,), dtype="int32")
userEmbeddingLayer = Embedding(input_dim=uNum, output_dim=dim)
itemEmbeddingLayer = Embedding(input_dim=iNum, output_dim=dim)
uEmb = Flatten()(userEmbeddingLayer(userInput))
iEmb = Flatten()(itemEmbeddingLayer(itemInput))
uAdvEmb = Flatten()(userEmbeddingLayer(userAdvInput))
iAdvEmb = Flatten()(itemEmbeddingLayer(itemAdvInput))
self.uEncoder = Model(userInput, uEmb)
self.iEncoder = Model(itemInput, iEmb)
self.discriminator_i = self.generate_discriminator()
self.discriminator_i.compile(optimizer="adam", loss="binary_crossentropy", metrics=['accuracy'])
self.discriminator_i.trainable = False
validity = self.discriminator_i(iAdvEmb)
self.discriminator_u = self.generate_discriminator()
self.discriminator_u.compile(optimizer="adam", loss="binary_crossentropy", metrics=['accuracy'])
self.discriminator_u.trainable = False
validity_u = self.discriminator_u(uAdvEmb)
pred = dot([uEmb, iEmb], axes=-1)
# pred = merge([uEmb, iEmb], mode="concat")
self.model = Model([userInput, itemInput], pred)
# self.model.compile(optimizer="adam", loss="mean_squared_error", metrics=['mse'])
# self.advModel = Model([userInput, itemInput, userAdvInput, itemAdvInput], [pred, validity_u, validity])
# self.advModel.compile(optimizer="adam",
# loss=["mean_squared_error", "binary_crossentropy", "binary_crossentropy"],
# metrics=['mse', 'acc', 'acc'], loss_weights=[1, self.weight, self.weight])
self.aae = Model([userInput, itemInput, userAdvInput, itemAdvInput],
fix_names([pred, validity_u, validity], ["xpred", "upred", "ipred"]))
mf_params = self.uEncoder.trainable_weights + self.iEncoder.trainable_weights
self.advModel = AdversarialModel(base_model=self.aae,
player_params=[mf_params, self.discriminator_u.trainable_weights,
self.discriminator_i.trainable_weights],
player_names=["mf", "disc_u", "disc_i"])
self.advModel.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=[Adam(), Adam(), Adam()],
loss={"upred": "binary_crossentropy", "ipred": "binary_crossentropy",
"xpred": "mean_squared_error"},
player_compile_kwargs=[{"loss_weights": {"upred": 1, "ipred": 1,
"xpred": 1}}] * 2)
def driver_gan(path, adversarial_optimizer):
# z \in R^100
latent_dim = 3
# x \in R^{28x28}
input_shape = (15, 6)
# generator (z -> x)
generator = model_generator(latent_dim, input_shape)
# encoder (x ->z)
encoder = model_encoder(latent_dim, input_shape)
# autoencoder (x -> x')
autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
# discriminator (x -> y)
discriminator_train, discriminator_test = model_discriminator(latent_dim, input_shape)
# bigan (z, x - > yfake, yreal)
bigan_generator = simple_bigan(generator, encoder, discriminator_test)
bigan_discriminator = simple_bigan(generator, encoder, discriminator_train)
# z generated on GPU based on batch dimension of x
x = bigan_generator.inputs[1]
z = normal_latent_sampling((latent_dim,))(x)
# eliminate z from inputs
bigan_generator = Model([x], fix_names(bigan_generator([z, x]), bigan_generator.output_names))
bigan_discriminator = Model([x], fix_names(bigan_discriminator([z, x]), bigan_discriminator.output_names))
# Merging encoder weights and generator weights
generative_params = generator.trainable_weights + encoder.trainable_weights
# print summary of models
generator.summary()
encoder.summary()
discriminator_train.summary()
bigan_discriminator.summary()
autoencoder.summary()
# build adversarial model
model = AdversarialModel(player_models=[bigan_generator, bigan_discriminator],
player_params=[generative_params, discriminator_train.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=[Adam(1e-7, decay=1e-7), Adam(1e-6, decay=1e-7)],
loss='binary_crossentropy')
# load driver data
train_dataset = [1,2,5]
test_dataset = [3,4]
train_reader = data_base(train_dataset)
test_reader = data_base(test_dataset)
xtrain, xtest = train_reader.read_files(),test_reader.read_files()
# ---------------------------------------------------------------------------------
# callback for image grid of generated samples
def generator_sampler():
zsamples = np.random.normal(size=(1 * 1, latent_dim)) #---------------------------------> (10,10)
return generator.predict(zsamples).reshape((1, 1, 15, 6))# confused ***********************************default (10,10,28,28)
# callback for image grid of autoencoded samples
def autoencoder_sampler():
xsamples = n_choice(xtest, 10) # the number of testdata set
xrep = np.repeat(xsamples, 5, axis=0) # the number of train dataset
xgen = autoencoder.predict(xrep).reshape((1, 1, 15, 6))
xsamples = xsamples.reshape((1, 1, 15, 6))
x = np.concatenate((xsamples, xgen), axis=1)
return x
# train network
y = gan_targets(xtrain.shape[0])
ytest = gan_targets(xtest.shape[0])
history = model.fit(x=xtrain, y=y, validation_data=(xtest, ytest),
nb_epoch=25, batch_size=10, verbose=0)
# save history
df = pd.DataFrame(history.history)
df.to_csv(os.path.join(path, "history.csv"))
# save model
encoder.save(os.path.join(path, "encoder.h5"))
generator.save(os.path.join(path, "generator.h5"))
discriminator_train.save(os.path.join(path, "discriminator.h5"))
def example_aae(path, adversarial_optimizer):
# z \in R^100
latent_dim = 256
units = 512
# x \in R^{28x28}
##input_shape = dim_ordering_shape((3, 128, 170))
input_shape = dim_ordering_shape((3, 32, 32))
#input_shape = (3,32,32)
###input_shape = (48,48,3)
# generator (z -> x)
generator = model_generator(latent_dim, units=units)
# encoder (x ->z)
encoder = model_encoder(latent_dim, input_shape, units=units)
# autoencoder (x -> x')
autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
# discriminator (z -> y)
discriminator = model_discriminator(latent_dim, units=units)
# build AAE
x = encoder.inputs[0]
z = encoder(x)
xpred = generator(z)
zreal = normal_latent_sampling((latent_dim, ))(x)
yreal = discriminator(zreal)
yfake = discriminator(z)
aae = Model(x, fix_names([xpred, yfake, yreal],
["xpred", "yfake", "yreal"]))
# print summary of models
print("generator (z -> x)")
generator.summary()
print("encoder (x ->z)")
encoder.summary()
print("autoencoder (x -> x')")
discriminator.summary()
print("discriminator (z -> y)")
autoencoder.summary()
# build adversarial model
generative_params = generator.trainable_weights + encoder.trainable_weights
model = AdversarialModel(
base_model=aae,
player_params=[generative_params, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(
adversarial_optimizer=adversarial_optimizer,
player_optimizers=[Adam(3e-4, decay=1e-4),
Adam(1e-3, decay=1e-4)],
loss={
"yfake": "binary_crossentropy",
"yreal": "binary_crossentropy",
"xpred": "mean_squared_error"
},
player_compile_kwargs=[{
"loss_weights": {
"yfake": 1e-1,
"yreal": 1e-1,
"xpred": 1e2
}
}] * 2)
# load mnist data
xtrain, xtest = benthoz_data()
print("xtrain shapes {}".format(xtrain.shape))
print("xtrain mean val {}".format(np.mean(xtrain)))
# callback for image grid of generated samples
def generator_sampler():
zsamples = np.random.normal(size=(10 * 10, latent_dim))
return dim_ordering_unfix(generator.predict(zsamples)).transpose(
(0, 2, 3, 1)).reshape((10, 10, 32, 32, 3))
#return generator.predict(zsamples).reshape((10, 10, 32, 32, 3))
generator_cb = ImageGridCallback(
os.path.join(path, "generated-epoch-{:03d}.png"), generator_sampler)
# callback for image grid of autoencoded samples
def autoencoder_sampler():
xsamples = n_choice(xtest, 10)
xrep = np.repeat(xsamples, 9, axis=0)
xgen = dim_ordering_unfix(autoencoder.predict(xrep)).reshape(
(10, 9, 3, 32, 32))
xsamples = dim_ordering_unfix(xsamples).reshape((10, 1, 3, 32, 32))
#xgen = autoencoder.predict(xrep).reshape((10, 9, 32, 32, 3))
#xsamples = xsamples.reshape((10, 1, 32, 32,3))
samples = np.concatenate((xsamples, xgen), axis=1)
samples = samples.transpose((0, 1, 3, 4, 2))
return samples
autoencoder_cb = ImageGridCallback(os.path.join(
path, "autoencoded-epoch-{:03d}.png"),
autoencoder_sampler,
cmap=None)
# train network
# generator, discriminator; pred, yfake, yreal
n = xtrain.shape[0]
print("num train samples {}".format(n))
y = [
xtrain,
np.ones((n, 1)),
np.zeros((n, 1)), xtrain,
np.zeros((n, 1)),
np.ones((n, 1))
]
ntest = xtest.shape[0]
ytest = [
xtest,
np.ones((ntest, 1)),
np.zeros((ntest, 1)), xtest,
np.zeros((ntest, 1)),
np.ones((ntest, 1))
]
history = fit(model,
x=xtrain,
y=y,
validation_data=(xtest, ytest),
callbacks=[generator_cb, autoencoder_cb],
nb_epoch=100,
batch_size=32)
#history = fit(model, x=xtrain, y=y, validation_data=(xtest, ytest),nb_epoch=100, batch_size=32)
# save history
df = pd.DataFrame(history.history)
df.to_csv(os.path.join(path, "history.csv"))
# save model
encoder.save(os.path.join(path, "encoder.h5"))
generator.save(os.path.join(path, "generator.h5"))
discriminator.save(os.path.join(path, "discriminator.h5"))
def example_faae(path, adversarial_optimizer):
latent_dim = 256
units = 512
input_shape = dim_ordering_shape((3, 32, 32))
# generator (z -> x)
generator = model_generator(latent_dim, units=units)
# encoder (x ->z)
encoder = model_encoder(latent_dim, input_shape, units=units)
# autoencoder (x -> x')
autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
# discriminator (z -> y)
discriminator = model_discriminator()
# build FAAE
zreal = discriminator.inputs[0]
x = generator.inputs[0]
z = generator(x)
xpred = encoder(z)
yreal = discriminator(zreal)
yfake = discriminator(z)
aae = Model([zreal, x],
fix_names([xpred, yfake, yreal], ["xpred", "yfake", "yreal"]))
# print summary of models
generator.summary()
encoder.summary()
discriminator.summary()
#encoder.load_weights(os.path.join(path, "encoder.h5"))
#generator.load_weights(os.path.join(path, "generator.h5"))
#discriminator.load_weights(os.path.join(path, "discriminator.h5"))
# build adversarial model
generative_params = generator.trainable_weights + encoder.trainable_weights
model = AdversarialModel(
base_model=aae,
player_params=[generative_params, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(
adversarial_optimizer=adversarial_optimizer,
player_optimizers=[Adam(3e-4, decay=1e-4),
Adam(1e-3, decay=1e-4)],
loss={
"yfake": "binary_crossentropy",
"yreal": "binary_crossentropy",
"xpred": "mean_squared_error"
},
player_compile_kwargs=[{
"loss_weights": {
"yfake": 1,
"yreal": 1,
"xpred": 8
}
}] * 2)
xtrain, xtest = cifar10_data()
def generator_sampler():
zsamples = np.random.randn(10 * 10, latent_dim)
return dim_ordering_unfix(generator.predict(zsamples)).transpose(
(0, 2, 3, 1)).reshape((10, 10, 32, 32, 3))
generator_cb = ImageGridCallback(
os.path.join(path, "generated-epoch-{:03d}.png"), generator_sampler)
def autoencoder_sampler():
xsamples = n_choice(xtest, 10)
xrep = np.repeat(xsamples, 9, axis=0)
xgen = dim_ordering_unfix(autoencoder.predict(xrep)).reshape(
(10, 9, 3, 32, 32))
xsamples = dim_ordering_unfix(xsamples).reshape((10, 1, 3, 32, 32))
samples = np.concatenate((xsamples, xgen), axis=1)
samples = samples.transpose((0, 1, 3, 4, 2))
return samples
autoencoder_cb = ImageGridCallback(os.path.join(
path, "autoencoded-epoch-{:03d}.png"),
autoencoder_sampler,
cmap=None)
train_datagen = gen_sample(128, 256, False)
test_datagen = gen_sample(32, 256, True)
history = model.fit_generator(train_datagen,
epochs=200,
steps_per_epoch=1000,
validation_data=test_datagen,
validation_steps=100,
callbacks=[generator_cb, autoencoder_cb])
# save history
df = pd.DataFrame(history.history)
df.to_csv(os.path.join(path, "history.csv"))
# save model
encoder.save(os.path.join(path, "encoder.h5"))
generator.save(os.path.join(path, "generator.h5"))
discriminator.save(os.path.join(path, "discriminator.h5"))
def example_aae(path, adversarial_optimizer):
# z \in R^100
latent_dim = 100
# x \in R^{28x28}
input_shape = (64, 64)
# generator (z -> x)
generator = model_generator(latent_dim, input_shape)
# encoder (x ->z)
encoder = model_encoder(latent_dim, input_shape)
# autoencoder (x -> x')
autoencoder = model_encoder(latent_dim, input_shape)
#autoencoder = Model(encoder.inputs, generator(encoder(encoder.inputs)))
# discriminator (z -> y)
discriminator = model_discriminator(latent_dim)
# assemple AAE
x = autoencoder.inputs[0]
#z = encoder(x)
xpred = autoencoder(x)
#zreal = normal_latent_sampling((latent_dim,))(x)
yreal = discriminator(concatenate([x,xpred],axis=3))
#yfake = discriminator(z)
aae = Model(x, fix_names([xpred, yreal], ["xpred", "yreal"]))
# print summary of models
generator.summary()
encoder.summary()
discriminator.summary()
autoencoder.summary()
adversarial_optimizer = AdversarialOptimizerSimultaneous()
model = AdversarialModel(base_model=aae,
player_params=[autoencoder.trainable_weights, discriminator.trainable_weights],
player_names=["autoencoder", "discriminator"])
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=['adam', Adam(1e-3, decay=1e-3)],
loss={"yreal": "binary_crossentropy",
"xpred": masked_mse},
player_compile_kwargs=[{"loss_weights": {"yreal": 1e-2, "xpred": 1}}] * 2)
History=model.fit(x=xtrain, y=y, validation_data=(xval, yval),epochs=100, batch_size=15)
Outputs = model.predict(xtest)
print(Outputs[0].shape)
Outputs = Outputs[0].reshape(Outputs[0].shape[0],64,64)
#plt.figure()
#plt.imshow(xtest[1,:,:,0])
#plt.colorbar()
#plt.show()
#plt.figure()
#plt.imshow(Outputs[1,:,:])
#plt.colorbar()
#plt.show()
#plt.figure()
#plt.imshow(ytest[0,1,:,:])
#plt.colorbar()
#plt.show()
return (History, Outputs)
