from chainer.datasets import mnist train, test = mnist.get_mnist(withlabel=True, ndim=1) import matplotlib.pyplot as plt x, t = train[0] plt.imshow(x.reshape(28, 28), cmap='gray') plt.axis('off') plt.show() print('label:', t) from chainer import iterators batchsize = 128 train_iter = iterators.SerialIterator(train, batchsize) test_iter = iterators.SerialIterator(test, batchsize, repeat=False, shuffle=False) import chainer import chainer.links as L import chainer.functions as F import random import numpy as np random.seed(0) np.random.seed(0) class MLP(chainer.Chain): def __init__(self, n_mid_units=100, n_out=10): super(MLP, self).__init__()
def main(): parser = argparse.ArgumentParser(description="WGAN-gp") parser.add_argument("--batchsize", "-b", type=int, default=64) parser.add_argument("--epoch", "-e", type=int, default=100) parser.add_argument("--gpu", "-g", type=int, default=0) parser.add_argument("--snapshot_interval", "-s", type=int, default=50) parser.add_argument("--display_interval", "-d", type=int, default=1) parser.add_argument("--n_dimz", "-z", type=int, default=128) parser.add_argument("--dataset", "-ds", type=str, default="mnist") parser.add_argument("--seed", type=int, default=0) parser.add_argument("--out", "-o", type=str, default="result") parser.add_argument("--method", "-m", type=str, default="ziz") parser.add_argument("--resume", '-r', default='') parser.add_argument("--PreNet", "-pn", type=str, default="WGANgp") parser.add_argument("--Premodel", "-pm", type=int, default=500) args = parser.parse_args() #import .py import Updater import Visualize import Network.mnist_net as Network #Get Pretrain Net if args.PreNet == "WGANgp": import WGANgp.Network.mnist_net as PreNetwork else: import WGAN.Network.mnist_net as PreNetwork #print settings print("GPU:{}".format(args.gpu)) print("max_epoch:{}".format(args.epoch)) print("Minibatch_size:{}".format(args.batchsize)) print("Dataset:{}".format(args.dataset)) print("Method:{}".format(args.method)) print('') out = os.path.join(args.out, args.method) #Set up NN gen = PreNetwork.DCGANGenerator(n_hidden=args.n_dimz) dis = PreNetwork.WGANDiscriminator() enc = Network.AE() #Load PreTrain model load_path = '{}/result/mnist/gen_epoch_{}.npz'.format(args.PreNet, args.Premodel) chainer.serializers.load_npz(load_path, gen) load_path = '{}/result/mnist/dis_epoch_{}.npz'.format(args.PreNet, args.Premodel) chainer.serializers.load_npz(load_path, dis) if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() gen.to_gpu() dis.to_gpu() enc.to_gpu() #Make optimizer def make_optimizer(model, alpha=0.0002, 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) opt_enc = make_optimizer(enc) #Get dataset train, _ = mnist.get_mnist(withlabel=True, ndim=3, scale=1.) train = [i[0] for i in train if(i[1]==1)] #ラベル1のみを選択 #Setup iterator train_iter = iterators.SerialIterator(train, args.batchsize) #Setup updater updater_args={ "models":(gen, dis, enc), "iterator":train_iter, "optimizer":{'gen':opt_gen, 'dis':opt_dis, 'enc':opt_enc}, "n_dimz":args.n_dimz, "device":args.gpu} if args.method=='izif': updater = Updater.izifUpdater(**updater_args) elif args.method=='izi': updater = Updater.iziUpdater(**updater_args) elif args.method=='ziz': updater = Updater.zizUpdater(**updater_args) else: raise NotImplementedError() #Setup trainer trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=out) snapshot_interval = (args.snapshot_interval, 'epoch') display_interval = (args.display_interval, 'epoch') trainer.extend( extensions.snapshot( filename='snapshot_epoch_{.updater.epoch}.npz'), trigger=(args.epoch, 'epoch')) trainer.extend(extensions.snapshot_object( gen, 'gen_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object( dis, 'dis_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object( enc, 'enc_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.LogReport( trigger=display_interval)) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'enc/loss', 'elapsed_time' ]), trigger=display_interval) trainer.extend(extensions.ProgressBar()) trainer.extend(Visualize.out_generated_image( gen, enc, 10, 10, args.seed, out, args.dataset), trigger=snapshot_interval) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()
def pretraining(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--seed', type=int, default=0) parser.add_argument('--batchsize', type=int, default=256) args = parser.parse_args() xp = np gpu_id = args.gpu seed = args.seed train, _ = mnist.get_mnist() train, _ = convert.concat_examples(train, device=gpu_id) batchsize = args.batchsize model = StackedDenoisingAutoEncoder(input_dim=train.shape[1]) if chainer.cuda.available and args.gpu >= 0: xp = cp model.to_gpu(gpu_id) xp.random.seed(seed) # Layer-Wise Pretrain print("Layer-Wise Pretrain") for i, dae in enumerate(model.children()): print("Layer {}".format(i + 1)) train_tuple = tuple_dataset.TupleDataset(train, train) train_iter = iterators.SerialIterator(train_tuple, batchsize) clf = L.Classifier(dae, lossfun=mean_squared_error) clf.compute_accuracy = False if chainer.cuda.available and args.gpu >= 0: clf.to_gpu(gpu_id) optimizer = optimizers.MomentumSGD(lr=0.1) optimizer.setup(clf) updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id) trainer = training.Trainer(updater, (50000, "iteration"), out="mnist_result") trainer.extend(extensions.LogReport()) trainer.extend( extensions.PrintReport(['iteration', 'main/loss', 'elapsed_time'])) trainer.extend(ChangeLearningRate(), trigger=(20000, "iteration")) trainer.run() train = dae.encode(train).data # Finetuning print("fine tuning") with chainer.using_config("train", False): train, _ = mnist.get_mnist() train, _ = convert.concat_examples(train, device=gpu_id) train_tuple = tuple_dataset.TupleDataset(train, train) train_iter = iterators.SerialIterator(train_tuple, batchsize) model = L.Classifier(model, lossfun=mean_squared_error) model.compute_accuracy = False if chainer.cuda.available and args.gpu >= 0: model.to_gpu(gpu_id) optimizer = optimizers.MomentumSGD(lr=0.1) optimizer.setup(model) updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id) trainer = training.Trainer(updater, (100000, "iteration"), out="mnist_result") trainer.extend(extensions.LogReport()) trainer.extend( extensions.PrintReport(['iteration', 'main/loss', 'elapsed_time'])) trainer.extend(ChangeLearningRate(), trigger=(20000, "iteration")) trainer.run() outfile = "StackedDenoisingAutoEncoder-seed{}.model".format(seed) serializers.save_npz(outfile, model.predictor)
def main(): parser = argparse.ArgumentParser(description="Vanilla_AE") parser.add_argument("--batchsize", "-b", type=int, default=128) parser.add_argument("--gpu", "-g", type=int, default=0) parser.add_argument("--snapshot", "-s", type=int, default=10) parser.add_argument("--n_dimz", "-z", type=int, default=16) parser.add_argument("--network", "-n", type=str, default='conv') args = parser.parse_args() if args.network=='conv': import Network.mnist_conv as Network elif args.network=='fl': import Network.mnist_fl as Network else: raise Exception('Error!') out = os.path.join('Pred', args.network, 'epoch_{}'.format(args.snapshot)) os.makedirs(out, exist_ok=True) def transform(in_data): img, label = in_data img = resize(img, (32, 32)) return img, label def plot_mnist_data(samples, label1, label2): for index, data in enumerate(samples):#(配列番号,要素) plt.subplot(5, 13, index + 1)#(行数, 列数, 何番目のプロットか) plt.axis('off')#軸はoff plt.imshow(data.reshape(32, 32), cmap="gray")#nearestで補完 if index == 0: plt.title("in_1", color='red') elif index == 12: plt.title("in_2", color='red') elif index == 1: plt.title("out_1", color='red') elif index == 11: plt.title("out_2", color='red') pict = os.path.join(out, "{}_{}.png".format(label1, label2)) plt.savefig(pict) plt.show() batchsize = args.batchsize gpu_id = args.gpu _, test = mnist.get_mnist(withlabel=True, ndim=3) test = TransformDataset(test, transform) xp = cupy AE = Network.AE(n_dimz=args.n_dimz, batchsize=args.batchsize) Critic = Network.Critic() AE.to_gpu() Critic.to_gpu() AE_path = os.path.join('result', args.network, 'AE_snapshot_epoch_{}.npz'.format(args.snapshot)) Critic_path = os.path.join('result', args.network, 'Critic_snapshot_epoch_{}.npz'.format(args.snapshot)) chainer.serializers.load_npz(AE_path, AE) chainer.serializers.load_npz(Critic_path, Critic) label1 = 1 label2 = 9 test1 = [i[0] for i in test if(i[1]==label1)] test2 = [i[0] for i in test if(i[1]==label2)] test1 = test1[0:5] test2 = test2[5:10] itp_list = [] for i in range(0,5): data1 = test1[i] data2 = test2[i] y1, y2, yc, alpha, z1, z2 = AE(xp.array([data1]).astype(np.float32), xp.array([data2]).astype(np.float32)) in1 = (data1*255).astype(np.uint8).reshape(32, 32) in2 = (data2*255).astype(np.uint8).reshape(32, 32) z_diff = (z2 - z1).data z_itp = z1.data#start point itp_list.append(in1) for j in range(1, 11):#間の座標を出す z_itp = xp.vstack((z_itp, z1.data+z_diff/10*j)) for k in range(0,11):#端から座標を移動して画像を出力 itp = AE(xp.copy(z_itp[k][None, ...]), z_itp[k], train=False) itp_out = (itp.data*255).astype(np.uint8).reshape(32, 32) itp_list.append(chainer.cuda.to_cpu(itp_out)) itp_list.append(in2) plot_mnist_data(itp_list, label1, label2)
def main(): parser = argparse.ArgumentParser(description='WGAN') 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=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("--snapshot_interval", "-s", type=int, default=50) parser.add_argument("--display_interval", "-d", type=int, default=1) parser.add_argument("--seed", type=int, default=0) parser.add_argument("--dataset", "-ds", type=str, default="mnist") parser.add_argument("--n_dimz", "-z", type=int, default=128) args = parser.parse_args() out = os.path.join(args.out, args.dataset) # Networks if args.dataset == "mnist": import Network.mnist_net as Network else: import Network.cifar10_net as Network gen = Network.DCGANGenerator(n_hidden=args.n_dimz) dis = Network.WGANDiscriminator() if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() gen.to_gpu() dis.to_gpu() # Optimizers opt_gen = chainer.optimizers.RMSprop(5e-5) opt_gen.setup(gen) opt_gen.add_hook(chainer.optimizer.GradientClipping(1)) opt_dis = chainer.optimizers.RMSprop(5e-5) opt_dis.setup(dis) opt_dis.add_hook(chainer.optimizer.GradientClipping(1)) opt_dis.add_hook(WeightClipping(0.01)) # Dataset if args.dataset == "mnist": train, _ = mnist.get_mnist(withlabel=False, ndim=3, scale=1.) else: train, _ = chainer.datasets.get_cifar10(withlabel=False, scale=1.) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) # Trainer import Updater updater = Updater.WGANUpdater(models=(gen, dis), iterator=train_iter, optimizer={ 'gen': opt_gen, 'dis': opt_dis }, n_dis=5, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=out) snapshot_interval = (args.snapshot_interval, 'epoch') display_interval = (args.display_interval, 'epoch') # Extensions trainer.extend(extensions.dump_graph('wasserstein distance')) trainer.extend( extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'), trigger=(args.epoch, 'epoch')) trainer.extend(extensions.snapshot_object( gen, 'gen_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object( dis, 'dis_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.LogReport()) trainer.extend( extensions.PlotReport(['wasserstein distance'], 'epoch', file_name='distance.png')) trainer.extend( extensions.PlotReport(['gen/loss'], 'epoch', file_name='loss.png')) trainer.extend(extensions.PrintReport( ['epoch', 'wasserstein distance', 'gen/loss', 'elapsed_time']), trigger=display_interval) trainer.extend(extensions.ProgressBar()) trainer.extend(Visualize.out_generated_image(gen, dis, 10, 10, args.seed, args.out, args.dataset), trigger=snapshot_interval) if args.resume: chainer.serializers.load_npz(args.resume, trainer) # Run trainer.run()
def set_dataset(self): if self.dataset == 'mnist': self.train_dataset, self.valid_dataset = mnist.get_mnist() else: raise ValueError
import math import numpy as np import chainer from chainer import backend from chainer import backends from chainer.backends import cuda from chainer import Function, FunctionNode, gradient_check, report, training, utils, Variable from chainer import datasets, initializers, iterators, optimizers, serializers from chainer import Link, Chain, ChainList import chainer.functions as F import chainer.links as L from chainer.training import extensions from chainer.datasets import mnist train, test = mnist.get_mnist() batchsize = 128 train_iter = iterators.SerialIterator(train, batchsize) test_iter = iterators.SerialIterator(test, batchsize, False, False) # model definition class MLP(Chain): def __init__(self, n_mid_units=100, n_out=10): super(MLP, self).__init__() with self.init_scope(): self.l1 = L.Linear(None, n_mid_units) self.l2 = L.Linear(n_mid_units, n_mid_units) self.l3 = L.Linear(n_mid_units, n_out) def forward(self, x):
def main(): parser = argparse.ArgumentParser(description="DCGAN") parser.add_argument("--batchsize", "-b", type=int, default=128) parser.add_argument("--epoch", "-e", type=int, default=100) parser.add_argument("--gpu", "-g", type=int, default=0) parser.add_argument("--snapshot_interval", "-s", type=int, default=10) parser.add_argument("--display_interval", "-d", type=int, default=1) parser.add_argument("--n_dimz", "-z", type=int, default=100) parser.add_argument("--dataset", "-ds", type=str, default="mnist") parser.add_argument("--seed", type=int, default=0) parser.add_argument("--out", "-o", type=str, default="result") parser.add_argument("--resume", '-r', default='') args = parser.parse_args() #import .py import Updater import Visualize import Network.mnist_net as Network #print settings print("GPU:{}".format(args.gpu)) print("epoch:{}".format(args.epoch)) print("Minibatch_size:{}".format(args.batchsize)) print("Dataset:{}".format(args.dataset)) print('') out = os.path.join(args.out, args.dataset) #Set up NN gen = Network.Generator(n_hidden=args.n_dimz) dis = Network.Discriminator() if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() gen.to_gpu() dis.to_gpu() #Make optimizer def make_optimizer(model, alpha=0.0002, beta1=0.5): optimizer = optimizers.Adam(alpha=alpha, beta1=beta1) #init_lr = alpha 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) #Get dataset train, _ = mnist.get_mnist(withlabel=True, ndim=3) train = [i[0] for i in train if (i[1] == 1)] #ラベル1のみを選択 #Setup iterator train_iter = iterators.SerialIterator(train, args.batchsize) #Setup updater updater = Updater.DCGANUpdater(models=(gen, dis), iterator=train_iter, optimizer={ 'gen': opt_gen, 'dis': opt_dis }, device=args.gpu) #Setup trainer trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=out) snapshot_interval = (args.snapshot_interval, 'epoch') display_interval = (args.display_interval, 'epoch') trainer.extend( extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'), trigger=(args.epoch, 'epoch')) trainer.extend(extensions.snapshot_object( gen, 'gen_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object( dis, 'dis_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.LogReport(trigger=display_interval)) trainer.extend(extensions.PrintReport( ['epoch', 'gen/loss', 'dis/loss', 'elapsed_time']), trigger=display_interval) trainer.extend(extensions.ProgressBar()) trainer.extend(Visualize.out_generated_image(gen, dis, 10, 10, args.seed, args.out, args.dataset), trigger=snapshot_interval) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()
import chainer, argparse, os import numpy as np import matplotlib.pyplot as plt import chainer.functions as F from PIL import Image from chainer import Variable from chainer.datasets import mnist parser = argparse.ArgumentParser(description="DCGAN") parser.add_argument("--n_dimz", "-z", type=int, default=100) parser.add_argument("--dataset", "-ds", type=str, default="mnist") parser.add_argument("--seed", type=int, default=0) args = parser.parse_args() import Network.mnist_net as Network train_valid, test = mnist.get_mnist(withlabel=True, ndim=3, scale=255.) test = [i[0] for i in test if (i[1] == 7)] #ラベル1のみを選択 test = test[0:1] gen = Network.Generator(n_hidden=args.n_dimz) enc = Network.Encoder(n_hidden=args.n_dimz) dis = Network.Discriminator() gen.to_cpu() enc.to_cpu() dis.to_cpu() load_path = 'result/{}/gen_epoch_100.npz'.format(args.dataset) chainer.serializers.load_npz(load_path, gen) load_path = 'result/{}/enc_epoch_100.npz'.format(args.dataset) chainer.serializers.load_npz(load_path, enc) load_path = 'result/{}/dis_epoch_100.npz'.format(args.dataset)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--seed', type=int, default=0) parser.add_argument('--model_seed', type=int, default=0) parser.add_argument('--cluster', type=int, default=10) parser.add_argument('--stop_iter', type=int, default=30) args = parser.parse_args() gpu_id = args.gpu seed = args.seed model_seed = args.model_seed np.random.seed(seed) train, _ = mnist.get_mnist() concat_train_data, concat_train_label = convert.concat_examples( train, device=gpu_id) perm = np.random.permutation(concat_train_data.shape[0]) # Load Pretrain Model sdae = StackedDenoisingAutoEncoder(concat_train_data.shape[1]) serializers.load_npz( "StackedDenoisingAutoEncoder-seed{}.model".format(args.model_seed), sdae) chains = [dae for dae in sdae.children()] model = DeepEmbeddedClustering(chains) if chainer.cuda.available and args.gpu >= 0: model.to_gpu(gpu_id) # Initialize centroid k = args.cluster Z = model(concat_train_data) Z.to_cpu() Z = Z.data kmeans = KMeans(n_clusters=k, n_init=20, random_state=seed).fit(Z) last_labels = kmeans.labels_ if chainer.cuda.available and args.gpu >= 0: centroids = cuda.to_gpu(kmeans.cluster_centers_) else: centroids = kmeans.cluster_centers_ model.add_centroids(centroids) optimizer = optimizers.MomentumSGD(lr=0.01) optimizer.setup(model) i = 0 with chainer.using_config("train", False): # Not use Trainer because stop condition is difficult print("train DEC") while True: print("Epoch {}".format(i + 1)) Z = model(concat_train_data) centroids = model.get_centroids() loss = tdistribution_kl_divergence(Z, centroids) print("loss {}".format(loss.data)) model.cleargrads() loss.backward() optimizer.update() if i % 5 == 0: new_labels = model.predict_label(concat_train_data) new_labels = cuda.to_cpu(new_labels) diff = float( len( np.where(np.equal(new_labels, last_labels) == False) [0])) / Z.shape[0] last_labels = new_labels plot_tsne(model, concat_train_data[perm[:500]], concat_train_label[perm[:500]], seed, i, "modelseed{}_seed{}".format(model_seed, seed)) print("diff {}".format(diff)) if diff <= 0.001: break if i > args.stop_iter: print("Couldn't reach tol") break i += 1 outfile = "DeepEmbeddedClustering_modelseed{}_seed{}.model".format( model_seed, seed) serializers.save_npz(outfile, model)
def main(): parser = argparse.ArgumentParser(description='Chainer example: MNIST') 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=20, help='Number of sweeps over the dataset to train') parser.add_argument('--frequency', '-f', type=int, default=-1, help='Frequency of taking a snapshot') 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('--resume', '-r', default='', help='Resume the training from snapshot') parser.add_argument('--unit', '-u', type=int, default=1000, help='Number of units') parser.add_argument('--noplot', dest='plot', action='store_false', help='Disable PlotReport extension') args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# unit: {}'.format(args.unit)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') reset_seed(0) train_val, test = mnist.get_mnist(withlabel=True, ndim=1) train, valid = split_dataset_random(train_val, 50000, seed=0) print('Training dataset size:', len(train)) print('Validation dataset size:', len(valid)) batchsize = 128 train_iter = iterators.SerialIterator(train, batchsize) valid_iter = iterators.SerialIterator(valid, batchsize) test_iter = iterators.SerialIterator(test, batchsize) net = MLP(n_mid_units=args.unit) optimizer = chainer.optimizers.SGD(lr=0.01).setup(net) # 学習 gpu_id = args.gpu if gpu_id >= 0: net.to_gpu(gpu_id) while train_iter.epoch < args.epoch: #------------------------------- train_batch = train_iter.next() x, t = chainer.dataset.concat_examples(train_batch, args.gpu) y = net(x) loss = F.softmax_cross_entropy(y, t) net.cleargrads() loss.backward() optimizer.update() #----------------------------------- # 1エポックごとにValidationデータに対する予測精度を図ってモデルの汎化性能が向上していることをチェックしよう if train_iter.is_new_epoch: print("epoch:{:02d}train_loss:{:.04f}".format( train_iter.epoch, float(to_cpu(loss.data)) ), end='') valid_losses = [] valid_accuracies = [] while True: valid_batch = valid_iter.next() x_valid, t_valid = chainer.dataset.concat_examples(valid_batch, gpu_id) # validationデータをforward with chainer.using_config("train", False), chainer.using_config("enable_backprop", False): y_valid = net(x_valid) # lossを計算 loss_valid = F.softmax_cross_entropy(y_valid, t_valid) valid_losses.append(to_cpu(loss_valid.array)) # 精度を計算 accuracy = F.accuracy(y_valid, t_valid) accuracy.to_cpu() valid_accuracies.append(accuracy.array) if valid_iter.is_new_epoch: valid_iter.reset() break print("val_loss:{:.04f} val_accuracy:{:.04f}".format( numpy.mean(valid_losses), numpy.mean(valid_accuracies) )) # テストデータでの評価 test_accuracies = [] while True: test_batch = test_iter.next() x_test, t_test = chainer.dataset.concat_examples(test_batch, gpu_id) with chainer.using_config("train", False), chainer.using_config("enable_backprop", False): y_test = net(x_test) # 精度を計算 accuracy = F.accuracy(y_test, t_test) accuracy.to_cpu() test_accuracies.append(accuracy.array) if test_iter.is_new_epoch: test_iter.reset() break print("test_accuracy:{:.04f}".format(numpy.mean(test_accuracies)))
def main(): parser = argparse.ArgumentParser(description="Vanilla_AE") parser.add_argument("--batchsize", "-b", type=int, default=64) parser.add_argument("--epoch", "-e", type=int, default=100) parser.add_argument("--gpu", "-g", type=int, default=0) parser.add_argument("--snapshot", "-s", type=int, default=10) parser.add_argument("--n_dimz", "-z", type=int, default=16) parser.add_argument("--dataset", "-d", type=str, default='mnist') parser.add_argument("--network", "-n", type=str, default='conv') args = parser.parse_args() def transform(in_data): img = in_data img = resize(img, (32, 32)) return img def transform2(in_data): img, label = in_data img = resize(img, (32, 32)) return img, label #import program import Updater import Visualizer #print settings print("GPU:{}".format(args.gpu)) print("epoch:{}".format(args.epoch)) print("Minibatch_size:{}".format(args.batchsize)) print('') out = os.path.join('result', args.network) batchsize = args.batchsize gpu_id = args.gpu max_epoch = args.epoch train_val, _ = mnist.get_mnist(withlabel=False, ndim=3) train_val = TransformDataset(train_val, transform) #for visualize _, test = mnist.get_mnist(withlabel=True, ndim=3) test = TransformDataset(test, transform2) label1 = 1 label2 = 5 test1 = [i[0] for i in test if (i[1] == label1)] test2 = [i[0] for i in test if (i[1] == label2)] test1 = test1[0:5] test2 = test2[5:10] if args.network == 'conv': import Network.mnist_conv as Network elif args.network == 'fl': import Network.mnist_fl as Network else: raise Exception('Error!') AE = Network.AE(n_dimz=args.n_dimz, batchsize=args.batchsize) Critic = Network.Critic() train, valid = split_dataset_random(train_val, 50000, seed=0) #set iterator train_iter = iterators.SerialIterator(train, batchsize) valid_iter = iterators.SerialIterator(valid, batchsize, repeat=False, shuffle=False) #optimizer def make_optimizer(model, alpha=0.0002, beta1=0.5): optimizer = optimizers.Adam(alpha=alpha, beta1=beta1) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001)) return optimizer opt_AE = make_optimizer(AE) opt_Critic = make_optimizer(Critic) #trainer updater = Updater.ACAIUpdater(model=(AE, Critic), iterator=train_iter, optimizer={ 'AE': opt_AE, 'Critic': opt_Critic }, device=args.gpu) trainer = training.Trainer(updater, (max_epoch, 'epoch'), out=out) trainer.extend(extensions.LogReport(log_name='log')) snapshot_interval = (args.snapshot, 'epoch') display_interval = (1, 'epoch') trainer.extend(extensions.snapshot_object( AE, filename='AE_snapshot_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object( Critic, filename='Critic_snapshot_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.PrintReport( ['epoch', 'Critic_loss', 'AE_loss', 'rec_loss']), trigger=display_interval) trainer.extend(extensions.ProgressBar()) trainer.extend(Visualizer.out_generated_image(AE, Critic, test1, test2, out), trigger=(1, 'epoch')) trainer.run() del trainer
def main(): parser = argparse.ArgumentParser(description="DCGAN") parser.add_argument("--batchsize", "-b", type=int, default=64) parser.add_argument("--max_iter", type=int, default=100000) parser.add_argument("--gpu", "-g", type=int, default=0) parser.add_argument("--snapshot_interval", "-s", type=int, default=1000) parser.add_argument("--display_interval", "-d", type=int, default=100) parser.add_argument("--n_dimz", "-z", type=int, default=128) parser.add_argument("--dataset", "-ds", type=str, default="mnist") parser.add_argument("--seed", type=int, default=0) parser.add_argument("--out", "-o", type=str, default="result") parser.add_argument("--resume", '-r', default='') args = parser.parse_args() #import .py import Updater import Visualize if args.dataset == "mnist": import Network.mnist_net as Network else: import Network.cifar10_net as Network #print settings print("GPU:{}".format(args.gpu)) print("max_iter:{}".format(args.max_iter)) print("Minibatch_size:{}".format(args.batchsize)) print("Dataset:{}".format(args.dataset)) print('') out = os.path.join(args.out, args.dataset) #Set up NN gen = Network.DCGANGenerator(n_hidden=args.n_dimz) dis = Network.WGANDiscriminator() if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() gen.to_gpu() dis.to_gpu() #Make optimizer def make_optimizer(model, alpha=0.0002, 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) #Get dataset if args.dataset == "mnist": train, _ = mnist.get_mnist(withlabel=False, ndim=3, scale=1.) else: train, _ = chainer.datasets.get_cifar10(withlabel=False, scale=1.) #Setup iterator train_iter = iterators.SerialIterator(train, args.batchsize) #Setup updater updater = Updater.WGANUpdater(models=(gen, dis), iterator=train_iter, optimizer={ 'gen': opt_gen, 'dis': opt_dis }, n_dis=5, lam=10, device=args.gpu) #Setup trainer trainer = training.Trainer(updater, (args.max_iter, 'iteration'), out=out) snapshot_interval = (args.snapshot_interval, 'iteration') display_interval = (args.display_interval, 'iteration') trainer.extend( extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'), trigger=(args.epoch, 'epoch')) 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', 'loss_grad', 'wasserstein_distance', 'elapsed_time' ]), trigger=display_interval) trainer.extend(extensions.ProgressBar()) trainer.extend(Visualize.out_generated_image(gen, dis, 10, 10, args.seed, args.out, args.dataset), trigger=snapshot_interval) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()
def main(): random.seed(0) np.random.seed(0) batch_size = 128 max_epoch = 10 train, test = mnist.get_mnist(withlabel=True, ndim=1) train_iter = iterators.SerialIterator(train, batch_size) test_iter = iterators.SerialIterator(test, batch_size, repeat=False, shuffle=False) model = MLP() optimizer = optimizers.SGD(lr=0.01) optimizer.setup(model) while train_iter.epoch < max_epoch: train_batch = train_iter.next() # ミニバッチ化したtrainデータから入力データと正解ラベルの抽出をする(options: gpu_id=None) x, t = concat_examples(train_batch) y = model(x) loss = F.softmax_cross_entropy(y, t) model.cleargrads() loss.backward() optimizer.update() # 1poch辺りの精度検証 if train_iter.is_new_epoch: # 現在のepoch 学習時の誤り率の出力 print('epoch:{:02d} train_loss:{:.04f} '.format( train_iter.epoch, float(loss.data)), end='') test_losses = [] test_accuracies = [] while True: test_batch = test_iter.next() x_test, t_test = concat_examples(test_batch) y_test = model(x_test) loss_test = F.softmax_cross_entropy(y_test, t_test) test_losses.append(loss_test.data) accuracy = F.accuracy(y_test, t_test) test_accuracies.append(accuracy.data) if test_iter.is_new_epoch: test_iter.epoch = 0 test_iter.current_position = 0 test_iter.is_new_epoch = False test_iter._pushed_position = None break # テストデータにおける誤り率と精度の出力 print('val_loss:{:.04f} val_accuracy:{:.04f}'.format( np.mean(test_losses), np.mean(test_accuracies))) # to_gpuにしている場合はmodel.to_cpu()してcpuの学習モデルにした方が良い serializers.save_npz('mnist.model', model)