def ali_model(self): self.encoder = self.encoder_model() self.decoder = self.decoder_model() disc_train_enc_dec, disc_train_disc = self.discriminator_model() bigan_train_enc_dec = simple_bigan(self.decoder, self.encoder, disc_train_enc_dec) bigan_train_disc = simple_bigan(self.decoder, self.encoder, disc_train_disc) x = bigan_train_enc_dec.inputs[1] z = normal_latent_sampling(self.embedding_size)(x) # fix names??? bigan_train_enc_dec = Model(x, bigan_train_enc_dec([z, x])) bigan_train_disc = Model(x, bigan_train_disc([z, x])) # encoder.summary() # decoder.summary() # disc_train_enc_dec.summary() # disc_train_disc.summary() # bigan_train_enc_dec.summary() # bigan_train_disc.summary() model = AdversarialModel(player_models=[bigan_train_enc_dec, bigan_train_disc], player_params=[self.encoder.trainable_weights + self.encoder.trainable_weights, \ disc_train_disc.trainable_weights], player_names=['encoder_decoder', 'discriminator']) model.adversarial_compile(adversarial_optimizer=AdversarialOptimizerScheduled(self.train_schedule), player_optimizers=[Adam(lr=5e-5, beta_1=0.5, beta_2=1e-3), \ Adam(lr=5e-5, beta_1=0.5, beta_2=1e-3)], loss=['mean_squared_error', 'mean_squared_error']) return model
def gan_model_test(): latent_dim = 10 input_dim = 5 generator = model_generator(input_dim=input_dim, latent_dim=latent_dim) discriminator = model_discriminator(input_dim=input_dim) gan = simple_gan(generator, discriminator, normal_latent_sampling((latent_dim,))) # build adversarial model model = AdversarialModel(base_model=gan, player_params=[generator.trainable_weights, discriminator.trainable_weights], player_names=["generator", "discriminator"]) adversarial_optimizer = AdversarialOptimizerSimultaneous() opt_g = Adam(1e-4) opt_d = Adam(1e-3) loss = 'binary_crossentropy' model.adversarial_compile(adversarial_optimizer=adversarial_optimizer, player_optimizers=[opt_g, opt_d], loss=loss) # train model batch_size = 32 n = batch_size * 8 x = np.random.random((n, input_dim)) y = gan_targets(n) fit(model, x, y, nb_epoch=3, batch_size=batch_size)
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 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 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] K.set_image_dim_ordering('tf') if K.backend() == "tensorflow": os.makedirs(path + '/logs',exist_ok=True) callbacks.append( TensorBoard(log_dir=os.path.join(path, 'logs'), histogram_freq=0, write_graph=True, write_images=True)) history = fit(model, x=xtrain, y=y, validation_data=(xtest, ytest), callbacks=callbacks, nb_epoch=nb_epoch, batch_size=32) # 히스토리를 CSV에 저장 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 train_gan(adversarial_optimizer, path, opt_g, opt_d, nb_epoch, generator, discriminator, latent_dim, targets=gan_targets, loss='mse'): csvpath = os.path.join(path, "history.csv") id = 0 while os.path.exists(csvpath): name = "history_%d" % id + ".csv" csvpath = os.path.join(path, name) print("Already exists: {}".format(csvpath)) id += 1 print("Training: {}".format(csvpath)) print(os.path.join(path, 'logs')) # gan (x - > yfake, yreal), z generated on GPU gan = simple_gan(generator, discriminator, normal_latent_sampling((latent_dim, ))) # 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) xtrain, xtest = db.get_dataset(5, 'train') y = targets(xtrain.shape[0]) ytest = targets(xtest.shape[0]) history = fit(model, x=xtrain, y=y, validation_data=(xtest, ytest), nb_epoch=nb_epoch, batch_size=1, verbose=2) # 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")) return generator
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)) # gan (x - > yfake, yreal), z is gaussian generated on GPU # can also experiment with uniform_latent_sampling generator.summary() discriminator.summary() gan = simple_gan(generator=generator, discriminator=discriminator, latent_sampling=normal_latent_sampling((latent_dim,))) # 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) # create callback to generate images 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) # 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 = fit(model, x=xtrain, y=y, validation_data=(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")) 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'): # gan (x - > yfake, yreal) # z generated on GPU gan = simple_gan(generator, discriminator, normal_latent_sampling((latent_dim, ))) # 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) # create callback to generate images 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) # train model xtrain, xtest = mnist_data() # targets = gan_targets -> a 0/1 címkéket rendeli az adatokhoz y = targets(xtrain.shape[0]) ytest = targets(xtest.shape[0]) callbacks = [generator_cb] history = fit(model, x=xtrain, y=y, validation_data=(xtest, ytest), callbacks=callbacks, nb_epoch=nb_epoch, batch_size=32)
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 run_gan(exp_dir, adversarial_optimizer, opt_g, opt_d, generator, discriminator, latent_dim, targets=gan_targets, loss='binary_crossentropy'): #print models generator.summary() discriminator.summary() gan = simple_gan(generator=generator, discriminator=discriminator, latent_sampling=normal_latent_sampling((latent_dim,))) # 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) # create callback to generate images zsamples = np.random.normal(size=(10 * 10, latent_dim)) def generator_sampler(): xpred = dim_ordering_unfix(generator.predict(zsamples)).transpose((0, 2, 3, 1)) xpred = scale_value(xpred, [0.0, 1.0]) return xpred.reshape((10, 10) + xpred.shape[1:]) save_image_cb = ImageGridCallback('./dcgan-v2-images/' + exp_dir + '/epoch-{:03d}.png', generator_sampler, cmap=None) save_model_cb = SaveModelWeights(generator, './dcgan-v2-model-weights/' + exp_dir) # train model xtrain, xtest = svhn_data() y = targets(xtrain.shape[0]) ytest = targets(xtest.shape[0]) callbacks = [save_image_cb, save_model_cb] #train model epoch_start = 0 epoch_count = 100 history = fit(model, x=xtrain, y=y, validation_data=(xtest, ytest), callbacks=callbacks, nb_epoch=epoch_start + epoch_count, batch_size=32, initial_epoch = epoch_start, shuffle=True) # save history to CSV df = pd.DataFrame(history.history) df.to_csv('./dcgan-v2-images/' + exp_dir + '/history.csv') #save final models generator.save('./dcgan-v2-model-weights/' + exp_dir + '/generator.h5') discriminator.save('./dcgan-v2-model-weights/' + exp_dir + '/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')
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')
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")
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"))
# 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_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_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 process_mnist(x): x = x.astype(np.float32) / 255. return x def mnist_data(): (x_train, y_train), (x_test, y_test) = mnist.load_data() return process_mnist(x_train), mnist_process(x_test) if __name__ == '__main__': # z in R^100 latent_dim = 100 # x in R^{28 x 28} input_shape = (1, 28, 28) # generator: (z -> x) gen_mod = generator() # discriminator: (x -> y) disc_mod = discriminator(input_shape) # GAN (x -> y_fake, y_real); z idedally generated on GPU gan = simple_gan(gen_mod, disc_mod, normal_latent_sampling((latent_dim, ))) gen_mod.summary() disc_mod.summary() gan.summary()
image_path=os.path.join(path,img_name) img=cv2.imread(image_path,cv2.IMREAD_GRAYSCALE) # cv2.imshow("Window",img) # cv2.waitKey(2) img=cv2.resize(img,(100,100)) img=np.asarray(img) temp.append(img) train_x= np.stack(temp) cv2.imshow("Window",temp[5][:]) cv2.waitKey(0) gan= simple_gan(model_G, model_D, normal_latent_sampling((5000,)) ) 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') history=model.fit(x=train_x, y=gan_targets(train_x.shape[0]), epochs=100, batch_size=batch_s) plt.plot(history.history['player_0_loss']) plt.plot(history.history['player_1_loss']) plt.plot(history.history['loss'])
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"))
# X_test is 10000 rows of 28x28 values. X_test = X_test.astype('float32') / 255 return X_train.reshape(-1, 28, 28, 1), X_test.reshape(-1, 28, 28, 1) if __name__ == "__main__": # z in R^100 latent_dim = 100 # generator (z -> x) generator = model_generator() # discriminator (x -> y) discriminator = model_discriminator(input_shape=(28, 28, 1)) # gan (x - > yfake, yreal), z generated on GPU gan = keras_adversarial.simple_gan( generator, discriminator, keras_adversarial.normal_latent_sampling((latent_dim, ))) # build adversarial model model = keras_adversarial.AdversarialModel( base_model=gan, player_params=[ generator.trainable_weights, discriminator.trainable_weights ], player_names=["generator", "discriminator"]) model.adversarial_compile( adversarial_optimizer=AdversarialOptimizerSimultaneous(), player_optimizers=[ keras.optimizers.Adam(1e-4, decay=1e-4), keras.optimizers.Adam(1e-3, decay=1e-4) ], loss='binary_crossentropy')
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 train_em_gan(adversarial_optimizer, generator, discriminator, gen_opt, disc_opt, latent_dim, h5_filename, h5_dataset_path, sample_shape, output_directory, verbose=1, loss='mean_squared_error', epochs=10, per_epoch=100, r_id="em-gan", is_large_model=False): gan = simple_gan(generator, discriminator, normal_latent_sampling((latent_dim, ))) if verbose >= 1: util.print_model_summaries(generator, discriminator, gan) 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=[gen_opt, disc_opt], loss=loss) zsamples = np.random.normal(size=(5, latent_dim)) sample_generator = util.h5_block_generator(h5_filename, h5_dataset_path, sample_shape, [1, 0, 0, 1]) def generator_sampler(): return generator.predict(zsamples) sampler = util.SampleEM(output_directory, generator_sampler, is_large_model) gen_saver = util.SaveModel(generator, os.path.join(output_directory, "generator")) disc_saver = util.SaveModel( discriminator, os.path.join(output_directory, "discriminator")) history = model.fit_generator(sample_generator, per_epoch, epochs=epochs, verbose=verbose, callbacks=[sampler, gen_saver, disc_saver], validation_data=sample_generator, validation_steps=(per_epoch // 5)) df = pd.DataFrame(history.history) df.to_csv(os.path.join(output_directory, "history.csv")) discriminator.save( os.path.join( output_directory, "gan_disc_" + str(epochs) + "_" + str(per_epoch) + "_" + r_id + ".h5")) generator.save( os.path.join( output_directory, "gan_gen_" + str(epochs) + "_" + str(per_epoch) + "_" + r_id + ".h5")) del model del discriminator del generator
return fun if __name__ == "__main__": # z \in R^100 latent_dim = 100 # x \in R^{28x28} input_shape = (1, 28, 28) # generator (z -> x) generator = model_generator() # discriminator (x -> y) discriminator = model_discriminator(input_shape=input_shape) # 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=AdversarialOptimizerSimultaneous(), player_optimizers=[Adam(1e-4, decay=1e-4), Adam(1e-3, decay=1e-4)], loss='binary_crossentropy') # train model
return Model(d_input,d_V) def mnist_process(x): x = x.astype(np.float32)/255.0 return x def mnist_data(): (xtrain,ytrain),(xtest,ytest)=mnist.load_data() return mnist_process(xtrain),mnist_process(xtest) if __name__ == "__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') def generator_sampler(): zsamples = np.random.normal(size=(10*10,latent_dim)) gen = dim_ordering_unfix(generator.predict(zsamples)) return gen.reshape((10,10,28,28)) generator_cb = ImageGridCallback("output/gan_convolutional/epoch-{:03d}.png",generator_sampler) xtrain,xtest=mnist_data() xtrain=dim_ordering_fix(xtrain.reshape((-1,1,28,28)))
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, 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(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 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(3e-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-1, "yreal": 1e-1, "xpred": 1e2}}) # load mnist data xtrain, xtest = cifar10_data() # 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)) 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)) 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] 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) # 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"))
kernel_regularizer=L1L2(1e-5, 1e-5)), Dense(units=hidden_2_units, activation='relu', kernel_regularizer=L1L2(1e-5, 1e-5)), Dense(units=output_dis_size, activation='sigmoid', kernel_regularizer=L1L2(1e-5, 1e-5)), ]) # 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)
Dense(units=784, activation='sigmoid', kernel_regularizer=L1L2(1e-5, 1e-5))) 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]):
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 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')
return gen.reshape((10, 10, 92, 92)) if __name__ == "__main__": # z \in R^100 latent_dim = 400 # x \in R^{92x92} input_shape = (1, 92, 92) # generator (z -> x) generator = model_generator() # discriminator (x -> y) discriminator = model_discriminator(input_shape=input_shape) # gan (x - > yfake, yreal), z generated on GPU gan = simple_gan(generator, discriminator, normal_latent_sampling((latent_dim, ))) #load ancien weights : #generator.load_weights('./output/gan_convolutional/generator.h5') #discriminator.load_weights('./output/gan_convolutional/discriminator.h5') # 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
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")