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で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)にこうして分けた後、何度も実行する際に異なる分け方になってしまわないよう、第3引数の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()