def build_critic_graph(generator, critic, batch_size=1): '''Builds the graph for training the critic part of the improved WGAN''' generator_in_critic_training_u = Input(shape=(38, 350, 1), name="noise_u") generator_in_critic_training_v = Input(shape=(38, 350, 1), name="noise_v") shower_in_critic_training_u = Input(shape=(38, 350, 1), name='shower_maps_u') shower_in_critic_training_v = Input(shape=(38, 350, 1), name='shower_maps_v') generator_out_critic_training = generator( [generator_in_critic_training_u, generator_in_critic_training_v]) # generator_out_critic_training = generator_in_critic_training out_critic_training_gen = critic(generator_out_critic_training) out_critic_training_shower = critic( [shower_in_critic_training_u, shower_in_critic_training_v]) averaged_batch = [] # averaged_batch.append(RandomWeightedAverage(batch_size, name='Average_u')([generator_out_critic_training[0], shower_in_critic_training_u])) # averaged_batch.append(RandomWeightedAverage(batch_size, name='Average_v')([generator_out_critic_training[1], shower_in_critic_training_v])) weights = K.random_uniform((batch_size, 1, 1, 1)) averaged_batch.append( RandomWeightedAverage(batch_size, weights, name='Average_u')( [generator_out_critic_training[0], shower_in_critic_training_u])) averaged_batch.append( RandomWeightedAverage(batch_size, weights, name='Average_v')( [generator_out_critic_training[1], shower_in_critic_training_v])) averaged_batch_out = critic(averaged_batch) return Model(inputs=[ generator_in_critic_training_u, generator_in_critic_training_v, shower_in_critic_training_u, shower_in_critic_training_v ], outputs=[ out_critic_training_gen, out_critic_training_shower, averaged_batch_out ]), averaged_batch
def build_generator_graph(generator, critic): '''Builds the graph for training the generator part of the improved WGAN''' generator_in = [ Input(shape=(38, 350, 1), name="Wire_U"), Input(shape=(38, 350, 1), name="Wire_V") ] generator_out = generator(generator_in) critic_out = critic(generator_out) return Model(inputs=(generator_in), outputs=[critic_out])
def build_critic_graph(generator, critic, batch_size=1): '''Builds the graph for training the critic part of the improved WGAN''' generator_in_critic_training = Input(shape=(38, 350, 1), name="noise") shower_in_critic_training = Input(shape=(38, 350, 1), name='shower_maps') generator_out_critic_training = generator([generator_in_critic_training]) # generator_out_critic_training = generator_in_critic_training out_critic_training_gen = critic(generator_out_critic_training) out_critic_training_shower = critic(shower_in_critic_training) averaged_batch = RandomWeightedAverage(batch_size, name='Average')([generator_out_critic_training, shower_in_critic_training]) averaged_batch_out = critic(averaged_batch) return Model(inputs=[generator_in_critic_training, shower_in_critic_training], outputs=[out_critic_training_gen, out_critic_training_shower, averaged_batch_out]), averaged_batch
def build_generator_graph(generator, critic): '''Builds the graph for training the generator part of the improved WGAN''' generator_in = Input(shape=(38, 350, 1)) generator_out = generator([generator_in]) critic_out = critic(generator_out) return Model(inputs=[generator_in], outputs=[critic_out])
sys.stdout = orig_stdout f.close() save_in_file() # The generator_model is used when we want to train the generator layers. # As such, we ensure that the discriminator layers are not trainable. # Note that once we compile this model, updating .trainable will have no effect within it. As such, it # won't cause problems if we later set discriminator.trainable = True for the discriminator_model, as long # as we compile the generator_model first. for layer in discriminator.layers: layer.trainable = False discriminator.trainable = False generator_input = Input(shape=[76, 350, 1]) generator_layers = generator(generator_input) discriminator_layers_for_generator = discriminator(generator_layers) generator_model = Model(inputs=[generator_input], outputs=[discriminator_layers_for_generator]) # We use the Adam paramaters from Gulrajani et al. generator_model.compile(optimizer=Adam(0.0001, beta_1=0.5, beta_2=0.9), loss=wasserstein_loss) # Now that the generator_model is compiled, we can make the discriminator layers trainable. for layer in discriminator.layers: layer.trainable = True for layer in generator.layers: layer.trainable = False discriminator.trainable = True generator.trainable = False
''' make trainable freeze part of the model the GAN is created ''' def make_trainable(model, trainable): """ Helper to freeze / unfreeze a model """ model.trainable = trainable for l in model.layers: l.trainable = trainable # Set up GAN by stacking the discriminator on top of the generator print('\nGenerative Adversarial Network') gan_input = Input(shape=[38, 350, 1]) gan_output = discriminator(generator(gan_input)) GAN = Model(gan_input, gan_output) print(GAN.summary()) g_opt = Adam(lr=2e-4, beta_1=0.5, decay=0.0005) make_trainable(discriminator, False) # freezes the discriminator when training the GAN GAN.compile(loss='binary_crossentropy', optimizer=g_opt) # Compile saves the trainable status of the model --> After the model is compiled, updating using make_trainable will have no effect print "Saving the structure in file" ''' Save into file: -Generator -Discriminator -GAN
def build_generator_predict(generator): '''Builds the graph for training the generator part of the improved WGAN''' generator_in = Input(shape=(38, 350, 1)) generator_out = generator([generator_in]) return Model(inputs=[generator_in], outputs=[generator_out])
else: raise ValueError("generator dimension " +str(dim) +"is not in the constrained dimensions for this structure: dimension must be in [2,4,6] for the TL,'braid_group','symmetric_group' and between (2,10) for ZxZ_group. ") if args.structure=='TL_algebra': if args.delta==0: raise ValueError("delta, a parameter for TL algebra, must be nonzero.") print("training the TL algebra generator.") print("generator function : R^"+str(args.generator_dimension) +"-> R^"+str(args.generator_dimension) ) Ugen=ut.generator(input_dim=args.generator_dimension ,bias= args.bias ,activation_function=args.network_generator_activation) M=tlnet.tl_algebra_net(Ugen,delta =args.delta ,input_dim=dim//2) model_name=model_string_gen("TL_algebra_relations_trainer_use_bias=") model_name_U_gen=model_string_gen("TL_algebra_generator_use_bias=") data_in=[data1,data2,data3] data_out=data1 if args.mode=='training': print("choosing the training mode. ") ut.train_net(M,data_in,data_out , weight_folder+model_name ,tlnet.tl_loss_wrapper(dim//2)