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 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 generated on GPU
gan = simple_gan(generator, discriminator,
normal_latent_sampling((latent_dim, )))
# print summary of models
generator.summary()
discriminator.summary()
gan.summary()
# build adversarial model
model = AdversarialModel(base_model=gan,
player_params=[
generator.trainable_weights,
discriminator.trainable_weights
],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=[opt_g, opt_d],
loss=loss)
# train model
zsamples = np.random.normal(size=(10 * 10, latent_dim))
def generator_sampler():
return generator.predict(zsamples).reshape((10, 10, 28, 28))
generator_cb = ImageGridCallback(os.path.join(path, "epoch-{:03d}.png"),
generator_sampler)
xtrain, xtest = mnist_data()
y = targets(xtrain.shape[0])
ytest = targets(xtest.shape[0])
history = model.fit(x=xtrain,
y=y,
validation_data=(xtest, ytest),
callbacks=[generator_cb],
nb_epoch=nb_epoch,
batch_size=32)
df = pd.DataFrame(history.history)
df.to_csv(csvpath)
generator.save(os.path.join(path, "generator.h5"))
discriminator.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 example_gan(adversarial_optimizer,
path,
X,
opt_g,
opt_d,
nb_epoch,
generator,
discriminator,
latent_dim,
targets=gan_targets,
loss='binary_crossentropy',
params={}):
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 generated on GPU
gan = simple_gan(generator, discriminator,
normal_latent_sampling((latent_dim, )))
# print summary of models
generator.summary()
discriminator.summary()
gan.summary()
# build adversarial model
model = AdversarialModel(base_model=gan,
player_params=[
generator.trainable_weights,
discriminator.trainable_weights
],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=[opt_g, opt_d],
loss=loss)
# train model
y = targets(X.shape[0])
history = model.fit(x=X,
y=y,
nb_epoch=params['epochs'],
batch_size=params['batch_size'])
# save history to CSV
df = pd.DataFrame(history.history)
df.to_csv(csvpath)
# save models
generator.save(os.path.join(path, "generator.h5"))
discriminator.save(os.path.join(path, "discriminator.h5"))
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))
generator.summary()
discriminator.summary()
gan = simple_gan(generator=generator,
discriminator=discriminator,
latent_sampling=normal_latent_sampling((latent_dim,)))
model = AdversarialModel(base_model=gan,
player_params=[generator.trainable_weights, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=[opt_g, opt_d],
loss=loss)
zsamples = np.random.normal(size=(10 * 10, latent_dim))
def generator_sampler():
xpred = dim_ordering_unfix(generator.predict(zsamples)).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)
xtrain, xtest = cifar10_data()
y = targets(xtrain.shape[0])
ytest = targets(xtest.shape[0])
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))
history = model.fit(x=xtrain, y=y, validation_data=(xtest, ytest),
callbacks=callbacks, nb_epoch=nb_epoch,
batch_size=32)
df = pd.DataFrame(history.history)
df.to_csv(csvpath)
generator.save(os.path.join(path, "generator.h5"))
discriminator.save(os.path.join(path, "discriminator.h5"))
def main():
latent_dim = 100
input_shape = (1, 28, 28)
generator = model_generator()
discriminator = model_discriminator(input_shape=input_shape)
gan = simple_gan(generator, discriminator,
normal_latent_sampling((latent_dim, )))
generator.summary()
discriminator.summary()
gan.summary()
model = AdversarialModel(base_model=gan,
player_params=[
generator.trainable_weights,
discriminator.trainable_weights
],
player_names=["generator", "discriminator"])
model.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=[Adam(1e-4, decay=1e-4),
Adam(1e-3, decay=1e-4)],
loss='binary_crossentropy')
generator_cb = ImageGridCallback(
"output/gan_convolutional/epoch-{:03d}.png",
generator_sampler(latent_dim, generator))
xtrain, xtest = mnist_data()
xtrain = dim_ordering_fix(xtrain.reshape((-1, 1, 28, 28)))
xtest = dim_ordering_fix(xtest.reshape((-1, 1, 28, 28)))
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],
nb_epoch=100,
batch_size=32)
df = pd.DataFrame(history.history)
df.to_csv("output/gan_convolutional/history.csv")
generator.save("output/gan_convolutional/generator.h5")
discriminator.save("output/gan_convolutional/discriminator.h5")
def main():
# set path
root_dir = os.path.abspath('.')
data_dir = os.path.join(root_dir, 'MData')
# load data
train = pd.read_csv(os.path.join(data_dir, 'Train', 'train.csv'))
# test = pd.read_csv(os.path.join(data_dir, 'test.csv'))
temp = []
for img_name in train.filename:
image_path = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)
img = imread(image_path, flatten=True)
img = img.astype('float32')
temp.append(img)
train_x = np.stack(temp)
train_x = train_x / 255
epochs = 1
batch_size = 128
model_1 = model_generator_cifar()
model_2 = model_discriminator_cifar()
# gan = simple_gan(model_1, model_2, normal_latent_sampling((100,)))
latent_dim = 100
gan = simple_gan(model_1, model_2, latent_sampling=normal_latent_sampling((latent_dim,)))
model = AdversarialModel(base_model=gan,player_params=[model_1.trainable_weights, model_2.trainable_weights])
model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(), player_optimizers=['adam', 'adam'], loss='binary_crossentropy')
history = model.fit(x=train_x, y=gan_targets(train_x.shape[0]), epochs=epochs, batch_size=batch_size)
zsamples = np.random.normal(size=(10, 100))
pred = model_1.predict(zsamples)
for i in range(pred.shape[0]):
plt.imshow(pred[i, :], cmap='gray')
plt.savefig('out/animals/'+str(i)+'.png')
# discriminator
model_2 = Sequential([
InputLayer(input_shape=d_input_shape),
Flatten(),
Dense(units=hidden_1_num_units, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)),
Dense(units=hidden_2_num_units, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)),
Dense(units=d_output_num_units, activation='sigmoid', kernel_regularizer=L1L2(1e-5, 1e-5)),
])
print model_1.summary()
print model_2.summary()
from keras_adversarial import AdversarialModel, simple_gan, gan_targets
from keras_adversarial import AdversarialOptimizerSimultaneous, normal_latent_sampling
gan = simple_gan(model_1, model_2, normal_latent_sampling((100,)))
model = AdversarialModel(base_model=gan,player_params=[model_1.trainable_weights, model_2.trainable_weights])
model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(), player_optimizers=['adam', 'adam'], loss='binary_crossentropy')
print gan.summary()
history = model.fit(x=train_x, y=gan_targets(train_x.shape[0]), epochs=10, batch_size=batch_size)
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"))
class MyGAN(object):
# --------------------------------------------------------------------------------------------------
def __init__(self,
x_shape,
z_shape,
gBuilder,
dBuilder,
dmBuilder,
amBuilder,
gan_targets=gan_targets,
c_shape=None):
self.x_shape = x_shape
self.z_shape = z_shape
self.c_shape = c_shape
self.gBuilder = gBuilder
self.dBuilder = dBuilder
self.amBuilder = amBuilder
self.dmBuilder = dmBuilder
self.gan_targets = gan_targets
if type(self.gan_targets) == str:
import keras_adversarial.adversarial_utils
self.gan_targets = getattr(keras_adversarial.adversarial_utils,
self.gan_targets)
super(MyGAN, self).__init__()
# --------------------------------------------------------------------------------------------------
def get_generator(self):
return self.gBuilder(self.x_shape, self.z_shape, self.c_shape)
# --------------------------------------------------------------------------------------------------
def get_discriminator(self):
return self.dBuilder(self.x_shape, self.c_shape)
# --------------------------------------------------------------------------------------------------
def compile(self):
self.dm = self.dmBuilder(self.get_discriminator())
self.am = self.amBuilder(self.get_generator(),
self.get_discriminator())
return self.am, self.dm
# --------------------------------------------------------------------------------------------------
def adversarial_compile(self, loss='binary_crossentropy', schedule=None):
dm, dmop = self.dmBuilder(self.get_discriminator()[0],
do_compile=False)
am, amop = self.amBuilder(self.get_generator(),
self.get_discriminator(),
do_compile=False)
self.am = am
self.dm = dm
## self.gan = Model( inputs=am.inputs + dm.inputs, outputs=am.outputs+dm.outputs )
self.player_models = (Model(inputs=am[0].inputs + dm.inputs,
outputs=am[0].outputs + dm.outputs),
Model(inputs=am[1].inputs + dm.inputs,
outputs=am[1].outputs + dm.outputs))
self.model = AdversarialModel(
player_models=self.player_models,
## base_model=self.gan,
player_params=[
self.get_discriminator()[0].trainable_weights,
self.get_generator().trainable_weights
],
player_names=["discriminator", "generator"])
## optimizer = AdversarialOptimizerSimultaneousWithLoops(nloops=nloops)
if not schedule is None:
optimizer = AdversarialOptimizerScheduled(schedule)
else:
optimizer = AdversarialOptimizerSimultaneous()
print(loss)
self.model.adversarial_compile(adversarial_optimizer=optimizer,
player_optimizers=[amop, dmop],
loss=loss)
# --------------------------------------------------------------------------------------------------
def adversarial_fit(self,
x_train,
z_train,
c_x_train=None,
c_z_train=None,
w_x_train=None,
w_z_train=None,
x_test=None,
z_test=None,
c_x_test=None,
c_z_test=None,
w_x_test=None,
w_z_test=None,
batch_size=256,
n_epochs=50,
plot_every=5,
monitor_dir="log",
checkpoint_every=50,
**kwargs):
if x_test is None:
x_test = x_train
if z_test is None:
z_test = z_train
if c_x_test is None:
c_x_test = c_x_train
if c_z_test is None:
c_z_test = c_z_train
if w_x_test is None:
w_x_test = w_x_train
if w_z_test is None:
w_z_test = w_z_train
if c_z_train is None:
c_z_train = c_x_train
if c_z_test is None:
c_z_test = c_x_test
if w_z_train is None:
w_z_train = w_x_train
if w_z_test is None:
w_z_test = w_x_test
has_c = not c_x_train is None
has_w = not w_x_train is None
if has_c:
train_x = [c_z_train, z_train, c_x_train, x_train]
test_x = [c_z_test, z_test, c_x_test, x_test]
else:
train_x = [z_train, x_train]
test_x = [z_test, x_test]
train_y = self.gan_targets(train_x[0].shape[0])
test_y = self.gan_targets(test_x[0].shape[0])
if has_w:
train_w = [w_z_train, w_x_train, w_z_train, w_x_train]
test_w = [w_z_test, w_x_test, w_z_test, w_x_test]
else:
train_w = None
test_w = None
if not os.path.exists(monitor_dir):
os.mkdir(monitor_dir)
plotter = plotting.SlicePlotter(self.get_generator(),
self.get_discriminator()[1],
x_test,
z_test,
c_x_test,
c_z_test,
plot_every=plot_every,
w_x_test=w_x_test,
w_z_test=w_z_test,
do_slices=True,
saveas='%s/sample' % monitor_dir)
tensorboard = TensorBoard(log_dir='%s/tensorboard' % monitor_dir,
histogram_freq=0)
csv = CSVLogger("%s/metrics.csv" % monitor_dir)
## checkpoint = ModelCheckpoint("%s/model-{epoch:02d}.hdf5" % monitor_dir, monitor='loss',
## save_best_only=False, save_weights_only=True,
## period=checkpoint_every)
checkpoint = MyCheckPoint(self, "%s/" % monitor_dir, checkpoint_every)
self.model.name = "adversarial_model"
self.model.fit(train_x,
train_y,
sample_weight=train_w,
nb_epoch=n_epochs,
batch_size=batch_size,
callbacks=[checkpoint, csv, tensorboard, plotter],
**kwargs)
# --------------------------------------------------------------------------------------------------
def fit(
self,
x_train,
z_train,
c_x_train=None,
c_z_train=None,
x_test=None,
z_test=None,
c_x_test=None,
c_z_test=None,
n_disc_steps=1,
n_gen_steps=1,
batch_size=256,
n_epochs=50,
plot_every=5,
print_every=1,
solution=None,
):
if x_test is None:
x_test = x_train
if z_test is None:
z_test = z_train
if c_x_test is None:
c_x_test = c_x_test
if c_z_test is None:
c_z_test = c_z_train
if c_z_train is None:
c_z_train = c_x_train
if c_z_test is None:
c_z_test = c_x_test
has_c = not c_x_train is None
self.compile()
n_batches = x_train.shape[0] // batch_size
generator = self.get_generator()
discriminator = self.get_discriminator()
am = self.am
dm = self.dm
print_every = n_batches // print_every
def train_batch(ib):
x_batch = x_train[ib * batch_size:(ib + 1) * batch_size]
z_batch = z_train[ib * batch_size:(ib + 1) * batch_size]
if has_c:
c_z_batch = c_z_train[ib * batch_size:(ib + 1) * batch_size]
c_x_batch = c_x_train[ib * batch_size:(ib + 1) * batch_size]
z_batch = [c_z_batch, z_batch]
g_batch = generator.predict(z_batch)[1]
else:
g_batch = generator.predict(z_batch)
x_train_b = np.vstack([x_batch, g_batch])
if has_c:
c_train_b = np.vstack([c_x_batch, c_z_batch])
x_train_b = [c_train_b, x_train_b]
y_train_b = np.ones((2 * batch_size, 1))
y_train_b[:batch_size, :] = 0
generator.trainable = False
for di in range(n_disc_steps):
d_loss = dm.train_on_batch(x_train_b, y_train_b)
#d_loss = [0,0]
generator.trainable = True
for di in range(n_gen_steps):
a_loss = am.train_on_batch(z_batch, np.zeros((batch_size, 1)))
# a_loss = [0,0]
if ib % print_every == 0:
msg = "%d: D: [%f %f] A: [%f %f]" % (ib, d_loss[0], d_loss[1],
a_loss[0], a_loss[1])
print(msg)
predictions = []
for iepoch in range(n_epochs):
if iepoch % plot_every == 0 or iepoch == n_epochs - 1:
if has_c:
x_predict = generator.predict([c_z_test, z_test])[1]
else:
x_predict = generator.predict(z_test)
predictions.append(x_predict)
if has_c:
x_discrim = discriminator.predict([c_x_test, x_test])
z_discrim = discriminator.predict([c_z_test, x_predict])
plotting.plot_summary_cond(x_test, c_x_test, x_predict,
c_z_test, z_test, x_discrim,
z_discrim) #, solution )
else:
x_discrim = discriminator.predict(x_test)
z_discrim = discriminator.predict(x_predict)
if x_test.shape[-1] == 1:
plotting.plot_summary(x_test.ravel(),
x_predict.ravel(),
z_test.ravel(), x_discrim,
z_discrim, solution)
else:
plotting.plot_summary_2d(x_test, x_predict, x_discrim,
z_discrim)
for ib in range(n_batches):
train_batch(ib)
gerador.add(Reshape((28, 28)))
# Discriminador
discriminador = Sequential()
discriminador.add(InputLayer(input_shape=(28, 28)))
discriminador.add(Flatten())
discriminador.add(
Dense(units=500, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)))
discriminador.add(
Dense(units=500, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)))
discriminador.add(
Dense(units=1, activation='sigmoid', kernel_regularizer=L1L2(1e-5, 1e-5)))
gan = simple_gan(gerador, discriminador, normal_latent_sampling((100, )))
modelo = AdversarialModel(
base_model=gan,
player_params=[gerador.trainable_weights, discriminador.trainable_weights])
modelo.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=['adam', 'adam'],
loss='binary_crossentropy')
modelo.fit(x=previsores_treinamento,
y=gan_targets(60000),
epochs=100,
batch_size=256)
amostras = np.random.normal(size=(20, 100))
previsao = gerador.predict(amostras)
for i in range(previsao.shape[0]):
plt.imshow(previsao[i, :], cmap='gray')
plt.show()
def main():
data_dir = "goldens_filtered_32x32_gray/"
out_dir = "m_gan_out/"
epochs = 1
batch_size = 64
# TODO: Research why these values were chosen
opt_g = Adam(1e-4, decay=1e-5)
opt_d = Adam(1e-3, decay=1e-5)
loss = 'binary_crossentropy'
latent_dim = 100
adversarial_optimizer = AdversarialOptimizerSimultaneous()
# My simple models
# generator = get_generator()
# discriminator = get_discriminator()
# CIFAR example convolutional models
generator = get_generator_cifar()
discriminator = get_discriminator_cifar()
gan = simple_gan(generator, discriminator,
normal_latent_sampling((latent_dim, )))
# print summary of models
generator.summary()
discriminator.summary()
gan.summary()
# build adversarial model
model = AdversarialModel(base_model=gan,
player_params=[
generator.trainable_weights,
discriminator.trainable_weights
],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=adversarial_optimizer,
player_optimizers=[opt_g, opt_d],
loss=loss)
temp = []
for img_name in os.listdir(data_dir):
image_path = data_dir + img_name
img = imread(image_path)
img = img.astype('float32')
temp.append(img)
train_x = np.stack(temp)
train_x = train_x / 255
# Side effects
model.fit(x=train_x,
y=gan_targets(train_x.shape[0]),
epochs=epochs,
batch_size=batch_size)
zsamples = np.random.normal(size=(10, latent_dim))
pred = generator.predict(zsamples)
for i in range(pred.shape[0]):
plt.imshow(pred[i, :])
plt.savefig(out_dir + str(i) + '.png')
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)
class FastAdversarialMF(MatrixFactorization):
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)
# 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"},
# player_compile_kwargs=[{"loss_weights": {"yfake": 1e-2, "yreal": 1e-2,
# "xpred": 1}}] * 2)
def init(self, users, items):
self.popular_user_x, self.rare_user_x = self.get_discriminator_train_data(users)
self.popular_item_x, self.rare_item_x = self.get_discriminator_train_data(items)
def train(self, x_train, y_train, batch_size):
# sample batches for User Discriminator
pop_idx = np.random.randint(0, len(self.popular_user_x), int(len(y_train) / 2))
rare_idx = np.random.randint(0, len(self.rare_user_x), int(len(y_train) / 2))
user_x = np.concatenate([self.popular_user_x[pop_idx], self.rare_user_x[rare_idx]])[:len(y_train)]
user_y = np.concatenate([np.ones(int(len(y_train) / 2)), np.zeros(int(len(y_train) / 2))])[:len(y_train)]
user_x = self.uEncoder.predict((user_x))
# sample mini-batches for Item Discriminator
pop_idx = np.random.randint(0, len(self.popular_item_x), int(len(y_train) / 2))
rare_idx = np.random.randint(0, len(self.rare_item_x), int(len(y_train) / 2))
item_x = np.concatenate([self.popular_item_x[pop_idx], self.rare_item_x[rare_idx]])[:len(y_train)]
item_y = np.concatenate([np.ones(int(len(y_train) / 2)), np.zeros(int(len(y_train) / 2))])[:len(y_train)]
item_x = self.iEncoder.predict((item_x))
# Train adversarial model
x = x_train + [user_x, item_x, user_x, item_x]
y = [y_train, user_y, item_y, y_train, user_y[::-1], item_y[::-1]]
history = self.advModel.fit(x=x, y=y, batch_size=batch_size, epochs=1, verbose=1)
return history
def generate_discriminator(self):
itemInput = Input(shape=(self.dim,))
hidden = Dense(self.dim, activation="relu")
finalHidden = Dense(1, activation="sigmoid")
pred = finalHidden(hidden(itemInput))
return Model(itemInput, pred)
def get_discriminator_train_data(self, x):
popularity = {}
for i in x:
if i in popularity:
popularity[i] += 1
else:
popularity[i] = 1
popularity = {k: v for k, v in sorted(popularity.items(), key=lambda x: x[1])[::-1]}
popularity = np.array(list(popularity.keys()))
popular_x = popularity[:int(len(popularity) * self.pop_percent)]
rare_x = popularity[int(len(popularity) * self.pop_percent):]
return popular_x, rare_x
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 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"))
# print(generator.summary())
# print(discriminator.summary())
# Build a GAN
gan = simple_gan(generator=generator,
discriminator=discriminator,
latent_sampling=normal_latent_sampling((100, )))
model = AdversarialModel(
base_model=gan,
player_params=[
generator.trainable_weights, discriminator.trainable_weights
],
)
model.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=['adam', 'adam'],
loss='binary_crossentropy')
history = model.fit(train_data,
gan_targets(train_data.shape[0]),
epochs=10,
batch_size=batch_size)
sample = np.random.normal(size=(10, 100))
pred = generator.predict(sample)
for i in range(pred.shape[0]):
plt.imshow(pred[i, :], cmap='gray')
plt.show()
# print(model.summary())
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 main():
# to stop potential randomness
seed = 128
rng = np.random.RandomState(seed)
# set path
root_dir = os.path.abspath('.')
data_dir = os.path.join(root_dir, 'Data')
# load data
train = pd.read_csv(os.path.join(data_dir, 'Train', 'train.csv'))
# test = pd.read_csv(os.path.join(data_dir, 'test.csv'))
temp = []
for img_name in train.filename:
image_path = os.path.join(data_dir, 'Train', 'Images', 'train',
img_name)
img = imread(image_path, flatten=True)
img = img.astype('float32')
temp.append(img)
train_x = np.stack(temp)
train_x = train_x / 255
# print image
img_name = rng.choice(train.filename)
filepath = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)
img = imread(filepath, flatten=True)
# pylab stuff, who f****n knows
# pylab.imshow(img, cmap='gray')
# pylab.axis('off')
# pylab.show()
# Levers
g_input_shape = 100
d_input_shape = (28, 28)
hidden_1_num_units = 500
hidden_2_num_units = 500
g_output_num_units = 784
d_output_num_units = 1
epochs = 25
batch_size = 128
# generator
model_1 = Sequential([
Dense(units=hidden_1_num_units,
input_dim=g_input_shape,
activation='relu',
kernel_regularizer=L1L2(1e-5, 1e-5)),
Dense(units=hidden_2_num_units,
activation='relu',
kernel_regularizer=L1L2(1e-5, 1e-5)),
Dense(units=g_output_num_units,
activation='sigmoid',
kernel_regularizer=L1L2(1e-5, 1e-5)),
Reshape(d_input_shape),
])
# discriminator
model_2 = Sequential([
InputLayer(input_shape=d_input_shape),
Flatten(),
Dense(units=hidden_1_num_units,
activation='relu',
kernel_regularizer=L1L2(1e-5, 1e-5)),
Dense(units=hidden_2_num_units,
activation='relu',
kernel_regularizer=L1L2(1e-5, 1e-5)),
Dense(units=d_output_num_units,
activation='sigmoid',
kernel_regularizer=L1L2(1e-5, 1e-5)),
])
gan = simple_gan(model_1, model_2, normal_latent_sampling((100, )))
model = AdversarialModel(
base_model=gan,
player_params=[model_1.trainable_weights, model_2.trainable_weights])
model.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=['adam', 'adam'],
loss='binary_crossentropy')
history = model.fit(x=train_x,
y=gan_targets(train_x.shape[0]),
epochs=10,
batch_size=batch_size)
zsamples = np.random.normal(size=(10, 100))
pred = model_1.predict(zsamples)
for i in range(pred.shape[0]):
plt.imshow(pred[i, :], cmap='gray')
plt.savefig('out/numbers/' + str(i) + '.png')
])
# Compiling the GAN
gan = simple_gan(model_g, model_d, normal_latent_sampling((100, )))
model = AdversarialModel(
base_model=gan,
player_params=[model_g.trainable_weights, model_d.trainable_weights])
model.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=['adam', 'adam'],
loss='binary_crossentropy')
# Training the GAN
res = model.fit(x=train_X,
y=gan_targets(train_X.shape[0]),
epochs=10,
batch_size=batch_size)
# Visualisation
plt.plot(history.history['player_0_loss'])
plt.plot(history.history['player_1_loss'])
plt.plot(history.history['loss'])
# Generation of the image
samples = np.random.normal(size=(10, 100))
pred = model_g.predict(samples)
for i in range(pred.shape[0]):
plt.imshow(pred[i, :], cmap='gray')
plt.show()
# print summary of models
generator.summary()
discriminator.summary()
gan.summary()
# build adversarial model
model = AdversarialModel(base_model=gan,
player_params=[generator.trainable_weights, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=[Adam(1e-4, decay=1e-4), Adam(1e-3, decay=1e-4)],
loss='binary_crossentropy')
# train model
generator_cb = ImageGridCallback("output/gan_convolutional/epoch-{:03d}.png",
generator_sampler(latent_dim, generator))
xtrain, xtest = mnist_data()
xtrain = dim_ordering_fix(xtrain.reshape((-1, 1, 28, 28)))
xtest = dim_ordering_fix(xtest.reshape((-1, 1, 28, 28)))
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], nb_epoch=100,
batch_size=32)
df = pd.DataFrame(history.history)
df.to_csv("output/gan_convolutional/history.csv")
generator.save("output/gan_convolutional/generator.h5")
discriminator.save("output/gan_convolutional/discriminator.h5")
def main():
# 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 (x -> y)
discriminator = model_discriminator(latent_dim, input_shape)
# bigan (x - > yfake, yreal), z generated on GPU
bigan = simple_bigan(generator, encoder, discriminator, normal_latent_sampling((latent_dim,)))
generative_params = generator.trainable_weights + encoder.trainable_weights
# print summary of models
generator.summary()
encoder.summary()
discriminator.summary()
bigan.summary()
autoencoder.summary()
# build adversarial model
model = AdversarialModel(base_model=bigan,
player_params=[generative_params, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=[Adam(1e-4, decay=1e-4), Adam(1e-3, decay=1e-4)],
loss='binary_crossentropy')
# train model
xtrain, xtest = mnist_data()
def generator_sampler():
zsamples = np.random.normal(size=(10 * 10, latent_dim))
return generator.predict(zsamples).reshape((10, 10, 28, 28))
generator_cb = ImageGridCallback("output/bigan/generated-epoch-{:03d}.png", generator_sampler)
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("output/bigan/autoencoded-epoch-{:03d}.png", autoencoder_sampler)
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)
df = pd.DataFrame(history.history)
df.to_csv("output/bigan/history.csv")
encoder.save("output/bigan/encoder.h5")
generator.save("output/bigan/generator.h5")
discriminator.save("output/bigan/discriminator.h5")
class UnifAI(object):
def __init__(self, config):
self.config = config
self.model_config = self.config.model_config # alias
self.module_builder = UnifAI_ModuleBuilder(
self.model_config, self.config.remote_weights_path
)
self.encoder = None
self.predictor = None
self.decoder = None
self.noisy_transformer = None
self.disentangler1 = None
self.disentangler2 = None
self.z_discriminator = None
self.model_inference = None
self.model_train = None
self.optimizers = self.config.optimizers # alias
self.compiled = False
def __random_target(self, x, dim, embedding_activation):
range_low = -1 if embedding_activation == 'tanh' else 0
range_high = 1
tfake = uniform_latent_sampling(
(dim,), low=range_low, high=range_high
)(x)
return tfake
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 build_model_train(self):
if self.model_train is None:
with tf.device('/gpu:0'):
# Build modules:
## Encoder: x -> [e1, e2]
## Predictor: e1 -> y
## Noisy-transformer: e1 -> noisy_e1
## Decoder: [noisy_e1, e2] -> x
self.encoder, self.predictor, self.decoder = \
self.module_builder.build_default_modules(
['encoder', 'predictor', 'decoder']
)
self.noisy_transformer = self.module_builder.build_module(
'noisy_transformer', name='noisy_transformer',
build_kwargs={
'params': [self.config.dropout_rate]
}
)
## Disentanglers:
self.disentangler1 = self.module_builder.build_module(
'disentangler', name='disentangler1',
build_kwargs={
'input_dim': self.model_config.embedding_dim_1,
'output_dim': self.model_config.embedding_dim_2
}
)
self.disentangler2 = self.module_builder.build_module(
'disentangler', name='disentangler2',
build_kwargs={
'input_dim': self.model_config.embedding_dim_2,
'output_dim': self.model_config.embedding_dim_1
}
)
## z_discriminator:
if self.config.bias:
self.z_discriminator = self.module_builder.build_module(
'z_discriminator', name='z_discriminator'
)
# Build 2 copies of the connected network
main_model = self.__build_connected_network_train(main=True)
adv_model = self.__build_connected_network_train(main=False)
models = [main_model, adv_model]
# Parallelize over GPUs
if self.config.num_gpus > 1:
for i in range(len(models)):
models[i] = \
multi_gpu_model(models[i], gpus=self.config.num_gpus)
# Create final model
## Gather params
main_params = self.encoder.trainable_weights + \
self.predictor.trainable_weights + self.decoder.trainable_weights
adv_params = self.disentangler1.trainable_weights + \
self.disentangler2.trainable_weights
if self.config.bias:
adv_params.extend(self.z_discriminator.trainable_weights)
## Build keras_adversarial model
self.model_train = AdversarialModel(
player_models=models,
player_params=[main_params, adv_params],
player_names=['main_model', 'adv_model']
)
def compile_model(self):
assert self.model_train is not None, 'run build_model_train()'
optimizers = self.config.optimizers
losses = self.config.losses
main_loss_weights = [lw for lw in self.config.loss_weights]
adv_loss_weights = [lw for lw in self.config.loss_weights]
player_compile_kwargs = [
{
'loss_weights': main_loss_weights,
'metrics': self.config.metrics
},
{
'loss_weights': adv_loss_weights,
'metrics': self.config.metrics
}
]
adversarial_optimizer = AdversarialOptimizerScheduled(
[int(p) for p in list(self.config.training_schedule)]
)
self.model_train.adversarial_compile(
adversarial_optimizer=adversarial_optimizer,
player_optimizers=optimizers,
loss=losses, player_compile_kwargs=player_compile_kwargs
)
self.compiled = True
def build_compiled_model(self):
self.build_model_train()
self.compile_model()
def fit(self, dtrain, dvalid, streaming_data=False, epochs=None,
callbacks=None, training_steps=None, validation_steps=None):
assert self.compiled, 'run compile_model() before training'
if streaming_data:
train_generator = dtrain
valid_generator = dvalid
self.model_train.fit_generator(
train_generator,
steps_per_epoch=training_steps,
validation_data=valid_generator,
validation_steps=validation_steps,
callbacks=callbacks,
epochs=epochs
)
else:
xtrain, ytrain = dtrain
xvalid, yvalid = dvalid
self.model_train.fit(
x=xtrain, y=ytrain,
validation_data=(xvalid, yvalid),
callbacks=callbacks, epochs=epochs,
batch_size=(self.config.batch_size * self.config.num_gpus)
)
def build_model_inference(self, checkpoint_epoch=None):
if self.model_inference is None:
device = '/cpu:0' if self.config.num_gpus > 1 else '/gpu:0'
with tf.device(device):
self.encoder = self.module_builder.build_module(
'encoder', epoch=checkpoint_epoch
)
self.predictor = self.module_builder.build_module(
'predictor', epoch=checkpoint_epoch
)
x = self.encoder.inputs[0]
e1, _ = self.encoder(x)
y = self.predictor(e1)
self.model_inference = Model(x, y)
# Parallelize over GPUs
if self.config.num_gpus > 1:
self.model_inference = multi_gpu_model(
self.model_inference, gpus=self.config.num_gpus
)
def predict(self, data, streaming_data=False, prediction_steps=None):
assert self.model_inference is not None, 'run build_model_inference() first'
if streaming_data:
return self.model_inference.predict_generator(data, steps=prediction_steps)
else:
return self.model_inference.predict(data)
def main():
# 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 (x -> y)
discriminator = model_discriminator(latent_dim, input_shape)
# bigan (x - > yfake, yreal), z generated on GPU
bigan = simple_bigan(generator, encoder, discriminator,
normal_latent_sampling((latent_dim, )))
generative_params = generator.trainable_weights + encoder.trainable_weights
# print summary of models
generator.summary()
encoder.summary()
discriminator.summary()
bigan.summary()
autoencoder.summary()
# build adversarial model
model = AdversarialModel(
base_model=bigan,
player_params=[generative_params, discriminator.trainable_weights],
player_names=["generator", "discriminator"])
model.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=[Adam(1e-4, decay=1e-4),
Adam(1e-3, decay=1e-4)],
loss='binary_crossentropy')
# train model
xtrain, xtest = mnist_data()
def generator_sampler():
zsamples = np.random.normal(size=(10 * 10, latent_dim))
return generator.predict(zsamples).reshape((10, 10, 28, 28))
generator_cb = ImageGridCallback("output/bigan/generated-epoch-{:03d}.png",
generator_sampler)
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(
"output/bigan/autoencoded-epoch-{:03d}.png", autoencoder_sampler)
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)
df = pd.DataFrame(history.history)
df.to_csv("output/bigan/history.csv")
encoder.save("output/bigan/encoder.h5")
generator.save("output/bigan/generator.h5")
discriminator.save("output/bigan/discriminator.h5")
bias_initializer='ones',
bias_constraint=non_neg()))
gan = simple_gan(generator, discriminator, normal_latent_sampling((25, )))
model = AdversarialModel(base_model=gan,
player_params=[
generator.trainable_weights,
discriminator.trainable_weights
])
model.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=['adam', 'adam'],
loss='binary_crossentropy')
test = model.fit(x=x_train,
y=gan_targets(np.array(x_train).shape[0]),
epochs=100,
batch_size=50,
shuffle=True)
discriminator.save('discriminator.h5')
generator.save('generator.h5')
generator = load_model('generator.h5')
houseTest = []
pred = generator.predict(np.random.uniform(-1.0, 1.0, size=(1, 25)))
for i in range(len(pred)):
houseTest.append(normalizationVector[i] * pred[i])
print(houseTest)
def gan():
# define variables
# 初始化一些参数
g_input_shape = 100 # 生成器输入层节点数
d_input_shape = (28, 28) # 辨别器输入层节点数
hidden_1_num_units = 500
hidden_2_num_units = 500
g_output_num_units = 784 # 生成器输出层节点数28*28
d_output_num_units = 1 # 辨别器输出层节点数1个，辨别是否是真实图片
epochs = 100
batch_size = 128
# 定义生成器，用于生成图片
model_g = Sequential([
Dense(units=hidden_1_num_units,
input_dim=g_input_shape,
activation='relu',
kernel_regularizer=L1L2(1e-5, 1e-5)),
Dense(units=hidden_2_num_units,
activation='relu',
kernel_regularizer=L1L2(1E-5, 1E-5)),
Dense(units=g_output_num_units,
activation='sigmoid',
kernel_regularizer=L1L2(1E-5, 1E-5)),
Reshape(d_input_shape)
])
# 定义分辨器，用于辨别图片
model_d = Sequential([
InputLayer(input_shape=d_input_shape),
Flatten(),
Dense(units=hidden_1_num_units,
activation='relu',
kernel_regularizer=L1L2(1E-5, 1E-5)),
Dense(units=hidden_2_num_units,
activation='relu',
kernel_regularizer=L1L2(1E-5, 1E-5)),
Dense(units=d_output_num_units,
activation='sigmoid',
kernel_regularizer=L1L2(1E-5, 1E-5))
])
# model_g.summary()
# model_d.summary()
from keras_adversarial import AdversarialModel, simple_gan, gan_targets
from keras_adversarial import AdversarialOptimizerSimultaneous, normal_latent_sampling
# 开始训练gan网络
gan = simple_gan(model_g, model_d, normal_latent_sampling((100, )))
# gan.summary()
# 在keras2.2.x版本中，下面的代码会报错，keras2.1.2中不会
model = AdversarialModel(
base_model=gan,
player_params=[model_g.trainable_weights, model_d.trainable_weights])
model.adversarial_compile(
adversarial_optimizer=AdversarialOptimizerSimultaneous(),
player_optimizers=['adam', 'adam'],
loss='binary_crossentropy')
# 使用训练数据进行训练
# 把keras_adversarial clone到了本地，然后替换掉了pip安装的keras_adversarial
# 解决了这个报错AttributeError: 'AdversarialModel' object has no attribute '_feed_output_shapes'
history = model.fit(x=train_x,
y=gan_targets(train_x.shape[0]),
epochs=epochs,
batch_size=batch_size)
# 保存为h5文件
model_g.save_weights('gan1_g.h5')
model_d.save_weights('gan1_d.h5')
model.save_weights('gan1.h5')
# 绘制训练结果的loss
plt.plot(history.history['player_0_loss'], label='player_0_loss')
plt.plot(history.history['player_1_loss'], label='player_1_loss')
plt.plot(history.history['loss'], label='loss')
plt.show()
# 训练之后100次之后生成的图像
# 随机生成10组数据，生成10张图像
zsample = np.random.normal(size=(10, 100))
pred = model_g.predict(zsample)
print(pred.shape) # (10,28,28)
for i in range(pred.shape[0]):
plt.imshow(pred[i, :], cmap='gray')
plt.show()
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"))
xtrain = x[:-10]
xtest = x[-10:]
mini = np.min(xtrain.ravel())
maxi = np.max(xtrain.ravel())
xtrain = (xtrain - mini) / (maxi - mini)
xtest = (xtest - mini) / (maxi - mini)
xtrain = dim_ordering_fix(xtrain.reshape((-1, 1, 92, 92)))
xtest = dim_ordering_fix(xtest.reshape((-1, 1, 92, 92)))
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],
nb_epoch=100,
batch_size=10)
df = pd.DataFrame(history.history)
df.to_csv("output/gan_convolutional/history.csv")
generator.save("output/gan_convolutional/generator.h5")
discriminator.save("output/gan_convolutional/discriminator.h5")
# print(xtrain[0])
"""
print(xtest[0])
"""
yy = generator_skampler(latent_dim, generator)
def generator_sampler():
xpred = dim_ordering_unfix(generator.predict(zsamples)).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)
# train model
xtrain, xtest = cifar10_data()
y = targets(xtrain.shape[0])
ytest = targets(xtest.shape[0])
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))
history = model.fit(x=dim_ordering_fix(xtrain),y=y,
validation_data=(dim_ordering_fix(xtest), ytest),
callbacks=callbacks, nb_epoch=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 main():
# z in R^100
latent_dim = 100
# x in R^{28x28}
# generator (z -> x)
generator = model_generator()
