def main():
parser = argparse.ArgumentParser(
description='Test Cartoon avatar Gan model')
parser.add_argument('--model_root',
default='pretrained_model/',
help='Root directory for models')
parser.add_argument('--model_name', default='', help='Model G name')
parser.add_argument('--nz',
default=100,
type=int,
help='Size of generator input')
opt = parser.parse_args()
model_root = opt.model_root
model_name = opt.model_name
nz = opt.nz
netG = Generator()
netG.load_state_dict(torch.load(model_root + model_name))
z = torch.randn(1, nz, 1, 1, device=device)
fake = netG(z).detach().cpu()
image_sample = vutils.make_grid(fake, padding=2, normalize=True)
utils.save_image(image_sample, 'output/image_sample.png', padding=2)
def visualizeSingleBatch(fp_loader_test,
opt,
exp_folder,
batches_done,
batch_size=8):
print('Loading saved model ... \n{}'.format(
'./checkpoints/{}_{}.pth'.format(exp_folder, batches_done)))
generatorTest = Generator()
generatorTest.load_state_dict(
torch.load('./checkpoints/{}_{}.pth'.format(exp_folder, batches_done)))
generatorTest = generatorTest.eval()
generatorTest.cuda()
with torch.no_grad():
# Unpack batch
mks, nds, eds, nd_to_sample, ed_to_sample = next(iter(fp_loader_test))
real_mks = Variable(mks.type(Tensor))
given_nds = Variable(nds.type(Tensor))
given_eds = eds
# Select random nodes
ind_fixed_nodes, _ = selectNodesTypes(nd_to_sample, batch_size, nds)
# build input
state = {'masks': real_mks, 'fixed_nodes': ind_fixed_nodes}
z, given_masks_in, given_nds, given_eds = _init_input(graph, state)
z, given_masks_in, given_nds, given_eds = z.to(device), given_masks_in.to(device), \
given_nds.to(device), given_eds.to(device)
gen_mks = generator(z, given_masks_in, given_nds, given_eds)
# Generate a batch of images
gen_mks = generatorTest(z, given_masks_in, given_nds, given_eds)
# Generate image tensors
real_imgs_tensor = combine_images(real_mks, given_nds, given_eds, \
nd_to_sample, ed_to_sample)
fake_imgs_tensor = combine_images(gen_mks, given_nds, given_eds, \
nd_to_sample, ed_to_sample)
# Save images
save_image(real_imgs_tensor, "./exps/{}/{}_real.png".format(exp_folder, batches_done), \
nrow=12, normalize=False)
save_image(fake_imgs_tensor, "./exps/{}/{}_fake.png".format(exp_folder, batches_done), \
nrow=12, normalize=False)
return
foreign_dir = '/home/tlchen/GanTicket/'
print(args)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
quant = True if 'GS8' in args.base_model_str else False
subnet_model_path = os.path.join('subnet_structures_ticket', args.dataset,
args.task, args.base_model_str, 'pth')
## Networks
# G:
dim_lst_path = os.path.join(subnet_model_path, 'epoch%d_netG.npy' % 199)
netG = Generator(args.input_nc,
args.output_nc,
dim_lst=np.load(dim_lst_path),
quant=quant).cuda()
# D:
netD = Discriminator(args.input_nc).cuda()
## results_dir:
optimizer_str = 'adam_lr%s_wd%s' % (args.lr, args.wd)
loss_str = ''
results_dir = os.path.join('cp_finetune_results', args.dataset, args.task,
args.base_model_str,
'%s_%s' % (optimizer_str, loss_str))
img_dir = os.path.join(results_dir, 'img')
pth_dir = os.path.join(results_dir, 'pth')
create_dir(img_dir), create_dir(pth_dir)
# Optimizers
syn_feature = netG(syn_noise, syn_att)
return syn_feature, syn_label, syn_att
""""pre-train a classifier on seen classes"""
trc = utils.train_cla(data.train_feature, data.train_label, CLA, device=opts.device, )
trc.run(50, data.test_seen_feature, data.test_seen_label, save_path='./cla_model')
# load best classifier
pre_cla = torch.load("./cla_model/model.pt")
for p in pre_cla.parameters(): # set requires_grad to False
p.requires_grad = False
if(opts.GD == 1):
netG = Generator(opts).to(opts.device)
netD = Discriminator(opts).to(opts.device)
else:
netG = Generator1(opts).to(opts.device)
netD = Discriminator1(opts).to(opts.device)
# seen reconstructor
netRS = Reconstructor(opts).to(opts.device)
# unseen reconstructor
netRU = Reconstructor(opts).to(opts.device)
if opts.optimizer == "ADAM":
optimzerF = optim.Adam
else:
optimzerF = optim.RMSprop
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', type=str, default='horse2zebra', choices=['summer2winter_yosemite', 'horse2zebra', 'cityscapes'])
parser.add_argument('--task', type=str, default='A2B', choices=['A2B', 'B2A'])
parser.add_argument('--epoch', type=int, default=199)
parser.add_argument('--gpu', default='7')
parser.add_argument('--model_str')
args = parser.parse_args()
print(args)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
quant = True if 'GS8' in args.model_str else False
# load dense model:
g_path = os.path.join('results', args.dataset, args.task, args.model_str, 'pth',
'epoch%d_netG.pth' % args.epoch)
dense_model = Generator(input_nc, output_nc, quant=quant)
dense_model.load_state_dict(torch.load(g_path))
dense_model = nn.DataParallel(dense_model)
# measure_model(dense_model, 256, 256) # 54168.000000M
# get channel numbers:
dim_lst = []
for m in dense_model.modules():
if isinstance(m, nn.InstanceNorm2d) and m.weight is not None:
gamma = m.weight.data.cpu().numpy()
channel_num = np.sum(gamma!=0)
dim_lst.append(channel_num)
print(dim_lst)
# construct subnet:
help="path to the dataset")
parser.add_argument("--lambda_gp",
type=int,
default=10,
help="lambda for gradient penalty")
opt = parser.parse_args()
exp_folder = "{}_{}".format(opt.exp_folder, opt.target_set)
os.makedirs("./exps/" + exp_folder, exist_ok=True)
# Loss function
adversarial_loss = torch.nn.BCEWithLogitsLoss()
distance_loss = torch.nn.L1Loss()
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
if torch.cuda.is_available():
device = torch.device('cuda:0')
generator.to(device)
discriminator.to(device)
adversarial_loss.to(device)
# Visualize a single batch
def visualizeSingleBatch(fp_loader_test,
opt,
exp_folder,
batches_done,
batch_size=8):
print('Loading saved model ... \n{}'.format(
# Use third party images with 102 categories flowers.
BATCH_SIZE = 128
EPOCH = 7
INPUT_SIZE = 8189
BUFFER_SIZE = 8000
NUM_CLASSES = 102
iter_number = (int)(INPUT_SIZE / BATCH_SIZE) + 1
image_root = utils.download_images()
train_ds = utils.load_data(image_root)
train_ds = utils.prepare_train_ds(train_ds,
BATCH_SIZE,
BUFFER_SIZE,
image_size=128)
# Guild generator and discriminator model.
generator_net = Generator(dtype=flags.FLAGS.dtype)
generator_optimizer = tf.train.AdamOptimizer(
learning_rate=flags.FLAGS.learning_rate_generator,
beta1=flags.FLAGS.beta1,
beta2=flags.FLAGS.beta2)
discriminator_net = Discriminator(alpha=flags.FLAGS.alpha,
dtype=flags.FLAGS.dtype)
discriminator_optimizer = tf.train.AdamOptimizer(
learning_rate=flags.FLAGS.learning_rate_discriminator,
beta1=flags.FLAGS.beta1,
beta2=flags.FLAGS.beta2)
# Print the network structure to show that the model is well built.
generator_net.build(input_shape=(None, 128))
discriminator_net.build(input_shape=(None, 128, 128, 3))
def main():
parser = argparse.ArgumentParser(
description='Train Cartoon avatar Gan models')
parser.add_argument('--crop_size',
default=64,
type=int,
help='Training images crop size')
parser.add_argument('--num_epochs',
default=50,
type=int,
help='Train epoch number')
parser.add_argument('--data_root',
default='data/cartoon',
help='Root directory for dataset')
parser.add_argument('--worker',
default=2,
type=int,
help='Number of workers for dataloader')
parser.add_argument('--batch_size',
default=16,
type=int,
help='Batch size during training')
parser.add_argument('--channels',
default=3,
type=int,
help='Number of channels in the training images')
parser.add_argument('--nz',
default=100,
type=int,
help='Size of generator input')
parser.add_argument('--ngf',
default=64,
type=int,
help='Size of feature maps in generator')
parser.add_argument('--ndf',
default=64,
type=int,
help='Size of feature maps in descriminator')
parser.add_argument('--lr',
default=0.0002,
type=float,
help='Learning rate for optimizer')
parser.add_argument('--beta1',
default=0.5,
type=float,
help='Beta1 hyperparam for Adam optimizers')
parser.add_argument('--beta2',
default=0.999,
type=float,
help='Beta2 hyperparam for Adam optimizers')
parser.add_argument('--ngpu',
default=1,
type=int,
help='Number of GPUs , use 0 for CPU mode')
parser.add_argument(
'--latent_vector_num',
default=8,
type=int,
help=
'latent vectors that we will use to visualize , 8 means that it will visualize 8 images during training'
)
opt = parser.parse_args()
dataroot = opt.data_root
workers = opt.worker
batch_size = opt.batch_size
image_size = opt.crop_size
nc = opt.channels
nz = opt.nz
ngf = opt.ngf
ndf = opt.ndf
num_epochs = opt.num_epochs
lr = opt.lr
beta1 = opt.beta1
beta2 = opt.beta2
ngpu = opt.ngpu
latent_vector_num = opt.latent_vector_num
# Create the dataset
dataset = dset.ImageFolder(root=dataroot,
transform=transforms.Compose([
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5),
(0.5, 0.5, 0.5)),
]))
# Create the dataloader
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=True,
num_workers=workers)
# Decide which device we want to run on
device = torch.device("cuda:0" if (
torch.cuda.is_available() and ngpu > 0) else "cpu")
# Create the generator
netG = Generator(ngpu, nz, ngf, nc).to(device)
# Create the Discriminator
netD = Discriminator(ngpu, nc, ndf).to(device)
# Handle multi-gpu if desired
if (device.type == 'cuda') and (ngpu > 1):
netG = nn.DataParallel(netG, list(range(ngpu)))
netD = nn.DataParallel(netD, list(range(ngpu)))
# Apply the weights_init function to randomly initialize all weights
# to mean=0, stdev=0.2.
netG.apply(weights_init)
netD.apply(weights_init)
# Setup Adam optimizers for both G and D
optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
# Print models
print(netG)
print(netD)
# Initialize BCELoss function
criterion = nn.BCELoss()
# Create batch of latent vectors that we will use to visualize
fixed_noise = torch.randn(latent_vector_num, nz, 1, 1, device=device)
#real and fake labels during training
real_label = 1
fake_label = 0
# Lists to keep track of progress
img_list = []
G_losses = []
D_losses = []
iters = 0
print("Starting Training ...")
for epoch in range(num_epochs):
for i, data in enumerate(dataloader, 0):
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
## Train with all-real batch
netD.zero_grad()
# Format batch
real_cpu = data[0].to(device)
b_size = real_cpu.size(0)
label = torch.full((b_size, ), real_label, device=device)
# Forward pass real batch through D
output = netD(real_cpu).view(-1)
# Calculate loss on all-real batch
errD_real = criterion(output, label)
# Calculate gradients for D in backward pass
errD_real.backward()
D_x = output.mean().item()
## Train with all-fake batch
# Generate batch of latent vectors
noise = torch.randn(b_size, nz, 1, 1, device=device)
# Generate fake image batch with G
fake = netG(noise)
label.fill_(fake_label)
# Classify all fake batch with D
output = netD(fake.detach()).view(-1)
# Calculate D's loss on the all-fake batch
errD_fake = criterion(output, label)
# Calculate the gradients for this batch
errD_fake.backward()
D_G_z1 = output.mean().item()
# Add the gradients from the all-real and all-fake batches
errD = errD_real + errD_fake
# Update D
optimizerD.step()
############################
# (2) Update G network: maximize log(D(G(z)))
###########################
netG.zero_grad()
label.fill_(real_label)
# fake labels are real for generator cost
# Since we just updated D, perform another forward pass of all-fake batch through D
output = netD(fake).view(-1)
# Calculate G's loss based on this output
errG = criterion(output, label)
# Calculate gradients for G
errG.backward()
D_G_z2 = output.mean().item()
# Update G
optimizerG.step()
# Output training stats
if i % 50 == 0:
# Save model data
torch.save(netG.state_dict(),
'pretrained_model/netG_epoch_%d.pth' % (iters))
torch.save(netD.state_dict(),
'pretrained_model/netD_epoch_%d.pth' % (iters))
# Print training stats
print(
'[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
% (epoch, num_epochs, i, len(dataloader), errD.item(),
errG.item(), D_x, D_G_z1, D_G_z2))
# Save Losses for plotting later
G_losses.append(errG.item())
D_losses.append(errD.item())
# Check how the generator is doing by saving G's output on fixed_noise
if (iters % 650 == 0) or ((epoch == num_epochs - 1) and
(i == len(dataloader) - 1)):
with torch.no_grad():
fake = netG(fixed_noise).detach().cpu()
img_list.append(
vutils.make_grid(fake, padding=2, normalize=True))
iters += 1
# Display and Save samples GIF
fig = plt.figure(figsize=(8, 8))
plt.axis("off")
ims = [[plt.imshow(np.transpose(i, (1, 2, 0)), animated=True)]
for i in img_list]
ani = animation.ArtistAnimation(fig,
ims,
interval=1000,
repeat_delay=1000,
blit=True)
ani.save('output/samples.gif', writer='imagemagick', fps=100)
opt = parser.parse_args()
print(opt)
# PARAMS
target_set = 8
phase = 'eval'
checkpoint = './checkpoints/exp_debug_E_165000.pth'
PREFIX = "./"
IM_SIZE = 64
output_dir = "./dump"
# Create folder
os.makedirs(opt.exp_folder, exist_ok=True)
# Initialize generator and discriminator
model = Generator()
model.load_state_dict(torch.load(checkpoint), strict=False)
model = model.eval()
# Initialize variables
cuda = True if torch.cuda.is_available() else False
if cuda:
model.cuda()
rooms_path = '../'
# initialize dataset iterator
fp_dataset_test = FloorplanGraphDataset(rooms_path,
transforms.Normalize(mean=[0.5],
std=[0.5]),
target_set=target_set,
split=phase)
## results_dir:
method_str = ('GS8' if args.quant else 'GS32')
gamma_optimizer_str = 'sgd_mom%s_lrgamma%s' % (args.momentum, args.lrgamma)
W_optimizer_str = 'adam_lrw%s_wd%s' % (args.lrw, args.wd)
opt_str = 'e%d-b%d' % (args.epochs, args.batch_size)
loss_str = 'rho%s_beta%s_%s' % (args.rho, args.beta, args.lc)
results_dir = os.path.join(
'results', args.dataset, args.task, '%s_%s_%s_%s_%s' %
(method_str, loss_str, opt_str, gamma_optimizer_str, W_optimizer_str))
img_dir = os.path.join(results_dir, 'img')
pth_dir = os.path.join(results_dir, 'pth')
create_dir(img_dir), create_dir(pth_dir)
## Networks
# G:
netG = Generator(args.input_nc, args.output_nc, quant=args.quant).cuda()
# D:
netD = Discriminator(args.input_nc).cuda()
# param list:
parameters_G, parameters_D, parameters_gamma = [], [], []
for name, para in netG.named_parameters():
if 'weight' in name and para.ndimension() == 1:
parameters_gamma.append(para)
else:
parameters_G.append(para)
for name, para in netD.named_parameters():
# print(name, para.size(), para.ndimension())
parameters_D.append(para)
print('parameters_gamma:', len(parameters_gamma))
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', default='3')
parser.add_argument('--cpus', default=4)
parser.add_argument('--quant', action='store_true', help='enable quantization (for both activation and weight)')
args = parser.parse_args()
model_str = 'GS8v2_rho0.002_beta0.001_vgg_e200-b8_sgd_mom0.5_lrgamma0.1_adam_lrw1e-05_wd0.001'
gen_photo_root_dir = os.path.join(model_str, 'gen')
real_photo_root_dir = os.path.join('/home/haotao/PyTorch-CycleGAN/datasets/leftImg8bit/val')
label_root_dir = os.path.join('/home/haotao/PyTorch-CycleGAN/datasets/gtFine/val')
# network:
netG = Generator(3, 3, quant=args.quant).cuda()
g_path = os.path.join('results/cityscapes/B2A', model_str, 'pth/epoch199_netG.pth')
netG.load_state_dict(torch.load(g_path))
# generate photo from labels:
with torch.no_grad():
for city in os.listdir(real_photo_root_dir):
real_photo_dir = os.path.join(real_photo_root_dir, city)
print('real_photo_dir:', real_photo_dir)
for real_photo_file_name in os.listdir(real_photo_dir):
# print('realphoto_file_name:', real_photo_file_name)
seg_color_file_name = '{}_{}'.format(real_photo_file_name.split('_leftImg8bit')[0], 'gtFine_color.png')
# print('seg_color_file_name:', seg_color_file_name)
gen_photo_file_name = real_photo_file_name
# print('gen_photo_file_name:', gen_photo_file_name)
seg_color = Image.open(os.path.join(label_root_dir, city, seg_color_file_name)).convert('RGB').resize((256, 256))
## results_dir:
method_str = 'distill'
W_optimizer_str = 'adam_lrw%s_wd%s' % (args.lrw, args.wd)
opt_str = 'e%d-b%d' % (args.epochs, args.batch_size)
loss_str = 'alpha%s_beta%s_%s' % (args.alpha, args.beta, args.lc)
results_dir = os.path.join(
'distill_results', args.dataset, args.task,
'%s_%s_%s_%s' % (method_str, loss_str, opt_str, W_optimizer_str))
img_dir = os.path.join(results_dir, 'img')
pth_dir = os.path.join(results_dir, 'pth')
create_dir(img_dir), create_dir(pth_dir)
## Networks
# G:
netG = Generator(args.input_nc,
args.output_nc,
quant=args.quant,
alpha=args.alpha).cuda()
# D:
netD = Discriminator(args.input_nc).cuda()
# FLOPs for G:
netG.cpu()
count_ops = measure_model(netG, 256, 256)
print("#parameters: %s" % model_param_num(netG))
f = open(os.path.join(results_dir, 'model_size.txt'), 'a+')
f.write('count_ops: {:.6f}M'.format(count_ops / 1024. / 1024.))
f.write("#parameters: %s" % model_param_num(netG))
f.close()
netG.cuda()
# Optimizers:
choices=['ori', 'transconv', 'nearest', 'bilinear'],
help='which upsample method to use in generater')
opt = parser.parse_args()
print(opt)
random.seed(opt.seed)
torch.manual_seed(opt.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(opt.seed)
# Networks
if opt.upsample == 'ori':
netG_A2B = Generator_ori(opt.input_nc, opt.output_nc)
netG_B2A = Generator_ori(opt.output_nc, opt.input_nc)
else:
netG_A2B = Generator(opt.input_nc, opt.output_nc)
netG_B2A = Generator(opt.output_nc, opt.input_nc)
netD_A = Discriminator(opt.input_nc)
netD_B = Discriminator(opt.output_nc)
netG_A2B.cuda()
netG_B2A.cuda()
netD_A.cuda()
netD_B.cuda()
netG_A2B.apply(weights_init_normal)
netG_B2A.apply(weights_init_normal)
netD_A.apply(weights_init_normal)
netD_B.apply(weights_init_normal)
torch.save(netG_A2B.state_dict(),