def __init__(self, name, dataset_type, mnist_loader, epochs): # prepare directories self.assets_dir = './assets/{:s}'.format(name) self.ckpt_dir = './checkpoints/{:s}'.format(name) if not os.path.isdir(self.assets_dir): os.makedirs(self.assets_dir) if not os.path.isdir(self.ckpt_dir): os.makedirs(self.ckpt_dir) # self.dataset_type = dataset_type self.mnist_loader = mnist_loader # tunable parameters self.y_dim = 10 self.z_dim = 100 self.learning_rate = 0.0002 self.epochs = epochs self.batch_size = 128 self.print_every = 30 self.save_every = 1 self.val_block_size = 10 # start building graphs tf.reset_default_graph() # create placeholders self.inputs_x = tf.placeholder(tf.float32, [None, 28, 28, 1], name='inputs_x') self.inputs_y = tf.placeholder(tf.float32, [None, self.y_dim], name='inputs_y') self.inputs_z = tf.placeholder(tf.float32, [None, self.z_dim], name='inputs_z') # create generator & discriminator self.g_out = network.generator(self.inputs_z, y=self.inputs_y, reuse=False, is_training=True) self.d_real_logits, _ = network.discriminator(self.inputs_x, y=self.inputs_y, reuse=False, is_training=True) self.d_fake_logits, _ = network.discriminator(self.g_out, y=self.inputs_y, reuse=True, is_training=True) # compute model loss self.d_loss, self.g_loss = self.model_loss(self.d_real_logits, self.d_fake_logits) # model optimizer self.d_opt, self.g_opt = self.model_opt(self.d_loss, self.g_loss) return
def __init__(self, age_size, id_num, model_path='./aim_model/'): self.model_path = model_path self.inp_holder = tf.placeholder(tf.float32, [None, 128, 128, 3]) # self.real_holder = tf.placeholder(tf.float32,[None,128,128,3]) self.uni_holder = tf.placeholder(tf.float32, [None, 2, 2, 512]) self.age_holder = tf.placeholder(tf.float32, [None, age_size]) self.target_holder = tf.placeholder(tf.float32, [None, 128, 128, 3]) self.id_holder = tf.placeholder(tf.float32, [None, id_num]) # get_feature self.feat = N.feat_encoder(self.inp_holder) # retrieve tensor for adv1 and ip adv1, ip = N.discriminator_f(self.feat, id_num) adv1_uni, _ = N.discriminator_f(self.uni_holder, id_num) # get attention A and C age_expanded = self.expand(self.age_holder, self.feat) aged_feature = tf.concat([age_expanded, self.feat], -1) self.A, self.C = N.generator_att(aged_feature) # construct synthesized image self.generated = self.A * self.C + (1. - self.A) * self.inp_holder # retrieve tensor for adv2 and ae adv2, age_pred = N.discriminator(self.generated, age_size) adv2_real, age_pred_real = N.discriminator(self.target_holder, age_size) # retrieve tensor for ai1 and ai2 ai1 = N.age_classify_r(self.feat, age_size) ai2 = N.age_classify(self.feat, age_size) # call loss builder functions print('Building losses...') self.build_loss_mc() self.build_loss_adv1(adv1, adv1_uni) self.build_loss_ip(ip) self.build_loss_adv2(adv2, adv2_real) self.build_loss_ae(age_pred, age_pred_real) self.build_loss_ai1(ai1) self.build_loss_ai2(ai2, age_size) self.build_loss_A() self.update_ops() self.accuracy = M.accuracy(ip, tf.argmax(self.id_holder, -1)) self.sess = tf.Session() M.loadSess(model_path, self.sess, init=True) self.saver = tf.train.Saver()
def __init__(self, batch_size, img_h, img_w, img_c, lambd, epoch, clean_path, noised_path, save_path, epsilon, learning_rate, beta1, beta2): self.batch_size = batch_size self.img_h = img_h self.img_w = img_w self.img_c = img_c self.epoch = epoch self.save_path = save_path self.clean_path = clean_path self.noised_path = noised_path self.img_clean = tf.placeholder(tf.float32, [None, None, None, img_c]) self.img_noised = tf.placeholder(tf.float32, [None, None, None, img_c]) G = RDBG("generator") D = discriminator("discriminator") self.img_denoised = G(self.img_noised) self.logit_real = D(self.img_clean, self.img_noised) self.logit_fake = D(self.img_denoised, self.img_noised) self.d_loss = -tf.reduce_mean( tf.log(self.logit_real + epsilon)) - tf.reduce_mean( tf.log(1 - self.logit_fake + epsilon)) self.l1_loss = tf.reduce_mean( tf.abs(self.img_denoised - self.img_clean)) self.g_loss = -tf.reduce_mean( tf.log(self.logit_fake + epsilon)) + lambd * self.l1_loss self.Opt_D = tf.train.AdamOptimizer(learning_rate, beta1=beta1, beta2=beta2).minimize( self.d_loss, var_list=D.var()) self.Opt_G = tf.train.AdamOptimizer(learning_rate, beta1=beta1, beta2=beta2).minimize( self.g_loss, var_list=G.var()) self.sess = tf.Session() self.sess.run(tf.global_variables_initializer())
def __init__(self): self.generator = lambda x: temporal_generator(x, feat_out) self.discriminator = lambda x: discriminator(x) self.global_step = tf.train.get_or_create_global_step() self.train_config() self.saver = tf.train.Saver(var_list=tf.trainable_variables())
def Main(): real_img = tf.placeholder("float", [BATCH_SIZE, IMG_SIZE, IMG_SIZE, 3]) z = tf.placeholder("float", [BATCH_SIZE, h]) G = generator("generator") D = discriminator("discriminator") k_t = tf.get_variable("k", initializer=[0.]) fake_img = G(z, IMG_SIZE, n) real_logits = D(real_img, IMG_SIZE, n, h) fake_logits = D(fake_img, IMG_SIZE, n, h) real_loss = l1_loss(real_img, real_logits) fake_loss = l1_loss(fake_img, fake_logits) D_loss = real_loss - k_t * fake_loss G_loss = fake_loss M_global = real_loss + tf.abs(GAMMA * real_loss - fake_loss) global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.inverse_time_decay(LEARNING_RATE, global_step, 5000, 0.5) Opt_D = tf.train.AdamOptimizer(learning_rate).minimize( D_loss, var_list=D.var(), global_step=global_step) Opt_G = tf.train.AdamOptimizer(learning_rate).minimize(G_loss, var_list=G.var()) with tf.control_dependencies([Opt_D, Opt_G]): clip = tf.clip_by_value(k_t + LAMBDA * (GAMMA * real_loss - fake_loss), 0, 1) update_k = tf.assign(k_t, clip) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) facedata = sio.loadmat("../TrainingSet/facedata.mat")["data"] saver = tf.train.Saver() # saver.restore(sess, "./save_para/.\\model.ckpt") for epoch in range(200): for i in range(facedata.shape[0] // BATCH_SIZE - 1): batch = facedata[i * BATCH_SIZE:i * BATCH_SIZE + BATCH_SIZE, :, :, :] / 127.5 - 1.0 z0 = np.random.uniform(0, 1, [BATCH_SIZE, h]) sess.run(update_k, feed_dict={real_img: batch, z: z0}) if i % 100 == 0: [dloss, gloss, Mglobal, fakeimg, step, lr] = sess.run([ D_loss, G_loss, M_global, fake_img, global_step, learning_rate ], feed_dict={ real_img: batch, z: z0 }) print( "step: %d, d_loss: %f, g_loss: %f, M_global: %f, Learning_rate: %f" % (step, dloss, gloss, Mglobal, lr)) Image.fromarray(np.uint8( 127.5 * (fakeimg[0, :, :, :] + 1))).save("./Results/" + str(step) + ".jpg") saver.save(sess, "./save_para/model.ckpt")
def __init__(self, training=True): N.bn_training = training self.inpholder = tf.placeholder(tf.float32, [None, 128, 128, 3]) self.feat = N.feat_encoder(self.inpholder) self.age_features = [] self.recon_features = [] self.recon_imgs = [] self.dis_scores = [] self.dis_feat_scores = [] self.dis_scores_real = [] self.dis_feat_scores_real = [] for i in range(10): age_feat = N.age_encoder(self.feat, i) self.age_features.append(age_feat) recon_img = N.generator(age_feat) self.recon_imgs.append(recon_img) recon_feature = N.feat_encoder(recon_img) self.recon_features.append(recon_feature) dis_scr = N.discriminator(recon_img) self.dis_scores.append(dis_scr) feat_dis_scr = N.discriminator_feature(recon_feature) self.dis_feat_scores.append(feat_dis_scr) dis_scr_real = N.discriminator(self.inpholder) self.dis_scores_real.append(dis_scr_real) feat_dis_scr_real = N.discriminator_feature(self.feat) self.dis_feat_scores_real.append(feat_dis_scr_real) self.age_features = tf.stack(self.age_features, 1) self.img_feature = N.attention_blk(self.age_features)
def train(batch_size=4, lambd=1e-3, init_lr=1e-4, clip_v=0.05, B=16, max_itr=100000, path_trainset="./ImageNet/", path_vgg="./vgg_para/", path_save_model="./save_para/"): inputs = tf.placeholder(tf.float32, [None, 96, 96, 3]) downsampled = tf.placeholder(tf.float32, [None, 24, 24, 3]) train_phase = tf.placeholder(tf.bool) learning_rate = tf.placeholder(tf.float32) G = generator("generator", B) D = discriminator("discriminator") SR = G(downsampled, train_phase) phi = vggnet(tf.concat([inputs, SR], axis=0), path_vgg) phi = tf.split(phi, num_or_size_splits=2, axis=0) phi_gt = phi[0] phi_sr = phi[1] real_logits = D(inputs, train_phase) fake_logits = D(SR, train_phase) D_loss = tf.reduce_mean(fake_logits) - tf.reduce_mean(real_logits) G_loss = -tf.reduce_mean(fake_logits) * lambd + tf.nn.l2_loss(phi_sr - phi_gt) / batch_size clip_D = [var.assign(tf.clip_by_value(var, -clip_v, clip_v)) for var in D.var_list()] D_opt = tf.train.RMSPropOptimizer(learning_rate).minimize(D_loss, var_list=D.var_list()) G_opt = tf.train.RMSPropOptimizer(learning_rate).minimize(G_loss, var_list=G.var_list()) sess = tf.Session() sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() # saver.restore(sess, "./save_para/.\\model.ckpt") lr0 = init_lr for itr in range(max_itr): if itr == max_itr // 2 or itr == max_itr * 3 // 4: lr0 = lr0 / 10 s0 = time.time() batch, down_batch = read_crop_data(path_trainset, batch_size, [96, 96, 3], 4) e0 = time.time() batch = batch/127.5 - 1 down_batch = down_batch/127.5 - 1 s1 = time.time() sess.run(D_opt, feed_dict={inputs: batch, downsampled: down_batch, train_phase: True, learning_rate: lr0}) sess.run(clip_D) sess.run(G_opt, feed_dict={inputs: batch, downsampled: down_batch, train_phase: True, learning_rate: lr0}) e1 = time.time() if itr % 200 == 0: [d_loss, g_loss, sr] = sess.run([D_loss, G_loss, SR], feed_dict={downsampled: down_batch, inputs: batch, train_phase: False}) raw = np.uint8((batch[0] + 1) * 127.5) bicub = misc.imresize(np.uint8((down_batch[0] + 1) * 127.5), [96, 96]) gen = np.uint8((sr[0, :, :, :] + 1) * 127.5) print("Iteration: %d, D_loss: %f, G_loss: %e, PSNR: %f, SSIM: %f, Read_time: %f, Update_time: %f" % (itr, d_loss, g_loss, psnr(raw, gen), ssim(raw, gen, multichannel=True), e0 - s0, e1 - s1)) Image.fromarray(np.concatenate((raw, bicub, gen), axis=1)).save("./results/" + str(itr) + ".jpg") if itr % 5000 == 0: saver.save(sess, path_save_model+"model.ckpt")
def test_discriminator(self): n = 2 h = 128 w = h c = 3 class_num = 3 input_tensor = tf.random_uniform((n, h, w, c)) output_src_tensor, output_cls_tensor = network.discriminator( input_tensor, class_num) with self.test_session() as sess: sess.run(tf.global_variables_initializer()) output_src, output_cls = sess.run([output_src_tensor, output_cls_tensor]) self.assertEqual(1, len(output_src.shape)) self.assertEqual(n, output_src.shape[0]) self.assertTupleEqual((n, class_num), output_cls.shape)
def __init__(self): self.dataloader = initialize_dataloader() self.generator = network.generator().to(configs.device) self.discriminator = network.discriminator().to(configs.device) self.optimizer_generator = torch.optim.Adam( self.generator.parameters(), lr=configs.learning_rate, betas=configs.betas) self.optimizer_discriminator = torch.optim.Adam( self.discriminator.parameters(), lr=configs.learning_rate, betas=configs.betas) self.loss = torch.nn.BCELoss() self.disloss = [] self.genloss = []
def model_loss(d_real_logits, d_fake_logits, inputs_x, inputs_p, lmbd_gp): # compute gradient penalty alpha = tf.random_uniform(shape=[], minval=-1., maxval=1.) differences = inputs_p - inputs_x interpolated = inputs_x + (alpha * differences) d_interpolate_logits, _ = network.discriminator(interpolated, reuse=True, is_training=True) gradients = tf.gradients(d_interpolate_logits, [interpolated])[0] slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1])) gradient_penalty = tf.reduce_mean((slopes - 1.) ** 2) # discriminator loss d_loss_real = utils.celoss_ones(d_real_logits) d_loss_fake = utils.celoss_zeros(d_fake_logits) d_loss = d_loss_real + d_loss_fake + lmbd_gp * gradient_penalty # generator loss g_loss = utils.celoss_ones(d_fake_logits) return d_loss, g_loss
def test_discriminator(self): n = 2 h = 128 w = h c = 3 class_num = 3 input_tensor = tf.random_uniform((n, h, w, c)) output_src_tensor, output_cls_tensor = network.discriminator( input_tensor, class_num) with self.test_session() as sess: sess.run(tf.global_variables_initializer()) output_src, output_cls = sess.run( [output_src_tensor, output_cls_tensor]) self.assertEqual(1, len(output_src.shape)) self.assertEqual(n, output_src.shape[0]) self.assertTupleEqual((n, class_num), output_cls.shape)
def main(_): if not os.path.exists(FLAGS.checkpoint_dir): print("Houston tengo un problem: No checkPoint directory found") return 0 if not os.path.exists(FLAGS.feature_dir): os.makedirs(FLAGS.feature_dir) if not os.path.exists(FLAGS.sample_dir): os.makedirs(FLAGS.sample_dir) #with tf.device("/gpu:0"): with tf.device("/cpu:0"): x = tf.placeholder(tf.float32, [ FLAGS.batch_size, FLAGS.output_size, FLAGS.output_size, FLAGS.c_dim ], name='d_input_images') d_netx, Dx, Dfx = network.discriminator(x, is_train=FLAGS.is_train, reuse=False) saver = tf.train.Saver() with tf.Session() as sess: print("starting session") sess.run(tf.global_variables_initializer()) model_dir = "%s_%s_%s" % (FLAGS.train_dataset, 64, FLAGS.output_size) save_dir = os.path.join(FLAGS.checkpoint_dir, model_dir) labels = utilities.get_labels(FLAGS.num_labels, FLAGS.labels_file) saver.restore(sess, save_dir) print("Model restored from file: %s" % save_dir) #extracting features from train dataset extract_features(x, labels, sess, Dfx) #extracting features from test dataset extract_features(x, labels, sess, Dfx, training=False) sess.close()
trainloader = torch.utils.data.DataLoader(trainset, batch_size=opts.batch, shuffle=True) testset = datasets.FashionMNIST('FMNIST_data/', download=True, train=False, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=1, shuffle=False) import trainer from tester import tester #Hyperparameters for our network output_size = opts.num_classes model = discriminator(opts).to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=opts.lr, betas=(opts.beta1, opts.beta2)) #trains the model trainer = trainer.trainer(opts, trainloader, model, optimizer, criterion) trainer.train() #trains the model tester = tester(opts, testloader, model) tester.test()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--dataset', required=True, help='cifar10 | imagenet') parser.add_argument('--dataroot', default='./data/', required=True, help='path to dataset') parser.add_argument('--out', help='Directory to output the result') parser.add_argument('--ngf', type=int, default=64) parser.add_argument('--ndf', type=int, default=64) parser.add_argument('--batchsize', type=int, default=32, help='input batch size') parser.add_argument('--imagesize', default=64, help='the height / width of the input image to network') parser.add_argument('--lr', type=float, default=0.0002, help='learning rate') parser.add_argument('--nz', default=64, help='Number of hidden units(z)') parser.add_argument('--epochs', default=100, help='number of epochs to train for') parser.add_argument('--ngpu', default=1, help='number of GPUs to use') parser.add_argument('--cuda', help='enables cuda') opt=parser.parse_args() print(opt) data_loader = CIFAR(batch_size= opt.batchsize) nc = 3 ''' if opt.dataset == 'cifar10': dataset = dset.CIFAR10(root=opt.dataroot, download=True, transform=transforms.Compose([ transforms.Resize(opt.imagesize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) nc = 3 else: dataset = dset.ImageFolder(root=opt.dataroot, transform=transforms.Compose([ transforms.Resize(opt.imagesize), transforms.CenterCrop(opt.imagesize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) ''' ''' GPUの使用について(例) x = torch.randn(10) y = torch.randn(10) x = x.to('cuda') y = y.to('cuda:0') # cudaの後に:数字で対応したGPUを使用 z = x * y z = z.to('cpu') # cpuへ ''' G_net = generator(ngf=opt.ngf, ngpu=1, nc=3, nz=opt.nz).to(device) #D_net = discriminator(ndf=opt.ndf, nc=3, ngpu=0).to(device) D_net = discriminator(ndf=opt.ndf, ngpu=1, nc=nc).to(device) ################## ### ここから上までで、モデルの構築 ################## # Initialize BCELoss function criterion = nn.BCELoss().to(device) # assert dataset # dataset = dset.ImageFolder(root = opt.dataroot) # dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchsize, shuffle=True) nc = 3 # setup optimizer optimizerG = torch.optim.Adam(G_net.parameters(), lr=opt.lr) optimizerD = torch.optim.Adam(D_net.parameters(), lr=opt.lr, betas=(0.5, 0.999)) # Generate batch of latent vectors input_noise = torch.randn(opt.batchsize, opt.nz, 1, 1, device=device) # batch * channels * height * width # Establish convention for real and fake labels during training real_label = 1 fake_label = 0 # Lists to keep track of progress G_loss_list = [] D_loss_list = [] print("Starting training loop...") ''' <DCGANのアルゴリズム> 1.ミニバッチサイズm個のノイズz1, z2, ..., zmをPg(z)から取り出す(生成する) 2.ミニバッチサイズm個のサンプルx1, x2, ..., xmをデータ生成分布Pdata(x)から取り出す 3.1/m sigma((log(D(x))) + (log(1 - D(G(z)))))式の、theta(d)における確率的勾配を上るようにDを更新 4.上記までをk回くりかえす 5.ミニバッチサイズm個のノイズz1, z2, ..., zmをPg(z)から取り出す 6.1/m sigma(log(1 - D(G(z)))))式の、theta(g)における確率的勾配を下るようにGを更新 7.ここまで全てを、訓練回数分だけ繰り返す (8.)Dを十分な回数(k回)更新した上で、Gを1回更新することで、常に鑑別機が新しいGの状態に適用できるように学習を進める ''' # For each epoch for epoch in range(opt.epochs): # For each batch in the dataloader for i_, data in enumerate(data_loader): ####################### # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)) ####################### ## Train with all-real batch # configure training data real_img = Variable(data[0]).to(device) # 勾配の初期化 optimizerD.zero_grad() # Forward pass through D real_label = Variable(torch.ones(opt.batchsize)).to(device) fake_label = Variable(torch.zeros(opt.batchsize)).to(device) real_out = D_net(real_img) # Calculate loss on all-real batch d_loss_real = criterion(real_out, real_label) ## Train with all-fake batch z = Variable(torch.randn(opt.batchsize, opt.nz, 1, 1)).to(device) fake_img = G_net(z) fake_out = D_net(fake_img) d_loss_fake = criterion(fake_out, fake_label) # Add the gradients from the all-real and all-fake batches d_loss = d_loss_real + d_loss_fake # Calculate gradients for D in backward pass d_loss.backward() # Update D optimizerD.step() ####################### # (2) Update G network: maximize log(D(G(z)) ####################### G_net.zero_grad() fake_img = G_net(z) fake_out = D_net(fake_img) g_loss = criterion(fake_out, real_label) # Calculate gradients for G in backward pass g_loss.backward() optimizerG.step() i = 0 # Output training stats if i % 1000 == 0: print(fake_img.size()) # Save Losses for plotting later G_loss_list.append(g_loss.item()) D_loss_list.append(d_loss.item())
def train(dir, random_dim, width, height, channels, batch_size, epoch): with tf.variable_scope('input'): real_image = tf.placeholder(tf.float32, shape = [None, height, width, channels], name = 'real_image') random_input = tf.placeholder(tf.float32, shape = [None, random_dim], name = 'random_input') fake_image = net.generator(random_input, channels, random_dim, is_train = True) real_result, _ = net.discriminator(real_image, is_train = True) fake_result, _ = net.discriminator(fake_image, is_train = True, reuse = True) fake_result_mean = tf.reduce_mean(fake_result) d_loss = tf.reduce_mean(real_result) - fake_result_mean g_loss = -fake_result_mean t_vars = tf.trainable_variables() d_vars = [var for var in t_vars if 'discriminator' in var.name] g_vars = [var for var in t_vars if 'generator' in var.name] learning_rate = 1e-3 trainer_d = tf.train.AdamOptimizer(learning_rate).minimize(-d_loss, var_list = d_vars) trainer_g = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list = g_vars) d_clip = [v.assign(tf.clip_by_value(v, -0.01, 0.01)) for v in d_vars] images_batch, samples_num = net.get_images_batch(dir, width, height, channels, batch_size) batch_num = int(samples_num / batch_size) total_batch = 0 sess = tf.Session() saver = tf.train.Saver() writer = tf.summary.FileWriter('logs/newPokemon/', sess.graph) sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) save_path = saver.save(sess, '/tmp/model.ckpt') ckpt = tf.train.latest_checkpoint('./model/newPokemon') saver.restore(sess, ckpt) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess = sess, coord = coord) tf.summary.scalar('loss_discriminator', d_loss) tf.summary.scalar('loss_generator', g_loss) summary_op = tf.summary.merge_all() print('total training sample num: %d' % samples_num) print('batch size: %d, batch num per epoch: %d, epoch num: %d' % (batch_size, batch_num, epoch)) print('start training...') for i in tqdm(range(epoch)): for j in range(batch_num): d_iters = 5 g_iters = 1 train_noise = np.random.uniform(-1.0, 1.0, size = [batch_size, random_dim]).astype(np.float32) for k in range(d_iters): train_image = sess.run(images_batch) sess.run(d_clip) _, dLoss = sess.run([trainer_d, d_loss], feed_dict = {random_input: train_noise, real_image: train_image}) for k in range(g_iters): _, gLoss = sess.run([trainer_g, g_loss], feed_dict = {random_input: train_noise}) if i == 0: if not os.path.exists('./newPokemon'): os.makedirs('./newPokemon') for index in range(train_image.shape[0]): image = train_image[index] save(image, './newPokemon/batch' + str(i) + '_image' + str(index) + '.jpg') if i % 100 == 0: if not os.path.exists('./model/newPokemon'): os.makedirs('./model/newPokemon') saver.save(sess, './model/newPokemon/' + str(i)) if i % 50 == 0: if not os.path.exists('./newPokemon'): os.makedirs('./newPokemon') sample_noise = np.random.uniform(-1.0, 1.0, size = [10, random_dim]).astype(np.float32) #[batch_size, random_dim]).astype(np.float32) imgtest = sess.run(fake_image, feed_dict = {random_input: sample_noise}) for index in range(imgtest.shape[0]): image = imgtest[index] save(image, './newPokemon/epoch' + str(i) + '_image' + str(index) + '.jpg') summary_str = sess.run(summary_op, feed_dict = {random_input: train_noise, real_image: train_image}) writer.add_summary(summary_str, i) print('train:[%d],d_loss:%f,g_loss:%f' % (i, dLoss, gLoss)) coord.request_stop() coord.join(threads)
### training phase # parameters setting # FOR HA B_real_ = torch.randn(num_train, opt.bit) B_fake_ = torch.randn(num_train, opt.bit) H_I_ = torch.zeros(num_train, opt.bit) H_S_ = torch.zeros(num_train, opt.bit) B_I = torch.sign(torch.sign(B_real_)) B_S = torch.sign(torch.sign(B_fake_)) # network G_A = network.generator(opt.input_ngc, opt.output_ngc, opt.ngf, opt.nb) G_B = network.generator(opt.input_ngc, opt.output_ngc, opt.ngf, opt.nb) D_A = network.discriminator(opt.input_ndc, opt.output_ngc, opt.ndf) net = models.resnet18(pretrained=True) net.fc = nn.Linear(2048, opt.bit) # net_dict = net.state_dict() # pretrain_dict = torch.load('./pre_resnet18.pkl') # pretrain_dict = {k[7:] : v for k, v in pretrain_dict.items() if k[7:] in net_dict} # net_dict.update(pretrain_dict) # net.load_state_dict(net_dict) # net.fc= nn.Linear(2048, opt.bit) H_A = net D_B = network.discriminator(opt.input_ndc, opt.bit, opt.ndf)
transform = transforms.Compose([ transforms.Resize((args.input_size, args.input_size)), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) train_loader_src = utils.data_load(os.path.join('data', args.src_data), 'train', transform, args.batch_size, shuffle=True, drop_last=True) train_loader_tgt = utils.data_load(os.path.join('data', args.tgt_data), 'train', transform, args.batch_size, shuffle=True, drop_last=True) test_loader_src = utils.data_load(os.path.join('data', args.src_data), 'test', transform, 1, shuffle=True, drop_last=True) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') A2BG = net.generator(args.in_ngc, args.out_ngc, args.ngf) B2AG = net.generator(args.in_ngc, args.out_ngc, args.ngf) AD = net.discriminator(args.in_ndc, args.out_ndc, args.ndf) BD = net.discriminator(args.in_ndc, args.out_ndc, args.ndf) print('---------- Networks initialized -------------') utils.print_network(A2BG) utils.print_network(AD) print('-----------------------------------------------') vgg16 = models.vgg16(pretrained=True) vgg16 = net.VGG(vgg16.features[:23]).to(device) A2BG.to(device) B2AG.to(device) AD.to(device) BD.to(device)
def main(args=None): img = tf.placeholder(tf.float32, shape=[None, 28, 28, 1], name='input_batch') return network.discriminator(img)
def __init__(self, name, dataset_type, gan_loss_type): # prepare directories self.assets_dir = './assets/{:s}'.format(name) self.ckpt_dir = './ckpts/{:s}'.format(name) self.ckpt_fn = os.path.join(self.ckpt_dir, '{:s}.ckpt'.format(name)) if not os.path.exists(self.assets_dir): os.makedirs(self.assets_dir) if not os.path.exists(self.ckpt_dir): os.makedirs(self.ckpt_dir) # setup variables self.dataset_type = dataset_type # tunable parameters self.z_dim = 100 self.learning_rate = 1e-4 self.epochs = 30 self.batch_size = 128 self.print_every = 30 self.save_every = 5 self.val_block_size = 10 self.lmbd_gp = 10.0 # start building graphs tf.reset_default_graph() # create placeholders self.running_bs = tf.placeholder(tf.int32, [], name='running_bs') self.latent_z = tf.placeholder(tf.float32, [None, self.z_dim], name='latent_z') self.real_images = tf.placeholder(tf.float32, [None, 28, 28, 1], name='real_images') # create generator & discriminator self.fake_images = network.generator(self.latent_z, is_training=True, use_bn=False) self.d_real_logits, _ = network.discriminator(self.real_images, is_training=True, use_bn=False) self.d_fake_logits, _ = network.discriminator(self.fake_images, is_training=True, use_bn=False) # compute model loss self.d_loss, self.g_loss = wgan_loss(self.d_real_logits, self.d_fake_logits) # add gradient penalty alpha = tf.random_uniform(shape=[self.running_bs, 1, 1, 1], minval=-1.0, maxval=1.0) interpolates = self.real_images + alpha * (self.fake_images - self.real_images) d_interpolates_logits, _ = network.discriminator(interpolates, is_training=True, use_bn=False) gradients = tf.gradients(d_interpolates_logits, [interpolates])[0] slopes = tf.sqrt( 0.0001 + tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2, 3])) gradient_penalty = tf.reduce_mean(tf.square(slopes - 1.0)) self.d_loss += self.lmbd_gp * gradient_penalty # prepare optimizers t_vars = tf.trainable_variables() d_vars = [ var for var in t_vars if var.name.startswith('discriminator') ] g_vars = [var for var in t_vars if var.name.startswith('generator')] # Optimize optimizer = tf.train.AdamOptimizer(self.learning_rate, beta1=0.5, beta2=0.9) self.d_opt = optimizer.minimize(self.d_loss, var_list=d_vars) self.g_opt = optimizer.minimize( self.g_loss, var_list=g_vars, global_step=tf.train.get_or_create_global_step()) # prepare saver for generator self.saver = tf.train.Saver(var_list=g_vars) return
batch_size=128, shuffle=False, num_workers=4, pin_memory=True) vggish_model = Vggish().to(device) load_weight(vggish_model, './save_models/vggish_mnist_best.pth') class_model = ClassifyNet().to(device) class_model.load_state_dict( torch.load('./save_models/classify_mnist_best.pth')['shared_layers']) G_model = generator(out_size=3).to(device) G_model.load_state_dict(torch.load('./save_models/emnist_G_best.pth.tar')) D_model = discriminator(in_size=3, ndf=128).to(device) D_model.load_state_dict(torch.load('./save_models/emnist_D_best.pth.tar')) optimizer = optim.Adam(vggish_model.parameters(), lr=1e-3) prec = test(vggish_model, class_model, G_model, test_loader, 0) best_prec = prec for epoch in range(1, 5): if epoch > 3: optimizer = optim.Adam(list(vggish_model.parameters()) + list(G_model.parameters()), lr=1e-4) train(vggish_model, class_model, G_model, D_model, train_loader, optimizer, epoch) prec = test(vggish_model, class_model, G_model, test_loader, epoch)
test = test_loader.__iter__().__next__()[0] img_size = test.size()[2] if opt.inverse_order: fixed_y_ = test[:, :, :, 0:img_size] fixed_x_ = test[:, :, :, img_size:] else: fixed_x_ = test[:, :, :, 0:img_size] fixed_y_ = test[:, :, :, img_size:] if img_size != opt.input_size: fixed_x_ = util.imgs_resize(fixed_x_, opt.input_size) fixed_y_ = util.imgs_resize(fixed_y_, opt.input_size) # network G = network.generator(opt.ngf) D = network.discriminator(opt.ndf) G.weight_init(mean=0.0, std=0.02) D.weight_init(mean=0.0, std=0.02) G.train() D.train() # loss BCE_loss = nn.BCELoss() L1_loss = nn.L1Loss() # Adam optimizer G_optimizer = optim.Adam(G.parameters(), lr=opt.lrG, betas=(opt.beta1, opt.beta2)) D_optimizer = optim.Adam(D.parameters(), lr=opt.lrD,
fixed_x_ = util.imgs_resize(fixed_x_, opt.input_size) fixed_y_ = util.imgs_resize(fixed_y_, opt.input_size) fixed_x_ = util.norm(fixed_x_) fixed_y_ = util.norm(fixed_y_) # variables x = tf.placeholder(tf.float32, shape=(None, opt.input_size, opt.input_size, train_loader.shape[3])) y = tf.placeholder(tf.float32, shape=(None, opt.input_size, opt.input_size, train_loader.shape[3])) # network G = network.generator(x, opt.ngf) D_positive, D_positive_logits = network.discriminator(x, y, opt.ndf) D_negative, D_negative_logits = network.discriminator(x, G, opt.ndf, reuse=True) # loss D_loss_positive = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=D_positive_logits, labels=tf.ones_like(D_positive_logits))) D_loss_negative = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=D_negative_logits, labels=tf.zeros_like(D_negative_logits))) D_loss = (D_loss_positive + D_loss_negative) * 0.5 G_loss_gan = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(
def main(_): if not os.path.exists(FLAGS.checkpoint_dir): os.makedirs(FLAGS.checkpoint_dir) if not os.path.exists(FLAGS.sample_dir): os.makedirs(FLAGS.sample_dir) if not os.path.exists(FLAGS.summaries_dir): os.makedirs(FLAGS.summaries_dir) with tf.device("/gpu:0"): #with tf.device("/cpu:0"): z = tf.placeholder(tf.float32, [FLAGS.batch_size, FLAGS.z_dim], name="g_input_noise") x = tf.placeholder(tf.float32, [FLAGS.batch_size, FLAGS.output_size, FLAGS.output_size, FLAGS.c_dim], name='d_input_images') Gz = network.generator(z) Dx, Dfx = network.discriminator(x) Dz, Dfz = network.discriminator(Gz, reuse=True) d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=Dx, labels=tf.ones_like(Dx))) d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=Dz, labels=tf.zeros_like(Dz))) d_loss = d_loss_real + d_loss_fake g_loss_perceptual = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = Dz, labels = tf.ones_like(Dz))) g_loss_features = tf.reduce_mean(tf.nn.l2_loss(Dfx-Dfz))/(FLAGS.image_size*FLAGS.image_size) g_loss = g_loss_perceptual + g_loss_features tvars = tf.trainable_variables() d_vars = [var for var in tvars if 'd_' in var.name] g_vars = [var for var in tvars if 'g_' in var.name] print(d_vars) print("---------------") print(g_vars) with tf.variable_scope(tf.get_variable_scope(),reuse=False): print("reuse or not: {}".format(tf.get_variable_scope().reuse)) assert tf.get_variable_scope().reuse == False, "Houston tengo un problem" d_trainer = tf.train.AdamOptimizer(FLAGS.learning_rate, FLAGS.beta1).minimize(d_loss, var_list=d_vars) g_trainer = tf.train.AdamOptimizer(FLAGS.learning_rate, FLAGS.beta1).minimize(g_loss, var_list=g_vars) tf.summary.scalar("generator_loss_percptual", g_loss_perceptual) tf.summary.scalar("generator_loss_features", g_loss_features) tf.summary.scalar("generator_loss_total", g_loss) tf.summary.scalar("discriminator_loss", d_loss) tf.summary.scalar("discriminator_loss_real", d_loss_real) tf.summary.scalar("discriminator_loss_fake", d_loss_fake) images_for_tensorboard = network.generator(z, reuse=True) tf.summary.image('Generated_images', images_for_tensorboard, 2) merged = tf.summary.merge_all() gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.30) gpu_options.allow_growth = True saver = tf.train.Saver() with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True)) as sess: print("starting session") summary_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/train', sess.graph) sess.run(tf.global_variables_initializer()) data_files = glob(os.path.join("./data", FLAGS.dataset, "*.jpg")) model_dir = "%s_%s_%s" % (FLAGS.dataset, 64, FLAGS.output_size) save_dir = os.path.join(FLAGS.checkpoint_dir, model_dir) if FLAGS.is_train: for epoch in range(FLAGS.epoch): d_total_cost = 0. g_total_cost = 0. shuffle(data_files) num_batches = min(len(data_files), FLAGS.train_size) // FLAGS.batch_size #num_batches = 2 for batch_i in range(num_batches): batch_files = data_files[batch_i*FLAGS.batch_size:(batch_i+1)*FLAGS.batch_size] batch = [utilities.load_image(batch_file, FLAGS.image_size, is_crop=FLAGS.is_crop, resize_w=FLAGS.output_size) for batch_file in batch_files] batch_x = np.array(batch).astype(np.float32) batch_z = np.random.normal(-1, 1, size=[FLAGS.batch_size, FLAGS.z_dim]).astype(np.float32) start_time = time.time() d_err, _ = sess.run([d_loss, d_trainer], feed_dict={z: batch_z, x: batch_x}) g_err, _ = sess.run([g_loss, g_trainer], feed_dict={z: batch_z, x: batch_x}) d_total_cost += d_err g_total_cost += g_err if batch_i % 10 == 0: summary = sess.run(merged, feed_dict={x: batch_x, z: batch_z}) summary_writer.add_summary(summary, (epoch-1)*(num_batches/30)+(batch_i/30)) print("Epoch: [%2d/%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \ % (epoch, FLAGS.epoch, batch_i, num_batches, time.time() - start_time, d_err, g_err)) print("Epoch:", '%04d' % (epoch+1), "d_cost=", \ "{:.9f}".format(d_total_cost/num_batches), "g_cost=", "{:.9f}".format(g_total_cost/num_batches)) sys.stdout.flush() save_path = saver.save(sess, save_dir) print("Model saved in path: %s" % save_path) sys.stdout.flush() sess.close()
data_reader.name_to_label_dict) test_data = Audio_Dataloader(test_filename, opts, data_reader.name_to_label_dict) trainloader = torch.utils.data.DataLoader(train_data, batch_size=opts.batch, shuffle=True, num_workers=opts.cpu_count) testloader = torch.utils.data.DataLoader(test_data, batch_size=opts.batch, shuffle=True, num_workers=opts.cpu_count) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") d = discriminator(opts, data_reader.return_class_size()).to(device) #optimizers D_optim = optim.Adam(d.parameters(), lr=opts.lr, betas=(opts.beta1, opts.beta2)) criterion = nn.CrossEntropyLoss() train = trainer(opts) #train the model train.train(d, D_optim, criterion, trainloader) #test the model if opts.resume: print('\nLoading the model\n') d = torch.load(opts.model_path)
# resize input_image for calculating reconstruction loss on a slightly smaller image. resulting_image_resized = tf.image.resize_images( input_image, [64, 64], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR) loss_recon = losses_helper.reconstruction_loss_l2(prediction, resulting_image_resized) loss_kl = losses_helper.KL_divergence_loss(z_mu, z_sigma) loss_recon = tf.reduce_mean(loss_recon) loss_kl = tf.reduce_mean(loss_kl) total_loss = tf.reduce_mean(loss_recon + loss_kl) ####### gan loss ####### if discriminator_on == True: real_d, conv_real = network.discriminator(resulting_image_resized, True) fake_d, conv_fake = network.discriminator(prediction, True, True) g_total_loss, d_total_loss = losses_helper.gan_loss( fake_d, real_d, conv_real, conv_fake) total_loss = g_total_loss + total_loss ####### initialize optimizer ####### MAX_ITERATIONS = 10000 alternate_global_step = tf.placeholder(tf.int32) global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False)
def __init__(self, name, dataset_type, gan_loss_type): # prepare directories self.assets_dir = './assets/{:s}'.format(name) self.ckpt_dir = './ckpts/{:s}'.format(name) self.ckpt_fn = os.path.join(self.ckpt_dir, '{:s}.ckpt'.format(name)) if not os.path.exists(self.assets_dir): os.makedirs(self.assets_dir) if not os.path.exists(self.ckpt_dir): os.makedirs(self.ckpt_dir) # setup variables self.dataset_type = dataset_type # tunable parameters self.z_dim = 100 self.learning_rate = 5e-5 self.epochs = 30 self.batch_size = 128 self.print_every = 30 self.save_every = 5 self.val_block_size = 10 # start building graphs tf.reset_default_graph() # create placeholders self.latent_z = tf.placeholder(tf.float32, [None, self.z_dim], name='latent_z') self.real_images = tf.placeholder(tf.float32, [None, 28, 28, 1], name='real_images') # create generator & discriminator self.fake_images = network.generator(self.latent_z, is_training=True, use_bn=True) self.d_real_logits, _ = network.discriminator(self.real_images, is_training=True, use_bn=True) self.d_fake_logits, _ = network.discriminator(self.fake_images, is_training=True, use_bn=True) # compute model loss self.d_loss, self.g_loss = wgan_loss(self.d_real_logits, self.d_fake_logits) # prepare optimizers t_vars = tf.trainable_variables() d_vars = [ var for var in t_vars if var.name.startswith('discriminator') ] g_vars = [var for var in t_vars if var.name.startswith('generator')] # add clipping op self.d_clip_op = tf.group( [p.assign(tf.clip_by_value(p, -0.01, 0.01)) for p in d_vars]) # Optimize optimizer = tf.train.RMSPropOptimizer(self.learning_rate) with tf.control_dependencies(tf.get_collection( tf.GraphKeys.UPDATE_OPS)): self.d_opt = optimizer.minimize(self.d_loss, var_list=d_vars) self.g_opt = optimizer.minimize( self.g_loss, var_list=g_vars, global_step=tf.train.get_or_create_global_step()) # prepare saver for generator self.saver = tf.train.Saver(var_list=g_vars) return
def __init__(self, model_path='./aim_model_gen/'): self.model_path = model_path self.inp_holder = tf.placeholder(tf.float32, [None, 128, 128, 3]) self.age_holder = tf.placeholder(tf.float32, [None, 1]) self.age_holder2 = tf.placeholder(tf.float32, [None, 1]) # get attention A and C age_expanded = self.expand(self.age_holder, self.inp_holder) aged_feature = tf.concat([age_expanded, self.inp_holder], -1) A, C = N.generator_att(aged_feature) # construct synthesized image generated = A * C + (1. - A) * self.inp_holder # get attention A2 and C2 age_expanded2 = self.expand(self.age_holder2, generated) aged_feature2 = tf.concat([age_expanded2, generated], -1) A2, C2 = N.generator_att(aged_feature2) generated2 = A2 * C2 + (1. - A2) * generated # retrieve tensor for adv2 and ae adv2, age_pred = N.discriminator(generated) adv2_real, age_pred_real = N.discriminator(self.inp_holder) adv2_2, age_pred2 = N.discriminator(generated2) feat = N.feat_encoder(self.inp_holder) feat1 = N.feat_encoder(generated) feat2 = N.feat_encoder(generated2) self.feat_loss = tf.reduce_mean( tf.square(feat - feat1) + tf.square(feat - feat2)) self.train_feat = tf.train.AdamOptimizer(0.00001).minimize( self.feat_loss, var_list=M.get_all_vars('gen_att')) # get gradient penalty # gamma1 = tf.random_uniform([],0.0,1.0) # interp1 = gamma1 * generated + (1. - gamma1) * self.inp_holder # interp1_y, _ = N.discriminator(interp1, 7) # grad_p1 = tf.gradients(interp1_y, interp1)[0] # grad_p1 = tf.sqrt(tf.reduce_sum(tf.square(grad_p1),axis=[1,2,3])) # grad_p1 = tf.reduce_mean(tf.square(grad_p1 - 1.) * 10.) # gamma2 = tf.random_uniform([],0.0,1.0) # interp2 = gamma2 * generated + (1. - gamma2) * self.inp_holder # interp2_y, _ = N.discriminator(interp2, 7) # grad_p2 = tf.gradients(interp2_y, interp2)[0] # grad_p2 = tf.sqrt(tf.reduce_sum(tf.square(grad_p2),axis=[1,2,3])) # grad_p2 = tf.reduce_mean(tf.square(grad_p2 - 1.) * 10.) grad_p1 = grad_p2 = 0. # call loss builder functions self.mc_loss, self.train_mc = self.build_loss_mc( generated2, self.inp_holder) self.adv2_loss_d1, self.adv2_loss_g1, self.train_adv2_1 = self.build_loss_adv2( adv2, adv2_real, grad_p1) self.adv2_loss_d2, self.adv2_loss_g2, self.train_adv2_2 = self.build_loss_adv2( adv2_2, adv2_real, grad_p2) self.age_cls_loss_dis, self.train_ae_dis = self.build_loss_ae_dis( age_pred_real, self.age_holder2) self.age_cls_loss_gen, self.train_ae_gen = self.build_loss_ae_gen( age_pred, self.age_holder) self.age_cls_loss_gen2, self.train_ae_gen2 = self.build_loss_ae_gen( age_pred2, self.age_holder2) self.loss_A, self.train_A = self.build_loss_A(A) self.loss_A2, self.train_A2 = self.build_loss_A(A2) self.update_ops() self.accuracy = M.accuracy(age_pred_real, tf.argmax(self.age_holder2, -1)) self.A1_l, self.A2_l = tf.reduce_mean(tf.square(A)), tf.reduce_mean( tf.square(A2)) self.generated = generated self.A, self.C = A, C self.sess = tf.Session() M.loadSess(model_path, self.sess, init=True) M.loadSess('./aim_model/', self.sess, var_list=M.get_all_vars('encoder')) self.saver = tf.train.Saver()
def __init__(self, name, dataset_type, gan_loss_type): # prepare directories self.assets_dir = './assets/{:s}'.format(name) self.ckpt_dir = './ckpts/{:s}'.format(name) self.ckpt_fn = os.path.join( self.ckpt_dir, '{:s}-{:s}.ckpt'.format(name, gan_loss_type)) if not os.path.exists(self.assets_dir): os.makedirs(self.assets_dir) if not os.path.exists(self.ckpt_dir): os.makedirs(self.ckpt_dir) # setup variables self.dataset_type = dataset_type self.gan_loss_type = gan_loss_type # tunable parameters self.y_dim = 10 self.z_dim = 128 self.learning_rate = 1e-4 self.epochs = 30 self.batch_size = 128 self.print_every = 30 self.save_every = 5 self.val_block_size = 10 # start building graphs tf.reset_default_graph() # create placeholders self.latent_z = tf.placeholder(tf.float32, [None, self.z_dim], name='latent_z') self.inputs_y = tf.placeholder(tf.float32, [None, self.y_dim], name='inputs_y') self.real_images = tf.placeholder(tf.float32, [None, 28, 28, 1], name='real_images') # create generator & discriminator self.fake_images = network.generator(self.latent_z, y=self.inputs_y, is_training=True, use_bn=True) self.d_real_logits, self.a_real_input = network.discriminator( self.real_images, y=self.inputs_y, is_training=True, use_bn=True) self.d_fake_logits, self.a_fake_input = network.discriminator( self.fake_images, y=self.inputs_y, is_training=True, use_bn=True) self.a_real_logits = network.classifier(self.a_real_input, self.y_dim, is_training=True, use_bn=True) self.a_fake_logits = network.classifier(self.a_fake_input, self.y_dim, is_training=True, use_bn=True) # compute model loss if gan_loss_type == 'v1': self.d_loss, self.g_loss = gan_loss_v1(self.d_real_logits, self.d_fake_logits) elif gan_loss_type == 'v2': self.d_loss, self.g_loss = gan_loss_v2(self.d_real_logits, self.d_fake_logits) else: raise ValueError('gan_loss_type must be either "v1" or "v2"!!') self.a_loss = auxilary_classifier_loss(self.a_real_logits, self.a_fake_logits, self.inputs_y) # prepare optimizers t_vars = tf.trainable_variables() d_vars = [ var for var in t_vars if var.name.startswith('discriminator') ] g_vars = [var for var in t_vars if var.name.startswith('generator')] # Optimize optimizer = tf.train.AdamOptimizer(self.learning_rate, beta1=0.5) with tf.control_dependencies(tf.get_collection( tf.GraphKeys.UPDATE_OPS)): self.d_opt = optimizer.minimize(self.d_loss, var_list=d_vars) self.g_opt = optimizer.minimize(self.g_loss, var_list=g_vars) self.a_opt = optimizer.minimize( self.a_loss, var_list=t_vars, global_step=tf.train.get_or_create_global_step()) # prepare saver for generator self.saver = tf.train.Saver(var_list=g_vars) return
def __init__(self, args, device): # parameters self.epoch = args.epochs self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.model_name = "GCGAN" self.Glayer_num = args.Glayer self.Dlayer_num = args.Dlayer self.Ghidden_num = args.Ghidden self.z_dim = args.z_dim self.num_worker = args.num_worker self.device = device dataset = MovieLensDataset(dataset=self.dataset, transform=transforms.Compose([ToTensor()])) dataset_num = len(dataset) train_num = int(dataset_num * 0.8) train_dataset, test_dataset = random_split( dataset, [train_num, dataset_num - train_num]) # load dataset self.train_loader = DataLoader(train_dataset, batch_size=self.batch_size, shuffle=True, num_workers=self.num_worker) self.test_loader = DataLoader(test_dataset, batch_size=len(dataset), shuffle=True, num_workers=self.num_worker) data = dataset[0]['u_perchase'] self.u_feature_num = dataset[0]['u_feature'].shape[0] self.v_feature_num = dataset[0]['v_feature'].shape[1] # networks init self.G = generator(input_dim=self.z_dim, feature_num=self.u_feature_num, output_dim=data.shape[0], layer_num=self.Glayer_num, hidden_num=self.Ghidden_num).to(self.device) self.D = discriminator(in_features_u=self.u_feature_num, num_item=data.shape[0], in_features_v=self.v_feature_num, rating=5, output_dim=1, layer_num=self.Dlayer_num).to(self.device) self.G_optimizer = optim.SGD(self.G.parameters(), lr=args.lrG) self.D_optimizer = optim.SGD(self.D.parameters(), lr=args.lrD) self.BCE_loss = nn.BCELoss().to(self.device) self.MSE_loss = nn.MSELoss().to(self.device) print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------')