def __init__(self,
startf=32,
maxf=256,
layer_count=3,
latent_size=128,
mapping_layers=5,
dlatent_avg_beta=None,
truncation_psi=None,
truncation_cutoff=None,
style_mixing_prob=None,
channels=3):
super(Model, self).__init__()
self.mapping = Mapping(num_layers=2 * layer_count,
latent_size=latent_size,
dlatent_size=latent_size,
mapping_fmaps=latent_size,
mapping_layers=mapping_layers)
self.generator = Generator(startf=startf,
layer_count=layer_count,
maxf=maxf,
latent_size=latent_size,
channels=channels)
self.dlatent_avg = DLatent(latent_size, self.mapping.num_layers)
self.latent_size = latent_size
self.dlatent_avg_beta = dlatent_avg_beta
self.truncation_psi = truncation_psi
self.style_mixing_prob = style_mixing_prob
self.truncation_cutoff = truncation_cutoff
def __init__(self, n_hidden):
self.n_hidden = n_hidden
self.gen = Generator(self.n_hidden)
if(random.randint(0,1) == 0):
chainer.serializers.load_npz('./gen_iter_41200.npz', self.gen)
else:
chainer.serializers.load_npz('./gen_iter_41100.npz', self.gen)
def train(args):
# setting for logging
if not os.path.exists(args.log):
os.mkdir(args.log)
logger = logging.getLogger()
logging.basicConfig(level=logging.INFO)
log_path = os.path.join(args.log, 'log')
file_handler = logging.FileHandler(log_path)
fmt = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
file_handler.setFormatter(fmt)
logger.addHandler(file_handler)
logger.info('Arguments...')
for arg, val in vars(args).items():
logger.info('{:>10} -----> {}'.format(arg, val))
x, y = gen_synthetic_data(DIM, DIM_EMB, NUM)
train_x, test_x, train_y, test_y = train_test_split(x, y, test_size=0.2)
valid_x, test_x, valid_y, test_y = train_test_split(test_x, test_y, test_size=0.5)
gen = Generator(DIM_EMB)
dis = Discriminator(DIM_EMB)
gen_opt = optimizers.Adam()
dis_opt = optimizers.Adam()
gen_opt.setup(gen)
dis_opt.setup(dis)
trainer = GANTrainer((gen, dis), (gen_opt, dis_opt), logger, (valid_x, valid_y), args.epoch)
trainer.fit(train_x, train_y)
def __init__(self, params):
# GPU
self.cuda = torch.cuda.is_available()
if self.cuda:
self.dtype = torch.cuda.FloatTensor
else:
self.dtype = torch.FloatTensor
# construct
if params.net == 'NF':
self.generator = GeneratorNF(params)
elif params.net == 'Res':
self.generator = ResGenerator(params)
elif params.net == 'MM':
self.generator = GeneratorMM(params)
else:
self.generator = Generator(params)
if self.cuda:
self.generator.cuda()
self.optimizer = torch.optim.Adam(self.generator.parameters(),
lr=params.lr,
betas=(params.beta1, params.beta2),
weight_decay=params.weight_decay)
self.scheduler = torch.optim.lr_scheduler.StepLR(
self.optimizer, step_size=params.step_size, gamma=params.step_size)
# training parameters
self.noise_dim = params.noise_dim
self.numIter = params.numIter
self.batch_size = params.batch_size
self.sigma = params.sigma
self.alpha_sup = params.alpha_sup
self.iter0 = 0
self.alpha = 0.1
# simulation parameters
self.user_define = params.user_define
if params.user_define:
self.n_database = params.n_database
else:
self.materials = params.materials
self.matdatabase = params.matdatabase
self.n_bot = params.n_bot.type(
self.dtype) # number of frequencies or 1
self.n_top = params.n_top.type(
self.dtype) # number of frequencies or 1
self.k = params.k.type(self.dtype) # number of frequencies
self.theta = params.theta.type(self.dtype) # number of angles
self.pol = params.pol # str of pol
self.target_reflection = params.target_reflection.type(self.dtype)
# 1 x number of frequencies x number of angles x (number of pol or 1)
# tranining history
self.loss_training = []
self.refractive_indices_training = []
self.thicknesses_training = []
def test_discriminate_fakevideo(self):
dis = Discriminator()
gen = Generator()
z = Variable(np.asarray(gen.make_noize(self.batchsize)))
self.assertEqual((self.batchsize, 100), z.shape)
x_fake = gen(z)
self.assertEqual(
(self.batchsize, 3, self.frame, self.height, self.width),
x_fake.shape)
y_fake = dis(x_fake)
self.assertEqual((self.batchsize, 1), y_fake.shape)
def generate(z, args):
gen = Generator()
npz.load_npz(args.gen, gen)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu()
if z is None:
z = gen.make_hidden(1)
with chainer.using_config('train', False):
x = gen(z)
x = x.data[0]
return x
def main():
gen = Generator(n_hidden=100)
chainer.backends.cuda.get_device_from_id(0).use()
serializers.load_npz("./result/gen_iter_25000.npz", gen)
gen.to_gpu() # Copy the model to the GPU
start = np.random.uniform(-1, 1, (100, 1, 1)).astype(np.float32)
end = np.random.uniform(-1, 1, (100, 1, 1)).astype(np.float32)
diff = end - start
for i in range(50):
arr = start + i * diff / 50
z = Variable(chainer.backends.cuda.to_gpu(arr.reshape(1, 100, 1, 1)))
with chainer.using_config('train', False):
x = gen(z)
x = chainer.backends.cuda.to_cpu(x.data)
x = np.asarray(np.clip(x * 255, 0.0, 255.0), dtype=np.uint8)
x = x.reshape(3, 96, 96).transpose(1, 2, 0)
Image.fromarray(x).save("./continuous/" + str(i) + ".png")
def main():
parser = argparse.ArgumentParser(description='Chainer example: DCGAN')
parser.add_argument('--label',
'-l',
type=int,
default=0,
help='Label to generate image')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output')
parser.add_argument('--model',
'-m',
default='result/gen.npz',
help='Snapshot of Generator')
parser.add_argument('--n_hidden',
'-n',
type=int,
default=100,
help='Number of hidden units (z)')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed of z at visualization stage')
args = parser.parse_args()
gen = Generator(n_hidden=args.n_hidden)
chainer.serializers.load_npz(args.model, gen)
if args.gpu >= 0:
gen.to_gpu(args.gpu)
np.random.seed(args.seed)
z = Variable(np.asarray(gen.make_hidden(1)))
with chainer.using_config('train', False):
x = gen(z, [args.label])[0]
x = np.asarray(np.clip(x.data * 255, 0.0, 255.0),
dtype=np.uint8).transpose(1, 2, 0)
path = os.path.join(args.out, '{}.png'.format(args.label))
Image.fromarray(x).save(path)
def test():
parser = argsparse.ArgumentParser()
parser.add_argument('--batch_size', type=int, default=1,
help='Batch Size')
parser.add_argument('--img_size', type=int, default=64,
help='Size of the image')
parser.add_argument('--z_dim', type=int, default=100,
help='Size of the latent variable')
parser.add_argument('--final_model', type=str, default='final_model',
help='Save INFO into logger after every x iterations')
parser.add_argument('--save_img', type=str, default='test',
help='Save predicted images')
parser.add_argument('--text_embed_dim', type=int, default=4800,
help='Size of the embeddding for the captions')
parser.add_argument('--text_reduced_dim', type=int, default=1024,
help='Reduced dimension of the caption encoding')
parser.add_argument('--text', type=str, help='Input text to be converted into image')
config = parser.parse_args()
if not os.path.exists(config.save_img):
os.makedirs('Data' + config.save_img)
start_time = time.time()
gen = Generator(batch_size=config.batch_size,
img_size=config.img_size,
z_dim=config.z_dim,
text_embed_dim=config.text_embed_dim,
text_reduced_dim=config.text_reduced_dim)
# Loading the trained model
G_path = os.path.join(config.final_model, '{}-G.pth'.format('final'))
gen.load_state_dict(torch.load(G_path))
# torch.load(gen.state_dict(), G_path)
gen.eval()
z = Variable(torch.randn(config.batch_size, config.z_dim)).cuda()
model = skipthoughts.load_model()
text_embed = skipthoughts.encode(model, config.text)
output_img = gen(text_embed, z)
save_image(output_img.cpu(), config.save_img, nrow=1, padding=0)
print ('Generated image save to {}'.format(config.save_img))
print ('Time taken for the task : {}'.format(time.time() - start_time))
def main():
gpu_id = 0
batchsize = 10
report_keys = ["loss_dis", "loss_gen"]
train_dataset = datasets.LabeledImageDataset(str(argv[1]))
train_iter = iterators.SerialIterator(train_dataset, batchsize)
models = []
generator = Generator()
discriminator = Discriminator()
opts = {}
opts["opt_gen"] = setup_adam_optimizer(generator)
opts["opt_dis"] = setup_adam_optimizer(discriminator)
models = [generator, discriminator]
chainer.cuda.get_device_from_id(gpu_id).use()
print("use gpu {}".format(gpu_id))
for m in models:
m.to_gpu()
updater_args = {
"iterator": {
'main': train_iter
},
"device": gpu_id,
"optimizer": opts,
"models": models
}
output = 'result'
display_interval = 20
evaluation_interval = 1000
max_iter = 10000
updater = Updater(**updater_args)
trainer = training.Trainer(updater, (max_iter, 'iteration'), out=output)
trainer.extend(
extensions.LogReport(keys=report_keys,
trigger=(display_interval, 'iteration')))
trainer.extend(extensions.PrintReport(report_keys),
trigger=(display_interval, 'iteration'))
trainer.extend(sample_generate(generator, output),
trigger=(evaluation_interval, 'iteration'),
priority=extension.PRIORITY_WRITER)
trainer.run()
def run_seq_gan():
config = Config()
n_samples = config.get('n_samples')
batch_size = config.get('batch_size')
gen_embedding_dim = config.get('gen_embedding_dim')
gen_hidden_dim = config.get('gen_hidden_dim')
dis_embedding_dim = config.get('dis_embedding_dim')
dis_hidden_dim = config.get('dis_hidden_dim')
dataset_features = config.get('dataset_features')
dataset_dtypes = config.get('dataset_dtypes')
generated_features = config.get('generated_features')
service_list = config.get('service_list')
protocol_service_dict = config.get('protocol_service_dict')
service_port_dict = config.get('service_port_dict')
file_path = config.get('file_path')
CUDA = torch.cuda.is_available()
dataset = Traffic_Dataset(file_path,
dataset_features,
dataset_dtypes,
generated_features,
batch_size=batch_size,
transform=build_input_indices)
vocab_dim = dataset.vocabulary_length
max_seq_len = dataset.max_seq_length
train_epochs = 100
g = Generator(gen_embedding_dim, gen_hidden_dim, vocab_dim, max_seq_len,
CUDA)
d = Discriminator(dis_embedding_dim, dis_hidden_dim, vocab_dim,
max_seq_len, CUDA)
if CUDA:
g.cuda()
d.cuda()
g_opt = optim.Adam(g.parameters())
d_opt = optim.Adagrad(d.parameters())
pre_training(g, d, g_opt, d_opt, dataset, n_samples, batch_size, CUDA)
training(g, d, g_opt, d_opt, dataset, train_epochs, n_samples, batch_size,
CUDA, service_list, protocol_service_dict, service_port_dict)
visualize(dataset_features, generated_features)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--model_path',
default='./progressive_growing_of_gans/Gs_chainer.npz')
args = parser.parse_args()
chainer.config.train = False
latent = np.random.randn(4, 512).astype(np.float32)
generator = Generator()
chainer.serializers.load_npz(args.model_path, generator)
with chainer.no_backprop_mode():
img = generator(latent)
print(img.shape)
# [-1, 1] -> [0, 255]
image = cuda.to_cpu(img.array) * 127.5 + 127.5
image = image.clip(0.0, 255.0).astype(np.float32)
utils.write_image(utils.tile_images(image, 2), 'out.png')
def __init__(self, opt):
self.opt = opt
self.global_step = opt.load_iter
self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
# define net class instance
self.G_net = Generator(opt).to(self.device)
self.D_net = Discriminator(opt).to(self.device)
if opt.load_model and opt.load_iter > 0:
self._load_pre_model(self.G_net, 'G')
self._load_pre_model(self.D_net, 'D')
# define objectives and optimizers
self.adv_loss = torch.mean # 这里的adv loss直接是真假结果的评分，真图越大越好，假图越小越好
# self.cls_loss = torch.nn.BCELoss() # ??????????? 有啥区别
self.cls_loss = F.binary_cross_entropy_with_logits
self.rec_loss = torch.mean
self.G_optimizer = torch.optim.Adam(self.G_net.parameters(), opt.G_lr, [opt.beta1, opt.beta2])
self.D_optimizer = torch.optim.Adam(self.D_net.parameters(), opt.D_lr, [opt.beta1, opt.beta2])
self.sample_gotten = False # 把它放在init里面，是因为它只随着类的调用初始化一次，是固定的sample
self.writer = TBVisualizer(opt)
def main():
parser = argparse.ArgumentParser(
description='Chainer: making music with DCGAN')
parser.add_argument('--iter',
'-i',
type=int,
default=1000,
help='which model we use')
args = parser.parse_args()
xp = cuda.cupy
gen = Generator(n_hidden=100, bottom_width=10, bottom_height=5)
serializers.load_npz('result/gen_iter_{}.npz'.format(args.iter), gen)
gen.to_gpu()
print_memory()
z = Variable(xp.asarray(gen.make_hidden(100)))
with chainer.using_config('train', False):
x = gen(z)
x = chainer.cuda.to_cpu(x.data)
arr = x2arr(x)
arr2midi(arr)
def __init__(self, args):
self.args = args
self.writer = SummaryWriter(args.output_dir)
self.iter_i = 1
# data
transform_list = [
transforms.Resize(args.imsize),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]
train_dataset = datasets.CIFAR10(
'./data',
train=True,
transform=transforms.Compose(transform_list),
download=True)
self.train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
num_workers=args.n_workers,
shuffle=True)
# network
self.G = Generator(args.nz, args.ngf, args.nc).to(args.device)
self.D = Discriminator(args.nc, args.ndf).to(args.device)
self.criterion = nn.BCELoss()
self.optimizer_G = optim.Adam(self.G.parameters(),
lr=args.lr,
betas=(args.beta1, args.beta2))
self.optimizer_D = optim.Adam(self.D.parameters(),
lr=args.lr,
betas=(args.beta1, args.beta2))
self.real_label = 1
self.fake_label = 0
self.fixed_z = torch.randn((args.batch_size, args.nz, 1, 1),
device=args.device)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--workers',
type=int,
help='number of data loading workers',
default=2)
parser.add_argument('--batch_size',
type=int,
default=50,
help='input batch size')
parser.add_argument('--nz',
type=int,
default=100,
help='size of the latent z vector')
parser.add_argument('--nch_g', type=int, default=64)
parser.add_argument('--nch_d', type=int, default=64)
parser.add_argument('--n_epoch',
type=int,
default=200,
help='number of epochs to train for')
parser.add_argument('--lr',
type=float,
default=0.0002,
help='learning rate, default=0.0002')
parser.add_argument('--beta1',
type=float,
default=0.5,
help='beta1 for adam. default=0.5')
parser.add_argument('--outf',
default='./result_lsgan',
help='folder to output images and model checkpoints')
opt = parser.parse_args()
print(opt)
try:
os.makedirs(opt.outf)
except OSError:
pass
# 乱数のシード（種）を固定
random.seed(0)
np.random.seed(0)
torch.manual_seed(0)
# STL-10のトレーニングデータセットとテストデータセットを読み込む
trainset = dset.STL10(root='./dataset/stl10_root',
download=True,
split='train+unlabeled',
transform=transforms.Compose([
transforms.RandomResizedCrop(64,
scale=(88 / 96,
1.0),
ratio=(1., 1.)),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.05,
contrast=0.05,
saturation=0.05,
hue=0.05),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5),
(0.5, 0.5, 0.5)),
])) # ラベルを使用しないのでラベルなしを混在した'train+unlabeled'を読み込む
testset = dset.STL10(root='./dataset/stl10_root',
download=True,
split='test',
transform=transforms.Compose([
transforms.RandomResizedCrop(64,
scale=(88 / 96, 1.0),
ratio=(1., 1.)),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.05,
contrast=0.05,
saturation=0.05,
hue=0.05),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5),
(0.5, 0.5, 0.5)),
]))
dataset = trainset + testset # STL-10のトレーニングデータセットとテストデータセットを合わせて訓練データとする
# 訓練データをセットしたデータローダーを作成する
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batch_size,
shuffle=True,
num_workers=int(opt.workers))
# 学習に使用するデバイスを得る。可能ならGPUを使用する
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('device:', device)
# 生成器G。ランダムベクトルから贋作画像を生成する
netG = Generator(nz=opt.nz, nch_g=opt.nch_g).to(device)
netG.apply(weights_init) # weights_init関数で初期化
print(netG)
# 識別器D。画像が、元画像か贋作画像かを識別する
netD = Discriminator(nch_d=opt.nch_d).to(device)
netD.apply(weights_init)
print(netD)
criterion = nn.MSELoss() # 損失関数は平均二乗誤差損失
# オプティマイザ−のセットアップ
optimizerD = optim.Adam(netD.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999),
weight_decay=1e-5) # 識別器D用
optimizerG = optim.Adam(netG.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999),
weight_decay=1e-5) # 生成器G用
fixed_noise = torch.randn(opt.batch_size, opt.nz, 1, 1,
device=device) # 確認用の固定したノイズ
# 学習のループ
for epoch in range(opt.n_epoch):
for itr, data in enumerate(dataloader):
real_image = data[0].to(device) # 元画像
sample_size = real_image.size(0) # 画像枚数
noise = torch.randn(sample_size, opt.nz, 1, 1,
device=device) # 正規分布からノイズを生成
real_target = torch.full((sample_size, ), 1.,
device=device) # 元画像に対する識別信号の目標値「1」
fake_target = torch.full((sample_size, ), 0.,
device=device) # 贋作画像に対する識別信号の目標値「0」
############################
# 識別器Dの更新
###########################
netD.zero_grad() # 勾配の初期化
output = netD(real_image) # 識別器Dで元画像に対する識別信号を出力
errD_real = criterion(output, real_target) # 元画像に対する識別信号の損失値
D_x = output.mean().item()
fake_image = netG(noise) # 生成器Gでノイズから贋作画像を生成
output = netD(fake_image.detach()) # 識別器Dで元画像に対する識別信号を出力
errD_fake = criterion(output, fake_target) # 贋作画像に対する識別信号の損失値
D_G_z1 = output.mean().item()
errD = errD_real + errD_fake # 識別器Dの全体の損失
errD.backward() # 誤差逆伝播
optimizerD.step() # Dのパラメーターを更新
############################
# 生成器Gの更新
###########################
netG.zero_grad() # 勾配の初期化
output = netD(fake_image) # 更新した識別器Dで改めて贋作画像に対する識別信号を出力
errG = criterion(
output, real_target) # 生成器Gの損失値。Dに贋作画像を元画像と誤認させたいため目標値は「1」
errG.backward() # 誤差逆伝播
D_G_z2 = output.mean().item()
optimizerG.step() # Gのパラメータを更新
print(
'[{}/{}][{}/{}] Loss_D: {:.3f} Loss_G: {:.3f} D(x): {:.3f} D(G(z)): {:.3f}/{:.3f}'
.format(epoch + 1, opt.n_epoch, itr + 1, len(dataloader),
errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))
if epoch == 0 and itr == 0: # 初回に元画像を保存する
vutils.save_image(real_image,
'{}/real_samples.png'.format(opt.outf),
normalize=True,
nrow=10)
############################
# 確認用画像の生成
############################
fake_image = netG(fixed_noise) # 1エポック終了ごとに確認用の贋作画像を生成する
vutils.save_image(fake_image.detach(),
'{}/fake_samples_epoch_{:03d}.png'.format(
opt.outf, epoch + 1),
normalize=True,
nrow=10)
############################
# モデルの保存
############################
if (epoch + 1) % 50 == 0: # 50エポックごとにモデルを保存する
torch.save(netG.state_dict(),
'{}/netG_epoch_{}.pth'.format(opt.outf, epoch + 1))
torch.save(netD.state_dict(),
'{}/netD_epoch_{}.pth'.format(opt.outf, epoch + 1))
def main():
parser = argparse.ArgumentParser(description='Train script')
parser.add_argument('--data_path',
type=str,
default="data/datasets/cifar10/train",
help='dataset directory path')
parser.add_argument('--class_name',
'-class',
type=str,
default='all_class',
help='class name (default: all_class(str))')
parser.add_argument('--num_workers',
type=int,
default=4,
help='number of parallel data loading processes')
parser.add_argument('--batchsize', '-b', type=int, default=16)
parser.add_argument('--max_iter', '-m', type=int, default=40000)
parser.add_argument('--gpu',
'-g',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--snapshot_interval',
type=int,
default=2500,
help='Interval of snapshot')
parser.add_argument('--evaluation_interval',
type=int,
default=5000,
help='Interval of evaluation')
parser.add_argument('--out_image_interval',
type=int,
default=1250,
help='Interval of evaluation')
parser.add_argument('--stage_interval',
type=int,
default=40000,
help='Interval of stage progress')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
parser.add_argument(
'--n_dis',
type=int,
default=1,
help='number of discriminator update per generator update')
parser.add_argument('--lam',
type=float,
default=10,
help='gradient penalty')
parser.add_argument('--gamma',
type=float,
default=750,
help='gradient penalty')
parser.add_argument('--pooling_comp',
type=float,
default=1.0,
help='compensation')
parser.add_argument('--pretrained_generator', type=str, default="")
parser.add_argument('--pretrained_discriminator', type=str, default="")
parser.add_argument('--initial_stage', type=float, default=0.0)
parser.add_argument('--generator_smoothing', type=float, default=0.999)
args = parser.parse_args()
record_setting(args.out)
report_keys = [
"stage", "loss_dis", "loss_gp", "loss_gen", "g", "inception_mean",
"inception_std", "FID"
]
max_iter = args.max_iter
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
generator = Generator()
generator_smooth = Generator()
discriminator = Discriminator(pooling_comp=args.pooling_comp)
# select GPU
if args.gpu >= 0:
generator.to_gpu()
generator_smooth.to_gpu()
discriminator.to_gpu()
print("use gpu {}".format(args.gpu))
if args.pretrained_generator != "":
chainer.serializers.load_npz(args.pretrained_generator, generator)
if args.pretrained_discriminator != "":
chainer.serializers.load_npz(args.pretrained_discriminator,
discriminator)
copy_param(generator_smooth, generator)
# Setup an optimizer
def make_optimizer(model, alpha=0.001, beta1=0.0, beta2=0.99):
optimizer = chainer.optimizers.Adam(alpha=alpha,
beta1=beta1,
beta2=beta2)
optimizer.setup(model)
# optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_gen = make_optimizer(generator)
opt_dis = make_optimizer(discriminator)
if args.class_name == 'all_class':
data_path = args.data_path
one_class_flag = False
else:
data_path = os.path.join(args.data_path, args.class_name)
one_class_flag = True
train_dataset = ImageDataset(data_path, one_class_flag=one_class_flag)
train_iter = chainer.iterators.MultiprocessIterator(
train_dataset, args.batchsize, n_processes=args.num_workers)
# Set up a trainer
updater = Updater(models=(generator, discriminator, generator_smooth),
iterator={'main': train_iter},
optimizer={
'opt_gen': opt_gen,
'opt_dis': opt_dis
},
device=args.gpu,
n_dis=args.n_dis,
lam=args.lam,
gamma=args.gamma,
smoothing=args.generator_smoothing,
initial_stage=args.initial_stage,
stage_interval=args.stage_interval)
trainer = training.Trainer(updater, (max_iter, 'iteration'), out=args.out)
trainer.extend(extensions.snapshot_object(
generator, 'generator_{.updater.iteration}.npz'),
trigger=(args.snapshot_interval, 'iteration'))
trainer.extend(extensions.snapshot_object(
generator_smooth, 'generator_smooth_{.updater.iteration}.npz'),
trigger=(args.snapshot_interval, 'iteration'))
trainer.extend(extensions.snapshot_object(
discriminator, 'discriminator_{.updater.iteration}.npz'),
trigger=(args.snapshot_interval, 'iteration'))
trainer.extend(
extensions.LogReport(keys=report_keys,
trigger=(args.display_interval, 'iteration')))
trainer.extend(extensions.PrintReport(report_keys),
trigger=(args.display_interval, 'iteration'))
trainer.extend(sample_generate(generator_smooth, args.out),
trigger=(args.out_image_interval, 'iteration'),
priority=extension.PRIORITY_WRITER)
trainer.extend(sample_generate_light(generator_smooth, args.out),
trigger=(args.evaluation_interval // 10, 'iteration'),
priority=extension.PRIORITY_WRITER)
trainer.extend(calc_inception(generator_smooth),
trigger=(args.evaluation_interval, 'iteration'),
priority=extension.PRIORITY_WRITER)
trainer.extend(calc_FID(generator_smooth),
trigger=(args.evaluation_interval, 'iteration'),
priority=extension.PRIORITY_WRITER)
trainer.extend(extensions.ProgressBar(update_interval=10))
# Run the training
trainer.run()
def run(self): ## train the network with jac
print('GLOnet can Start Here!!!!!!!!!!!!!!!!!!!!!!!!!!')
output_dir = 'E:\\LAB\\Project GLOnet-LumeircalAPI\\GLOnet-LumericalAPI\\results'
restore_from = None
json_path = os.path.join(output_dir, 'Params.json')
assert os.path.isfile(json_path), "No json file found at {}".format(
json_path)
params = utils.Params(json_path)
params.output_dir = output_dir
params.cuda = torch.cuda.is_available()
params.restore_from = restore_from
params.numIter = int(params.numIter)
params.noise_dims = int(params.noise_dims)
params.gkernlen = int(params.gkernlen)
params.step_size = int(params.step_size)
# make directory
os.makedirs(output_dir + '/outputs', exist_ok=True)
os.makedirs(output_dir + '/model', exist_ok=True)
os.makedirs(output_dir + '/figures/histogram', exist_ok=True)
os.makedirs(output_dir + '/figures/deviceSamples', exist_ok=True)
generator = Generator(params)
## save model
#torch.save(generator,output_dir+'/net.pth')
if params.cuda:
generator.cuda()
# Define the optimizer
optimizer = torch.optim.Adam(generator.parameters(),
lr=params.lr,
betas=(params.beta1, params.beta2))
# Define the scheduler
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=params.step_size,
gamma=params.gamma)
# Load model data
if restore_from is not None:
params.checkpoint = utils.load_checkpoint(restore_from, generator,
optimizer, scheduler)
logging.info('Model data loaded')
# Train the model and save
if params.numIter != 0:
logging.info('Start training')
train(generator,
optimizer,
scheduler,
params,
func=self.callable_fom,
jac=self.callable_jac,
callback=self.callback)
# Generate images and save
logging.info('Start generating devices')
evaluate(generator, func=self.callable_fom, numImgs=10, params=params)
return
def main():
parser = argparse.ArgumentParser(description='Chainer example: DCGAN')
parser.add_argument('--batchsize',
'-b',
type=int,
default=50,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=1000,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dataset',
'-i',
default='filelist.txt',
help='List file of image files.')
parser.add_argument('--dataset_root',
default='.',
help='Root directory to retrieve images from.')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--n_hidden',
'-n',
type=int,
default=100,
help='Number of hidden units (z)')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# n_hidden: {}'.format(args.n_hidden))
print('# epoch: {}'.format(args.epoch))
# Set up a neural network to train
gen = Generator(n_hidden=args.n_hidden)
dis = Discriminator()
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu() # Copy the model to the GPU
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001), 'hook_dec')
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
# Set up dataset
train = chainer.datasets.LabeledImageDataset(args.dataset,
root=args.dataset_root)
print('# data-size: {}'.format(len(train)))
print('# data-shape: {}'.format(train[0][0].shape))
print('')
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
# Set up a trainer
updater = GANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'gen/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(
extensions.PlotReport(['gen/loss', 'dis/loss'],
x_key='iteration',
trigger=display_interval))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, dis, 10, 10, args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
# Save generator model
if args.gpu >= 0:
gen.to_cpu()
chainer.serializers.save_npz(os.path.join(args.out, 'gen.npz'), gen)
def _init_model(self):
self.model_woman = Generator()
self.model_woman.load(opt.path + 'female.pth')
self.model_man = Generator()
self.model_man.load(opt.path + "male.pth")
parser = argparse.ArgumentParser(description='DCGAN trainer for ETL9')
parser.add_argument('--gpu', '-g', default=-1, type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--input', '-i', default=None, type=str,
help='input model file path without extension')
parser.add_argument('--output', '-o', required=True, type=str,
help='output model file path without extension')
parser.add_argument('--iter', default=100, type=int,
help='number of iteration')
parser.add_argument('--out_image_dir', default=None, type=str,
help='output directory to output images')
parser.add_argument('--dataset', '-d', default='dataset/etl9g.pkl', type=str,
help='dataset file path')
args = parser.parse_args()
gen_model = Generator()
optimizer_gen = optimizers.Adam(alpha=0.0002, beta1=0.5)
optimizer_gen.setup(gen_model)
optimizer_gen.add_hook(chainer.optimizer.WeightDecay(0.00001))
dis_model = Discriminator()
optimizer_dis = optimizers.Adam(alpha=0.0002, beta1=0.5)
optimizer_dis.setup(dis_model)
optimizer_dis.add_hook(chainer.optimizer.WeightDecay(0.00001))
if args.input != None:
serializers.load_hdf5(args.input + '.gen.model', gen_model)
serializers.load_hdf5(args.input + '.gen.state', optimizer_gen)
serializers.load_hdf5(args.input + '.dis.model', dis_model)
serializers.load_hdf5(args.input + '.dis.state', optimizer_dis)
if args.out_image_dir != None:
def __init__(self):
warnings.filterwarnings('ignore')
self.start_time = time()
self.args = get_args()
if self.args.checkpoint_dir_name:
dir_name = self.args.checkpoint_dir_name
else:
dir_name = datetime.datetime.now().strftime('%y%m%d%H%M%S')
self.path_to_dir = Path(__file__).resolve().parents[1]
self.path_to_dir = os.path.join(self.path_to_dir, *['log', dir_name])
os.makedirs(self.path_to_dir, exist_ok=True)
# tensorboard
path_to_tensorboard = os.path.join(self.path_to_dir, 'tensorboard')
os.makedirs(path_to_tensorboard, exist_ok=True)
self.writer = SummaryWriter(path_to_tensorboard)
# model saving
os.makedirs(os.path.join(self.path_to_dir, 'model'), exist_ok=True)
path_to_model = os.path.join(self.path_to_dir, *['model', 'model.tar'])
# csv
os.makedirs(os.path.join(self.path_to_dir, 'csv'), exist_ok=True)
self.path_to_results_csv = os.path.join(self.path_to_dir,
*['csv', 'results.csv'])
path_to_args_csv = os.path.join(self.path_to_dir, *['csv', 'args.csv'])
if not self.args.checkpoint_dir_name:
with open(path_to_args_csv, 'a') as f:
args_dict = vars(self.args)
param_writer = csv.DictWriter(f, list(args_dict.keys()))
param_writer.writeheader()
param_writer.writerow(args_dict)
# logging by hyperdash
if not self.args.no_hyperdash:
from hyperdash import Experiment
self.exp = Experiment('Generation task on ' + self.args.dataset +
' dataset with GAN')
for key in vars(self.args).keys():
exec("self.args.%s = self.exp.param('%s', self.args.%s)" %
(key, key, key))
else:
self.exp = None
self.dataloader = get_dataloader(self.args.dataset,
self.args.image_size,
self.args.batch_size)
sample_data = self.dataloader.__iter__().__next__()[0]
image_channels = sample_data.shape[1]
z = torch.randn(self.args.batch_size, self.args.z_dim)
self.sample_z = z.view(z.size(0), z.size(1), 1, 1)
self.Generator = Generator(self.args.z_dim, image_channels,
self.args.image_size)
self.Generator_optimizer = optim.Adam(self.Generator.parameters(),
lr=self.args.lr_Generator,
betas=(self.args.beta1,
self.args.beta2))
self.writer.add_graph(self.Generator, self.sample_z)
self.Generator.to(self.args.device)
self.Discriminator = Discriminator(image_channels,
self.args.image_size)
self.Discriminator_optimizer = optim.Adam(
self.Discriminator.parameters(),
lr=self.args.lr_Discriminator,
betas=(self.args.beta1, self.args.beta2))
self.writer.add_graph(self.Discriminator, sample_data)
self.Discriminator.to(self.args.device)
self.BCELoss = nn.BCELoss()
self.sample_z = self.sample_z.to(self.args.device)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batchsize', '-b', type=int, default=32,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--source', default='mnist')
parser.add_argument('--target', default='mnist_m')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--seed', type=int, default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--n_processes', type=int, default=16,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
gen = Generator(
n_hidden=params['gen']['n_hidden'],
n_resblock=params['gen']['n_resblock'],
n_ch=params['gen']['n_ch'], wscale=params['gaussian_wscale'],
res=params['res_image'], bn_eps=params['bn_eps'])
dis = Discriminator(
n_ch=params['dis']['n_ch'], wscale=params['gaussian_wscale'],
bn_eps=params['bn_eps'], dr_prob=params['dis']['dropout_prob'],
noise_sigma=params['dis']['noise_sigma']
)
cls = L.Classifier(DigitClassifier(n_class=params['n_class']))
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
cls.to_gpu()
p_opt = params['optimize']
# Setup an optimizer
def make_optimizer(model):
optimizer = chainer.optimizers.Adam(alpha=p_opt['base_lr'],
beta1=p_opt['beta1'])
optimizer.setup(model)
optimizer.add_hook(
chainer.optimizer.WeightDecay(p_opt['weight_decay']))
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
opt_cls = make_optimizer(cls)
def load_dataset(name, dtype='train'):
if name == 'mnist':
train, _ = chainer.datasets.get_mnist(withlabel=True, ndim=3)
dataset = TransformDataset(train, transform=gray2rgb)
return TransformDataset(dataset, transform=scale)
elif name == 'mnist_m':
dataset = get_mnist_m(dtype, withlabel=True)
return TransformDataset(dataset, transform=scale)
else:
raise NotImplementedError
source = load_dataset(args.source)
# from chainer.datasets import split_dataset
# source, _ = split_dataset(source, split_at=1000)
target_train = load_dataset(args.target, dtype='train')
source_iter = MultiprocessIterator(
source, args.batchsize, n_processes=args.n_processes)
target_train_iter = MultiprocessIterator(
target_train, args.batchsize, n_processes=args.n_processes)
# Set up a trainer
updater = PixelDAUpdater(
models=(gen, dis, cls),
iterator={'main': source_iter, 'target': target_train_iter},
optimizer={
'gen': opt_gen, 'dis': opt_dis, 'cls': opt_cls},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (1, 'epoch')
display_interval = (10, 'iteration')
for opt in [opt_gen, opt_cls, opt_dis]:
trainer.extend(
extensions.ExponentialShift('alpha', p_opt['alpha_decay_rate'],
optimizer=opt),
trigger=(p_opt['alpha_decay_steps'], 'iteration'))
trainer.extend(
extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'gen/loss', 'dis/loss', 'cls/loss',
'validation/main/accuracy'
]), trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
# Save two plot images to the result dir
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['gen/loss', 'dis/loss', 'cls/loss'],
'iteration', trigger=(100, 'iteration'),
file_name='loss.png'))
trainer.extend(
extensions.PlotReport(['validation/main/accuracy'],
'epoch', file_name='accuracy.png'))
# Dump examples of generated images for every epoch
trainer.extend(out_generated_image(source_iter, gen, args.gpu, args.out))
# Evaluate the model with the test dataset for each epoch
target_test = load_dataset(args.target, dtype='test')
target_test_iter = MultiprocessIterator(
target_test, args.batchsize, n_processes=args.n_processes,
repeat=False, shuffle=False)
trainer.extend(
extensions.Evaluator(target_test_iter, cls, device=args.gpu))
# Visualize computational graph for debug
# trainer.extend(extensions.dump_graph('gen/loss', out_name='gen.dot'))
# trainer.extend(extensions.dump_graph('dis/loss', out_name='dis.dot'))
# trainer.extend(extensions.dump_graph('cls/loss', out_name='cls.dot'))
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batchsize', '-b', type=int, default=50)
parser.add_argument('--epoch', '-e', type=int, default=1000)
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--out', '-o', default='')
parser.add_argument('--resume', '-r', default='')
parser.add_argument('--n_noise', '-n', type=int, default=100)
parser.add_argument('--seed', type=int, default=0)
parser.add_argument('--snapshot_interval', type=int, default=1000)
parser.add_argument('--display_interval', type=int, default=100)
args = parser.parse_args()
out_dir = 'result'
if args.out != '':
out_dir = '{}/{}'.format(out_dir, args.out)
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# n_hidden: {}'.format(args.n_noise))
print('# epoch: {}'.format(args.epoch))
print('# out: {}'.format(out_dir))
print('')
gen = Generator(n_noise=args.n_noise, n_class=10)
dis = Discriminator(n_class=10)
if args.gpu >= 0:
cuda.get_device_from_id(args.gpu)
gen.to_gpu()
dis.to_gpu()
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001), 'hook_dec')
return optimizer
gen_optimizer = make_optimizer(gen)
dis_optimizer = make_optimizer(dis)
train, _ = chainer.datasets.get_cifar10(withlabel=True)
transformer = lambda data: (gen.make_noise(), ) + data
train = chainer.datasets.TransformDataset(train, transformer)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
updater = CGANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': gen_optimizer,
'dis': dis_optimizer
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=out_dir)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'gen/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(
extensions.PlotReport(['gen/loss', 'dis/loss'],
x_key='iteration',
trigger=display_interval))
trainer.extend(extensions.ProgressBar(update_interval=10))
gen_func = lambda data: gen(data[0], data[1])
def data_func(gen):
def _data_func(index):
return (gen.make_noise(), index // 10)
return _data_func
trainer.extend(
GenerateImage(gen_func,
data_func(gen),
file_name='{}/{}'.format(
out_dir, 'preview/{.updater.iteration:0>8}.png'),
rows=10,
cols=10,
seed=800,
device=args.gpu,
trigger=snapshot_interval))
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--workers',
type=int,
help='number of data loading workers',
default=2)
parser.add_argument('--batch',
type=int,
default=50,
help='input batch size')
parser.add_argument('--nz',
type=int,
default=100,
help='size of the latent z vector')
parser.add_argument('--ng_ch', type=int, default=64)
parser.add_argument('--nd_ch', type=int, default=64)
parser.add_argument('--epoch',
type=int,
default=50,
help='number of epochs to train for')
parser.add_argument('--lr',
type=float,
default=0.0002,
help='learning rate, default=0.0002')
parser.add_argument('--beta1',
type=float,
default=0.5,
help='beta1 for adam. default=0.5')
parser.add_argument('--outf',
default='./result',
help='folder to output images and model checkpoints')
opt = parser.parse_args()
print(opt)
batch_size = opt.batch
epoch_size = opt.epoch
try:
os.makedirs(opt.outf)
except OSError:
pass
random.seed(0)
torch.manual_seed(0)
dataset = dset.SVHN(root='../svhn_root',
download=True,
transform=transforms.Compose([
transforms.Resize(64),
transforms.ColorJitter(brightness=0,
contrast=0,
saturation=0,
hue=0.5),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5),
(0.5, 0.5, 0.5)),
]))
dataloader = torch.utils.data.DataLoader(dataset[:50000],
batch_size=batch_size,
shuffle=True,
num_workers=int(opt.workers))
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('device:', device)
nz = int(opt.nz)
netG = Generator().to(device)
netG.apply(weights_init)
print(netG)
netD = Discriminator().to(device)
netD.apply(weights_init)
print(netD)
criterion = nn.MSELoss() # criterion = nn.BCELoss()
fixed_noise = torch.randn(batch_size, nz, 1, 1, device=device)
real_label = 1
fake_label = 0
# setup optimizer
optimizerD = optim.Adam(netD.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999),
weight_decay=1e-5)
optimizerG = optim.Adam(netG.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999),
weight_decay=1e-5)
for epoch in range(epoch_size):
for itr, data in enumerate(dataloader):
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
# train with real
netD.zero_grad()
real_image = data[0].to(device)
sample_size = real_image.size(0)
label = torch.full((sample_size, ), real_label, device=device)
output = netD(real_image)
errD_real = criterion(output, label)
errD_real.backward()
D_x = output.mean().item()
# train with fake
noise = torch.randn(sample_size, nz, 1, 1, device=device)
fake_image = netG(noise)
label.fill_(fake_label)
output = netD(fake_image.detach())
errD_fake = criterion(output, label)
errD_fake.backward()
D_G_z1 = output.mean().item()
errD = errD_real + errD_fake
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
output = netD(fake_image)
errG = criterion(output, label)
errG.backward()
D_G_z2 = output.mean().item()
optimizerG.step()
print(
'[{}/{}][{}/{}] Loss_D: {:.3f} Loss_G: {:.3f} D(x): {:.3f} D(G(z)): {:.3f}/{:.3f}'
.format(epoch + 1, opt.n_epoch, itr + 1, len(dataloader),
errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))
if epoch == 0 and itr == 0:
vutils.save_image(real_image,
'{}/real_samples.png'.format(opt.outf),
normalize=True,
nrow=10)
fake_image = netG(fixed_noise)
vutils.save_image(fake_image.detach(),
'{}/fake_samples_epoch_{:03d}.png'.format(
opt.outf, epoch + 1),
normalize=True,
nrow=10)
# do checkpointing
if (epoch + 1) % 100 == 0:
torch.save(netG.state_dict(),
'{}/netG_epoch_{}.pth'.format(opt.outf, epoch + 1))
torch.save(netD.state_dict(),
'{}/netD_epoch_{}.pth'.format(opt.outf, epoch + 1))
def main():
parser = argparse.ArgumentParser(description='DCGAN')
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=500,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dataset',
'-i',
default='',
help='Directory of image files.')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result image')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--gennum',
'-v',
default=10,
help='visualize image rows and columns number')
parser.add_argument('--n_hidden',
'-n',
type=int,
default=100,
help='Number of hidden units (z)')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# n_hidden: {}'.format(args.n_hidden))
print('# epoch: {}'.format(args.epoch))
print('')
#学習モデルの作成
gen = Generator(n_hidden=args.n_hidden)
dis = Discriminator()
if args.gpu >= 0:
#modelをGPU用に変換
chainer.cuda.get_device(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
#oputimizerのsetup
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001), 'hook_dec')
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
if args.dataset == '':
#データセットの読み込み defaultはcifar10
train, _ = chainer.datasets.get_cifar10(withlabel=False, scale=255.)
else:
all_files = os.listdir(args.dataset)
image_files = [f for f in all_files if ('png' in f or 'jpg' in f)]
print('{} contains {} image files'.format(args.dataset,
len(image_files)))
train = chainer.datasets\
.ImageDataset(paths=image_files, root=args.dataset)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
#trainerのセットアップ
updater = DCGANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.epoch}.npz'),
trigger=(100, 'epoch'))
trainer.extend(extensions.snapshot_object(gen,
'gen_iter_{.updater.epoch}.npz'),
trigger=(100, 'epoch'))
trainer.extend(extensions.snapshot_object(dis,
'dis_iter_{.updater.epoch}.npz'),
trigger=(100, 'epoch'))
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'gen/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, dis, int(args.gennum),
int(args.gennum), args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
#学習済みmodelの読み込み
chainer.serializers.load_npz(args.resume, trainer)
#学習の実行
trainer.run()
chainer.serializers.save_npz("genmodel{0}".format(args.datasets), trainer)
# [email protected] # # or create issues # ============================================================================= import sys import os import numpy as np import torch import torch.nn as nn import torchvision.utils as vutils import matplotlib.pyplot as plt from net import Generator device = torch.device("cuda:0" if ( torch.cuda.is_available() and ngpu > 0) else "cpu") netG = Generator().to(device) ## 载入模型权重 modelpath = sys.argv[1] savepath = sys.argv[2] netG.load_state_dict( torch.load(modelpath, map_location=lambda storage, loc: storage)) netG.eval() ## 设置推理模式，使得dropout和batchnorm等网络层在train和val模式间切换 torch.no_grad() ## 停止autograd模块的工作，以起到加速和节省显存 nz = 100 for i in range(0, 100): noise = torch.randn(64, nz, 1, 1, device=device) fake = netG(noise).detach().cpu() rows = vutils.make_grid(fake, padding=2, normalize=True) fig = plt.figure(figsize=(8, 8))
def main():
parser = argparse.ArgumentParser(description='Train GAN')
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dataset',
'-i',
default='data/celebA/',
help='Directory of image files.')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--snapshot_interval',
type=int,
default=10000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=1000,
help='Interval of displaying log to console')
parser.add_argument('--unrolling_steps', type=int, default=0)
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# batchsize: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
gen = Generator()
dis = Discriminator(unrolling_steps=args.unrolling_steps)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001), 'hook_dec')
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
# Setup a dataset
all_files = os.listdir(args.dataset)
image_files = [f for f in all_files if ('png' in f or 'jpg' in f)]
print('{} contains {} image files'.format(args.dataset, len(image_files)))
train = CelebADataset(paths=image_files, root=args.dataset)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
# Set up a trainer
updater = DCGANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(extensions.snapshot(
filename='snapshot_gan_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(
extensions.LogReport(trigger=display_interval,
log_name='train_gan.log'))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'gen/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(
extensions.PlotReport(['gen/loss', 'dis/loss'],
trigger=display_interval,
file_name='gan-loss.png'))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, dis, 10, 10, args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer example: DCGAN')
parser.add_argument('--batchsize',
'-b',
type=int,
default=50,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=1000,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dataset',
'-i',
default='',
help='Directory of image files. Default is cifar-10.')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--n_hidden',
'-n',
type=int,
default=100,
help='Number of hidden units (z)')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# n_hidden: {}'.format(args.n_hidden))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
gen = Generator(n_hidden=args.n_hidden)
dis = Discriminator()
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu() # Copy the model to the GPU
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(0.0001),
'hook_dec')
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
if args.dataset == '':
# Load the CIFAR10 dataset if args.dataset is not specified
train, _ = chainer.datasets.get_cifar10(withlabel=False, scale=255.)
else:
all_files = os.listdir(args.dataset)
image_files = [f for f in all_files if ('png' in f or 'jpg' in f)]
print('{} contains {} image files'.format(args.dataset,
len(image_files)))
train = chainer.datasets\
.ImageDataset(paths=image_files, root=args.dataset)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
# Set up a trainer
updater = DCGANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'gen/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, dis, 10, 10, args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
"""Embedding labels to one-hot form.
Args:
labels: (LongTensor) class labels, sized [N,].
num_classes: (int) number of classes.
Returns:
(tensor) encoded labels, sized [N, #classes].
"""
y = torch.eye(num_classes)
return y[labels]
# create the objects for loss function, two networks and for the two optimizers
adversarial_loss = torch.nn.BCELoss()
generator = Generator(latent=opt.latent, n_classes=opt.n_classes, num_filters=opt.num_filters, channels=opt.channels)
discriminator = Discriminator(channels=opt.channels, num_filters=opt.num_filters, n_classes=opt.n_classes)
optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.learning_rate, betas=(opt.beta_1, opt.beta_2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.learning_rate, betas=(opt.beta_1, opt.beta_2))
# put the nets on gpu
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
generator, discriminator = generator.to(device), discriminator.to(device)
print(generator)
# generator.apply(weights_init)
# discriminator.apply(weights_init)
# start training
current_epoch = 0
for epoch in range(opt.n_epochs):
for i, (inputs, labels) in enumerate(dataloader):