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('-----------------------------------------------')
