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)
