def __init__(self, model, pruning_rate, previous_masks, current_dataset_idx, previous_samples=None, unrelated_tasks=None): self.model = model self.pruning_rate = pruning_rate self.pruner = pruner.Pruner(self.model, self.pruning_rate, previous_masks, current_dataset_idx) self.unrelated_tasks = unrelated_tasks self.discriminator = discriminator.Discriminator( previous_samples, unrelated_tasks) self.criterion = nn.CrossEntropyLoss() self.optimizer = optim.SGD(self.model.parameters(), lr=1e-3, momentum=0.9) self.decay = [10] self.scheduler = MultiStepLR(self.optimizer, milestones=self.decay, gamma=0.2)
def __init__(self, channels, width, heigth, num_classes: int, embed_size: int, latent_dim: int = 100, lr: float = 0.002, b1: float = 0.5, b2: float = 0.999, batch_size: int = 1024, **kwargs): super().__init__() self.save_hyperparameters() # networks data_shape = (channels, width, heigth) self.generator = generator.Generator( num_classes=num_classes, embed_size=embed_size, latent_dim=self.hparams.latent_dim, img_shape=data_shape, output_dim=int(np.prod(data_shape))) self.discriminator = discriminator.Discriminator( img_shape=data_shape, output_dim=int(np.prod(data_shape)), num_classes=num_classes, ) self.validation_z = torch.rand(batch_size, self.hparams.latent_dim) self.example_input_array = torch.zeros(2, self.hparams.latent_dim)
def build_discriminator(self): #with tf.variable_scope("discriminator"): self.discriminator = discriminator.Discriminator( n_node=self.n_node, n_relation=self.n_relation, node_emd_init=self.node_embed_init_d, relation_emd_init=None)
def __init__(self, latent_spaces, batch_size): super(ANVAE, self).__init__() self.batch_size = batch_size self.latent_spaces = 3 self.level_sizes = [1, 1, 1] self.input_s = [32, 32, 1] self.latent_channels = 20 self.h_dim = 1000 self.encoder = encoder.Encoder(self.latent_spaces, self.input_s) self.decoder = decoder.Decoder(self.encoder( tf.zeros([self.batch_size, 32, 32, 1]), False), latent_channels=self.latent_channels, level_sizes=self.level_sizes) self.discriminator = discriminator.Discriminator( self.latent_spaces, self.input_s, self.h_dim) self.lr_ae = .0001 self.lr_dc = .0001 self.lr_gen = .0001 self.ae_optimizer = tf.keras.optimizers.Adamax(self.lr_ae, clipnorm=2) self.gen_optimizer = tf.keras.optimizers.Adamax(self.lr_gen, clipnorm=2) self.dc_optimizer = tf.keras.optimizers.Adamax(self.lr_dc, clipnorm=2) self.ae_loss_weight = 1. self.gen_loss_weight = 6. self.dc_loss_weight = 6. self.lastEncVars = [] self.lastDecVars = [] self.lastDiscVars = [] self.debugCount = 0 self.counter = 1 self.log_writer = tf.summary.create_file_writer(logdir='./tf_summary') self.step_count = 0 self.conv_layers = [] self.sr_u = {} self.sr_v = {} self.num_power_iter = 4 for layer in self.encoder.layers: if isinstance(layer, tf.keras.layers.Conv2D) or isinstance( layer, tf.keras.layers.DepthwiseConv2D): self.conv_layers.append(layer) for layer in self.decoder.layers: if isinstance(layer, tf.keras.layers.Conv2D) or isinstance( layer, tf.keras.layers.DepthwiseConv2D): self.conv_layers.append(layer) for layer in self.discriminator.layers: if isinstance(layer, tf.keras.layers.Conv2D) or isinstance( layer, tf.keras.layers.DepthwiseConv2D): self.conv_layers.append(layer)
def __init__(self, vocab_size, batch_size, pre_gen_epochs, pre_dis_epochs, gan_epochs, generate_sum, sequence_len, lr, real_file, fake_file, eval_file, update_rate): super(Solver, self).__init__() self.vocal_size = vocab_size self.batch_size = batch_size self.pre_gen_epochs = pre_gen_epochs self.pre_dis_epochs = pre_dis_epochs self.gan_epochs = gan_epochs self.generate_sum = generate_sum self.sequence_len = sequence_len self.lr = lr self.real_file = real_file self.fake_file = fake_file self.eval_file = eval_file self.update_rate = update_rate self.discriminator = discriminator.Discriminator( sequence_len, vocab_size, DisParams.emb_dim, DisParams.filter_sizes, DisParams.num_filters, DisParams.dropout) self.generator = generator.Generator(vocab_size, GenParams.emb_dim, GenParams.hidden_dim, GenParams.num_layers) self.target_lstm = target_lstm.TargetLSTM(vocab_size, GenParams.emb_dim, GenParams.hidden_dim, GenParams.num_layers) self.discriminator = util.to_cuda(self.discriminator) self.generator = util.to_cuda(self.generator) self.target_lstm = util.to_cuda(self.target_lstm)
def build_discriminator(self): """initialize the discriminator""" with tf.variable_scope("discriminator"): self.discriminator = discriminator.Discriminator( n_node=self.n_node, node_emd_init=self.node_embed_init_d, node_features=self.node_feature_init)
def __init__(self, prn, receiver, param_list=_M_ARRAY_DATA_NAMES): """ Constructs a Channel object with specified prn and measurement length. """ self.prn = prn self.receiver = receiver self.rawfile = self.receiver.rawfile self._measurement_logs_on = False self.init_measurement_logs(param_list=param_list) self._cpcount = 0 # internal codeperiod counter self.cp[0] = 0 # Initialize correlator. self.correlator = correlator.Correlator(self.prn, channel=self) # Initialize discriminators and loopfilters. self.cdiscriminator = discriminator.Discriminator(flavor='DLL', channel=self) self.idiscriminator = discriminator.Discriminator(flavor='PLL', channel=self) self.cloopfilter = loopfilter.LoopFilter(self.rawfile.T, Bnp=3.0, channel=self) self.iloopfilter = loopfilter.LoopFilter(self.rawfile.T, Bnp=40.0, channel=self) # Initialize lockdetector and snrmeter. self.lockdetector = lockdetector.LockDetector(N=20, k=1.5, lossthreshold=50, lockthreshold=240) self.snrmeter = snrmeter.SignalNoiseMeter(N=20, T=self.rawfile.T)
def trainer(model_params): datasets = load_dataset('dataset', model_params) train_set = datasets[0][0] + datasets[0][1] valid_set = datasets[1][0] + datasets[1][1] test_set = datasets[2][0] + datasets[2][1] labels = {dataset: i for (i, dataset) in enumerate(model_params.data_set)} train_generator = DataGenerator(train_set, labels, batch_size=model_params.batch_size, shuffle=True) valid_generator = DataGenerator(valid_set, labels, batch_size=model_params.batch_size, shuffle=True) model = discriminator.Discriminator(model_params) model.train(train_generator, valid_generator) model.save() print('Done!')
def init_GAN(): # models generator = g.Generator() discriminator = d.Discriminator() # Loss functions adversarial_loss = torch.nn.MSELoss() categorical_loss = torch.nn.CrossEntropyLoss() continuous_loss = torch.nn.MSELoss() if cuda: generator.cuda() discriminator.cuda() adversarial_loss.cuda() categorical_loss.cuda() continuous_loss.cuda() generator.apply(weights_init_normal) discriminator.apply(weights_init_normal) return generator, discriminator, adversarial_loss, categorical_loss, continuous_loss
def create_model(actions, sampling=False): policy_net = seq2seq_model.Seq2SeqModel( FLAGS.architecture, FLAGS.seq_length_in if not sampling else 50, FLAGS.seq_length_out if not sampling else 25, FLAGS.size, # hidden layer size FLAGS.num_layers, FLAGS.batch_size, summaries_dir, FLAGS.loss_to_use if not sampling else "sampling_based", len( actions ), device, not FLAGS.omit_one_hot, FLAGS.residual_velocities, stochastic = True, dtype=torch.float32) discrim_net = discriminator.Discriminator( not FLAGS.omit_one_hot, FLAGS.discrim_hidden_size, FLAGS.batch_size, FLAGS.discrim_num_layers, len( actions ) ) #initalize a new model if FLAGS.load <= 0 and FLAGS.discrim_load <=0: print("Creating model with fresh parameters.") #TODO: Initial parameter here return policy_net, discrim_net #Load model from iteration if os.path.isfile(os.path.join(train_dir, 'pretrain-policy-checkpoint-{0}.pt'.format(FLAGS.load))): policy_net.load_state_dict(torch.load(os.path.join(train_dir, 'pretrain-policy-checkpoint-{0}.pt'.format(FLAGS.load)))) elif FLAGS.load > 0: raise ValueError("Asked to load pretrain policy checkpoint {0}, but it does not seem to exist".format(FLAGS.load)) if os.path.isfile(os.path.join(train_dir, 'pretrain-discrim-checkpoint-{0}.pt'.format(FLAGS.discrim_load))): policy_net.load_state_dict(torch.load(os.path.join(train_dir, 'discrim-checkpoint-{0}.pt'.format(FLAGS.load)))) elif FLAGS.discrim_load > 0: raise ValueError("Asked to load pretrain discrim checkpoint {0}, but it does not seem to exist".format(FLAGS.discrim_load)) return policy_net, discrim_net
def train(train_dataset, test_dataset, epochs, tr_urls): gen = generator.Generator() generator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) discr = discriminator.Discriminator() discriminator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) checkpoint = tf.train.Checkpoint( generator_optimizer=generator_optimizer, discriminator_optimizer=discriminator_optimizer, generator=gen, discriminator=discr) summary_writer = tf.summary.create_file_writer( variables.LOG_DIR + '/' + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) for epoch in range(epochs): start = time.time() imgi = 0 for input_image, target in train_dataset: print('epoch ' + str(epoch) + ' - train: ' + str(imgi) + '/' + str(len(tr_urls))) imgi += 1 train_step(input_image, target, gen, generator_optimizer, discr, discriminator_optimizer, summary_writer, epoch) if (epochs + 1) % 3 == 0: checkpoint.save(file_prefix=variables.CHECK_DIR + 'ckpt') print('Time taken for epoch {} is {} sec\n'.format( epoch + 1, time.time() - start)) checkpoint.save(file_prefix=variables.CHECK_DIR + 'ckpt') checkpoint.restore(tf.train.latest_checkpoint(variables.CHECK_DIR)) # clear imgi = 0 for inp, tar in test_dataset.take(5): generate_images(gen, inp, tar) imgi += 1
def main(config: str): config = load_config(config) parameters = config['parameters'] train_data = load_data( data_path=config['data']['directory'], img_size=parameters['img_size'], batch_size=parameters['batch_size'], use_rgb=parameters["rgb"], ) gen = generator.Generator( generator.GeneratorConfig.from_config_dict(parameters)) disc = discriminator.Discriminator( discriminator.DiscriminatorConfig.from_config_dict(parameters)) trainer = Trainer(gen, disc, noise_dim=parameters['generator']['noise_dim'], rgb=parameters["rgb"]) trainer.train(dataset=train_data, epochs=config['train']['epochs'], save_interval=config['train']['save_interval']) gen.save("saved_model") tfjs.converters.save_keras_model(gen, "saved_js_model")
def __init__(self, z_dim=512, resolution=1024, randomize_noise=True, gpu_id=0): self.z_dim = z_dim self.gpu = gpu_id torch.cuda.set_device(self.gpu) # loss function : non-saturating loss with R1 regularization self.loss_function_G = loss.G_logistic_nonsaturating() self.loss_function_D = loss.D_logistic() self.G = generator.Generator(self.z_dim, resolution=resolution, randomize_noise=randomize_noise).cuda( self.gpu) self.D = discriminator.Discriminator(resolution=resolution).cuda( self.gpu) self.train_G_losses = [] self.train_D_losses = []
VOCAB_SIZE, MAX_SEQ_LEN, gpu=CUDA) oracle.load_state_dict(torch.load(oracle_state_dict_path)) oracle_samples = torch.load(oracle_samples_path).type(torch.LongTensor) # a new oracle can be generated by passing oracle_init=True in the generator constructor # samples for the new oracle can be generated using helpers.batchwise_sample() gen = generator.Generator(GEN_EMBEDDING_DIM, GEN_HIDDEN_DIM, VOCAB_SIZE, MAX_SEQ_LEN, gpu=CUDA) dis = discriminator.Discriminator(DIS_EMBEDDING_DIM, DIS_HIDDEN_DIM, VOCAB_SIZE, MAX_SEQ_LEN, gpu=CUDA) if CUDA: oracle = oracle.cuda() gen = gen.cuda() dis = dis.cuda() oracle_samples = oracle_samples.cuda() #训练GENERATOR MLE print('Starting Generator MLE Training...') gen_optimizer = optim.Adam(gen.parameters(), lr=1e-2) train_generator_MLE(gen, gen_optimizer, oracle, oracle_samples, MLE_TRAIN_EPOCHS)
return minibatch, rescaled with tf.device('/cpu:0'): minibatch, rescaled = read(filenames) resnet = srResNet.srResNet(rescaled) result = (resnet.conv5 + 1) * 127.5 gen_var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES) dbatch = tf.concat([tf.cast(minibatch, tf.float32), result], 0) vgg = vgg19.Vgg19() vgg.build(dbatch) fmap = tf.split(vgg.conv5_4, 2) content_loss = tf.losses.mean_squared_error(fmap[0], fmap[1]) disc = discriminator.Discriminator(dbatch) D_x, D_G_z = tf.split(tf.squeeze(disc.dense2), 2) adv_loss = tf.reduce_mean(tf.square(D_G_z - 1.0)) gen_loss = (adv_loss + content_loss) disc_loss = (tf.reduce_mean(tf.square(D_x - 1.0) + tf.square(D_G_z))) disc_var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES) for x in gen_var_list: disc_var_list.remove(x) global_step = tf.Variable(0, trainable=0, name='global_step') gen_train_step1 = tf.train.AdamOptimizer(learn_rate1).minimize( gen_loss, global_step, gen_var_list) #gen_train_step2=tf.train.AdamOptimizer(learn_rate2).minimize(gen_loss,global_step) disc_train_step1 = tf.train.AdamOptimizer(learn_rate1).minimize( disc_loss, global_step, disc_var_list) #disc_train_step2=tf.train.AdamOptimizer(learn_rate2).minimize(disc_loss,global_step)
def build_discriminator(self): """initializing the discriminator""" with tf.compat.v1.variable_scope("discriminator"): self.discriminator = discriminator.Discriminator( self.graph.n_node, self.node_embed_init_d, config)
def parse_args(): """ Creates command line arguments with the same name and default values as those in the global opts variable Then updates opts using their respective argument values """ # Parse command line arguments to assign to the global opt variable parser = argparse.ArgumentParser( description= 'colorize images using conditional generative adversarial networks') for opt_name, value in opts.items(): parser.add_argument("--%s" % opt_name, default=value) # Update global opts variable using flag values args = parser.parse_args() for opt_name, _ in opts.items(): opts[opt_name] = getattr(args, opt_name) parse_args() with tf.Session() as sess: # Initialize networks gen = generator.Generator() disc = discriminator.Discriminator() # Train them t = Trainer(sess, gen, disc, opts) t.train()
args.vocab_size, args.max_seq_len, gpu=args.cuda, oracle_init=True) gen = generator.Generator( args.g_emb_dim, args.g_hid_dim, args.vocab_size, args.max_seq_len, gpu=args.cuda, ) dis = discriminator.Discriminator(args.d_emb_dim, args.d_hid_dim, args.vocab_size, args.max_seq_len, gpu=args.cuda) if args.cuda: oracle = oracle.cuda() gen = gen.cuda() dis = dis.cuda() oracle_samples = helpers.batchwise_sample(oracle, args.num_data) if args.oracle_save is not None: torch.save(oracle.state_dict(), args.oracle_save) logger = logger.Logger(args.log_dir) # GENERATOR MLE TRAINING gen_optimizer = optim.Adam(gen.parameters(), lr=1e-2)
def __init__(self): # self.IsTraining = tf.placeholder(tf.bool) """ This is placeholder for the input for the Generator it is a4 channnel input """ self.GeneratorInput=tf.placeholder(tf.float32, [None, None, None, 4]) """ The DiscriminatorLabelsFake is always an array of zeros expanded of the same sized as batch size For the DiscriminatorLabelsReal are an array of ones expanded of the same sized as batch size The GeneratorLabels shall take the same labels as that of DiscriminatorRealLabels The TargetImagePlaceholder is for when we need to feed the target image for the discriminnator """ self.DiscriminatorLabelsFake=tf.placeholder(tf.float32, [None, 1]) self.DiscriminatorLabelsReal=tf.placeholder(tf.float32, [None, 1]) self.GeneratorLabels=tf.placeholder(tf.float32, [None, 1]) self.TargetImagePlaceholder=tf.placeholder(tf.float32, [None, None, None, 3]) self.GeneratedImage=generator.network(self.GeneratorInput) """ The discriminator generates 2 outputs , the activation and the logits = sigmoid(activation) =P(Input=FakeImage) This is generated for both when fake image is fed(logit expected to be 1),and realimage is fed(logit expected to be 0) """ self.DiscriminatorOutReal,self.DiscriminatorLogitsReal=discriminator.Discriminator(Target=self.TargetImagePlaceholder,DarkInput=self.GeneratorInput) self.DiscriminatorOutFake,self.DiscriminatorLogitsFake=discriminator.Discriminator(Target=self.GeneratedImage,DarkInput=self.GeneratorInput,reuse=True) """ As the target and the computation graph are different when the generated image is fed or the true target is, we compute 2 sigmoid crossentropy losses and the sum of both is the Final loss for the discriminnator Discriminatorloss=SigLoss(P(Discriminator thinks True target is correct),logit=1)+SigLoss(P(Discriminator thinks Generated Image is correct),logit =0) the first term is the RealLoss and the second term is FakeLoss """ self.DiscriminatorRealLoss=tf.reduce_mean(self.cross_entropy(logits=self.DiscriminatorLogitsReal, labels=self.DiscriminatorLabelsReal)) self.DiscriminatorFakeLoss=tf.reduce_mean(self.cross_entropy(logits=self.DiscriminatorLogitsFake, labels=self.DiscriminatorLabelsFake)) self.DiscriminatorLoss=tf.reduce_mean(self.DiscriminatorRealLoss+self.DiscriminatorFakeLoss) """ GeneratorLoss=SigLoss(P(Discriminator thinks Generated Image is correct),logit =1) """ self.GeneratorLoss=tf.reduce_mean(self.cross_entropy(logits=self.DiscriminatorLogitsFake, labels=self.GeneratorLabels)) """ This is for the user to observe how well with time is the model able to generate images simillar to the target """ self.GeneratorABS=tf.losses.absolute_difference(self.GeneratedImage,self.TargetImagePlaceholder) self.TrainableVars=tf.trainable_variables() """ d_vars are the weights of the discriminator as all of them is under the scope of "Discriminator" This is necessary for allowing the optimizer to minimize the loss wrt discriminator weights g_vars are the weights of the generator as all of them is under the scope of "Generator" This is necessary for allowing the optimizer to minimize the loss wrt generator weights """ self.d_vars=[var for var in self.TrainableVars if 'Discriminator' in var.name] self.g_vars=[var for var in self.TrainableVars if 'Generator' in var.name] """ In Soumith Chintala's GAN hacks tutorial, he sugest to feed all Generated and Real Targets be fed in exclusicve batches the following 2 optimizers allows us to do the same They optimize Discriminator weights only """ self.DiscriminatorOptimizerReal=tf.train.AdamOptimizer(0.00001).minimize(self.DiscriminatorRealLoss,var_list=self.d_vars) self.DiscriminatorOptimizerFake=tf.train.AdamOptimizer(0.00001).minimize(self.DiscriminatorFakeLoss,var_list=self.d_vars) """ The followinng Optimizers are for minizing the Generator and Discriminator Loss wrt their weights """ self.gen_loss_lambda1 = 1.0 self.GeneratorOptimizer=tf.train.AdamOptimizer(0.00001).minimize(self.GeneratorLoss+self.gen_loss_lambda1*self.GeneratorABS,var_list=self.g_vars) self.GeneratorGradients=tf.train.AdamOptimizer(0.00001).compute_gradients(self.GeneratorLoss,var_list=self.g_vars) self.DiscriminatorOptimizer=tf.train.AdamOptimizer(0.00001).minimize(self.DiscriminatorLoss,var_list=self.d_vars) self.Session = tf.Session() self.saver=tf.train.Saver() self.init_op= tf.initialize_all_variables() self.Session.run(self.init_op) self.BatchReplayBool=True self.BatchSize=1 self.TrainSize=10 self.HmEpochs=10 self.PatchSize=64 self.save_path="./models/" with open('DoDtrain_exposures.json') as f: self.TrainDict = json.load(f) with open('DoDval_exposures.json') as f: self.ValidDict = json.load(f) if tf.train.latest_checkpoint(self.save_path) is not None: self.checkpoint = tf.train.latest_checkpoint(self.save_path) self.saver.restore(self.Session,self.checkpoint)
def main(_argv): weight_decay = FLAGS.weight_decay learning_rate = FLAGS.learning_rate batch_size = FLAGS.batch_size epoch = FLAGS.epoch log_dir = FLAGS.logdir use_lsgan = FLAGS.use_lsgan norm = FLAGS.norm lambda1 = FLAGS.lambda1 lambda2 = FLAGS.lambda2 beta1 = FLAGS.beta1 ngf = FLAGS.ngf G = generator.Generator('G',ngf,weight_decay,norm=norm,more=True) F = generator.Generator('F',ngf,weight_decay,norm=norm,more=True) D_Y = discriminator.Discriminator('D_Y',reg=weight_decay,norm=norm) D_X = discriminator.Discriminator('D_X',reg=weight_decay,norm=norm) forbuild=np.random.rand(1,768,768,3).astype(np.float32) built=G(forbuild) built=F(forbuild) built=D_Y(forbuild) built=D_X(forbuild) source_data=data.source_data(batch_size) target_data=data.target_data(batch_size) train_loss_G = tf.keras.metrics.Mean('train_loss_G', dtype=tf.float32) train_loss_F = tf.keras.metrics.Mean('train_loss_F', dtype=tf.float32) train_loss_DX = tf.keras.metrics.Mean('train_loss_DX', dtype=tf.float32) train_loss_DY = tf.keras.metrics.Mean('train_loss_DY', dtype=tf.float32) train_loss = [train_loss_G,train_loss_F,train_loss_DX,train_loss_DY] generator_g_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) generator_f_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) discriminator_x_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) discriminator_y_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) train_summary_writer = tf.summary.create_file_writer(log_dir) ckpt = tf.train.Checkpoint(G=G,F=F,D_X=D_X,D_Y=D_Y,generator_g_optimizer=generator_g_optimizer,generator_f_optimizer=generator_f_optimizer,discriminator_x_optimizer=discriminator_x_optimizer,discriminator_y_optimizer=discriminator_y_optimizer) ckpt_manager = tf.train.CheckpointManager(ckpt, log_dir, max_to_keep=10) start =0 lr = lr_sch(start) if ckpt_manager.latest_checkpoint: ckpt.restore(ckpt_manager.latest_checkpoint) start=int(ckpt_manager.latest_checkpoint.split('-')[-1]) lr = lr_sch(start) print ('Latest checkpoint restored!!') for ep in range(start,epoch,1): print('Epoch:'+str(ep+1)) for step, source in enumerate(source_data): target = next(iter(target_data)) fake_y, cycled_x,fake_x,cycled_y,same_x,same_y, total_gen_g_loss,total_gen_f_loss,disc_x_loss,disc_y_loss,steps = train_step(G,F,D_Y,D_X,source,target,generator_g_optimizer,generator_f_optimizer,discriminator_x_optimizer,discriminator_y_optimizer,train_loss,lambda1,lambda2) print('Step: '+str(steps.numpy())+' , G loss: '+str(total_gen_g_loss.numpy())+' , F loss: '+str(total_gen_f_loss.numpy())+' , D_X loss: '+str(disc_x_loss.numpy())+' , D_Y loss: '+str(disc_y_loss.numpy())) if (steps.numpy()-1)%10==0: source=tf.image.convert_image_dtype((source+1)/2,dtype = tf.uint8) target=tf.image.convert_image_dtype((target+1)/2,dtype = tf.uint8) fake_y=tf.image.convert_image_dtype((fake_y+1)/2,dtype = tf.uint8) cycled_x=tf.image.convert_image_dtype((cycled_x+1)/2,dtype = tf.uint8) same_x=tf.image.convert_image_dtype((same_x+1)/2,dtype = tf.uint8) fake_x=tf.image.convert_image_dtype((fake_x+1)/2,dtype = tf.uint8) cycled_y=tf.image.convert_image_dtype((cycled_y+1)/2,dtype = tf.uint8) same_y=tf.image.convert_image_dtype((same_y+1)/2,dtype = tf.uint8) with train_summary_writer.as_default(): tf.summary.scalar('Learning_rate', lr, step=steps) tf.summary.scalar('Loss/G_loss', train_loss[0].result(), step=steps) tf.summary.scalar('Loss/F_loss', train_loss[1].result(), step=steps) tf.summary.scalar('Loss/DX_loss', train_loss[2].result(), step=steps) tf.summary.scalar('Loss/DY_loss', train_loss[3].result(), step=steps) tf.summary.image('image_source/source',source,max_outputs=1,step=steps) tf.summary.image('image_source/fake_target',fake_y,max_outputs=1, step=steps) tf.summary.image('image_source/cycle_source',cycled_x,max_outputs=1,step=steps) tf.summary.image('image_source/same_source',same_x,max_outputs=1, step=steps) tf.summary.image('image_target/target',target,max_outputs=1,step=steps) tf.summary.image('image_target/fake_source',fake_x,max_outputs=1, step=steps) tf.summary.image('image_target/cycle_target',cycled_y,max_outputs=1,step=steps) tf.summary.image('image_target/same_target',same_y,max_outputs=1, step=steps) train_loss[0].reset_states() train_loss[1].reset_states() train_loss[2].reset_states() train_loss[3].reset_states() lr = lr_sch(ep) generator_g_optimizer.learning_rate = lr generator_f_optimizer.learning_rate = lr discriminator_x_optimizer.learning_rate = lr discriminator_y_optimizer.learning_rate = lr ckpt_save_path = ckpt_manager.save()
if classname.find('Conv') != -1: nn.init.normal_(m.weight.data, 0.0, 0.02) elif classname.find('BatchNorm') != -1: nn.init.normal_(m.weight.data, 1.0, 0.02) nn.init.constant_(m.bias.data, 0) # =============== GENEREATOR =============>>> n_gen = generator.Generator(args.ngpu).to(device) if (device.type == 'cuda') and (args.ngpu > 1): n_gen = nn.DataParallel(n_gen, list(range(args.ngpu))) n_gen.apply(weights_init) # ============ DISCRIMINATOR =====>>> n_disc = discriminator.Discriminator(args.ngpu).to(device) if (device.type == 'cuda') and (args.ngpu > 1): n_disc = nn.DataParallel(n_disc, list(range(args.ngpu))) n_disc.apply(weights_init) # ====== LOSS ==========>>> loss = nn.BCELoss() # Establish convention for real and fake labels during training real_label = 1 fake_label = 0 # ============== OPTIMISERS ===============>>> optimizerD = optim.Adam(n_disc.parameters(),
def GAN(data_name = "circle"): # hyperparameters G_learning_rate = 2e-4 D_learning_rate = 2e-4 batch_size = 1000 epoc_num = 20000 d_steps = 1 g_steps = 1 dim = 0 ori_z = None if data_name == "circle": dim = 2 z_size = dim input_size = dim output_size = input_size img_dir = "imgs_circle" sample_true_data_func = sample_true_data_circle plot_true_data_and_noise(img_dir, sample_true_data_func, dim) g_dim_list = [z_size, 128, 128, output_size] g_act_list = [tf.nn.leaky_relu, tf.nn.leaky_relu, tf.nn.tanh] elif data_name == "Gaussian": dim = 2 z_size = dim input_size = dim output_size = input_size img_dir = "imgs_Gaussian" sample_true_data_func = sample_true_data_Gaussian plot_true_data_and_noise(img_dir, sample_true_data_func, dim) g_dim_list = [z_size, 128, 128, output_size] g_act_list = [tf.nn.leaky_relu, tf.nn.leaky_relu, None] elif data_name == "mnist": # increase epoc_num for mnist batch_size = 250 epoc_num = 120000 img_height = 28 img_width = 28 dim = img_height * img_width z_size = dim input_size = dim output_size = input_size img_dir = "imgs_mnist" global mnist mnist = input_data.read_data_sets('MNIST_data', one_hot=True) sample_true_data_func = sample_true_data_mnist g_dim_list = [z_size, 128, 128, output_size] g_act_list = [tf.nn.leaky_relu, tf.nn.leaky_relu, tf.sigmoid] ori_z = sample_noise(batch_size, dim) d_dim_list = [input_size, 128, 128, 1] d_act_list = [tf.nn.leaky_relu, tf.nn.leaky_relu, tf.nn.sigmoid] # build graph Generator = generator.Generator(batch_size, g_dim_list, g_act_list, scope_name = "Generator") Discriminator = discriminator.Discriminator(batch_size, d_dim_list, d_act_list, scope_name = "Discriminator") generator_output = Generator.build() data_preds, gen_preds = Discriminator.build(generator_output) G_loss = -tf.reduce_mean(tf.log(gen_preds)) D_loss = -tf.reduce_mean((tf.log(data_preds) + tf.log(1 - gen_preds))) # G trainer G_trainer = tf.train.AdamOptimizer(G_learning_rate) G_step = G_trainer.minimize(G_loss, var_list = Generator.get_var_list()) # D trainer D_trainer = tf.train.AdamOptimizer(D_learning_rate) D_step = D_trainer.minimize(D_loss, var_list = Discriminator.get_var_list()) G_loss_list = [] D_loss_list = [] with tf.Session() as sess: #graph_writer = tf.summary.FileWriter("logs/", sess.graph) sess.run(tf.global_variables_initializer()) m = batch_size # train proces for i in range(epoc_num): # 1. d steps for optimize D for d in range(d_steps): # sample m noise samples {z_1, z_2, ..., z_m} from p_z(z) z = sample_noise(m, dim) # sample m examples {x_1, x_2, ..., x_m} from p_data(x) (true_data) true_samples = sample_true_data_func(num = m) # update D d_loss, _, d_probs, g_probs = sess.run([D_loss, D_step, data_preds, gen_preds], feed_dict = { Generator.get_input_layer_tensor() : z, # p_z Discriminator.get_input_layer_tensor() : true_samples, # true data }) G_loss_list.append(d_loss) # 2. g steps for optimize G for g in range(g_steps): # sample m noise samples {z_1, z_2, ..., z_m} from p_z(z) z = sample_noise(m, dim) # sample m examples {x_1, x_2, ..., x_m} from p_data(x) (true_data) true_samples = sample_true_data_func(num = m) zero_data_for_G = np.zeros((m, dim)) # update G g_loss, _, g_data = sess.run([G_loss, G_step, generator_output], feed_dict = { Generator.get_input_layer_tensor() : z, # p_z Discriminator.get_input_layer_tensor() : zero_data_for_G, # zero data or true data? }) D_loss_list.append(g_loss) if i % 100 == 0: print(str(i) + " of " + str(epoc_num) + ", " + "{:.2f}".format(100.0 * i / epoc_num) + "%") if (i + 1) % 1000 == 0 or i == 0: z = sample_noise(m, dim) if data_name == "mnist": z = ori_z gen_data = sess.run([generator_output], feed_dict = { Generator.get_input_layer_tensor() : z, # p_z }) if data_name == "mnist": save_gen_img_data(img_dir, gen_data, i + 1, img_height, img_width) else: plot_gen_data(img_dir, gen_data, i + 1) plot_loss_fig(img_dir, D_loss_list, G_loss_list)
batch_size=config.batch_size, shuffle=True, num_workers=workers, drop_last=True) device = torch.device("cuda" if ( torch.cuda.is_available() and config.gpus > 0) else "cpu") # Create discriminator and generator netG = generator.Generator(config.channels_noise, config.channels_img, config.features_g, config.gpus, config.classes).to(device) netG.apply(weights_initialize) netD = discriminator.Discriminator(config.channels_img, config.features_d, config.gpus, config.classes).to(device) netD.apply(weights_initialize) # Setup Optimizer for G and D optimizerD = optim.Adam(netD.parameters(), lr=config.lrD, betas=(config.beta1, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=config.lrG, betas=(config.beta1, 0.999)) netG.train() netD.train() criterion = nn.BCELoss() real_label = 1
import discriminator from tensorboardX import SummaryWriter data = np.load('expert_data.npy') expert_data = collections.deque() for x in data: expert_data.append(x) sess = tf.Session() state_size = 4 action_size = 2 n_step = 128 agent = ppo.PPO(sess, state_size, action_size) dis = discriminator.Discriminator(sess, state_size, action_size) env = gym.make('CartPole-v0') score = 0 episode = 0 p = 0 gail = True writer = SummaryWriter() state = env.reset() while True: values_list, states_list, actions_list, dones_list, logp_ts_list, rewards_list = \ [], [], [], [], [], []
def __init__(self, in_dim=512, embed_dim=16, latent_std=1.0, strt_dim=3, n_heads=4, init_knl=3, max_pos=1000, pos_conv_knl=3, chstl_fc_layers=4, chstl_activ=tf.keras.layers.LeakyReLU(alpha=0.1), chsyn_fc_activation=tf.keras.layers.LeakyReLU(alpha=0.1), chsyn_encoder_layers=3, chsyn_decoder_layers=3, chsyn_fc_layers=3, chsyn_norm_epsilon=1e-6, chsyn_transformer_dropout_rate=0.2, chsyn_noise_std=0.5, time_features=3, tmstl_fc_layers=4, tmstl_activ=tf.keras.layers.LeakyReLU(alpha=0.1), tmsyn_encoder_layers=3, tmsyn_decoder_layers=3, tmsyn_fc_layers=3, tmsyn_norm_epsilon=1e-6, tmsyn_transformer_dropout_rate=0.2, tmsyn_fc_activation=tf.keras.layers.LeakyReLU(alpha=0.1), tmsyn_noise_std=0.5, d_kernel_size=3, d_encoder_layers=1, d_decoder_layers=1, d_fc_layers=3, d_norm_epsilon=1e-6, d_transformer_dropout_rate=0.2, d_fc_activation=tf.keras.activations.tanh, d_out_dropout=0.3, d_recycle_fc_activ=tf.keras.activations.elu, mode_='comb'): super(WGAN, self).__init__() if mode_ in ['chords', 'comb']: assert embed_dim % n_heads == 0, 'make sure: embed_dim % chsyn_n_heads == 0' # ---------------------------------- settings ---------------------------------- self.mode_ = mode_ self.embed_dim = embed_dim self.time_features = time_features # 3 for [velocity, velocity, time since last start, chords duration] self.in_dim = in_dim self.strt_dim = strt_dim self.latent_std = latent_std # callback settings self.ckpts = dict() self.ckpt_managers = dict() # optimisers self.optimizer_gen = tf.keras.optimizers.Adam(0.01, beta_1=0.9, beta_2=0.98, epsilon=1e-9) self.optimizer_disc = tf.keras.optimizers.Adam(0.0001, beta_1=0.9, beta_2=0.98, epsilon=1e-9) # losses self.train_loss_gen = tf.keras.metrics.Mean(name='train_loss_gen') self.train_loss_disc = tf.keras.metrics.Mean(name='train_loss_disc') # ---------------------------------- layers ---------------------------------- # generators if mode_ != 'time': self.chords_style = generator.Mapping(fc_layers=chstl_fc_layers, activ=chstl_activ) self.chords_syn = generator.ChordsSynthesis( embed_dim=embed_dim, init_knl=init_knl, strt_dim=strt_dim, n_heads=n_heads, fc_activation=chsyn_fc_activation, encoder_layers=chsyn_encoder_layers, decoder_layers=chsyn_decoder_layers, fc_layers=chsyn_fc_layers, norm_epsilon=chsyn_norm_epsilon, transformer_dropout_rate=chsyn_transformer_dropout_rate, noise_std=chsyn_noise_std) if mode_ != 'chords': self.time_style = generator.Mapping(fc_layers=tmstl_fc_layers, activ=tmstl_activ) self.time_syn = generator.TimeSynthesis( time_features=time_features, init_knl=init_knl, strt_dim=strt_dim, fc_activation=tmsyn_fc_activation, encoder_layers=tmsyn_encoder_layers, decoder_layers=tmsyn_decoder_layers, fc_layers=tmsyn_fc_layers, norm_epsilon=tmsyn_norm_epsilon, transformer_dropout_rate=tmsyn_transformer_dropout_rate, noise_std=tmsyn_noise_std, max_pos=max_pos, pos_conv_knl=pos_conv_knl) # discriminator if mode_ == 'chords': self.disc = discriminator.ChordsDiscriminator( embed_dim=embed_dim, n_heads=n_heads, fc_activation=d_fc_activation, encoder_layers=d_encoder_layers, decoder_layers=d_decoder_layers, fc_layers=d_fc_layers, norm_epsilon=d_norm_epsilon, transformer_dropout_rate=d_transformer_dropout_rate, pre_out_dim=in_dim, out_dropout=d_out_dropout, recycle_fc_activ=d_recycle_fc_activ) elif mode_ == 'time': self.disc = discriminator.TimeDiscriminator( time_features=time_features, fc_activation=d_fc_activation, encoder_layers=d_encoder_layers, decoder_layers=d_decoder_layers, fc_layers=d_fc_layers, norm_epsilon=d_norm_epsilon, transformer_dropout_rate=d_transformer_dropout_rate, pre_out_dim=in_dim, out_dropout=d_out_dropout, recycle_fc_activ=d_recycle_fc_activ) else: # mode_ == 'comb' self.disc = discriminator.Discriminator( embed_dim=embed_dim, n_heads=n_heads, kernel_size=d_kernel_size, fc_activation=d_fc_activation, encoder_layers=d_encoder_layers, decoder_layers=d_decoder_layers, fc_layers=d_fc_layers, norm_epsilon=d_norm_epsilon, transformer_dropout_rate=d_transformer_dropout_rate, pre_out_dim=in_dim, out_dropout=d_out_dropout, recycle_fc_activ=d_recycle_fc_activ)
def build_discriminator(self): self.discriminator = discriminator.Discriminator(n_node = self.n_node, node_emd_init=self.node_embed_init_d)
#Define Models AEncoder = ABot_Encoder.ABotEncoder(params) ADecoder = ABot_Decoder.ABotDecoder(params) QEncoder = QBot_Encoder.QBotEncoder(params) QDecoder = QBot_Decoder.QBotDecoder(params) embedding_weights = np.random.random( (params['vocab_size'], params['embed_size'])) embedding_weights[0, :] = np.zeros((1, params['embed_size'])) ABot_embedding_layer = ABot.EmbeddingLayer(embedding_weights) QBot_embedding_layer = QBot.EmbeddingLayer(embedding_weights) sampler = ABot.GumbelSampler() embedding_weights_discr = np.random.random( (params['vocab_size'], params['embed_size'])) embedding_weights_discr[0, :] = np.zeros((1, params['embed_size'])) print(embedding_weights_discr) discriminator = Discriminator.Discriminator(params, embedding_weights_discr) #Criterion criterion = {} criterion['CrossEntropyLoss'] = nn.CrossEntropyLoss(reduce=False) criterion['HingeEmbeddingLoss'] = nn.HingeEmbeddingLoss(margin=0.0, size_average=False) criterion['MSELoss'] = nn.MSELoss(size_average=False) criterion['BCELoss'] = nn.BCELoss(size_average=False) #Optimizer ABot_optimizer = torch.optim.Adam([{ 'params': AEncoder.parameters() }, { 'params': ADecoder.parameters() }, {
GEN_HIDDEN_DIM, GEN_EMBEDDING_DIM, MAX_SEQ_LEN, device=DEVICE) gen_optimizer = optim.Adam(gen.parameters(), lr=1e-2) if DISCRIMINATOR_LM: dis = discriminator_LM.Discriminator(DIS_EMBEDDING_DIM, DIS_HIDDEN_DIM, VOCAB_SIZE, MAX_SEQ_LEN, device=DEVICE) else: dis = discriminator.Discriminator(DIS_EMBEDDING_DIM, DIS_HIDDEN_DIM, VOCAB_SIZE, MAX_SEQ_LEN, device=DEVICE) dis_optimizer = optim.Adagrad(dis.parameters()) ## ADAGRAD ?? if CUDA: dis = dis.cuda() # OPTIONAL: Pretrain generator # checkpoint = torch.load('generator_checkpoint.pth.tar') print('Starting Generator MLE Training...') train_generator_MLE(gen, gen_optimizer, train_data_loader, MLE_TRAIN_EPOCHS) # # OPTIONAL: Pretrain discriminator # print('\nStarting Discriminator Training...')
gen_optimizer = Ranger(itertools.chain(state_encoder.parameters(),reason_decoder.parameters()), lr=1e-5,weight_decay= 1e-5) # train_generator_MLE(state_encoder, reason_decoder, gen_optimizer, PRE_TRAIN_GEN) print('\nStarting Generator Evaluating...') best_epoch = dev_generator(state_encoder, reason_decoder, gen_optimizer, name="pretrain_gen") pretrained_gen_path = "./model/pretrain_gen"+str(best_epoch)+".pth" state_encoder.load_state_dict(torch.load(pretrained_gen_path)["state_encoder"]) reason_decoder.load_state_dict(torch.load(pretrained_gen_path)["reason_decoder"]) embedding.load_state_dict(torch.load(pretrained_gen_path)["embed"]) state = {"state_encoder": state_encoder.state_dict(), "reason_decoder": reason_decoder.state_dict(), 'embed': embedding.state_dict()} pretrained_gen_path = "./model/pretrain_gen.pth" torch.save(state, pretrained_gen_path) # PRETRAIN DISCRIMINATOR dis = discriminator.Discriminator(hidden_size,DIS_HIDDEN_DIM).to( device) # use directly as classifier dis_option_encoder = EncoderRNN(VOCAB_SIZE, EMBED_DIM, hidden_size=int(hidden_size), embedding=embedding, bidirectional= False).to(device) print('\nStarting Discriminator Training...') dis_optimizer = Ranger(itertools.chain(dis_option_encoder.parameters(),dis.parameters()), lr=1e-5, weight_decay= 1e-4) # train_discriminator(dis, dis_option_encoder, dis_optimizer, PRE_TRAIN_DIS) print('\nStarting Discriminator Evaluating...') best_epoch = dev_discriminator(dis, dis_option_encoder, name="pretrain_dis") pretrained_dis_path = "./model/pretrain_dis"+str(best_epoch)+".pth" dis_option_encoder.load_state_dict(torch.load(pretrained_dis_path)["dis_option_encoder"]) dis.load_state_dict(torch.load(pretrained_dis_path)["dis"]) embedding.load_state_dict(torch.load(pretrained_dis_path)["embed"]) state = {"dis_option_encoder": dis_option_encoder.state_dict(), "dis": dis.state_dict(),'embed': embedding.state_dict()} pretrained_dis_path = "./model/pretrain_dis.pth" torch.save(state, pretrained_dis_path)
def train(device=device): batch_size = 1024 image_size = 64 G_out_D_in = 3 G_in = 100 G_hidden = 64 D_hidden = 64 epochs = 5 lr = 0.001 betal = 0.5 dataset = torchvision.datasets.ImageFolder(root='./dcgan/pic',transform=transforms.Compose( [ transforms.Resize(image_size), transforms.CenterCrop(image_size), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ] )) dataloader = torch.utils.data.DataLoader(dataset=dataset,batch_size=batch_size,shuffle=True) netg = generator.Generator(G_in,G_hidden,G_out_D_in).to(device) print(netg) netd = discriminator.Discriminator(G_out_D_in,D_hidden).to(device) print(netd) criterion = nn.BCELoss() fixed_noise = torch.randn(64,G_in,1,1,device=device) real_label = 1 fake_label = 0 optimizerd = optim.Adam(netd.parameters(),lr=lr,betas=(betal,0.999)) optimizerg = optim.Adam(netg.parameters(),lr=lr,betas=(betal,0.999)) img_list = [] g_losses = [] d_losses = [] iters = 0 print('start') for epoch in range(epochs): for i,data in enumerate(dataloader,0): netd.zero_grad() real_cpu = data[0].to(device) b_size =real_cpu.size(0) label = torch.full((b_size,),real_label,device=device) output = netd(real_cpu).view(-1) errD_real = criterion(output,label) errD_real.backward() D_x = output.mean().item() noise = torch.randn(b_size,G_in,1,1,device=device) fake = netg(noise) label.fill_(fake_label) output = netd(fake.detach()).view(-1) errd_fake = criterion(output,label) errd_fake.backward() d_g_z1 = output.mean().item() errd = errD_real+errd_fake optimizerd.step() netg.zero_grad() label.fill_(real_label) output = netd(fake).view(-1) errg = criterion(output,label) errg.backwar() d_g_z2 = output.mean().item() optimizerg.step() if(i%50 == 0): print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f' % (epoch, epochs, i, len(dataloader), errd.item(), errg.item(), D_x, d_g_z1, d_g_z2)) g_losses.append(errg.item()) d_losses.append(errd.item()) if (iters%500 == 0) or((epoch == epochs-1)and(i == len(dataloader)-1)): with torch.no_grad(): fake = netg(fixed_noise).detach().cpu() img_list.append(utils.make_grid(fake,padding=2,normalize=True)) iters = iters+1 torch.save(netd,'netd.pkl') torch.save(netd.state_dict(),'netd_parameters.pkl') torch.save(netg,'net.pkl') torch.save(netg.state_dict(),'net_parameters.pkl') return g_losses,d_losses,img_list