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: DCGAN MNIST')
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=100,
help='Number of sweeps over the dataset to train')
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('--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')
parser.add_argument('--optimizer',
'-p',
type=str,
default='Adam',
help='optimizer')
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()
# z_1 = Variable(xp.asarray(gen.make_hidden(args.batchsize)))
#model = L.Classifier(MLP(args.unit, 10))
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
'''
こんなふうにargs.optimizerによって、選択出来る
if args.optimizer == 'AdaGrad':
optimizer = chainer.optimizers.AdaGrad()
elif args.optimizer == 'SGD':
optimizer = chainer.optimizers.SGD()
elif args.optimizer == 'MomentumSGD':
optimizer = chainer.optimizers.MomentumSGD()
elif args.optimizer == 'RMSprop':
optimizer = chainer.optimizers.RMSprop()
else:
optimizer = chainer.optimizers.Adam()
'''
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)
'''
下のコードで、ndim=3で３次元で保存.MNISTの訓練データとテストデータをこれで取ってくる.
trainとtest,どちらも画像データとそのラベルのペアからなるtuple_datasetの形になっている.
画像は1 * 28 * 28の3次元配列
ラベルは画像が数値の画像なので、その数値自体、つまり0から9の整数値.
またデータ数は60000データ、testは10000データ
画像は1 * 28 * 28 = 784の大きさなので、入力層の次元数は784.また出力層はラベルが0から9の10種類なので、10次元.
'''
# Load the MNIST dataset
train, _ = chainer.datasets.get_mnist(
withlabel=False, ndim=3, scale=255.) # ndim=3 : (ch,width,height)
train_iter = chainer.iterators.SerialIterator(train,
args.batchsize,
shuffle=False)
#test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False)
# Trainerを利用する場合、訓練データはtuple_datasetの形にする必要がある
# これでデータセットオブジェクト自体は準備完了.例えばtrain[i]などどするとi番目の(data, label)というタプルを返すリストと同様のものになっている.
# iterators.SerialIteratorを使うことで、epoch毎に自動でミニバッチを作り、データをminibatch毎に取り出すことができる.
# train, valid = split_dataset_random(train_val, 50000, seed = 0)
# train用(50000data)とvalid用(10000data)にこうして分けた後、何度も実行する際に異なる分け方になってしまわないよう、第３引数のseedを設定しておく.
# loss_func = DirectedGANUpdaterを追加してみた
# Set up a trainer
updater = DirectedGANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu,
loss_func=DirectedGANUpdater)
#updater = training.updaters.StandardUpdater(train_iter, optimizer, device = args.gpu, loss_func = model.get_loss_func())
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
'''
デフォルトでは、1epochごとにlogにlossやaccuracyが記録されるが、
1epoch時点で例えばかなりlossが減少しているな、という時、
こんなふうにすると：
trainer.extend(extensions.LogReport(trigger=(100, 'iteration')))
これで100iterationごとに記録される。
'''
epoch_interval = (1, 'epoch')
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.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
# テストデータを使ってモデルの評価を行う機能
# trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# test_iterを使ってepoch毎に評価している
# trainer.extend(extensions.dump_graph(root_name='main/loss', out_name="cg.dot"))
# ネットワークの形をグラフで表示できるようにdot形式で保存する. main/lossは答えとの差の大きさ.
# trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
# epochごとのtrainerの情報を保存する.それを読み込んで、途中から再開などができる.
trainer.extend(extensions.LogReport(trigger=display_interval))
# epochごとにlogをだす.
# trainer.extend(extensions.LogReport(logname = "log", trigger = (1, 'epoch'))) みたいに書く。
# trigger = (1, 'epoch')なら1epoch毎に出力される. trigger = (1, 'iteration')なら1iteration毎に出力される,
trainer.extend(extensions.PrintReport(
['epoch', 'iteration', 'gen/loss', 'dis/loss', 'reconstruction/loss']),
trigger=display_interval)
# logで出す情報を指定する. reconstruction/lossを追加して書いたが、gen/lossの代わりに書いてもいいかも.
# trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy']))
# main/lossは答えとの差の大きさ. main/accuracyは正解率.
# 損失関数の値をグラフにする機能
# trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], x_key='epoch', file_name='loss.png'))
# 正答率をグラフにする機能
# trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'], x_key='epoch', file_name='accuracy.png'))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, dis, 10, 10, args.seed, args.out),
trigger=epoch_interval)
if args.resume:
# Resume from a snapshot
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('--device', '-d', type=str, default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
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', type=str,
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=10000,
help='Interval of snapshot')
parser.add_argument('--display_interval', type=int, default=1000,
help='Interval of displaying log to console')
parser.add_argument('--use-pixelshuffler', action='store_true')
args = parser.parse_args()
if chainer.get_dtype() == np.float16:
warnings.warn(
'This example may cause NaN in FP16 mode.', RuntimeWarning)
device = chainer.get_device(args.device)
device.use()
print('Device: {}'.format(device))
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, use_pixelshuffler=args.use_pixelshuffler)
dis = Discriminator()
gen.to_device(device) # Copy the model to the device
dis.to_device(device)
# 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.)
elif args.dataset.endswith('h5'):
print('parsing as food-101 from kaggle')
train = h5py.File(args.dataset, 'r')['images'].value.astype(np.float32).transpose(0, 3, 1, 2)
elif args.dataset.endswith('npy'):
print('parsing as preprocessed npy')
train = np.load(args.dataset).astype(np.float32)
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 = chainer.datasets.TransformDataset(train, DataAugmentation())
# Setup an iterator
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
# Setup an updater
updater = DCGANUpdater(
models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen, 'dis': opt_dis},
device=device)
# Setup a trainer
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=1000))
trainer.extend(
out_generated_image(
gen, dis,
10, 10, args.seed, args.out),
trigger=snapshot_interval)
if args.resume is not None:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
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)
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()
def main():
import numpy as np
import argparse
# パーサーを作る
parser = argparse.ArgumentParser(
prog='train', # プログラム名
usage='train DCGAN to dish', # プログラムの利用方法
description='description', # 引数のヘルプの前に表示
epilog='end', # 引数のヘルプの後で表示
add_help=True, # -h/–help オプションの追加
)
# 引数の追加
parser.add_argument('-s', '--seed', help='seed', type=int, required=True)
parser.add_argument('-n',
'--number',
help='the number of experiments.',
type=int,
required=True)
parser.add_argument('--hidden',
help='the number of codes of Generator.',
type=int,
default=100)
parser.add_argument('-e',
'--epoch',
help='the number of epoch, defalut value is 300',
type=int,
default=300)
parser.add_argument('-bs',
'--batch_size',
help='batch size. defalut value is 128',
type=int,
default=128)
parser.add_argument('-g',
'--gpu',
help='specify gpu by this number. defalut value is 0',
choices=[0, 1],
type=int,
default=0)
parser.add_argument(
'-ks',
'--ksize',
help='specify ksize of generator by this number. any of following;'
' 4 or 6. defalut value is 6',
choices=[4, 6],
type=int,
default=6)
parser.add_argument(
'-dis',
'--discriminator',
help='specify discriminator by this number. any of following;'
' 0: original, 1: minibatch discriminatio, 2: feature matching, 3: GAP. defalut value is 3',
choices=[0, 1, 2, 3],
type=int,
default=3)
parser.add_argument(
'-ts',
'--tensor_shape',
help=
'specify Tensor shape by this numbers. first args denotes to B, seconds to C.'
' defalut value are B:32, C:8',
type=int,
default=[32, 8],
nargs=2)
parser.add_argument('-V',
'--version',
version='%(prog)s 1.0.0',
action='version',
default=False)
# 引数を解析する
args = parser.parse_args()
gpu = args.gpu
batch_size = args.batch_size
n_hidden = args.hidden
epoch = args.epoch
seed = args.seed
number = args.number # number of experiments
if args.ksize == 6:
pad = 2
else:
pad = 1
out = pathlib.Path("result_{0}".format(number))
if not out.exists():
out.mkdir()
out /= pathlib.Path("result_{0}_{1}".format(number, seed))
if not out.exists():
out.mkdir()
# 引数(ハイパーパラメータの設定)の書き出し
with open(out / "args.txt", "w") as f:
f.write(str(args))
print('GPU: {}'.format(gpu))
print('# Minibatch-size: {}'.format(batch_size))
print('# n_hidden: {}'.format(n_hidden))
print('# epoch: {}'.format(epoch))
print('# out: {}'.format(out))
print('# seed: {}'.format(seed))
print('# ksize: {}'.format(args.ksize))
print('# pad: {}'.format(pad))
# fix seed
np.random.seed(seed)
if chainer.backends.cuda.available:
chainer.backends.cuda.cupy.random.seed(seed)
# import discrimination & set up
# if args.discriminator == 0:
# print("# Original Discriminator")
# from discriminator import Discriminator
# from updater import DCGANUpdater
# dis = Discriminator()
if args.discriminator == 1:
print("# Discriminator applied Minibatch Discrimination")
print('# Tensor shape is A x {0} x {1}'.format(args.tensor_shape[0],
args.tensor_shape[1]))
from discriminator_md import Discriminator
from updater import DCGANUpdater
dis = Discriminator(B=args.tensor_shape[0], C=args.tensor_shape[1])
elif args.discriminator == 3:
print("# Discriminator applied GAP")
from discriminator import Discriminator
from updater import DCGANUpdater
dis = Discriminator()
"""
elif args.discriminator == 2:
print("# Discriminator applied matching")
from discriminator_fm import Discriminator
from updater_fm import DCGANUpdater
"""
print('')
# Set up a neural network to train
gen = Generator(n_hidden=n_hidden, ksize=args.ksize, pad=pad)
if gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(gpu).use()
gen.to_gpu() # Copy the model to the GPU
dis.to_gpu()
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
# Prepare Dataset
"""
paths = ["rsize_data_128", "test_rsize_data_128",
"unlabeled_rsize_data_128"] # resize data 128
"""
paths = ["center_crop_data_128"] # center ctop data
data_path = []
for path in paths:
data_dir = pathlib.Path(path)
abs_data_dir = data_dir.resolve()
print("data dir path:", abs_data_dir)
data_path += [path for path in abs_data_dir.glob("*.jpg")]
print("data length:", len(data_path))
data = ImageDataset(paths=data_path) # dtype=np.float32
train_iter = chainer.iterators.SerialIterator(data, batch_size)
# Set up a updater and trainer
updater = DCGANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=gpu)
trainer = training.Trainer(updater, (epoch, 'epoch'), out=out)
snapshot_interval = (10, 'epoch')
display_interval = (1, 'epoch')
# storage method is hdf5
trainer.extend(extensions.snapshot(
filename='snapshot_epoch_{.updater.epoch}.npz', savefun=save_npz),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(gen,
'gen_epoch_{.updater.epoch}.npz',
savefun=save_npz),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(dis,
'dis_epoch_{.updater.epoch}.npz',
savefun=save_npz),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'gen/loss', 'dis/loss', 'elapsed_time',
'dis/accuracy'
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(out_generated_image(gen, dis, 5, 5, seed, out),
trigger=display_interval)
trainer.extend(
extensions.PlotReport(['gen/loss', 'dis/loss'],
x_key='epoch',
file_name='loss_{0}_{1}.jpg'.format(
number, seed),
grid=False))
trainer.extend(extensions.dump_graph("gen/loss", out_name="gen.dot"))
trainer.extend(extensions.dump_graph("dis/loss", out_name="dis.dot"))
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='3d pose generator')
parser.add_argument('--batch_size',
'-b',
type=int,
default=16,
help='Number of images in each mini-batch')
parser.add_argument('--img_size', '-is', type=int, default=128)
parser.add_argument('--iteration',
'-i',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--snapshot_interval',
type=int,
default=50000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=10,
help='Interval of displaying log to console')
parser.add_argument('--visualize_interval',
type=int,
default=20,
help='Interval of visualizing')
parser.add_argument('--visualize_size',
type=int,
default=10,
help='Interval of visualizing')
parser.add_argument('--loss_type',
type=str,
default='dcgan',
choices=['dcgan', 'hinge', 'wgan', 'mse'])
parser.add_argument('--n_dis', type=int, default=5)
parser.add_argument('--dim_noise', type=int, default=3)
parser.add_argument('--dif_index', type=int, default=1)
parser.add_argument('--dataset',
type=str,
default='coil20',
choices=['mnist', 'coil20', 'coil100'])
args = parser.parse_args()
# Customized output directory
uid = str(uuid.uuid4())[:8]
if args.out == '':
config = Config()
config.add('batch_size', args.batch_size)
config.add('img_size', args.img_size)
config.add('iteration', args.iteration)
config.add('loss_type', args.loss_type)
config.add('dim_noise', args.dim_noise)
config.add('display_interval', args.display_interval)
config.add('snapshot_interval', args.snapshot_interval)
config.add('visualize_interval', args.visualize_interval)
config.add('visualize_size', args.visualize_size)
config.add('dif_index', args.dif_index)
config.add('n_dis', args.n_dis)
config.add('dataset', args.dataset)
args.out = 'result/{}'.format(uid)
os.makedirs(args.out)
config.save(os.path.join(args.out, 'config.yml'))
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batch_size))
print('# iteration: {}'.format(args.iteration))
print('# out dir: {}'.format(args.out))
print('')
if args.dataset == 'mnist':
from models.net_MNIST_no_encode import Generator
from models.net_MNIST import Discriminator
from datasets.mnist.loader import get_ref_and_real_data
train, _ = chainer.datasets.get_mnist(
withlabel=False, ndim=3, scale=255.) # ndim=3 : (ch,width,height)
ref_images = train[:args.visualize_size]
data = get_ref_and_real_data(ref_images, 0.4, 20)
init_ch = 1
elif args.dataset == 'coil20':
from dis_models.discriminator import Discriminator
from gen_models.generator import Generator
from datasets.coil20.loader import get_ref_and_real_data, get_train_index, get_train_index_rand
train = get_train_index()
indexes = get_train_index_rand(size=args.visualize_size)
ref_index = train[indexes]
data = get_ref_and_real_data(ref_index,
img_size=args.img_size,
dim_noise=args.dim_noise,
dif_index=args.dif_index)
init_ch = 1
elif args.dataset == 'coil100':
from dis_models.discriminator import Discriminator
from gen_models.generator import Generator
from datasets.coil100.loader import get_ref_and_real_data, get_train_index, get_train_index_rand
train = get_train_index()
indexes = get_train_index_rand(size=args.visualize_size)
ref_index = train[indexes]
data = get_ref_and_real_data(ref_index,
img_size=args.img_size,
dim_noise=args.dim_noise,
dif_index=args.dif_index)
init_ch = 3
train_iter = chainer.iterators.SerialIterator(train, args.batch_size)
from updaters.updater import Updater
gen = Generator(init_ch=init_ch,
dim_z=args.dim_noise,
bottom_size=args.img_size)
dis = Discriminator(init_ch=init_ch,
dim_z=args.dim_noise,
bottom_size=args.img_size)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
# Setup an optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
# TODO: refactoring
updater = Updater(models=(gen, dis),
img_size=args.img_size,
loss_type=args.loss_type,
dim_noise=args.dim_noise,
dif_index=args.dif_index,
n_dis=args.n_dis,
dataset=args.dataset,
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.iteration, 'iteration'),
out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
visualize_interval = (args.visualize_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', 'dis/acc_real',
'dis/acc_fake'
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
# Visualizer
trainer.extend(out_generated_image(gen, data, args.out, args.gpu),
trigger=visualize_interval)
# Loss visualize
trainer.extend(extensions.PlotReport(['gen/loss', 'dis/loss'],
'iteration',
file_name='loss.png'),
trigger=display_interval)
# Accuracy visualize
trainer.extend(extensions.PlotReport(['dis/acc_real', 'dis/acc_fake'],
'iteration',
file_name='acc.png'),
trigger=display_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
chainer.serializers.save_npz(open(os.path.join(args.out, 'gen.npz')), gen)
chainer.serializers.save_npz(open(os.path.join(args.out, 'dis.npz')), dis)
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 main():
parser = argparse.ArgumentParser(description='Chainer example: DCGAN')
parser.add_argument(
'--batchsize',
'-b',
type=int,
default=50, # default=50
help='Number of images in each mini-batch')
parser.add_argument(
'--epoch',
'-e',
type=int,
default=10000, # defalt=500
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument(
'--dataset',
'-i',
default='train_illya.txt', # defalt=''
help='Directory of image files. Default is cifar-10.')
parser.add_argument(
'--out',
'-o',
default='result_anime_illya4', # defalt='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, # defalt=1000
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
parser.add_argument(
'--noise_sigma',
type=float,
default=0.2, # best: 0.2
help='Std of noise added the descriminator')
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, wscale=0.02)
dis = Discriminator(init_sigma=args.noise_sigma, wscale=0.02)
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
# https://elix-tech.github.io/ja/2017/02/06/gan.html
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.00001), 'hook_dec')
return optimizer
# # For WGAN
# # Not good
# def make_optimizer(model, alpha=0.0001, beta1=0.0, beta2=0.9):
# optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1, beta2=beta2)
# optimizer.setup(model)
# 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, _ = cifar.get_cifar10(withlabel=False, scale=255.)
else:
resized_paths = resize_data(args.dataset, insize + 16)
train = PreprocessedDataset(resized_paths, crop_size=insize)
print('{} contains {} image files'.format(args.dataset, train.__len__()))
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)
# updater = WGANGPUpdater(
# models=(gen, dis),
# iterator=train_iter,
# optimizer={
# 'gen': opt_gen, 'dis': opt_dis},
# device=args.gpu,
# l=10,
# n_c=5
# )
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',
#'epoch', 'iteration', 'gen/loss', 'dis/loss/gan', 'dis/loss/grad', # For WGAN
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, dis, 5, 5, args.seed, args.out),
trigger=snapshot_interval)
# 次第にDescriminatorのノイズを低減させる
@training.make_extension(trigger=snapshot_interval)
def shift_sigma(trainer):
s = dis.shift_sigma(alpha_sigma=0.9)
print('sigma={}'.format(s))
print('')
trainer.extend(shift_sigma) # 通常のDCGANではコメントイン
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description="Complitation GAN")
parser.add_argument("--batchsize",
"-b",
type=int,
default=50,
help="Number of images in each mini-batch")
parser.add_argument("--iter",
"-i",
type=int,
default=1000000,
help="Number of iter to learning")
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 the result")
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("--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")
args = parser.parse_args()
print("GPU: {}".format(args.gpu))
print("# Minibatch-size: {}".format(args.batchsize))
print("# Iter: {}".format(args.iter))
print()
gen = Generator(input_width=256, input_height=256, ch=256)
dis = Discriminator(input_width=256, input_height=256, ch=512)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
def make_optimizer(model, alpha=0.0002, beta1=0.5, weightdecay=True):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
if weightdecay:
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001),
"hook_dec")
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
train, test = load_train()
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
updater = CompGANUpdater(tc=29000,
td=1000,
alpha=0.5,
models=(gen, dis),
iterator=train_iter,
optimizer={
"gen": opt_gen,
"dis": opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.iter, "iteration"), 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, test[:16], 4, 4, args.seed,
args.out),
trigger=display_interval)
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
initial_image(test[:16], 4, 4, args.seed, args.out)
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer: DZGAN MNIST')
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=50,
help='Number of sweeps over the dataset to train')
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('--resume',
'-r',
type=str,
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')
parser.add_argument('--disresume',
'-d',
type=str,
default='',
help='Resume the training from snapshot')
parser.add_argument('--genresume',
'-gen',
type=str,
default='',
help='Resume the training from snapshot')
parser.add_argument('--n_class',
'-c',
type=int,
default=0,
help='class num')
parser.add_argument('--n_sigma',
'-s',
type=float,
default=0,
help='sigma param')
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('')
#add command temp
if not os.path.exists(args.out):
os.makedirs(args.out)
path = str(args.out) + '/lastcommand.txt'
with open(path, mode='w') as f:
f.write(str(args))
f.close()
# Set up a neural network to train
gen = Generator(n_hidden=args.n_hidden, n_class=args.n_class)
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_gen(model, alpha=2e-4, 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
def make_optimizer_dis(model, alpha=2e-4, 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(gen)
opt_dis = make_optimizer_dis(dis)
# Load the MNIST dataset
train, _ = chainer.datasets.get_mnist(
withlabel=True, ndim=3, scale=255.) # ndim=3 : (ch,width,height)
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,
n_hidden=args.n_hidden,
n_sigma=args.n_sigma)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
epoch_interval = (1, 'epoch')
visual_interval = (1, 'epoch')
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.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_epoch_{.updater.epoch}.npz'),
trigger=epoch_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, 20, args.seed, args.out,
args.n_sigma),
trigger=visual_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
if args.disresume:
chainer.serializers.load_npz(args.disresume, dis)
if args.genresume:
chainer.serializers.load_npz(args.genresume, gen)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='WGAN(GP) MNIST')
parser.add_argument('--mode', '-m', type=str, default='WGAN',
help='WGAN or WGANGP')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch', '-e', type=int, default=100,
help='number of epochs to learn')
parser.add_argument('--batchsize', '-b', type=int, default=100,
help='learning minibatch size')
parser.add_argument('--optimizer', type=str, default='Adam',
help='optimizer')
parser.add_argument('--out', '-o', type=str, default='model',
help='path to the output directory')
parser.add_argument('--dimz', '-z', type=int, default=20,
help='dimention of encoded vector')
parser.add_argument('--n_dis', type=int, default=5,
help='dimention of encoded vector')
parser.add_argument('--seed', type=int, default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--snapepoch', '-s', type=int, default=10,
help='number of epochs to snapshot')
parser.add_argument('--load_gen_model', type=str, default='',
help='load generator model')
parser.add_argument('--load_dis_model', type=str, default='',
help='load generator model')
args = parser.parse_args()
if not os.path.exists(args.out):
os.makedirs(args.out)
print(args)
gen = net.Generator(784, args.dimz, 500)
dis = net.Discriminator(784, 500)
if args.load_gen_model != '':
chainer.serializers.load_npz(args.load_gen_model, gen)
if args.load_dis_model != '':
chainer.serializers.load_npz(args.load_dis_model, dis)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
print('GPU {}'.format(args.gpu))
xp = np if args.gpu < 0 else cuda.cupy
if args.optimizer == 'Adam':
opt_gen = chainer.optimizers.Adam(alpha=0.0001, beta1=0.5, beta2=0.9)
opt_dis = chainer.optimizers.Adam(alpha=0.0001, beta1=0.5, beta2=0.9)
opt_gen.setup(gen)
opt_dis.setup(dis)
opt_dis.add_hook(WeightClipping(0.01))
elif args.optimizer == 'RMSprop':
opt_gen = chainer.optimizers.RMSprop(5e-5)
opt_dis = chainer.optimizers.RMSprop(5e-5)
opt_gen.setup(gen)
opt_gen.add_hook(chainer.optimizer.GradientClipping(1))
opt_dis.setup(dis)
opt_dis.add_hook(chainer.optimizer.GradientClipping(1))
opt_dis.add_hook(WeightClipping(0.01))
train, _ = chainer.datasets.get_mnist(withlabel=False)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize, shuffle=True)
if args.mode == 'WGAN':
updater = WGANUpdater(
models=(gen, dis),
iterators={
'main': train_iter
},
optimizers={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu,
params={
'batchsize': args.batchsize,
'n_dis': args.n_dis
})
elif args.mode == 'WGANGP':
updater = WGANGPUpdater(
models=(gen, dis),
iterators={
'main': train_iter
},
optimizers={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu,
params={
'batchsize': args.batchsize,
'n_dis': args.n_dis,
'lam': 10
})
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(extensions.dump_graph('was. dist'))
snapshot_interval = (args.snapepoch, 'epoch')
trainer.extend(extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.PlotReport(['loss/gen'], 'epoch', file_name='generator.png'))
if args.mode == 'WGAN':
log_keys = ['epoch', 'was. dist', 'gen/loss', 'dis/loss']
elif args.mode == 'WGANGP':
log_keys = ['epoch', 'was. dist', 'grad. pen', 'gen/loss']
trainer.extend(extensions.LogReport(keys=log_keys))
trainer.extend(extensions.PrintReport(log_keys))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, 20, 20, args.seed, args.out),
trigger=(1, 'epoch'))
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer example: DCGAN')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
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('--data_length',
'-dl',
type=int,
default=20,
help='length of one data')
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=10,
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')
parser.add_argument('--visualize_interval',
type=int,
default=100,
help='Interval of saving visualized image')
args = parser.parse_args()
# Set up a neural network to train
gen = Generator(n_hidden=args.n_hidden, data_length=args.data_length)
dis = Discriminator(data_length=args.data_length)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
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):
# 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)
train = TrajectoryDataset(data_length=args.data_length)
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')
visualize_interval = (args.visualize_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, train, 10, args.seed,
args.out),
trigger=visualize_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
# This enables a ctr-C without triggering errors
import signal
signal.signal(signal.SIGINT, lambda x, y: sys.exit(0))
parser = argparse.ArgumentParser(description='GAN practice on MNIST')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='number of epochs to learn')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--out',
'-o',
type=str,
default='model',
help='path to the output directory')
parser.add_argument('--dimz',
'-z',
type=int,
default=20,
help='dimention of encoded vector')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--snapepoch',
'-s',
type=int,
default=10,
help='number of epochs to snapshot')
parser.add_argument('--load_gen_model',
type=str,
default='',
help='load generator model')
parser.add_argument('--load_dis_model',
type=str,
default='',
help='load generator model')
args = parser.parse_args()
if not os.path.exists(args.out):
os.makedirs(args.out)
print(args)
gen = net.Generator(784, args.dimz, 500)
dis = net.Discriminator(784, 500)
if args.load_gen_model != '':
chainer.serializers.load_npz(args.load_gen_model, gen)
print('Generator model loaded successfully!')
if args.load_dis_model != '':
chainer.serializers.load_npz(args.load_dis_model, dis)
print('Discriminator model loaded successfully!')
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
print('GPU {}'.format(args.gpu))
xp = np if args.gpu < 0 else cuda.cupy
opt_gen = chainer.optimizers.Adam()
opt_dis = chainer.optimizers.Adam()
opt_gen.setup(gen)
opt_dis.setup(dis)
dataset = MnistDataset('./data')
# train, val = chainer.datasets.split_dataset_random(dataset, int(len(dataset) * 0.9))
train_iter = chainer.iterators.SerialIterator(dataset,
args.batchsize,
shuffle=True)
# val_iter = chainer.iterators.SerialIterator(val, args.batchsize, repeat=False, shuffle=False)
updater = GANUpdater(models=(gen, dis),
iterators={'main': train_iter},
optimizers={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu,
params={
'batchsize': args.batchsize,
'n_latent': args.dimz
})
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapepoch, 'epoch')
display_interval = (100, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(gen, 'gen{.updater.epoch}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(dis, 'dis{.updater.epoch}.npz'),
trigger=snapshot_interval)
log_keys = ['epoch', 'iteration', 'gen/loss', 'dis/loss']
trainer.extend(
extensions.LogReport(keys=log_keys, trigger=display_interval))
trainer.extend(extensions.PrintReport(log_keys), trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, 10, 10, args.seed, args.out),
trigger=(1, 'epoch'))
trainer.run()
def main():
parser = argparse.ArgumentParser(description='ChainerMN example: DCGAN')
parser.add_argument('--batchsize',
'-b',
type=int,
default=50,
help='Number of images in each mini-batch')
parser.add_argument('--communicator',
type=str,
default='hierarchical',
help='Type of communicator')
parser.add_argument('--epoch',
'-e',
type=int,
default=1000,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', action='store_true', help='Use GPU')
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('--gen_model',
'-r',
default='',
help='Use pre-trained generator for training')
parser.add_argument('--dis_model',
'-d',
default='',
help='Use pre-trained discriminator for training')
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()
# Prepare ChainerMN communicator.
if args.gpu:
if args.communicator == 'naive':
print("Error: 'naive' communicator does not support GPU.\n")
exit(-1)
comm = chainermn.create_communicator(args.communicator)
device = comm.intra_rank
else:
if args.communicator != 'naive':
print('Warning: using naive communicator '
'because only naive supports CPU-only execution')
comm = chainermn.create_communicator('naive')
device = -1
if comm.mpi_comm.rank == 0:
print('==========================================')
print('Num process (COMM_WORLD): {}'.format(MPI.COMM_WORLD.Get_size()))
if args.gpu:
print('Using GPUs')
print('Using {} communicator'.format(args.communicator))
print('Num hidden unit: {}'.format(args.n_hidden))
print('Num Minibatch-size: {}'.format(args.batchsize))
print('Num epoch: {}'.format(args.epoch))
print('==========================================')
# Set up a neural network to train
gen = Generator(n_hidden=args.n_hidden)
dis = Discriminator()
if device >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(device).use()
gen.to_gpu() # Copy the model to the GPU
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, comm, alpha=0.0002, beta1=0.5):
# Create a multi node optimizer from a standard Chainer optimizer.
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.Adam(alpha=alpha, beta1=beta1), comm)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001), 'hook_dec')
return optimizer
opt_gen = make_optimizer(gen, comm)
opt_dis = make_optimizer(dis, comm)
# Split and distribute the dataset. Only worker 0 loads the whole dataset.
# Datasets of worker 0 are evenly split and distributed to all workers.
if comm.rank == 0:
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)
else:
train = None
train = chainermn.scatter_dataset(train, comm)
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=device)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Some display and output extensions are necessary only for one worker.
# (Otherwise, there would just be repeated outputs.)
if comm.rank == 0:
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
# Save only model parameters.
# `snapshot` extension will save all the trainer module's attribute,
# including `train_iter`.
# However, `train_iter` depends on scattered dataset, which means that
# `train_iter` may be different in each process.
# Here, instead of saving whole trainer module, only the network models
# are saved.
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',
'elapsed_time',
]),
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)
# Start the training using pre-trained model, saved by snapshot_object
if args.gen_model:
chainer.serializers.load_npz(args.gen_model, gen)
if args.dis_model:
chainer.serializers.load_npz(args.dis_model, dis)
# Run the training
trainer.run()
'gen_epoch_{.updater.epoch}.npz',
savefun=save_npz),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(dis,
'dis_epoch_{.updater.epoch}.npz',
savefun=save_npz),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'gen/loss',
'dis/loss',
'elapsed_time',
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(out_generated_image(gen, dis, 5, 5, seed, out),
trigger=display_interval)
trainer.extend(
extensions.PlotReport(['gen/loss', 'dis/loss'],
x_key='epoch',
file_name='loss_{0}_{1}.jpg'.format(
number, seed),
grid=False))
trainer.extend(extensions.dump_graph("gen/loss", out_name="gen.dot"))
trainer.extend(extensions.dump_graph("dis/loss", out_name="dis.dot"))
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='ChainerMN example: DCGAN')
parser.add_argument('--batchsize', '-b', type=int, default=50,
help='Number of images in each mini-batch')
parser.add_argument('--communicator', type=str,
default='hierarchical', help='Type of communicator')
parser.add_argument('--epoch', '-e', type=int, default=1000,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', action='store_true',
help='Use GPU')
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('--gen_model', '-r', default='',
help='Use pre-trained generator for training')
parser.add_argument('--dis_model', '-d', default='',
help='Use pre-trained discriminator for training')
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()
# Prepare ChainerMN communicator.
if args.gpu:
if args.communicator == 'naive':
print("Error: 'naive' communicator does not support GPU.\n")
exit(-1)
comm = chainermn.create_communicator(args.communicator)
device = comm.intra_rank
else:
if args.communicator != 'naive':
print('Warning: using naive communicator '
'because only naive supports CPU-only execution')
comm = chainermn.create_communicator('naive')
device = -1
if comm.rank == 0:
print('==========================================')
print('Num process (COMM_WORLD): {}'.format(comm.size))
if args.gpu:
print('Using GPUs')
print('Using {} communicator'.format(args.communicator))
print('Num hidden unit: {}'.format(args.n_hidden))
print('Num Minibatch-size: {}'.format(args.batchsize))
print('Num epoch: {}'.format(args.epoch))
print('==========================================')
# Set up a neural network to train
gen = Generator(n_hidden=args.n_hidden)
dis = Discriminator()
if device >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(device).use()
gen.to_gpu() # Copy the model to the GPU
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, comm, alpha=0.0002, beta1=0.5):
# Create a multi node optimizer from a standard Chainer optimizer.
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.Adam(alpha=alpha, beta1=beta1), comm)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001), 'hook_dec')
return optimizer
opt_gen = make_optimizer(gen, comm)
opt_dis = make_optimizer(dis, comm)
# Split and distribute the dataset. Only worker 0 loads the whole dataset.
# Datasets of worker 0 are evenly split and distributed to all workers.
if comm.rank == 0:
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)
else:
train = None
train = chainermn.scatter_dataset(train, comm)
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=device)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Some display and output extensions are necessary only for one worker.
# (Otherwise, there would just be repeated outputs.)
if comm.rank == 0:
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
# Save only model parameters.
# `snapshot` extension will save all the trainer module's attribute,
# including `train_iter`.
# However, `train_iter` depends on scattered dataset, which means that
# `train_iter` may be different in each process.
# Here, instead of saving whole trainer module, only the network models
# are saved.
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', 'elapsed_time',
]), 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)
# Start the training using pre-trained model, saved by snapshot_object
if args.gen_model:
chainer.serializers.load_npz(args.gen_model, gen)
if args.dis_model:
chainer.serializers.load_npz(args.dis_model, dis)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='DCGAN')
parser.add_argument('--batchsize', '-b', default=50, type=int)
parser.add_argument('--epoch', '-e', default=1000, type=int)
parser.add_argument('--gpu', '-g', default=0, type=int)
parser.add_argument('--out', '-o', default='result')
parser.add_argument('--n_hidden', '-n', default=100, type=int)
parser.add_argument('--snapshot_interval', default=1000, type=int)
args = parser.parse_args()
print('=== DCGAN ===')
# rootディレクトリ退避
root = os.getcwd()
# 出力フォルダ作成
if not os.path.exists(args.out):
print('** create result')
os.mkdir(args.out)
save_path = args.out + '/' + time.strftime('%y%m%d_%H%M%S',
time.localtime())
os.makedirs(save_path)
os.chdir(save_path)
# loggerの設定
logger_names = ['losses', 'debug']
loggers = {}
for logger_name in logger_names:
loggers[logger_name] = set_logger(logger_name, save_path)
loggers['debug'].debug('# batchsize: {}'.format(args.batchsize))
loggers['debug'].debug('# epoch: {}'.format(args.epoch))
loggers['debug'].debug('# n_hidden: {}'.format(args.n_hidden))
loggers['debug'].debug('')
# 学習用のモデル設定
gen = Generator(n_hidden=args.n_hidden)
dis = Discriminator()
# cpu or gpu
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
xp = chainer.cuda.cupy if args.gpu >= 0 else np
def make_optimizer(model, alpha=0.002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
# MNISTデータ読み込み
# contents['datas'] -> (60000, 784)
# contents['labels] -> (60000,)
with open(root + '/mnist.pkl', 'rb') as f:
contents = pickle.load(f)
loggers['debug'].debug('# data_size: {}'.format(
contents['datas'].shape[0]))
loggers['debug'].debug('')
# バッチ作成
iterator_train = Iterator(contents, args.batchsize)
# 学習ループ
iteration = 1
for epoch in range(1, args.epoch + 1):
start_time = time.time()
print('# epoch gen/loss dis/loss')
# ミニバッチ学習
for yielded in iterator_train(shuffle=True):
batch = yielded
# names = batch.keys()
# variables = {}
# データ整形 --- 784 -> 1ch, 28*28
b_size = batch['datas'].shape[0]
d = batch['datas'].reshape(b_size, 1, 28, 28)
datas = chainer.Variable(xp.asarray(d, dtype=xp.float32))
# variables['datas'] = datas
# 勾配クリア
gen.cleargrads()
dis.cleargrads()
## 順伝播(DCGAN)
# x_real = variables['datas'] / 255.
x_real = datas / 255.
# Discriminatorの出力値(本物入力)
y_real = dis(x=x_real)
# 入力ノイズデータ作成
z = chainer.Variable(xp.asarray(gen.make_hidden(b_size)))
# Generatorの出力値(ノイズ入力)
x_fake = gen(z)
# Discriminatorの出力値(偽物入力)
y_fake = dis(x_fake)
## Discriminatorの誤差関数
# 本物画像に対して本物(1)を出力させたい
# 本物を本物と判定するほどL1は小さくなる
L1 = F.sum(F.softplus(-y_real)) / b_size
# 偽物画像に対して偽物(0)を出力させたい
# 偽物を偽物と判定するほどL2は小さくなる
L2 = F.sum(F.softplus(y_fake)) / b_size
dis_loss = L1 + L2
## Generatorの誤差関数
# 偽物画像を入力した時のDiscriminatorの出力を本物(1)に近づける
# 偽物で本物と判定するほどlossは小さくなる
gen_loss = F.sum(F.softplus(-y_fake)) / b_size
loggers['losses'].debug('# epoch: {}, iteration{}'.format(
epoch, iteration))
loggers['losses'].debug('gen/loss: {} dis/loss: {}'.format(
gen_loss.data, dis_loss.data))
print('{} {} {}'.format(epoch, gen_loss.data, dis_loss.data))
# 誤差逆伝播 -> 重み更新
dis_loss.backward()
opt_dis.update()
gen_loss.backward()
opt_gen.update()
if iteration % args.snapshot_interval == 0:
out_generated_image(gen, 10, 10, 0, iteration, xp)
iteration += 1
passed_time = time.time() - start_time
print('*** passed time in this epoch: {}[sec]'.format(passed_time))
loggers['debug'].debug('# epoch: {}'.format(epoch))
loggers['debug'].debug('# passed_time: {}[sec]'.format(passed_time))
print('=== Save Model ====')
gen.to_cpu()
chainer.serializers.save_npz('./generator.npz', gen)
dis.to_cpu()
chainer.serializers.save_npz('./discriminator.npz', dis)
# computational_graph作成
print('=== Draw Computational Graph ===')
_val_style = {
'shape': 'octagon',
'fillcolor': '#E0E0E0',
'style': 'filled'
}
_fanc_style = {
'shape': 'record',
'fillcolor': '#6495ED',
'style': 'filled'
}
with open('computational_graph.dot', 'w') as o:
g = build_computational_graph([gen_loss, dis_loss],
variable_style=_val_style,
function_style=_fanc_style)
o.write(g.dump())
def main():
parser = argparse.ArgumentParser(description='LSGAN')
parser.add_argument('--batchsize',
'-b',
type=int,
default=20,
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('--image_size',
type=int,
default=64,
help='Size of output image')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console (iter)')
parser.add_argument('--preview_interval',
type=int,
default=1,
help='Interval of preview (epoch)')
parser.add_argument('--snapshot_interval',
type=int,
default=10,
help='Interval of snapshot (epoch)')
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 = net.Generator(n_hidden=args.n_hidden, image_size=args.image_size)
# dis = Discriminator()
dis = net.Discriminator2()
# dis = net.Discriminator3()
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.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)
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize,
n_processes=4)
def resize_converter(batch, device=None, padding=None):
new_batch = []
for image in batch:
C, W, H = image.shape
if C == 4:
image = image[:3, :, :]
if W < H:
offset = (H - W) // 2
image = image[:, :, offset:offset + W]
elif W > H:
offset = (W - H) // 2
image = image[:, offset:offset + H, :]
image = image.transpose(1, 2, 0)
image = imresize(image, (args.image_size, args.image_size),
interp='bilinear')
image = image.transpose(2, 0, 1)
image = image / 255. # 0. ~ 1.
# Augumentation... Random vertical flip
if np.random.rand() < 0.5:
image = image[:, :, ::-1]
# Augumentation... Tone correction
mode = np.random.randint(4)
# mode == 0 -> no correction
if mode == 1:
gain = 0.2 * np.random.rand() + 0.9 # 0.9 ~ 1.1
image = np.power(image, gain)
elif mode == 2:
gain = 1.5 * np.random.rand() + 1e-10 # 0 ~ 1.5
image = np.tanh(gain * (image - 0.5))
range_min = np.tanh(gain * (-0.5)) # @x=0.5
range_max = np.tanh(gain * 0.5) # @x=1.0
image = (image - range_min) / (range_max - range_min)
elif mode == 3:
gain = 2.0 * np.random.rand() + 1e-10 # 0 ~ 1.5
image = np.sinh(gain * (image - 0.5))
range_min = np.tanh(gain * (-0.5)) # @x=0.5
range_max = np.tanh(gain * 0.5) # @x=1.0
image = (image - range_min) / (range_max - range_min)
image = 2. * image - 1.
new_batch.append(image.astype(np.float32))
return concat_examples(new_batch, device=device, padding=padding)
# Set up a trainer
updater = DCGANUpdater(models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
device=args.gpu,
converter=resize_converter)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
display_interval = (args.display_interval, 'iteration')
preview_interval = (args.preview_interval, 'epoch')
snapshot_interval = (args.snapshot_interval, 'epoch')
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=preview_interval)
if args.resume:
# Resume from a snapshot
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('--device', '-d', type=str, default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
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', type=str,
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')
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu', '-g', dest='device',
type=int, nargs='?', const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
device = chainer.get_device(args.device)
device.use()
print('Device: {}'.format(device))
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()
gen.to_device(device) # Copy the model to the device
dis.to_device(device)
# 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)
# Setup an iterator
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
# Setup an updater
updater = DCGANUpdater(
models=(gen, dis),
iterator=train_iter,
optimizer={
'gen': opt_gen, 'dis': opt_dis},
device=device)
# Setup a trainer
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 is not None:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer: DCGAN MNIST')
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=0,
help='GPU ID (negative value indicates CPU)')
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')
parser.add_argument('--image_dir',
default='./img',
help='Training image directory')
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()
dis = Discriminator()
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
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
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
def read_dataset(image_dir):
fs = os.listdir(image_dir)
dataset = []
for fn in fs:
img = Image.open(f"{args.image_dir}/{fn}").convert('RGB')
dataset.append((np.asarray(img,
dtype=np.float32).transpose(2, 0, 1)))
return dataset
dataset = read_dataset(args.image_dir)
train_iter = chainer.iterators.SerialIterator(dataset,
args.batchsize,
repeat=True,
shuffle=True)
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)
epoch_interval = (1, 'epoch')
# 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.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_epoch_{.updater.epoch}.npz'),
trigger=epoch_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=epoch_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
