def __init__(self,
train_set,
test_set,
loss_name="WGAN-GP",
mixed_precision=False,
learning_rate=2e-4,
tmp_path=None,
out_path=None):
super(CycleGAN, self).__init__()
#接收数据集和相关参数
self.train_set = train_set
self.test_set = test_set
self.tmp_path = tmp_path
self.out_path = out_path
#定义模型
self.G = networks.Generator(name="G_X2Y")
self.F = networks.Generator(name="G_Y2X")
if loss_name in ["WGAN-SN", "WGAN-GP-SN"]:
self.Dy = networks.Discriminator(name="If_is_real_Y",
use_sigmoid=False,
sn=True)
self.Dx = networks.Discriminator(name="If_is_real_X",
use_sigmoid=False,
sn=True)
self.loss_name = loss_name[:-3]
elif loss_name in ["WGAN", "WGAN-GP"]:
self.Dy = networks.Discriminator(name="If_is_real_Y",
use_sigmoid=False,
sn=False)
self.Dx = networks.Discriminator(name="If_is_real_X",
use_sigmoid=False,
sn=False)
self.loss_name = loss_name
elif loss_name in ["Vanilla", "LSGAN"]:
self.Dy = networks.Discriminator(name="If_is_real_Y",
use_sigmoid=True,
sn=False)
self.Dx = networks.Discriminator(name="If_is_real_X",
use_sigmoid=True,
sn=False)
self.loss_name = loss_name
else:
raise ValueError("Do not support the loss " + loss_name)
self.model_list = [self.G, self.F, self.Dy, self.Dx]
#定义损失函数 优化器 记录等
self.gan_loss = GanLoss(self.loss_name)
self.optimizers_list = self.optimizers_config(
mixed_precision=mixed_precision, learning_rate=learning_rate)
self.mixed_precision = mixed_precision
self.matrics_list = self.matrics_config()
self.checkpoint_config()
self.get_seed()
def __init__(self, conf):
# Acquire configuration
self.conf = conf
# Define the GAN
self.G = networks.Generator(conf).cuda()
self.U = networks.Upsampler().cuda()
# Input tensors
self.g_input = torch.FloatTensor(1, 3, conf.input_crop_size,
conf.input_crop_size).cuda()
# Define loss function
self.L1 = nn.L1Loss()
# Initialize networks weightsZ
self.G.apply(networks.weights_init_G)
self.U.apply(networks.weights_init_U)
# Optimizers
self.optimizer_G = torch.optim.Adam(self.G.parameters(),
lr=conf.g_lr,
betas=(conf.beta1, 0.999))
self.optimizer_U = torch.optim.Adam(self.U.parameters(),
lr=conf.u_lr,
betas=(conf.beta1, 0.999))
print('*' * 60 +
'\nSTARTED DBPI-BlindSR on: \"%s\"...' % conf.input_image_path)
self.ds = nn.AvgPool2d(2, ceil_mode=True)
def main():
opt = get_opt()
# Define the Generators, only G_A is used for testing
netG_A = networks.Generator(opt.input_nc, opt.output_nc, opt.ngf, opt.n_res, opt.dropout)
if opt.u_net:
netG_A = networks.U_net(opt.input_nc, opt.output_nc, opt.ngf)
if opt.cuda:
netG_A.cuda()
# Do not need to track the gradients during testing
utils.set_requires_grad(netG_A, False)
netG_A.eval()
netG_A.load_state_dict(torch.load(opt.net_GA))
# Load the data
transform = transforms.Compose([transforms.Resize((opt.sizeh, opt.sizew)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))])
dataloader = DataLoader(ImageDataset(opt.rootdir, transform=transform, mode='val'), batch_size=opt.batch_size,
shuffle=False, num_workers=opt.n_cpu)
Tensor = torch.cuda.FloatTensor if opt.cuda else torch.Tensor
input_A = Tensor(opt.batch_size, opt.input_nc, opt.size, opt.size)
for i, batch in enumerate(dataloader):
name, image = batch
real_A = input_A.copy_(image)
fake_B = netG_A(real_A)
batch_size = len(name)
# Save the generated images
for j in range(batch_size):
image_name = name[j].split('/')[-1]
path = 'generated_image/' + image_name
utils.save_image(fake_B[j, :, :, :], path)
def __init__(self, conf):
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3,4,5,6,7'
# Acquire configuration
self.conf = conf
self._device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Define the GAN
self.G = networks.Generator(conf)
self.D = networks.Discriminator(conf)
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
print("gpu num : ", torch.cuda.device_count())
# dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs
self.G = nn.DataParallel(self.G)
self.D = nn.DataParallel(self.D)
print("haha, gpu num : ", torch.cuda.device_count())
self.G.to(self._device)
self.D.to(self._device)
# Calculate D's input & output shape according to the shaving done by the networks
if torch.cuda.device_count() > 1:
self.d_input_shape = self.G.module.output_size
self.d_output_shape = self.d_input_shape - self.D.module.forward_shave
else:
self.d_input_shape = self.G.output_size
self.d_output_shape = self.d_input_shape - self.D.forward_shave
# Input tensors
self.g_input = torch.FloatTensor(1, 3, conf.input_crop_size, conf.input_crop_size).cuda()
self.d_input = torch.FloatTensor(1, 3, self.d_input_shape, self.d_input_shape).cuda()
# The kernel G is imitating
self.curr_k = torch.FloatTensor(conf.G_kernel_size, conf.G_kernel_size).cuda()
# Losses
self.GAN_loss_layer = loss.GANLoss(d_last_layer_size=self.d_output_shape).cuda()
self.bicubic_loss = loss.DownScaleLoss(scale_factor=conf.scale_factor).cuda()
self.sum2one_loss = loss.SumOfWeightsLoss().cuda()
self.boundaries_loss = loss.BoundariesLoss(k_size=conf.G_kernel_size).cuda()
self.centralized_loss = loss.CentralizedLoss(k_size=conf.G_kernel_size, scale_factor=conf.scale_factor).cuda()
self.sparse_loss = loss.SparsityLoss().cuda()
self.loss_bicubic = 0
# Define loss function
self.criterionGAN = self.GAN_loss_layer.forward
# Initialize networks weights
self.G.apply(networks.weights_init_G)
self.D.apply(networks.weights_init_D)
# Optimizers
self.optimizer_G = torch.optim.Adam(self.G.parameters(), lr=conf.g_lr, betas=(conf.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(self.D.parameters(), lr=conf.d_lr, betas=(conf.beta1, 0.999))
print('*' * 60 + '\nSTARTED KernelGAN on: \"%s\"...' % conf.input_image_path)
def __init__(self, conf):
# Acquire configuration
self.conf = conf
# Define the GAN
self.G = networks.Generator(conf).cuda()
self.D = networks.Discriminator(conf).cuda()
# Calculate D's input & output shape according to the shaving done by the networks
self.d_input_shape = self.G.output_size
self.d_output_shape = self.d_input_shape - self.D.forward_shave
# Input tensors
self.g_input = torch.FloatTensor(1, 3, conf.input_crop_size,
conf.input_crop_size).cuda()
self.d_input = torch.FloatTensor(1, 3, self.d_input_shape,
self.d_input_shape).cuda()
# The kernel G is imitating
self.curr_k = torch.FloatTensor(conf.G_kernel_size,
conf.G_kernel_size).cuda()
# Losses
self.GAN_loss_layer = loss.GANLoss(
d_last_layer_size=self.d_output_shape).cuda()
self.bicubic_loss = loss.DownScaleLoss(
scale_factor=conf.scale_factor).cuda()
self.sum2one_loss = loss.SumOfWeightsLoss().cuda()
self.boundaries_loss = loss.BoundariesLoss(
k_size=conf.G_kernel_size).cuda()
self.centralized_loss = loss.CentralizedLoss(
k_size=conf.G_kernel_size, scale_factor=conf.scale_factor).cuda()
self.sparse_loss = loss.SparsityLoss().cuda()
self.loss_bicubic = 0
# Define loss function
self.criterionGAN = self.GAN_loss_layer.forward
# Initialize networks weights
self.G.apply(networks.weights_init_G)
self.D.apply(networks.weights_init_D)
# Optimizers
self.optimizer_G = torch.optim.Adam(self.G.parameters(),
lr=conf.g_lr,
betas=(conf.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(self.D.parameters(),
lr=conf.d_lr,
betas=(conf.beta1, 0.999))
self.iteration = 0 # for tensorboard
# self.ground_truth_kernel = np.loadtxt(conf.ground_truth_kernel_path)
# writer.add_image("ground_truth_kernel", (self.ground_truth_kernel - np.min(self.ground_truth_kernel)) / (np.max(self.ground_truth_kernel - np.min(self.ground_truth_kernel))), 0, dataformats="HW")
print('*' * 60 +
'\nSTARTED KernelGAN on: \"%s\"...' % conf.input_image_path)
def init_gan_model(model_dir, nb_of_classes):
device = torch.device("cuda:0")
generator_net = networks.Generator().to(device)
discriminator_net = networks.ClassifierDiscriminator(nb_of_classes=nb_of_classes).to(device)
generator_net.apply(networks.weights_init)
discriminator_net.apply(networks.weights_init)
utils.print_and_log(model_dir, generator_net)
utils.print_and_log(model_dir, discriminator_net)
learning_rate = 0.0002
beta1 = 0.5
discriminator_optimizer = optim.Adam(discriminator_net.parameters(), lr=learning_rate, betas=(beta1, 0.999))
generator_optimizer = optim.Adam(generator_net.parameters(), lr=learning_rate, betas=(beta1, 0.999))
criterion = nn.CrossEntropyLoss()
return discriminator_net, generator_net, criterion, discriminator_optimizer, generator_optimizer
def __init__(self, latent_size, generator_folder, restore,
param_optimizer):
self.strategy = tf.distribute.MirroredStrategy()
# Dynamic parameters
with self.strategy.scope():
self.generator = networks.Generator(
latent_size=latent_size, generator_folder=generator_folder)
self.encoder = networks.Encoder(latent_size=latent_size)
self.current_resolution = 1
self.current_width = 2**self.current_resolution
self.res_batch = {
2: 64,
4: 32,
8: 16,
16: 8,
32: 4,
64: 2,
128: 1,
256: 1
}
self.res_epoch = {
2: 10,
4: 20,
8: 30,
16: 50,
32: 60,
64: 80,
128: 100,
256: 400
}
# Static parameters
self.generate = True
self.learning_rate = 0.0001
self.latent_size = 1024
self.restore = restore
self.optimizer = param_optimizer
def init_model(model_dir):
device = torch.device("cuda:0")
generator_net = networks.Generator().to(device)
discriminator_net = networks.Discriminator().to(device)
generator_net.apply(networks.weights_init)
discriminator_net.apply(networks.weights_init)
utils.print_and_log(model_dir, generator_net)
utils.print_and_log(model_dir, discriminator_net)
learning_rate = 0.0002
beta1 = 0.5
discriminator_optimizer = optim.Adam(discriminator_net.parameters(),
lr=learning_rate,
betas=(beta1, 0.999))
generator_optimizer = optim.Adam(generator_net.parameters(),
lr=learning_rate,
betas=(beta1, 0.999))
return discriminator_net, generator_net, discriminator_optimizer, generator_optimizer
def main(args):
generator = networks.Generator()
print(generator)
discriminator = networks.Discriminator()
print(discriminator)
fp = os.path.join(os.path.abspath(''), dn)
if not os.path.exists(dn):
os.makedirs(fp)
manual_seed = 999
torch.manual_seed(manual_seed)
batch_size = 1000
fixed_size = 10000
train_epoch = 20000
lr_d = 0.00002
lr_g = 0.0002
beta1 = 0.5
generator = networks.Generator(d_noise, d_data)
discriminator = networks.Discriminator(d_data)
s = sampler.SAMPLER()
# plt.ion()
fig = plt.figure(figsize=(6, 6))
fig.canvas.set_window_title("2D Generation")
fig.suptitle(f"dimension data:{d_data}, dimension noise:{d_noise}")
if d_data == 2: # 感觉这个if 可以写在sampler类里面，没必要在这里拿出来
sam = s.sampler(bs=batch_size)
sam_show = s.sampler(bs=fixed_size)
ax1 = fig.add_subplot(221)
ax2 = fig.add_subplot(222)
ax3 = fig.add_subplot(223)
ax4 = fig.add_subplot(224)
def main():
# Get training options
opt = get_opt()
device = torch.device("cuda") if opt.cuda else torch.device("cpu")
# Define the networks
# netG_A: used to transfer image from domain A to domain B
netG_A = networks.Generator(opt.input_nc, opt.output_nc, opt.ngf, opt.n_res, opt.dropout)
if opt.u_net:
netG_A = networks.U_net(opt.input_nc, opt.output_nc, opt.ngf)
# netD_B: used to test whether an image is from domain A
netD_B = networks.Discriminator(opt.input_nc + opt.output_nc, opt.ndf)
# Initialize the networks
if opt.cuda:
netG_A.cuda()
netD_B.cuda()
utils.init_weight(netG_A)
utils.init_weight(netD_B)
if opt.pretrained:
netG_A.load_state_dict(torch.load('pretrained/netG_A.pth'))
netD_B.load_state_dict(torch.load('pretrained/netD_B.pth'))
# Define the loss functions
criterion_GAN = utils.GANLoss()
if opt.cuda:
criterion_GAN.cuda()
criterion_l1 = torch.nn.L1Loss()
# Define the optimizers
optimizer_G = torch.optim.Adam(netG_A.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
optimizer_D_B = torch.optim.Adam(netD_B.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
# Create learning rate schedulers
lr_scheduler_G = torch.optim.lr_scheduler.LambdaLR(optimizer_G, lr_lambda = utils.Lambda_rule(opt.epoch, opt.n_epochs, opt.n_epochs_decay).step)
lr_scheduler_D_B = torch.optim.lr_scheduler.LambdaLR(optimizer_D_B, lr_lambda = utils.Lambda_rule(opt.epoch, opt.n_epochs, opt.n_epochs_decay).step)
# Define the transform, and load the data
transform = transforms.Compose([transforms.Resize((opt.sizeh, opt.sizew)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))])
dataloader = DataLoader(PairedImage(opt.rootdir, transform = transform, mode = 'train'), batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_cpu)
# numpy arrays to store the loss of epoch
loss_G_array = np.zeros(opt.n_epochs + opt.n_epochs_decay)
loss_D_B_array = np.zeros(opt.n_epochs + opt.n_epochs_decay)
# Training
for epoch in range(opt.epoch, opt.n_epochs + opt.n_epochs_decay):
start = time.strftime("%H:%M:%S")
print("current epoch :", epoch, " start time :", start)
# Empty list to store the loss of each mini-batch
loss_G_list = []
loss_D_B_list = []
for i, batch in enumerate(dataloader):
if i % 20 == 1:
print("current step: ", i)
current = time.strftime("%H:%M:%S")
print("current time :", current)
print("last loss G_A:", loss_G_list[-1], "last loss D_B:", loss_D_B_list[-1])
real_A = batch['A'].to(device)
real_B = batch['B'].to(device)
# Train the generator
utils.set_requires_grad([netG_A], True)
optimizer_G.zero_grad()
# Compute fake images and reconstructed images
fake_B = netG_A(real_A)
# discriminators require no gradients when optimizing generators
utils.set_requires_grad([netD_B], False)
# GAN loss
prediction_fake_B = netD_B(torch.cat((fake_B, real_A), dim=1))
loss_gan = criterion_GAN(prediction_fake_B, True)
#L1 loss
loss_l1 = criterion_l1(real_B, fake_B) * opt.l1_loss
# total loss without the identity loss
loss_G = loss_gan + loss_l1
loss_G_list.append(loss_G.item())
loss_G.backward()
optimizer_G.step()
# Train the discriminator
utils.set_requires_grad([netG_A], False)
utils.set_requires_grad([netD_B], True)
# Train the discriminator D_B
optimizer_D_B.zero_grad()
# real images
pred_real = netD_B(torch.cat((real_B, real_A), dim=1))
loss_D_real = criterion_GAN(pred_real, True)
# fake images
fake_B = netG_A(real_A)
pred_fake = netD_B(torch.cat((fake_B, real_A), dim=1))
loss_D_fake = criterion_GAN(pred_fake, False)
# total loss
loss_D_B = (loss_D_real + loss_D_fake) * 0.5
loss_D_B_list.append(loss_D_B.item())
loss_D_B.backward()
optimizer_D_B.step()
# Update the learning rate
lr_scheduler_G.step()
lr_scheduler_D_B.step()
# Save models checkpoints
torch.save(netG_A.state_dict(), 'model/netG_A_pix.pth')
torch.save(netD_B.state_dict(), 'model/netD_B_pix.pth')
# Save other checkpoint information
checkpoint = {'epoch': epoch,
'optimizer_G': optimizer_G.state_dict(),
'optimizer_D_B': optimizer_D_B.state_dict(),
'lr_scheduler_G': lr_scheduler_G.state_dict(),
'lr_scheduler_D_B': lr_scheduler_D_B.state_dict()}
torch.save(checkpoint, 'model/checkpoint.pth')
# Update the numpy arrays that record the loss
loss_G_array[epoch] = sum(loss_G_list) / len(loss_G_list)
loss_D_B_array[epoch] = sum(loss_D_B_list) / len(loss_D_B_list)
np.savetxt('model/loss_G.txt', loss_G_array)
np.savetxt('model/loss_D_B.txt', loss_D_B_array)
end = time.strftime("%H:%M:%S")
print("current epoch :", epoch, " end time :", end)
print("G loss :", loss_G_array[epoch], "D_B loss :", loss_D_B_array[epoch])
# val_embeddings = dataservices.Doc2Vec(
# "paragraph-vectors/data/sentences_train_model.dbow_numnoisewords\
# .2_vecdim.100_batchsize.32_lr.0.001000_epoch.100_loss.0.781092.csv"
# ) # change this to val
# val_dataset = dataservices.RecipeQADataset(
# "recipeqa/new_val_cleaned.json",
# "recipeqa/features/val",
# val_embeddings
# )
# val_dataloader = torch.utils.data.DataLoader(
# val_dataset, batch_size=opt.batchSize,
# shuffle=True, num_workers=int(opt.workers),
# collate_fn=dataservices.batch_collator(device=device)
# )
netG = networks.Generator(opt).to(device)
netD = networks.Discriminator(opt).to(device)
def weights_init(m):
pass
criterionD = nn.BCEWithLogitsLoss() # logsigmoid + binary cross entropy
criterionG = nn.CrossEntropyLoss() # logsoftmax + multi-class cross entropy
optimizerD = optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
def fscore(probabilities, labels):
def mask(input):
netG = networks.Generator(opt.input_nc, opt.output_nc, opt.ngf, opt.norm, not opt.no_dropout,opt.gpu_ids)
_,mask = netG(input)
return mask
# ハイパーパラメータの定義
lr = 0.0001
betas = (0.5, 0.999)
batch_size = 1
input_size = 128 # patch_size = 8(128/2^4)
num_epochs = 200
lambda_cycle = 10.0
lambda_identity = 5.0
# GPUが使用できるか確認
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print('使用デバイス：', device)
# 各生成器と判別器をインスタンス化
G_A2B = net.Generator()
G_B2A = net.Generator()
D_A = net.Discriminator()
D_B = net.Discriminator()
# GPUが使用できるならモデルをGPUに載せて初期化
if device == 'cuda:0':
G_A2B.cuda()
G_B2A.cuda()
D_A.cuda()
D_B.cuda()
print('ネットワークの初期化中...', end='')
G_A2B.apply(utils.weights_init)
G_B2A.apply(utils.weights_init)
D_A.apply(utils.weights_init)
def main():
# Get training options
opt = get_opt()
# Define the networks
# netG_A: used to transfer image from domain A to domain B
# netG_B: used to transfer image from domain B to domain A
netG_A = networks.Generator(opt.input_nc, opt.output_nc, opt.ngf,
opt.n_res, opt.dropout)
netG_B = networks.Generator(opt.output_nc, opt.input_nc, opt.ngf,
opt.n_res, opt.dropout)
if opt.u_net:
netG_A = networks.U_net(opt.input_nc, opt.output_nc, opt.ngf)
netG_B = networks.U_net(opt.output_nc, opt.input_nc, opt.ngf)
# netD_A: used to test whether an image is from domain B
# netD_B: used to test whether an image is from domain A
netD_A = networks.Discriminator(opt.input_nc, opt.ndf)
netD_B = networks.Discriminator(opt.output_nc, opt.ndf)
# Initialize the networks
if opt.cuda:
netG_A.cuda()
netG_B.cuda()
netD_A.cuda()
netD_B.cuda()
utils.init_weight(netG_A)
utils.init_weight(netG_B)
utils.init_weight(netD_A)
utils.init_weight(netD_B)
if opt.pretrained:
netG_A.load_state_dict(torch.load('pretrained/netG_A.pth'))
netG_B.load_state_dict(torch.load('pretrained/netG_B.pth'))
netD_A.load_state_dict(torch.load('pretrained/netD_A.pth'))
netD_B.load_state_dict(torch.load('pretrained/netD_B.pth'))
# Define the loss functions
criterion_GAN = utils.GANLoss()
if opt.cuda:
criterion_GAN.cuda()
criterion_cycle = torch.nn.L1Loss()
# Alternatively, can try MSE cycle consistency loss
#criterion_cycle = torch.nn.MSELoss()
criterion_identity = torch.nn.L1Loss()
# Define the optimizers
optimizer_G = torch.optim.Adam(itertools.chain(netG_A.parameters(),
netG_B.parameters()),
lr=opt.lr,
betas=(opt.beta1, 0.999))
optimizer_D_A = torch.optim.Adam(netD_A.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
optimizer_D_B = torch.optim.Adam(netD_B.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
# Create learning rate schedulers
lr_scheduler_G = torch.optim.lr_scheduler.LambdaLR(
optimizer_G,
lr_lambda=utils.Lambda_rule(opt.epoch, opt.n_epochs,
opt.n_epochs_decay).step)
lr_scheduler_D_A = torch.optim.lr_scheduler.LambdaLR(
optimizer_D_A,
lr_lambda=utils.Lambda_rule(opt.epoch, opt.n_epochs,
opt.n_epochs_decay).step)
lr_scheduler_D_B = torch.optim.lr_scheduler.LambdaLR(
optimizer_D_B,
lr_lambda=utils.Lambda_rule(opt.epoch, opt.n_epochs,
opt.n_epochs_decay).step)
Tensor = torch.cuda.FloatTensor if opt.cuda else torch.Tensor
input_A = Tensor(opt.batch_size, opt.input_nc, opt.sizeh, opt.sizew)
input_B = Tensor(opt.batch_size, opt.output_nc, opt.sizeh, opt.sizew)
# Define two image pools to store generated images
fake_A_pool = utils.ImagePool()
fake_B_pool = utils.ImagePool()
# Define the transform, and load the data
transform = transforms.Compose([
transforms.Resize((opt.sizeh, opt.sizew)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
])
dataloader = DataLoader(ImageDataset(opt.rootdir,
transform=transform,
mode='train'),
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.n_cpu)
# numpy arrays to store the loss of epoch
loss_G_array = np.zeros(opt.n_epochs + opt.n_epochs_decay)
loss_D_A_array = np.zeros(opt.n_epochs + opt.n_epochs_decay)
loss_D_B_array = np.zeros(opt.n_epochs + opt.n_epochs_decay)
# Training
for epoch in range(opt.epoch, opt.n_epochs + opt.n_epochs_decay):
start = time.strftime("%H:%M:%S")
print("current epoch :", epoch, " start time :", start)
# Empty list to store the loss of each mini-batch
loss_G_list = []
loss_D_A_list = []
loss_D_B_list = []
for i, batch in enumerate(dataloader):
if i % 50 == 1:
print("current step: ", i)
current = time.strftime("%H:%M:%S")
print("current time :", current)
print("last loss G:", loss_G_list[-1], "last loss D_A",
loss_D_A_list[-1], "last loss D_B", loss_D_B_list[-1])
real_A = input_A.copy_(batch['A'])
real_B = input_B.copy_(batch['B'])
# Train the generator
optimizer_G.zero_grad()
# Compute fake images and reconstructed images
fake_B = netG_A(real_A)
fake_A = netG_B(real_B)
if opt.identity_loss != 0:
same_B = netG_A(real_B)
same_A = netG_B(real_A)
# discriminators require no gradients when optimizing generators
utils.set_requires_grad([netD_A, netD_B], False)
# Identity loss
if opt.identity_loss != 0:
loss_identity_A = criterion_identity(
same_A, real_A) * opt.identity_loss
loss_identity_B = criterion_identity(
same_B, real_B) * opt.identity_loss
# GAN loss
prediction_fake_B = netD_B(fake_B)
loss_gan_B = criterion_GAN(prediction_fake_B, True)
prediction_fake_A = netD_A(fake_A)
loss_gan_A = criterion_GAN(prediction_fake_A, True)
# Cycle consistent loss
recA = netG_B(fake_B)
recB = netG_A(fake_A)
loss_cycle_A = criterion_cycle(recA, real_A) * opt.cycle_loss
loss_cycle_B = criterion_cycle(recB, real_B) * opt.cycle_loss
# total loss without the identity loss
loss_G = loss_gan_B + loss_gan_A + loss_cycle_A + loss_cycle_B
if opt.identity_loss != 0:
loss_G += loss_identity_A + loss_identity_B
loss_G_list.append(loss_G.item())
loss_G.backward()
optimizer_G.step()
# Train the discriminator
utils.set_requires_grad([netD_A, netD_B], True)
# Train the discriminator D_A
optimizer_D_A.zero_grad()
# real images
pred_real = netD_A(real_A)
loss_D_real = criterion_GAN(pred_real, True)
# fake images
fake_A = fake_A_pool.query(fake_A)
pred_fake = netD_A(fake_A.detach())
loss_D_fake = criterion_GAN(pred_fake, False)
#total loss
loss_D_A = (loss_D_real + loss_D_fake) * 0.5
loss_D_A_list.append(loss_D_A.item())
loss_D_A.backward()
optimizer_D_A.step()
# Train the discriminator D_B
optimizer_D_B.zero_grad()
# real images
pred_real = netD_B(real_B)
loss_D_real = criterion_GAN(pred_real, True)
# fake images
fake_B = fake_B_pool.query(fake_B)
pred_fake = netD_B(fake_B.detach())
loss_D_fake = criterion_GAN(pred_fake, False)
# total loss
loss_D_B = (loss_D_real + loss_D_fake) * 0.5
loss_D_B_list.append(loss_D_B.item())
loss_D_B.backward()
optimizer_D_B.step()
# Update the learning rate
lr_scheduler_G.step()
lr_scheduler_D_A.step()
lr_scheduler_D_B.step()
# Save models checkpoints
torch.save(netG_A.state_dict(), 'model/netG_A.pth')
torch.save(netG_B.state_dict(), 'model/netG_B.pth')
torch.save(netD_A.state_dict(), 'model/netD_A.pth')
torch.save(netD_B.state_dict(), 'model/netD_B.pth')
# Save other checkpoint information
checkpoint = {
'epoch': epoch,
'optimizer_G': optimizer_G.state_dict(),
'optimizer_D_A': optimizer_D_A.state_dict(),
'optimizer_D_B': optimizer_D_B.state_dict(),
'lr_scheduler_G': lr_scheduler_G.state_dict(),
'lr_scheduler_D_A': lr_scheduler_D_A.state_dict(),
'lr_scheduler_D_B': lr_scheduler_D_B.state_dict()
}
torch.save(checkpoint, 'model/checkpoint.pth')
# Update the numpy arrays that record the loss
loss_G_array[epoch] = sum(loss_G_list) / len(loss_G_list)
loss_D_A_array[epoch] = sum(loss_D_A_list) / len(loss_D_A_list)
loss_D_B_array[epoch] = sum(loss_D_B_list) / len(loss_D_B_list)
np.savetxt('model/loss_G.txt', loss_G_array)
np.savetxt('model/loss_D_A.txt', loss_D_A_array)
np.savetxt('model/loss_D_b.txt', loss_D_B_array)
if epoch % 10 == 9:
torch.save(netG_A.state_dict(),
'model/netG_A' + str(epoch) + '.pth')
torch.save(netG_B.state_dict(),
'model/netG_B' + str(epoch) + '.pth')
torch.save(netD_A.state_dict(),
'model/netD_A' + str(epoch) + '.pth')
torch.save(netD_B.state_dict(),
'model/netD_B' + str(epoch) + '.pth')
end = time.strftime("%H:%M:%S")
print("current epoch :", epoch, " end time :", end)
print("G loss :", loss_G_array[epoch], "D_A loss :",
loss_D_A_array[epoch], "D_B loss :", loss_D_B_array[epoch])
def __init__(self, opt):
"""Initialize the CycleGAN class.
Parameters:
opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
"""
self.opt = opt
self.isTrain = opt.isTrain
self.device = opt.device
self.model_save_dir = opt.model_dir
self.loss_names = []
self.model_names = []
self.optimizers = []
self.image_paths = []
self.epoch = 0
self.num_epochs = opt.nr_epochs
# specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>
self.loss_names = ['D_A', 'G_A', 'cycle_A', 'D_B', 'G_B', 'cycle_B']
# specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>
if self.isTrain:
self.model_names = ['G_A', 'G_B', 'D_A', 'D_B']
else: # during test time, only load Gs
self.model_names = ['G_A', 'G_B']
# define networks (both Generators and discriminators)
# The naming is different from those used in the paper.
# Code (vs. paper): G_A (G), G_B (F), D_A (D_Y), D_B (D_X)
self.netG_A = networks.Generator(opt.input_nc, opt.output_nc, opt.ngf,
opt.n_layers_G).to(self.device)
self.netG_B = networks.Generator(opt.output_nc, opt.input_nc, opt.ngf,
opt.n_layers_G).to(self.device)
if self.isTrain: # define discriminators
self.netD_A = networks.NLayerDiscriminator(
opt.output_nc, opt.ndf, opt.n_layers_D).to(self.device)
self.netD_B = networks.NLayerDiscriminator(
opt.input_nc, opt.ndf, opt.n_layers_D).to(self.device)
# self.netD_A = networks.define_D(opt.output_nc, opt.ndf, opt.netD,
# opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)
# self.netD_B = networks.define_D(opt.input_nc, opt.ndf, opt.netD,
# opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)
if self.isTrain:
self.fake_A_pool = networks.MotionPool(
opt.pool_size
) # create image buffer to store previously generated images
self.fake_B_pool = networks.MotionPool(
opt.pool_size
) # create image buffer to store previously generated images
# define loss functions
self.criterionGAN = networks.GANLoss(opt.gan_mode).to(
self.device) # define GAN loss.
self.criterionCycle = torch.nn.L1Loss()
# self.criterionIdt = torch.nn.L1Loss()
# initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
self.optimizer_G = torch.optim.Adam(itertools.chain(
self.netG_A.parameters(), self.netG_B.parameters()),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(
self.netD_A.parameters(), self.netD_B.parameters()),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizers.append(self.optimizer_G)
self.optimizers.append(self.optimizer_D)
self.schedulers = [
networks.get_scheduler(optimizer, opt)
for optimizer in self.optimizers
]
def __init__(self, conf):
# Acquire configuration
self.conf = conf
self.cur_iter = 0
self.max_iters = conf.max_iters
# Define input tensor
self.input_tensor = torch.FloatTensor(1, 3, conf.input_crop_size,
conf.input_crop_size).cuda()
self.real_example = torch.FloatTensor(1, 3, conf.output_crop_size,
conf.output_crop_size).cuda()
# Define networks
self.G = networks.Generator(conf.G_base_channels, conf.G_num_resblocks,
conf.G_num_downscales, conf.G_use_bias,
conf.G_skip)
self.D = networks.MultiScaleDiscriminator(conf.output_crop_size,
self.conf.D_max_num_scales,
self.conf.D_scale_factor,
self.conf.D_base_channels)
self.GAN_loss_layer = networks.GANLoss()
self.Reconstruct_loss = networks.WeightedMSELoss(use_L1=conf.use_L1)
self.RandCrop = networks.RandomCrop(
[conf.input_crop_size, conf.input_crop_size],
must_divide=conf.must_divide)
self.SwapCrops = networks.SwapCrops(conf.crop_swap_min_size,
conf.crop_swap_max_size)
# Make all networks run on GPU
self.G.cuda()
self.D.cuda()
self.GAN_loss_layer.cuda()
self.Reconstruct_loss.cuda()
self.RandCrop.cuda()
self.SwapCrops.cuda()
# Define loss function
self.criterionGAN = self.GAN_loss_layer.forward
self.criterionReconstruction = self.Reconstruct_loss.forward
# Keeping track of losses- prepare tensors
self.losses_G_gan = torch.FloatTensor(conf.print_freq).cuda()
self.losses_D_real = torch.FloatTensor(conf.print_freq).cuda()
self.losses_D_fake = torch.FloatTensor(conf.print_freq).cuda()
self.losses_G_reconstruct = torch.FloatTensor(conf.print_freq).cuda()
if self.conf.reconstruct_loss_stop_iter > 0:
self.losses_D_reconstruct = torch.FloatTensor(
conf.print_freq).cuda()
# Initialize networks
self.G.apply(networks.weights_init)
self.D.apply(networks.weights_init)
# Initialize optimizers
self.optimizer_G = torch.optim.Adam(self.G.parameters(),
lr=conf.g_lr,
betas=(conf.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(self.D.parameters(),
lr=conf.d_lr,
betas=(conf.beta1, 0.999))
# Learning rate scheduler
# First define linearly decaying functions (decay starts at a special iter)
start_decay = conf.lr_start_decay_iter
end_decay = conf.max_iters
# def lr_function(n_iter):
# return 1 - max(0, 1.0 * (n_iter - start_decay) / (conf.max_iters - start_decay))
lr_function = LRPolicy(start_decay, end_decay)
# Define learning rate schedulers
self.lr_scheduler_G = torch.optim.lr_scheduler.LambdaLR(
self.optimizer_G, lr_function)
self.lr_scheduler_D = torch.optim.lr_scheduler.LambdaLR(
self.optimizer_D, lr_function)
def main():
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
if torch.backends.cudnn.enabled:
torch.backends.cudnn.benchmark = True
prepare_result()
make_edge_promoting_img()
# data_loader
landscape_dataloader = CreateTrainDataLoader(args, "landscape")
anime_dataloader = CreateTrainDataLoader(args, "anime")
landscape_test_dataloader = CreateTestDataLoader(args, "landscape")
anime_test_dataloader = CreateTestDataLoader(args, "anime")
generator = networks.Generator(args.ngf)
if args.latest_generator_model != '':
if torch.cuda.is_available():
generator.load_state_dict(torch.load(args.latest_generator_model))
else:
# cpu mode
generator.load_state_dict(
torch.load(args.latest_generator_model,
map_location=lambda storage, loc: storage))
discriminator = networks.Discriminator(args.in_ndc, args.out_ndc, args.ndf)
if args.latest_discriminator_model != '':
if torch.cuda.is_available():
discriminator.load_state_dict(
torch.load(args.latest_discriminator_model))
else:
discriminator.load_state_dict(
torch.load(args.latest_discriminator_model,
map_location=lambda storage, loc: storage))
VGG = networks.VGG19(init_weights=args.vgg_model, feature_mode=True)
generator.to(device)
discriminator.to(device)
VGG.to(device)
generator.train()
discriminator.train()
VGG.eval()
G_optimizer = optim.Adam(generator.parameters(),
lr=args.lrG,
betas=(args.beta1, args.beta2))
D_optimizer = optim.Adam(discriminator.parameters(),
lr=args.lrD,
betas=(args.beta1, args.beta2))
# G_scheduler = optim.lr_scheduler.MultiStepLR(optimizer=G_optimizer, milestones=[args.train_epoch // 2, args.train_epoch // 4 * 3], gamma=0.1)
# D_scheduler = optim.lr_scheduler.MultiStepLR(optimizer=D_optimizer, milestones=[args.train_epoch // 2, args.train_epoch // 4 * 3], gamma=0.1)
print('---------- Networks initialized -------------')
utils.print_network(generator)
utils.print_network(discriminator)
utils.print_network(VGG)
print('-----------------------------------------------')
BCE_loss = nn.BCELoss().to(device)
Hinge_loss = nn.HingeEmbeddingLoss().to(device)
L1_loss = nn.L1Loss().to(device)
MSELoss = nn.MSELoss().to(device)
Adv_loss = BCE_loss
pre_train_hist = {}
pre_train_hist['Recon_loss'] = []
pre_train_hist['per_epoch_time'] = []
pre_train_hist['total_time'] = []
""" Pre-train reconstruction """
if args.latest_generator_model == '':
print('Pre-training start!')
start_time = time.time()
for epoch in range(args.pre_train_epoch):
epoch_start_time = time.time()
Recon_losses = []
for lcimg, lhimg, lsimg in landscape_dataloader:
lcimg, lhimg, lsimg = lcimg.to(device), lhimg.to(
device), lsimg.to(device)
# train generator G
G_optimizer.zero_grad()
x_feature = VGG((lcimg + 1) / 2)
mask = mask_gen()
hint = torch.cat((lhimg * mask, mask), 1)
gen_img = generator(lsimg, hint)
G_feature = VGG((gen_img + 1) / 2)
Recon_loss = 10 * L1_loss(G_feature, x_feature.detach())
Recon_losses.append(Recon_loss.item())
pre_train_hist['Recon_loss'].append(Recon_loss.item())
Recon_loss.backward()
G_optimizer.step()
per_epoch_time = time.time() - epoch_start_time
pre_train_hist['per_epoch_time'].append(per_epoch_time)
print('[%d/%d] - time: %.2f, Recon loss: %.3f' %
((epoch + 1), args.pre_train_epoch, per_epoch_time,
torch.mean(torch.FloatTensor(Recon_losses))))
# Save
if (epoch + 1) % 5 == 0:
with torch.no_grad():
generator.eval()
for n, (lcimg, lhimg,
lsimg) in enumerate(landscape_dataloader):
lcimg, lhimg, lsimg = lcimg.to(device), lhimg.to(
device), lsimg.to(device)
mask = mask_gen()
hint = torch.cat((lhimg * mask, mask), 1)
g_recon = generator(lsimg, hint)
result = torch.cat((lcimg[0], g_recon[0]), 2)
path = os.path.join(
args.name + '_results', 'Reconstruction',
args.name + '_train_recon_' + f'epoch_{epoch}_' +
str(n + 1) + '.png')
plt.imsave(
path,
(result.cpu().numpy().transpose(1, 2, 0) + 1) / 2)
if n == 4:
break
for n, (lcimg, lhimg,
lsimg) in enumerate(landscape_test_dataloader):
lcimg, lhimg, lsimg = lcimg.to(device), lhimg.to(
device), lsimg.to(device)
mask = mask_gen()
hint = torch.cat((lhimg * mask, mask), 1)
g_recon = generator(lsimg, hint)
result = torch.cat((lcimg[0], g_recon[0]), 2)
path = os.path.join(
args.name + '_results', 'Reconstruction',
args.name + '_test_recon_' + f'epoch_{epoch}_' +
str(n + 1) + '.png')
plt.imsave(
path,
(result.cpu().numpy().transpose(1, 2, 0) + 1) / 2)
if n == 4:
break
total_time = time.time() - start_time
pre_train_hist['total_time'].append(total_time)
with open(os.path.join(args.name + '_results', 'pre_train_hist.pkl'),
'wb') as f:
pickle.dump(pre_train_hist, f)
torch.save(
generator.state_dict(),
os.path.join(args.name + '_results', 'generator_pretrain.pkl'))
else:
print('Load the latest generator model, no need to pre-train')
train_hist = {}
train_hist['Disc_loss'] = []
train_hist['Gen_loss'] = []
train_hist['Con_loss'] = []
train_hist['per_epoch_time'] = []
train_hist['total_time'] = []
print('training start!')
start_time = time.time()
real = torch.ones(args.batch_size, 1, args.input_size // 4,
args.input_size // 4).to(device)
fake = torch.zeros(args.batch_size, 1, args.input_size // 4,
args.input_size // 4).to(device)
for epoch in range(args.train_epoch):
epoch_start_time = time.time()
generator.train()
Disc_losses = []
Gen_losses = []
Con_losses = []
for i, ((acimg, ac_smooth_img, _), (lcimg, lhimg, lsimg)) in enumerate(
zip(anime_dataloader, landscape_dataloader)):
acimg, ac_smooth_img, lcimg, lhimg, lsimg = acimg.to(
device), ac_smooth_img.to(device), lcimg.to(device), lhimg.to(
device), lsimg.to(device)
if i % args.n_dis == 0:
# train G
G_optimizer.zero_grad()
mask = mask_gen()
hint = torch.cat((lhimg * mask, mask), 1)
gen_img = generator(lsimg, hint)
D_fake = discriminator(gen_img)
D_fake_loss = Adv_loss(D_fake, real)
x_feature = VGG((lcimg + 1) / 2)
G_feature = VGG((gen_img + 1) / 2)
Con_loss = args.con_lambda * L1_loss(G_feature,
x_feature.detach())
Gen_loss = D_fake_loss + Con_loss
Gen_losses.append(D_fake_loss.item())
train_hist['Gen_loss'].append(D_fake_loss.item())
Con_losses.append(Con_loss.item())
train_hist['Con_loss'].append(Con_loss.item())
Gen_loss.backward()
G_optimizer.step()
# G_scheduler.step()
# train D
D_optimizer.zero_grad()
D_real = discriminator(acimg)
D_real_loss = Adv_loss(D_real, real) # Hinge Loss (?)
mask = mask_gen()
hint = torch.cat((lhimg * mask, mask), 1)
gen_img = generator(lsimg, hint)
D_fake = discriminator(gen_img)
D_fake_loss = Adv_loss(D_fake, fake)
D_edge = discriminator(ac_smooth_img)
D_edge_loss = Adv_loss(D_edge, fake)
Disc_loss = D_real_loss + D_fake_loss + D_edge_loss
# Disc_loss = D_real_loss + D_fake_loss
Disc_losses.append(Disc_loss.item())
train_hist['Disc_loss'].append(Disc_loss.item())
Disc_loss.backward()
D_optimizer.step()
# G_scheduler.step()
# D_scheduler.step()
per_epoch_time = time.time() - epoch_start_time
train_hist['per_epoch_time'].append(per_epoch_time)
print(
'[%d/%d] - time: %.2f, Disc loss: %.3f, Gen loss: %.3f, Con loss: %.3f'
% ((epoch + 1), args.train_epoch, per_epoch_time,
torch.mean(torch.FloatTensor(Disc_losses)),
torch.mean(torch.FloatTensor(Gen_losses)),
torch.mean(torch.FloatTensor(Con_losses))))
if epoch % 2 == 1 or epoch == args.train_epoch - 1:
with torch.no_grad():
generator.eval()
for n, (lcimg, lhimg,
lsimg) in enumerate(landscape_dataloader):
lcimg, lhimg, lsimg = lcimg.to(device), lhimg.to(
device), lsimg.to(device)
mask = mask_gen()
hint = torch.cat((lhimg * mask, mask), 1)
g_recon = generator(lsimg, hint)
result = torch.cat((lcimg[0], g_recon[0]), 2)
path = os.path.join(
args.name + '_results', 'Transfer',
str(epoch + 1) + '_epoch_' + args.name + '_train_' +
str(n + 1) + '.png')
plt.imsave(path,
(result.cpu().numpy().transpose(1, 2, 0) + 1) /
2)
if n == 4:
break
for n, (lcimg, lhimg,
lsimg) in enumerate(landscape_test_dataloader):
lcimg, lhimg, lsimg = lcimg.to(device), lhimg.to(
device), lsimg.to(device)
mask = mask_gen()
hint = torch.cat((lhimg * mask, mask), 1)
g_recon = generator(lsimg, hint)
result = torch.cat((lcimg[0], g_recon[0]), 2)
path = os.path.join(
args.name + '_results', 'Transfer',
str(epoch + 1) + '_epoch_' + args.name + '_test_' +
str(n + 1) + '.png')
plt.imsave(path,
(result.cpu().numpy().transpose(1, 2, 0) + 1) /
2)
if n == 4:
break
torch.save(
generator.state_dict(),
os.path.join(args.name + '_results',
'generator_latest.pkl'))
torch.save(
generator.state_dict(),
os.path.join(args.name + '_results',
'discriminator_latest.pkl'))
total_time = time.time() - start_time
train_hist['total_time'].append(total_time)
print("Avg one epoch time: %.2f, total %d epochs time: %.2f" %
(torch.mean(torch.FloatTensor(
train_hist['per_epoch_time'])), args.train_epoch, total_time))
print("Training finish!... save training results")
torch.save(generator.state_dict(),
os.path.join(args.name + '_results', 'generator_param.pkl'))
torch.save(discriminator.state_dict(),
os.path.join(args.name + '_results', 'discriminator_param.pkl'))
with open(os.path.join(args.name + '_results', 'train_hist.pkl'),
'wb') as f:
pickle.dump(train_hist, f)
def __init__(self, config):
super(PGGAN, self).__init__()
self.tf_record_dir = config.tf_record_dir
self.latent_size = config.latent_size
self.label_size = config.label_size
self.labels_exist = self.label_size > 0
self.dimensionality = config.dimensionality
self.num_channels = config.num_channels
self.learning_rate = config.lr
self.gpus = config.gpus
self.d_repeats = config.d_repeats
self.iters_per_transition = config.kiters_per_transition
self.iters_per_resolution = config.kiters_per_resolution
self.start_resolution = config.start_resolution
self.target_resolution = config.target_resolution
self.resolution_batch_size = config.resolution_batch_size
self.img_ext = config.img_ext
self.generator = networks.Generator(self.latent_size,
dimensionality=self.dimensionality,
num_channels=self.num_channels,
fmap_base=config.g_fmap_base)
self.discriminator = networks.Discriminator(
self.label_size,
dimensionality=self.dimensionality,
num_channels=self.num_channels,
fmap_base=config.d_fmap_base)
self.run_id = Path(config.run_id)
self.generated_dir = self.run_id.joinpath(config.generated_dir)
self.model_dir = self.run_id.joinpath(config.model_dir)
self.log_dir = self.run_id.joinpath(config.log_dir)
self.run_id.mkdir(exist_ok=True)
self.generated_dir.mkdir(exist_ok=True)
self.model_dir.mkdir(exist_ok=True)
self.train_summary_writer = tf.summary.create_file_writer(
str(self.log_dir))
current_resolution = 2
self.add_resolution()
while 2**current_resolution < self.start_resolution:
self.add_resolution()
current_resolution += 1
self.strategy = config.strategy
if self.strategy is not None:
with self.strategy.scope():
self.generator = networks.Generator(
self.latent_size,
dimensionality=self.dimensionality,
num_channels=self.num_channels,
fmap_base=config.g_fmap_base)
self.discriminator = networks.Discriminator(
self.label_size,
dimensionality=self.dimensionality,
num_channels=self.num_channels,
fmap_base=config.d_fmap_base)
current_resolution = 2
self.add_resolution()
while 2**current_resolution < self.start_resolution:
self.add_resolution()
current_resolution += 1
# get the datasets ready for iterations
test_dataset = get_data.TestDatasetFromFolder(opt.image_dir, test_patients, opt.num_cross, opt.num_source, opt.input_ch, opt.output_ch, \
opt.log_file, opt.height_image, opt.cross_ID, opt.test_target, transform=transforms.Compose([
transforms.ToTensor()
# , normalize
]))
test_loader = DataLoader(test_dataset, batch_size=opt.batch_size, num_workers=opt.workers)
print('length of test dataset: ', len(test_dataset))
netG = networks.Generator(opt).cuda()
# print('\nGenerator:\n', netG)
netD = networks.NLayerDiscriminator(opt).cuda()
# print('\nDiscriminator:\n', netD)
Conv3D = networks.Conv3DBlock(opt).cuda()
# print('\nConv3D blocks:\n', Conv3D)
print('\n\n\nUploading model...')
model_path = os.path.join(opt.chkpnt_dir, 'model_best.pth.tar')
if os.path.isfile(model_path):
utils.print_and_save_msg(f"=> loading Model '{model_path}'", opt.log_file)
checkpoint = torch.load(model_path)
netG.load_state_dict(checkpoint['Generator'])
# netD.load_state_dict(checkpoint['Discriminator'])
test_data = DatasetProcessing(TEST_DIR)
num_train, num_test = len(train_data) , len(test_data)
train_loader = DataLoader(train_data,batch_size = opt.batch_size, shuffle = True, num_workers = 4)
test_loader = DataLoader(test_data,batch_size = opt.batch_size, shuffle = False, num_workers = 1)
train_labels = LoadLabel(TRAIN_DIR)
train_labels_onehot = EncodingOnehot(train_labels, nclasses)
test_labels = LoadLabel(TEST_DIR)
test_labels_onehot = EncodingOnehot(test_labels, nclasses)
Y = train_labels_onehot
G = networks.Generator(opt.g_input_size,opt.g_hidden_size,opt.g_output_size)
H = networks.Hashnet(opt.h_input_size,opt.h_hidden_size,opt.bit)
# print(G)
# print(D)
# print(H)
G_dict = G.state_dict()
pretrained_dict = torch.load('./G2_models.pt')
pretrained_dict = pretrained_dict.state_dict()
pretrained_dict = {k : v for k, v in pretrained_dict.items() if k in G_dict}
G_dict.update(pretrained_dict)
G.load_state_dict(G_dict)
G.cuda()
def train(epochs, batch_size, input_dir, model_save_dir):
# Make an instance of the VGG class
vgg_model = VGG_MODEL(image_shape)
# Get High-Resolution(HR) [148,148,3] in this case and corresponding Low-Resolution(LR) images
x_train_lr, x_train_hr = utils.load_training_data(input_dir, [148, 148, 3])
#Based on the the batch size, get the total number of batches
batch_count = int(x_train_hr.shape[0] / batch_size)
#Get the downscaled image shape based on the downscale factor
image_shape_downscaled = utils.get_downscaled_shape(
image_shape, downscale_factor)
# Initialize the generator network with the input image shape as the downscaled image shape (shape of LR images)
generator = networks.Generator(input_shape=image_shape_downscaled)
# Initialize the discriminator with the input image shape as the original image shape (HR image shape)
discriminator = networks.Discriminator(image_shape)
# Get the optimizer to tweak parameters based on loss
optimizer = vgg_model.get_optimizer()
# Compile the three models - generator, discriminator and gan(comb of both gen and disc - this network will train generator and will not tweak discriminator)
generator.compile(loss=vgg_model.vgg_loss, optimizer=optimizer)
discriminator.compile(loss="binary_crossentropy", optimizer=optimizer)
gan = networks.GAN_Network(generator, discriminator,
image_shape_downscaled, optimizer,
vgg_model.vgg_loss)
# Run training for the number of epochs defined
for e in range(1, epochs + 1):
print('-' * 15, 'Epoch %d' % e, '-' * 15)
for _ in tqdm(range(batch_count)):
# Get the next batch of LR and HR images
image_batch_lr, image_batch_hr = utils.get_random_batch(
x_train_lr, x_train_hr, x_train_hr.shape[0], batch_size)
generated_images_sr = generator.predict(image_batch_lr)
print(generated_images_sr.shape)
real_data_Y = np.ones(
batch_size) - np.random.random_sample(batch_size) * 0.2
fake_data_Y = np.random.random_sample(batch_size) * 0.2
discriminator.trainable = True
print(real_data_Y.shape)
d_loss_real = discriminator.train_on_batch(image_batch_hr,
real_data_Y)
d_loss_fake = discriminator.train_on_batch(generated_images_sr,
fake_data_Y)
discriminator_loss = 0.5 * np.add(d_loss_fake, d_loss_real)
rand_nums = np.random.randint(0,
x_train_hr.shape[0],
size=batch_size)
image_batch_hr = x_train_hr[rand_nums]
image_batch_lr = x_train_lr[rand_nums]
gan_Y = np.ones(
batch_size) - np.random.random_sample(batch_size) * 0.2
discriminator.trainable = False
gan_loss = gan.train_on_batch(image_batch_lr,
[image_batch_hr, gan_Y])
print("discriminator_loss : %f" % discriminator_loss)
print("gan_loss :", gan_loss)
gan_loss = str(gan_loss)
if e % 50 == 0:
generator.save_weights(model_save_dir + 'gen_model%d.h5' % e)
discriminator.save_weights(model_save_dir + 'dis_model%d.h5' % e)
networks.save_model(gan)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import torch
import torch.nn as nn
import torch.utils.data as data
import matplotlib.pyplot as plt
import networks as net
import dataloader as dl
##### Generatorの動作チェック #####
G = net.Generator()
input_image = torch.randn(128, 128, 3)
input_image = input_image.view(1, 3, 128, 128)
fake_image = G(input_image)
print('fake image:', fake_image.shape)
##### Discriminatorの動作チェック #####
D = net.Discriminator()
d_out = D(fake_image)
print('Discriminator output',
nn.Sigmoid()(d_out).shape) # 出力にSigmoidをかけて[0, 1]に変換
##### Dataset, DataLoaderの動作チェック #####
train_img_A, train_img_B = dl.make_datapath_list(is_train=True)
# Datasetを作成
mean = (0.5, )
std = (0.5, )
train_dataset = dl.UnpairedDataset(train_img_A,
], 0)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
return mask.to(device)
outputPath = f"predict_results/{args.name}"
os.makedirs(outputPath + "/predicts", exist_ok=True)
os.makedirs(outputPath + "/lines", exist_ok=True)
os.makedirs(outputPath + "/originals", exist_ok=True)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
landscape_test_dataloader = CreateTestDataLoader(args, "landscape")
generator = networks.Generator(args.ngf)
if args.latest_generator_model != '':
if torch.cuda.is_available():
generator.load_state_dict(torch.load(args.latest_generator_model))
else:
# cpu mode
generator.load_state_dict(
torch.load(args.latest_generator_model,
map_location=lambda storage, loc: storage))
generator.to(device)
generator.eval()
i = 0
with torch.no_grad():
