def _init_model(self):
self._enc_model = models.Encoder(density=8, size=self._image_size,
latent_size=self._latent_size)
self._gen_model = models.Generator(density=8, size=self._image_size,
latent_size=self._latent_size)
self._dis_model = models.Discriminator(density=8, size=self._image_size)
self._enc_dis_model = models.Encoder(density=8, size=self._image_size,
latent_size=self._latent_size)
self._gen_dis_model = models.Generator(density=8, size=self._image_size,
latent_size=self._latent_size)
self._optimizer_enc = optimizers.Adam(alpha=0.0001, beta1=0.5)
self._optimizer_enc.setup(self._enc_model)
self._optimizer_enc.add_hook(chainer.optimizer.WeightDecay(0.00001))
self._optimizer_gen = optimizers.Adam(alpha=0.0001, beta1=0.5)
self._optimizer_gen.setup(self._gen_model)
self._optimizer_gen.add_hook(chainer.optimizer.WeightDecay(0.00001))
self._optimizer_enc_dis = optimizers.Adam(alpha=0.0001, beta1=0.5)
self._optimizer_enc_dis.setup(self._enc_dis_model)
self._optimizer_enc_dis.add_hook(chainer.optimizer.WeightDecay(0.00001))
self._optimizer_gen_dis = optimizers.Adam(alpha=0.0001, beta1=0.5)
self._optimizer_gen_dis.setup(self._gen_dis_model)
self._optimizer_gen_dis.add_hook(chainer.optimizer.WeightDecay(0.00001))
self._optimizer_dis = optimizers.Adam(alpha=0.0001, beta1=0.5)
self._optimizer_dis.setup(self._dis_model)
self._optimizer_dis.add_hook(chainer.optimizer.WeightDecay(0.00001))
self._enc_model.to_gpu(self._gpu) # send to main GPU
self._gen_model.to_gpu(self._gpu)
self._dis_model.to_gpu(self._gpu)
def test(dataset="datasets/horse2zebra", batch=1, imSize=128, inputChannels=3, outputChannels=3, cuda=False,
cpus=-1, genXtoY="minecraftday2night/weights/netXtoY.pth", genYtoX="minecraftday2night/weights/netYtoX.pth"):
print(dataset, batch, imSize, inputChannels, outputChannels, cuda, cpus, genXtoY, genYtoX)
if cpus <= 0:
global threads
threads = multiprocessing.cpu_count()
else:
threads = cpus
XtoY = models.Generator(inputChannels, outputChannels)
YtoX = models.Generator(inputChannels, outputChannels)
if cuda:
XtoY.cuda()
YtoX.cuda()
XtoY.load_state_dict(torch.load(genXtoY))
YtoX.load_state_dict(torch.load(genYtoX))
XtoY.eval()
YtoX.eval()
Tensor = torch.cuda.FloatTensor if cuda else torch.Tensor
input_x = Tensor(batch, inputChannels, imSize, imSize)
input_y = Tensor(batch, outputChannels, imSize, imSize)
transformList = [transforms.Resize(int(imSize), Image.ANTIALIAS),
transforms.CenterCrop(imSize),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
dataset = DataLoader(utils.LoadDataset(dataset, transformList=transformList, mode='test'),
batch_size=batch, shuffle=False, num_workers=threads)
if not os.path.exists('minecraftday2night/x'):
os.makedirs('minecraftday2night/x')
if not os.path.exists('minecraftday2night/y'):
os.makedirs('minecraftday2night/y')
for i, batch in enumerate(dataset):
currentBatch_x = Variable(input_x.copy_(batch['x']))
currentBatch_y = Variable(input_y.copy_(batch['y']))
# Generate minecraftday2night
fake_y = 0.5 * (XtoY(currentBatch_x).data + 1.0)
fake_x = 0.5 * (YtoX(currentBatch_y).data + 1.0)
save_image(fake_x, 'minecraftday2night/x/%04d.jpg' % (i + 1))
save_image(fake_y, 'minecraftday2night/y/%04d.jpg' % (i + 1))
sys.stdout.write('\rGenerated %04d of %04d' % (i + 1, len(dataset)))
sys.stdout.write('\n')
def _create_models(self) -> None:
cfg = self._config
device = self._device
self._generator = models.Generator(style_code_dim=cfg.style_code_dim, )
self._generator_ema = models.Generator(
style_code_dim=cfg.style_code_dim, )
self._generator_ema.load_state_dict(self._generator.state_dict())
self._mapping = models.Mapping(
latent_dim=cfg.mapper_latent_code_dim,
hidden_dim=cfg.mapper_hidden_dim,
out_dim=cfg.style_code_dim,
num_shared_layers=cfg.mapper_shared_layers,
num_heads=cfg.num_domains,
)
self._mapping_ema = models.Mapping(
latent_dim=cfg.mapper_latent_code_dim,
hidden_dim=cfg.mapper_hidden_dim,
out_dim=cfg.style_code_dim,
num_shared_layers=cfg.mapper_shared_layers,
num_heads=cfg.num_domains,
)
self._mapping_ema.load_state_dict(self._mapping.state_dict())
self._style_encoder = models.StyleEncoder(
style_code_dim=cfg.style_code_dim,
num_heads=cfg.num_domains,
)
self._style_encoder_ema = models.StyleEncoder(
style_code_dim=cfg.style_code_dim,
num_heads=cfg.num_domains,
)
self._style_encoder_ema.load_state_dict(
self._style_encoder.state_dict())
self._discriminator = models.Discriminator(num_heads=cfg.num_domains, )
self._generator.to(device)
self._generator_ema.eval().to(device)
self._mapping.to(device)
self._mapping_ema.eval().to(device)
self._style_encoder.to(device)
self._style_encoder_ema.eval().to(device)
self._discriminator.to(device)
def __init__(self, fine_tuning=True):
super(C_GAN, self).__init__()
self.G_A2B = models.Generator(3, 3)
self.G_B2A = models.Generator(3, 3)
self.D_A = models.Discriminator(3)
self.D_B = models.Discriminator(3)
self.G_A2B.apply(init_parameters)
self.G_A2B.apply(init_parameters)
self.D_A.apply(init_parameters)
self.D_B.apply(init_parameters)
self.fake_a_buffer = ReplayBuffer()
self.fake_b_buffer = ReplayBuffer()
def sampling(netG_path, out, size=10000):
"""
sampling a series of tokens squentially for molecule generation
Args:
netG_path (str): The file path of generator.
out (str): The file path of genrated molecules including SMILES, and its scores for each sample
size (int): The number of molecules required to be generated.
env (utils.Environment): The environment to provide the scores of all objectives for each sample
Returns:
smiles (List): A list of generated SMILES-based molecules
"""
batch_size = 250
samples = []
voc = utils.Voc(init_from_file="data/voc.txt")
netG = models.Generator(voc)
netG.load_state_dict(torch.load(netG_path))
batch = size // batch_size
mod = size % batch_size
for i in tqdm(range(batch + 1)):
if i == 0:
if mod == 0: continue
tokens = netG.sample(batch)
else:
tokens = netG.sample(batch_size)
smiles = [voc.decode(s) for s in tokens]
samples.extend(smiles)
return samples
def __init__(self, device, model, model_num_labels, image_nc, box_min,
box_max):
output_nc = image_nc
self.device = device
self.model_num_labels = model_num_labels
self.model = model
self.input_nc = image_nc
self.output_nc = output_nc
self.box_min = box_min
self.box_max = box_max
self.gen_input_nc = image_nc
self.netG = models.Generator(self.gen_input_nc, image_nc).to(device)
self.netDisc = models.Discriminator(image_nc).to(device)
# initialize all weights
self.netG.apply(weights_init)
self.netDisc.apply(weights_init)
# initialize optimizers
self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=0.001)
self.optimizer_D = torch.optim.Adam(self.netDisc.parameters(),
lr=0.001)
if not os.path.exists(models_path):
os.makedirs(models_path)
def training(is_lstm=True):
voc = utils.Voc(init_from_file="data/voc.txt")
if is_lstm:
netP_path = 'output/lstm_chembl'
netE_path = 'output/lstm_ligand'
else:
netP_path = 'output/gru_chembl'
netE_path = 'output/gru_ligand'
prior = models.Generator(voc, is_lstm=is_lstm)
if not os.path.exists(netP_path + '.pkg'):
df = pd.read_table()
chembl = df.read_table("data/chembl_corpus.txt").Token
chembl = torch.LongTensor(voc.encode([seq.split(' ') for seq in chembl]))
chembl = DataLoader(chembl, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
prior.fit(chembl, out=netP_path, epochs=50)
prior.load_state_dict(torch.load(netP_path + '.pkg'))
# explore = model.Generator(voc)
df = pd.read_table('data/ligand_corpus.txt').drop_duplicates('Smiles')
valid = df.sample(len(df) // 10).Token
train = df.drop(valid.index).Token
# explore.load_state_dict(torch.load(netP_path + '.pkg'))
train = torch.LongTensor(voc.encode([seq.split(' ') for seq in train]))
train = DataLoader(train, batch_size=BATCH_SIZE, shuffle=True)
valid = torch.LongTensor(voc.encode([seq.split(' ') for seq in valid]))
valid = DataLoader(TensorDataset(valid), batch_size=BATCH_SIZE, shuffle=True)
print('Fine tuning progress begins to be trained...')
prior.fit(train, loader_valid=valid, out=netE_path, epochs=1000, lr=lr)
print('Fine tuning progress training is finished...')
def __init__(self, hyperparameters):
super(FUNIT_Trainer, self).__init__()
self.generator = models.Generator()
self.discriminator = models.Discriminator(
hyperparameters['source_classes'])
self.gan_loss = nn.BCELoss(size_average=True, reduce=True)
# The paper was not clear about this loss, as it references VAE papers using BSE but uses L1 itself
self.content_reconstruction_loss = nn.L1Loss(size_average=True,
reduce=True)
# Same as content reconstruction loss: unclear
self.feature_matching_loss = nn.L1Loss(size_average=True, reduce=True)
lr = hyperparameters['lr']
# Setup the optimizers
beta1 = hyperparameters['beta1']
beta2 = hyperparameters['beta2']
dis_params = list(self.discriminator.parameters())
gen_params = list(self.generator.parameters())
self.dis_opt = torch.optim.Adam(
[p for p in dis_params if p.requires_grad],
lr=lr,
betas=(beta1, beta2),
weight_decay=hyperparameters['weight_decay'])
self.gen_opt = torch.optim.Adam(
[p for p in gen_params if p.requires_grad],
lr=lr,
betas=(beta1, beta2),
weight_decay=hyperparameters['weight_decay'])
def __init__(
self,
device,
model,
n_labels,
n_channels,
target,
lr,
l_inf_bound,
alpha,
beta,
gamma,
kappa,
c,
n_steps_D,
n_steps_G,
is_relativistic
):
self.device = device
self.n_labels = n_labels # number of labels of the target model
self.model = model # target model
self.target = target # target dataset name
self.lr = lr # learning rate
self.l_inf_bound = l_inf_bound # petrubation bound
self.alpha = alpha # weight for GAN loss
self.beta = beta # weight for hinge loss
self.gamma = gamma # weight for adv loss
self.kappa = kappa # Used in Adv loss
self.c = c # used in hinge_loss
self.n_steps_D = n_steps_D # number of steps to train the discriminator per batch
self.n_steps_G = n_steps_G # number of steps to train the generator per batch
self.is_relativistic = is_relativistic
self.G = models.Generator(n_channels, n_channels, target).to(device)
self.D = models.Discriminator(n_channels).to(device)
# initialize all weights
self.G.apply(init_weights)
self.D.apply(init_weights)
# initialize optimizers
self.optimizer_G = torch.optim.Adam(self.G.parameters(), lr=self.lr)
self.optimizer_D = torch.optim.Adam(self.D.parameters(), lr=self.lr)
# create model save path if it doesn't exist
if not os.path.exists(models_path):
os.makedirs(models_path)
# create loss plot save path if it doesn't exist
if not os.path.exists('{}{}/'.format(losses_path, target)):
os.makedirs('{}{}/'.format(losses_path, target))
def __init__(self, device, model, model_num_labels, image_nc, box_min,
box_max, eps, pgd_iter, models_path, out_path, model_name,
writer, E_lr, advG_lr, defG_lr):
output_nc = image_nc
self.device = device
self.model_num_labels = model_num_labels
self.model = model
self.input_nc = image_nc
self.output_nc = output_nc
self.box_min = box_min
self.box_max = box_max
self.eps = eps
self.pgd_iter = pgd_iter
self.models_path = models_path
self.out_path = out_path
self.model_name = model_name
self.writer = writer
self.E_lr = E_lr
self.advG_lr = advG_lr
self.defG_lr = defG_lr
self.en_input_nc = image_nc
self.E = models.Encoder(image_nc).to(device)
self.defG = models.Generator(adv=False).to(device)
self.advG = models.Generator(y_dim=model_num_labels,
adv=True).to(device)
self.pgd = PGD(self.model,
self.E,
self.defG,
self.device,
self.eps,
step_size=self.eps / 4)
# initialize all weights
self.E.apply(weights_init)
self.defG.apply(weights_init)
self.advG.apply(weights_init)
# initialize optimizers
self.optimizer_E = torch.optim.Adam(self.E.parameters(), lr=self.E_lr)
self.optimizer_defG = torch.optim.Adam(self.defG.parameters(),
lr=self.defG_lr)
self.optimizer_advG = torch.optim.Adam(self.advG.parameters(),
lr=self.advG_lr)
def main():
parser = argparse.ArgumentParser(description='Train WSISR on compressed TMA dataset')
parser.add_argument('--batch-size', default=32, type=int, help='Batch size')
parser.add_argument('--patch-size', default=224, type=int, help='Patch size')
parser.add_argument('--up-scale', default=5, type=float, help='Targeted upscale factor')
parser.add_argument('--num-workers', default=1, type=int, help='Number of workers')
parser.add_argument('--num-epochs', default=900, type=int, help='Number of epochs, more epochs are desired for GAN training')
parser.add_argument('--g-lr', default=0.0001, type=float, help='Learning rate of the generator')
parser.add_argument('--d-lr', default=0.00001, type=float, help='Learning rate of the descriminator')
parser.add_argument('--percep-weight', default=0.01, type=float, help='GAN loss weight')
parser.add_argument('--run-from', default=None, type=str, help='Load weights from a previous run, use folder name in [weights] folder')
parser.add_argument('--start-epoch', default=1, type=int, help='Starting epoch for the curriculum, start at 1/2 of the epochs to skip the curriculum')
parser.add_argument('--gan', default=1, type=int, help='Use GAN')
parser.add_argument('--num-critic', default=1, type=int, help='Interval of training the descriminator')
args = parser.parse_args()
warnings.filterwarnings('ignore')
device = torch.device('cuda:0')
tensor = torch.cuda.FloatTensor
data.generate_compress_csv()
valid_dataset = new_compress_curriculum(args, args.up_scale, 'valid')
generator = models.Generator()
generator.to(device);
discriminator = models.Discriminator()
discriminator.to(device);
criterionL = nn.L1Loss().cuda()
criterionMSE = nn.MSELoss().cuda()
optimizer_G = torch.optim.Adam(generator.parameters(), lr=args.g_lr)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=args.d_lr)
patch = (1, args.patch_size // 2 ** 4, args.patch_size // 2 ** 4)
if args.run_from is not None:
generator.load_state_dict(torch.load(os.path.join('weights', args.run_from, 'generator.pth')))
try:
discriminator.load_state_dict(torch.load(os.path.join('weights', args.run_from, 'discriminator.pth')))
except:
print('Discriminator weights not found!')
pass
optimizer_G = torch.optim.Adam(generator.parameters(), lr=args.g_lr)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=args.d_lr)
scheduler_G = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer_G, args.num_epochs, args.g_lr*0.05)
scheduler_D = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer_D, args.num_epochs, args.d_lr*0.05)
run = datetime.now().strftime("%Y-%m-%d--%H-%M-%S")
cur_length = int(0.5*args.num_epochs)
init_scale = 2**2
step_size = (2**args.up_scale-init_scale) / cur_length
for epoch in range(args.start_epoch, args.num_epochs):
factor = min(log2(init_scale+(epoch-1)*step_size), args.up_scale)
print('curriculum updated: {} '.format(factor))
train_dataset = new_compress_curriculum(args, factor, 'train', stc=True)
train(args, epoch, run, train_dataset, generator, discriminator, optimizer_G, optimizer_D, criterionL, criterionMSE, tensor, device, patch)
scheduler_G.step()
scheduler_D.step()
if epoch % 1 == 0:
fid, psnr = test(args, generator, data.compress_csv_path('valid'))
print_output(generator, valid_dataset, device)
print('\r>>>> PSNR: {}, FID: {}'.format(psnr, fid))
test(args, generator, data.compress_csv_path('valid'), stitching=True)
def init_models_res(opt):
# generator initialization:
netG = models.Generator(opt).to(opt.device)
netG.apply(models.weights_init)
# discriminator initialization:
netD = models.WDiscriminator_mask(opt).to(opt.device)
netD.apply(models.weights_init)
return netD, netG
def __init__(self, args):
self.gan_c = args.percep_weight
self.gan = args.gan
self.device = args.device
self.patch = (1, args.patch_size // 2 ** 4, args.patch_size // 2 ** 4)
self.dis_freq = args.dis_freq
self.num_epochs = args.num_epochs
self.patch_size = args.patch_size
self.batch_size = args.batch_size
self.dis_out_shape = (self.batch_size, 1, self.patch_size // 2 ** 4, self.patch_size // 2 ** 4)
self.num_workers = args.num_workers
self.up_scale = args.up_scale
self.generator = models.Generator()
self.generator.to(self.device)
self.discriminator = models.Discriminator()
self.discriminator.to(self.device)
self.tester = Tester(args, 'output')
self.optimizer_G = torch.optim.Adam(self.generator.parameters(), lr=args.g_lr)
self.optimizer_D = torch.optim.Adam(self.discriminator.parameters(), lr=args.d_lr)
self.criterionL = nn.L1Loss().to(self.device)
self.criterionMSE = nn.MSELoss().to(self.device)
self.scheduler_G = torch.optim.lr_scheduler.CosineAnnealingLR(self.optimizer_G, self.num_epochs,
args.g_lr * 0.05)
self.scheduler_D = torch.optim.lr_scheduler.CosineAnnealingLR(self.optimizer_D, self.num_epochs,
args.d_lr * 0.05)
self.weight_dir = os.path.join(args.dir, 'weights')
os.makedirs(self.weight_dir, exist_ok=True)
self.log_path = os.path.join(args.dir, 'logs')
os.makedirs(self.log_path, exist_ok=True)
if args.run_from is not None:
gen_path = os.path.join(self.weight_dir, 'generator_{}.pth'.format(args.run_from))
if os.path.exists(gen_path):
self.generator.load_state_dict(torch.load(gen_path))
else:
raise FileNotFoundError('Generator weights not found!')
dis_path = os.path.join(self.weight_dir, 'discriminator_{}.pth'.format(args.run_from))
if os.path.exists(dis_path):
self.generator.load_state_dict(torch.load(dis_path))
else:
print('Discriminator weights not found!')
pass
self.start_epoch = args.run_from + 1
else:
self.start_epoch = 0
# writing log for training
self.writer = SummaryWriter(self.log_path)
def init_model(self):
# Construct Generator / Discriminator NN
self.DiscA = models.Discriminator_5()
self.DiscB = models.Discriminator_5()
self.GenA = models.Generator(9) # Generator with 9 ResNets
self.GenB = models.Generator(9) # Generator with 9 ResNets
# Make CUDA tensors
if cuda_flag:
device = torch.device("cuda:0")
num_device = torch.cuda.device_count()
print("Number of devices: ", num_device)
self.DiscA = nn.DataParallel(
self.DiscA, device_ids=[i for i in range(num_device)])
self.DiscB = nn.DataParallel(
self.DiscB, device_ids=[i for i in range(num_device)])
self.GenA = nn.DataParallel(
self.GenA, device_ids=[i for i in range(num_device)])
self.GenB = nn.DataParallel(
self.GenB, device_ids=[i for i in range(num_device)])
print("Sending models to device")
self.DiscA = self.DiscA.to(device)
self.DiscB = self.DiscB.to(device)
self.GenA = self.GenA.to(device)
self.GenB = self.GenB.to(device)
# Optimizer
print("Optimizer init")
self.DiscA_opt = torch.optim.Adam(self.DiscA.parameters(),
lr=learning_rate,
betas=(beta1, beta2))
self.DiscB_opt = torch.optim.Adam(self.DiscB.parameters(),
lr=learning_rate,
betas=(beta1, beta2))
self.GenA_opt = torch.optim.Adam(self.GenA.parameters(),
lr=learning_rate,
betas=(beta1, beta2))
self.GenB_opt = torch.optim.Adam(self.GenB.parameters(),
lr=learning_rate,
betas=(beta1, beta2))
def __init__(self,opt):
self.opt = opt
self.wh = int(np.sqrt(opt.num_classes))
self.G = models.Generator(opt)
self.G.cuda()
self.latent = Get_Latent_Y(opt)
self.latent.get_latent()
filename = "%s_netG.pth"%args.e
self.G.load_state_dict(torch.load(filename))
if args.eval:
self.G.eval()
def __init__(self, dataloader, args):
self.dataloader = dataloader
self.args = args
self.kimgs = 0
self.res = 2
self.batchSize = {2: 128, 3: 128, 4: 128, 5: 64, 6: 32, 7: 16, 8: 8}
self.kticks = {2: 100, 3: 100, 4: 80, 5: 60, 6: 60, 7: 40, 8: 20}
self.device = torch.device("cuda:0")
# Forming output folders
self.out_imgs = os.path.join(args.outf, 'images')
self.out_checkpoints = os.path.join(args.outf, 'checkpoints')
utils.mkdirp(self.out_imgs)
utils.mkdirp(self.out_checkpoints)
# Defining networks and optimizers
self.netG = models.Generator()
self.netD = models.Discriminator()
print('Generator')
print(self.netG)
print('Discriminator')
print(self.netD)
# Weight initialization
self.netG.apply(utils.weights_init)
self.netD.apply(utils.weights_init)
# Defining loss criterions
self.criterion = nn.BCELoss()
self.netD.cuda()
self.netG.cuda()
self.criterion.cuda()
# Defining optimizers
self.optimizerD = optim.Adam(self.netD.parameters(),
lr=args.lr,
betas=(args.beta1, 0.999))
self.optimizerG = optim.Adam(self.netG.parameters(),
lr=args.lr,
betas=(args.beta1, 0.999))
# Other variables
self.real_label = 1
self.fake_label = 0
self.fixed_noise = torch.randn(8,
self.args.nz,
1,
1,
device=self.device)
def __init__(
self,
device,
model,
n_labels,
n_channels,
target,
lr,
l_inf_bound,
alpha,
beta,
gamma,
kappa,
c,
n_steps_D,
n_steps_G,
):
self.device = device
self.n_labels = n_labels
self.model = model
self.target = target
self.lr = lr
self.l_inf_bound = l_inf_bound
self.alpha = alpha
self.beta = beta
self.gamma = gamma
self.kappa = kappa
self.c = c
self.n_steps_D = n_steps_D
self.n_steps_G = n_steps_G
self.G = models.Generator(n_channels, n_channels, target).to(device)
self.D = models.Discriminator(n_channels).to(device)
# initialize all weights
self.G.apply(init_weights)
self.D.apply(init_weights)
# initialize optimizers
self.optimizer_G = torch.optim.Adam(self.G.parameters(), lr=self.lr)
self.optimizer_D = torch.optim.Adam(self.D.parameters(), lr=self.lr)
if not os.path.exists(models_path):
os.makedirs(models_path)
if not os.path.exists('{}{}/'.format(losses_path, target)):
os.makedirs('{}{}/'.format(losses_path, target))
def make_inference(model_name='Generator', checkpoint_path=None):
image_plotter = VisdomImagePlotter(env_name="test")
ngpu = 1
b_size = 128
device = torch.device("cuda:0" if (
torch.cuda.is_available() and ngpu > 0) else "cpu")
model = models.Generator(checkpoint_path=checkpoint_path)
model.to(device)
noise = torch.randn(b_size, model.nz, 1, 1, device=device)
with torch.no_grad():
fake = model(noise).detach().cpu()
image_plotter.plot(vutils.make_grid(fake, padding=2, normalize=True),
name="generator-output")
def init_models_res(opt):
# generator initialization:
netG = models.Generator(opt).to(opt.device)
netG.apply(models.weights_init)
if opt.netG != '':
netG.load_state_dict(torch.load(opt.netG))
# discriminator initialization:
netD = models.WDiscriminator(opt).to(opt.device)
netD.apply(models.weights_init)
if opt.netD != '':
netD.load_state_dict(torch.load(opt.netD))
return netD, netG
def __init__(self, opt):
self.opt = opt
self.G = models.Generator(opt)
self.D = models.Discriminator()
self.Lsloss = torch.nn.MSELoss()
self.optimizerG = torch.optim.Adam(self.G.parameters(), 1e-4,
(0, 0.999))
self.optimizerD = torch.optim.Adam(self.D.parameters(), 4e-4,
(0, 0.999))
self.d_losses = []
self.g_losses = []
self.G.cuda()
self.D.cuda()
self.G.apply(self.weights_init)
self.D.apply(self.weights_init)
self.latent_ebdy_generator = Get_Latent_Y(opt)
def main(): args = parse_args() config = Config(args) # 出力先の作成 os.makedirs(config.output_dir, exist_ok=True) # モデルの作成 model = models.generate_model(config.model) # 画像サイズの修正 img_orig = load_image(config.original_image, [config.width, config.height]) img_style = load_image(config.style_image, [config.width, config.height] if not config.no_resize_style else None) # 画像を生成 generator = models.Generator(model, img_orig, img_style, config) generator.generate(config)
def createModels(self):
"""
This function will create models and their optimizers
"""
self.gen = models.Generator().cuda()
self.disc = models.Discriminator().cuda()
self.gOptimizer = Adam(self.gen.parameters(),
lr=self.gLR,
betas=(0.0, 0.99))
self.dOptimizer = Adam(self.disc.parameters(),
lr=self.dLR,
betas=(0.0, 0.99))
print(
'Models Instantiated. # of trainable parameters Disc:%e; Gen:%e' %
(sum([np.prod([*p.size()]) for p in self.disc.parameters()]),
sum([np.prod([*p.size()]) for p in self.gen.parameters()])))
def __init__(self,opt):
self.opt = opt
self.G = models.Generator(opt)
self.D = models.Discriminator(opt)
self.Lsloss = torch.nn.MSELoss()
self.optimizerG = torch.optim.Adam(self.G.parameters(),opt.g_lr,opt.g_betas)
self.optimizerD = torch.optim.Adam(self.D.parameters(),opt.d_lr,opt.d_betas)
self.d_losses = []
self.wd_losses = []
self.g_losses = []
self.wg_losses = []
self.losses = {'d':[],'g':[],'wd':[],'wg':[]}
self.G.cuda()
self.D.cuda()
self.G.apply(self.weights_init)
self.D.apply(self.weights_init)
self.latent_ebdy_generator = Get_Latent_Y(opt)
self.generate_imgs_count = 0
if False:
self.G.share_memory()
self.processes = []
self.main_to_thread1 = mp.Queue(maxsize=1)
self.main_to_thread2 = mp.Queue(maxsize=1)
self.main_to_thread3 = mp.Queue(maxsize=1)
self.main_to_thread4 = mp.Queue(maxsize=1)
self.thread1_to_main = mp.Queue(maxsize=1)
self.thread2_to_main = mp.Queue(maxsize=1)
self.thread3_to_main = mp.Queue(maxsize=1)
self.thread4_to_main = mp.Queue(maxsize=1)
self.thread1_grad = mp.Queue(maxsize=1)
self.thread2_grad = mp.Queue(maxsize=1)
self.thread3_grad = mp.Queue(maxsize=1)
self.thread4_grad = mp.Queue(maxsize=1)
p1 = mp.Process(target=func,args=(self.G,self.main_to_thread1,self.thread1_to_main,self.thread1_grad,self.optimizerG))
p1.start()
self.processes.append(p1)
p2 = mp.Process(target=func,args=(self.G,self.main_to_thread2,self.thread2_to_main,self.thread2_grad,self.optimizerG))
p2.start()
self.processes.append(p2)
p3 = mp.Process(target=func,args=(self.G,self.main_to_thread3,self.thread3_to_main,self.thread3_grad,self.optimizerG))
p3.start()
self.processes.append(p3)
p4 = mp.Process(target=func,args=(self.G,self.main_to_thread4,self.thread4_to_main,self.thread4_grad,self.optimizerG))
p4.start()
self.processes.append(p4)
def inpaint(args):
dataset = datasets.RandomPatchDataset(args.test_data_dir,weighted_mask=True, window_size=args.window_size)
dataloader = DataLoader(dataset, batch_size=args.batch_size)
# Loading trained GAN model
saved_gan = torch.load(args.gan_path)
generator = models.Generator(args).cuda()
discriminator = models.Discriminator(args).cuda()
generator.load_state_dict(saved_gan["state_dict_G"])
discriminator.load_state_dict(saved_gan["state_dict_D"])
for i, (corrupted_images, original_images, masks, weighted_masks) in enumerate(dataloader):
corrupted_images, masks, weighted_masks = corrupted_images.cuda(), masks.cuda(), weighted_masks.cuda()
z_optimum = nn.Parameter(torch.FloatTensor(np.random.normal(0, 1, (corrupted_images.shape[0],args.latent_dim,))).cuda())
optimizer_inpaint = optim.Adam([z_optimum])
print("Starting backprop to input ...")
for epoch in range(args.optim_steps):
optimizer_inpaint.zero_grad()
generated_images = generator(z_optimum)
discriminator_opinion = discriminator(generated_images)
c_loss = context_loss(corrupted_images, generated_images, weighted_masks)
prior_loss = torch.sum(-torch.log(discriminator_opinion))
inpaint_loss = c_loss + args.prior_weight*prior_loss
inpaint_loss.backward()
optimizer_inpaint.step()
print("[Epoch: {}/{}] \t[Loss: \t[Context: {:.3f}] \t[Prior: {:.3f}] \t[Inpaint: {:.3f}]] \r".format(1+epoch, args.optim_steps, c_loss,
prior_loss, inpaint_loss),end="")
print("")
blended_images = posisson_blending(masks, generated_images.detach(), corrupted_images)
image_range = torch.min(corrupted_images), torch.max(corrupted_images)
save_image(corrupted_images, "../outputs/corrupted_{}.png".format(i), normalize=True, range=image_range, nrow=5)
save_image(generated_images, "../outputs/output_{}.png".format(i), normalize=True, range=image_range, nrow=5)
save_image(blended_images, "../outputs/blended_{}.png".format(i), normalize=True, range=image_range, nrow=5)
save_image(original_images, "../outputs/original_{}.png".format(i), normalize=True, range=image_range, nrow=5)
del z_optimum, optimizer_inpaint
def __init__(self, opt, num_classes, source_train_ds, source_test_ds,
target_train_ds, mean, std):
super().__init__(opt, num_classes, source_train_ds, source_test_ds)
self.target_train_ds = target_train_ds
self.mean = mean
self.std = std
# Defining networks and optimizers
self.generator = models.Generator(opt, num_classes)
self.discriminator = models.Discriminator(opt, num_classes)
# Weight initialization
self.generator.apply(utils.weights_init)
self.discriminator.apply(utils.weights_init)
# Defining loss criterions
self.criterion_c = nn.CrossEntropyLoss()
self.criterion_s = nn.BCELoss()
if opt.gpu >= 0:
self.discriminator.cuda()
self.generator.cuda()
self.criterion_c.cuda()
self.criterion_s.cuda()
# Defining optimizers
self.optimizer_discriminator = optim.Adam(
self.discriminator.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
self.optimizer_generator = optim.Adam(self.generator.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
# Other variables
self.real_label_val = 1
self.fake_label_val = 0
gen_input_nc = image_nc
# Define what device we are using
print("CUDA Available: ",torch.cuda.is_available())
device = torch.device("cuda" if (use_cuda and torch.cuda.is_available()) else "cpu")
# load the pretrained model
pretrained_model = "./MNIST_target_model.pth"
target_model = MNIST_target_net().to(device)
target_model.load_state_dict(torch.load(pretrained_model))
target_model.eval()
# load the generator of adversarial examples
pretrained_generator_path = './models/netG.pth.tar'
pretrained_G = models.Generator(gen_input_nc, image_nc).to(device)
pretrained_G.load_state_dict(torch.load(pretrained_generator_path))
pretrained_G.eval()
# test adversarial examples in MNIST training dataset
mnist_dataset = torchvision.datasets.MNIST('./dataset', train=True, transform=transforms.ToTensor(), download=True)
train_dataloader = DataLoader(mnist_dataset, batch_size=batch_size, shuffle=False, num_workers=1)
num_correct = 0
num_all = 0
for i, data in enumerate(train_dataloader, 0):
test_img, test_label = data
test_img, test_label = test_img.to(device), test_label.to(device)
perturbation = pretrained_G(test_img)
perturbation = torch.clamp(perturbation, -0.3, 0.3)
adv_img = perturbation + test_img
adv_img = torch.clamp(adv_img, 0, 1)
help='attributes to learn')
parser.add_argument('--img_size', dest='img_size', type=int, default=128)
parser.add_argument('--batch_size', dest='batch_size', type=int, default=1)
parser.add_argument('--experiment_name',
dest='experiment_name',
default='stgan_128')
args = parser.parse_args()
# model
atts = args.atts
n_att = len(atts)
img_size = args.img_size
batch_size = args.batch_size
experiment_name = args.experiment_name
Gen = models.Generator()
Dis = models.Discriminator(n_att)
Enc = models.Encoder()
Stu = models.Stu()
x = tf.ones(shape=[2, 128, 128, 3], dtype=tf.float32)
a = tf.ones(shape=[2, 13], dtype=tf.float32)
z = Enc(x)
z_stu = Stu(z, a)
x_fake = Gen(z_stu, a - a)
d, att = Dis(x)
lr = tf.Variable(initial_value=0., trainable=False)
g_opt = tf.optimizers.Adam(lr, beta_1=0., beta_2=0.99)
d_opt = tf.optimizers.Adam(lr, beta_1=0., beta_2=0.99)
eps = utils.sample_z_motion(16, dim_z_motion)
#store
fc_path = os.path.join(fc_path, 'eps.pth')
torch.save(eps, fc_path)
else:
fc_path = os.path.join(fc_path, 'eps.pth')
return torch.load(fc_path), fc_path
fc_dir = './fc_dir/'
## Initialize Generator, RNN, and latent codes
generator = models.Generator(ngpu, z_dim, ngf, ndf, nc)
generator = generator.cuda()
gru = models.GRU(dim_z_motion, 500, gpu=True)
gru.initWeight()
gru = gru.cuda()
z_c = utils.sample_z_content(dim_z_content)
## Start training
for ep in range(num_epoch):
#Random shuffle data_folder
np.random.shuffle(data_folders)
os.makedirs(os.path.join(args.output_dir, 'checkpoints'))
if not os.path.isdir(os.path.join(args.output_dir, 'samples')):
os.makedirs(os.path.join(args.output_dir, 'samples'))
# pickle to avoid encoding errors with json
with open(os.path.join(args.output_dir, 'charmap.pickle'), 'wb') as f:
pickle.dump(charmap, f)
with open(os.path.join(args.output_dir, 'inv_charmap.pickle'), 'wb') as f:
pickle.dump(inv_charmap, f)
real_inputs_discrete = tf.placeholder(tf.int32,
shape=[args.batch_size, args.seq_length])
real_inputs = tf.one_hot(real_inputs_discrete, len(charmap))
fake_inputs = models.Generator(args.batch_size, args.seq_length,
args.layer_dim, len(charmap))
fake_inputs_discrete = tf.argmax(fake_inputs,
fake_inputs.get_shape().ndims - 1)
disc_real = models.Discriminator(real_inputs, args.seq_length, args.layer_dim,
len(charmap))
disc_fake = models.Discriminator(fake_inputs, args.seq_length, args.layer_dim,
len(charmap))
disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real)
gen_cost = -tf.reduce_mean(disc_fake)
# WGAN lipschitz-penalty
alpha = tf.random_uniform(shape=[args.batch_size, 1, 1], minval=0., maxval=1.)
differences = fake_inputs - real_inputs
print(opt)
# gpuが使えるかどうか
cuda = True if torch.cuda.is_available() else False
print("GPUは使えますか？ (True/False) ----> ", cuda)
if cuda:
gpu_id = input('使用するGPUの番号を入れてください : ')
os.environ["CUDA_VISIBLE_DEVICES"] = gpu_id
device = torch.device('cuda:' + gpu_id if torch.cuda.is_available() else 'cpu')
# ネットワークのインスタンスを作成
# generator用のネットワークを作成
torch.manual_seed(opt.generator_seed)
generator = models.Generator(n_filter=opt.n_filter,
generator_kernel_size=opt.generator_kernel_size,
p=opt.p,
q=opt.q)
print(generator)
# discriminator用のネットワークを作成
torch.manual_seed(opt.discriminator_seed)
discriminator = models.Discriminator(
q=opt.q, discriminator_hidden_unit=opt.discriminator_hidden_unit)
print(discriminator)
# ニューラルネットを用いた非線形モデルによる人工データを作成
mseed = 0
n_unit1 = 16
n_unit2 = 16
sigma_ = 2
seed = 10
