def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--epoch',
'-e',
default=100,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare VAE model, defined in net.py
model = net.VAE(784, args.dimz, 500)
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# Initialize
if args.initmodel:
chainer.serializers.load_npz(args.initmodel, model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist(withlabel=False)
if args.test:
train, _ = chainer.datasets.split_dataset(train, 100)
test, _ = chainer.datasets.split_dataset(test, 100)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up an updater. StandardUpdater can explicitly specify a loss function
# used in the training with 'loss_func' option
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)
trainer.extend(
extensions.Evaluator(test_iter,
model,
device=args.gpu,
eval_func=model.get_loss_func(k=10)))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/rec_loss',
'validation/main/rec_loss', 'elapsed_time'
]))
trainer.extend(extensions.ProgressBar())
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
model.to_cpu()
serializers.save_npz('model/vae.npz', model)
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--initmodel', '-m', default='',
help='Initialize the model from given file')
parser.add_argument('--resume', '-r', default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu', '-g', default=-1, type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--epoch', '-e', default=100, type=int,
help='number of epochs to learn')
parser.add_argument('--dimz', '-z', default=20, type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize', '-b', type=int, default=100,
help='learning minibatch size')
parser.add_argument('--test', action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--opt',default='adam')
parser.add_argument('--lr', type=float, default=0.001)
parser.add_argument('--mc', type=int, default=1)
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare VAE model, defined in net.py
model = net.VAE(784, args.dimz, 500)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(device_id=args.gpu).use()
model.to_gpu()
# Setup an optimizer
if args.opt == 'adam' :
optimizer = chainer.optimizers.Adam(alpha=args.lr)
# optimizer = chainer.optimizers.Adam()
else :
optimizer = chainer.optimizers.AdaGrad(lr=args.lr)
optimizer.setup(model)
# # Initialize
# if args.initmodel:
# chainer.serializers.load_npz(args.initmodel, model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist(withlabel=False)
train_label, test_label = chainer.datasets.get_mnist(withlabel=True)
print('mnist: ', train.shape)
# if args.test:
# train, _ = chainer.datasets.split_dataset(train, 100)
# test, _ = chainer.datasets.split_dataset(test, 100)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
train_iter_for_k = chainer.iterators.SerialIterator(train_label, args.batchsize,
repeat=False, shuffle=False)
test_iter_for_k = chainer.iterators.SerialIterator(test_label, args.batchsize,
repeat=False, shuffle=False)
# Set up an updater. StandardUpdater can explicitly specify a loss function
# used in the training with 'loss_func' option
updater = training.updaters.StandardUpdater(
train_iter, optimizer,
device=args.gpu, loss_func=model.get_loss_func(k=args.mc))
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu,
eval_func=model.get_loss_func(k=10)), name='val')
trainer.extend(net.VAE_Evaluator(train_iter_for_k, model,
device=args.gpu, access_name = 'train_acc', k=10), trigger=(20, 'epoch'))
trainer.extend(net.VAE_Evaluator(test_iter_for_k, model,
device=args.gpu, access_name='test_acc', k=10), trigger=(20, 'epoch'))
# trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}'), trigger=(20, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss',
'main/rec_loss', 'main/kl', 'elapsed_time', 'val/main/loss', 'val/main/rec_loss', 'val/main/kl',
'train_acc/acc', 'train_acc/ari', 'train_acc/nmi', 'test_acc/acc', 'test_acc/ari', 'test_acc/nmi']))
trainer.extend(extensions.PlotReport(['main/loss', 'main/rec_loss', 'main/kl', 'val/main/loss', 'val/main/rec_loss',
'val/main/kl'], x_key='epoch', file_name='loss.png'))
trainer.extend(extensions.PlotReport(
['train_acc/acc', 'train_acc/ari', 'train_acc/nmi', 'test_acc/acc', 'test_acc/ari', 'test_acc/nmi'], x_key='epoch',
file_name='accuracy.png'))
trainer.extend(net.sample_generate(model,args.out),trigger=(2, 'epoch'))
trainer.extend(extensions.ProgressBar())
# if args.resume:
# chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
# Visualize the results
def save_images(x, filename):
import matplotlib.pyplot as plt
plt.gray()
fig, ax = plt.subplots(3, 3, figsize=(9, 9), dpi=100)
for ai, xi in zip(ax.flatten(), x):
ai.imshow(xi.reshape(28, 28))
fig.savefig(filename)
model.to_cpu()
train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
x = chainer.Variable(np.asarray(train[train_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
save_images(x.array, os.path.join(args.out, 'train'))
save_images(x1.array, os.path.join(args.out, 'train_reconstructed'))
test_ind = [3, 2, 1, 18, 4, 8, 11, 17, 61]
x = chainer.Variable(np.asarray(test[test_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
save_images(x.array, os.path.join(args.out, 'test'))
save_images(x1.array, os.path.join(args.out, 'test_reconstructed'))
# draw images from randomly sampled z
z = chainer.Variable(
np.random.normal(0, 1, (9, args.dimz)).astype(np.float32))
x = model.decode(z)
save_images(x.array, os.path.join(args.out, 'sampled'))
mnist['data'] /= 255
mnist['target'] = mnist['target'].astype(np.int32)
if args.test:
mnist['data'] = mnist['data'][0:100]
mnist['target'] = mnist['target'][0:100]
N = 30
else:
N = 60000
x_train, x_test = np.split(mnist['data'], [N])
y_train, y_test = np.split(mnist['target'], [N])
N_test = y_test.size
# Prepare VAE model, defined in net.py
model = net.VAE(784, n_latent, 500)
if args.gpu >= 0:
cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
xp = np if args.gpu < 0 else cuda.cupy
# Setup optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)
# Init/Resume
if args.initmodel:
print('Load model from', args.initmodel)
serializers.load_npz(args.initmodel, model)
if args.resume:
print('Load optimizer state from', args.resume)
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--epoch',
'-e',
default=100,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare VAE model, defined in net.py
model = net.VAE(784, args.dimz, 500)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# Initialize / Resume
if args.initmodel:
chainer.serializers.load_npz(args.initmodel, model)
if args.resume:
chainer.serializers.load_npz(args.resume, optimizer)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist(withlabel=False)
if args.test:
train, _ = chainer.datasets.split_dataset(train, 100)
test, _ = chainer.datasets.split_dataset(test, 100)
train_count = len(train)
test_count = len(test)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
while train_iter.epoch < args.epoch:
sum_loss = 0
sum_rec_loss = 0
batch = train_iter.next()
x_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
# Update model based on the loss function
# defined by model.get_loss_func()
optimizer.update(model.get_loss_func(), x)
sum_loss += float(model.loss.data) * len(x.data)
sum_rec_loss += float(model.rec_loss.data) * len(x.data)
if train_iter.is_new_epoch:
print('train mean loss={}, mean reconstruction loss={}'.format(
sum_loss / train_count, sum_rec_loss / train_count))
# evaluation
sum_loss = 0
sum_rec_loss = 0
for batch in test_iter:
x_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
loss_func = model.get_loss_func(k=10)
loss_func(x)
sum_loss += float(model.loss.data) * len(x.data)
sum_rec_loss += float(model.rec_loss.data) * len(x.data)
test_iter.reset()
print('test mean loss={}, mean reconstruction loss={}'.format(
sum_loss / test_count, sum_rec_loss / test_count))
# Note that os.makedirs(path, exist_ok=True) can be used
# if this script only supports python3
if not os.path.exists(args.out):
os.mkdir(args.out)
# Save the model and the optimizer
print('save the model')
chainer.serializers.save_npz(os.path.join(args.out, 'mlp.model'), model)
print('save the optimizer')
chainer.serializers.save_npz(os.path.join(args.out, 'mlp.state'),
optimizer)
# Visualize the results
def save_images(x, filename):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(3, 3, figsize=(9, 9), dpi=100)
for ai, xi in zip(ax.flatten(), x):
ai.imshow(xi.reshape(28, 28))
fig.savefig(filename)
model.to_cpu()
train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
x = chainer.Variable(np.asarray(train[train_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
save_images(x.data, os.path.join(args.out, 'train'))
save_images(x1.data, os.path.join(args.out, 'train_reconstructed'))
test_ind = [3, 2, 1, 18, 4, 8, 11, 17, 61]
x = chainer.Variable(np.asarray(test[test_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
save_images(x.data, os.path.join(args.out, 'test'))
save_images(x1.data, os.path.join(args.out, 'test_reconstructed'))
# draw images from randomly sampled z
z = chainer.Variable(
np.random.normal(0, 1, (9, args.dimz)).astype(np.float32))
x = model.decode(z)
save_images(x.data, os.path.join(args.out, 'sampled'))
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--epoch',
'-e',
default=100,
type=int,
help='number of epochs to learn')
parser.add_argument('--dim-hidden',
'-u',
default=500,
type=int,
help='dimention of hidden layers')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--vqvae', action='store_true', help='Use VQVAE')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare VAE model, defined in net.py
if args.vqvae:
model = net.VQVAE(784, args.dimz, args.dim_hidden)
else:
model = net.VAE(784, args.dimz, args.dim_hidden)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# Setup an optimizer
optimizer = chainer.optimizers.Adam(1e-4)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.GradientClipping(5.))
# Initialize
if args.initmodel:
chainer.serializers.load_npz(args.initmodel, model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist(withlabel=False)
if args.test:
train, _ = chainer.datasets.split_dataset(train, 100)
test, _ = chainer.datasets.split_dataset(test, 100)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up an updater. StandardUpdater can explicitly specify a loss function
# used in the training with 'loss_func' option
updater = training.StandardUpdater(train_iter,
optimizer,
device=args.gpu,
loss_func=model.get_loss_func())
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(
extensions.Evaluator(test_iter,
model,
device=args.gpu,
eval_func=model.get_loss_func(k=10)))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/rec_loss',
'validation/main/rec_loss', 'main/other_loss',
'validation/main/other_loss', 'elapsed_time'
]))
trainer.extend(extensions.ProgressBar())
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
@chainer.training.make_extension()
def confirm_images(trainer):
# Visualize the results
def save_images(x, filename):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(3, 3, figsize=(9, 9), dpi=100)
for ai, xi in zip(ax.flatten(), x):
ai.imshow(xi.reshape(28, 28))
fig.savefig(filename)
plt.close()
model.to_cpu()
train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
x = chainer.Variable(np.asarray(train[train_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
save_images(x.data, os.path.join(args.out, 'train'))
save_images(x1.data, os.path.join(args.out, 'train_reconstructed'))
test_ind = [3, 2, 1, 18, 4, 8, 11, 17, 61]
x = chainer.Variable(np.asarray(test[test_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
save_images(x.data, os.path.join(args.out, 'test'))
save_images(x1.data, os.path.join(args.out, 'test_reconstructed'))
# draw images from randomly sampled z
if args.vqvae:
z = model.sample(size=9)
else:
z = chainer.Variable(
np.random.normal(0, 1, (9, args.dimz)).astype(np.float32))
x = model.decode(z)
save_images(x.data, os.path.join(args.out, 'sampled'))
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
trainer.extend(confirm_images, trigger=(args.epoch // 10, 'epoch'))
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--epoch',
'-e',
default=100,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
if 0 <= args.gpu:
cuda.get_device_from_id(args.gpu).use()
# net内VAEオブジェクトの生成
textVae = net.VAE(600, args.dimz, 300, 100)
chainer.serializers.load_npz("birds_txt.npz", textVae)
if 0 <= args.gpu:
textVae.to_gpu() # GPUを使うための処理
model = net_img.VAE(1, 20, 64, textVae)
chainer.serializers.load_npz("birds_all.npz", model)
if 0 <= args.gpu:
model.to_gpu() # GPUを使うための処理
# optimizer(パラメータ更新用)
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# モデルの読み込み npzはnumpy用
"""
if args.initmodel:
chainer.serializers.load_npz(args.initmodel, model)
"""
traint = np.load('birds_txt.npy')
traini = np.load('birds_img.npy')
traini = traini.reshape((len(traini), 1, 128, 128))
train = tuple_dataset.TupleDataset(traint, traini)
train, test = train_test_split(train, test_size=0.2, random_state=50)
#------------------イテレーターによるデータセットの設定-----------------------------------
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
#---------------------------------------------------------------
# Set up an updater. StandardUpdater can explicitly specify a loss function
# used in the training with 'loss_func' option
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)
trainer.extend(
extensions.Evaluator(test_iter,
model,
device=args.gpu,
eval_func=model.get_loss_func(k=10)))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/rec_loss',
'validation/main/rec_loss', 'elapsed_time'
]))
# trainer.extend(extensions.ProgressBar())
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# トレーナーの実行
#trainer.run()
# Visualize the results
def save_images(x, filename):
import matplotlib.pyplot as plt
import matplotlib.cm as cm
fig, ax = plt.subplots(3, 3, figsize=(9, 9), dpi=100)
for ai, xi in zip(ax.flatten(), x):
ai.imshow(xi.reshape(128, 128), cmap=cm.gray)
fig.savefig(filename)
#model.to_cpu()
train_ind = [4]
x = chainer.Variable(np.asarray(traint[train_ind]))
print(x)
with chainer.using_config('train', False), chainer.no_backprop_mode():
mu, ln_var = textVae.encode(x)
x2 = model.decode(mu)
print(x2)
save_images(x2.array, os.path.join(args.out, 'train'))
save_images(x2.array, os.path.join(args.out, 'train_reconstructed'))
def main():
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
default=20,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--out',
'-o',
type=str,
default='./result/',
help='dir to save snapshots.')
parser.add_argument('--interval',
'-i',
type=int,
default=5,
help='interval of save images.')
parser.add_argument
args = parser.parse_args()
batchsize = args.batchsize
n_epoch = args.epoch
n_latent = args.dimz
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare dataset
print('load MNIST dataset')
model = net.VAE(784, n_latent, 500)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
xp = np if args.gpu < 0 else cuda.cupy
# Setup optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
train, test = chainer.datasets.get_mnist(withlabel=False)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# 訓練結果をロード
chainer.serializers.load_npz(f'./result/vae/snapshot_epoch_20', trainer)
# 400個のランダムな正規分布の乱数ベクトルを生成
z = chainer.Variable(
np.random.normal(0, 1, (400, n_latent)).astype(np.float32))
# 乱数を元にデコード
x = model.decode(z)
save_image(x.data, "C.png")
def main():
parser = argparse.ArgumentParser(description='Chainer test:')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--epoch',
'-e',
default=100,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--vae', action='store_true', help='pre-training vae')
args = parser.parse_args()
train, test = chainer.datasets.get_mnist(ndim=3)
print('before:data: {0}, test: {1}'.format(np.shape(train), len(test)))
if args.vae:
model = net.VAE(784, args.dimz, 500)
serializers.load_npz('model/vae.npz', model)
datas, _ = chainer.datasets.get_mnist(withlabel=False)
print('datas: {0}, train: {1}'.format(datas.ndim, np.shape(train)))
x = chainer.Variable(np.asarray(datas))
with chainer.using_config('train', False), chainer.no_backprop_mode():
train = model.forward(x)
train = np.reshape(train, (len(x), 2))
print('after:train: {0}, test: {1}'.format(np.shape(train), len(test)))
# sys.exit()
# モデルの生成
model = net.CNN()
optimizer = optimizers.Adam()
optimizer.setup(model)
# パラメータの更新
iterator = iterators.SerialIterator(train, 1000)
updater = training.StandardUpdater(iterator, optimizer)
trainer = training.Trainer(updater, (10, 'epoch'))
trainer.run()
# 評価
ok = 0
for i in range(len(test)):
x = Variable(np.array([test[i][0]], dtype=np.float32))
t = test[i][1]
out = model.fwd(x)
ans = np.argmax(out.data)
if (ans == t):
ok += 1
print((ok * 1.0) / len(test))
def main():
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
default=20,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--out',
'-o',
type=str,
default='./result/',
help='dir to save snapshots.')
parser.add_argument('--interval',
'-i',
type=int,
default=5,
help='interval of save images.')
parser.add_argument
args = parser.parse_args()
batchsize = args.batchsize
n_epoch = args.epoch
n_latent = args.dimz
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare dataset
print('load MNIST dataset')
model = net.VAE(784, n_latent, 500)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
xp = np if args.gpu < 0 else cuda.cupy
# Setup optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
train, test = chainer.datasets.get_mnist(withlabel=False)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
if not os.path.exists(os.path.join(args.out, 'cg.dot')):
print('dump computational graph of `main/loss`')
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(
extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}'),
trigger=(args.interval, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# if you want to output different log files epoch by epoch,
# use below statement.
#trainer.extend(extensions.LogReport(log_name='log_'+'{epoch}'))
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss']))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# if you want to show the result images epoch by epoch,
# use the extension below.
@training.make_extension(trigger=(args.interval, 'epoch'))
def save_images(trainer):
out_dir = os.path.join(trainer.out,
'epoch_{}'.format(str(trainer.updater.epoch)))
if not os.path.exists(out_dir):
os.mkdir(out_dir)
train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
x = chainer.Variable(np.asarray(train[train_ind]), volatile='on')
x1 = model.decode(model.encode(x)[0])
save_image(x.data, filename=os.path.join(out_dir, 'train'))
save_image(x1.data,
filename=os.path.join(out_dir, 'train_reconstructed'))
test_ind = [3, 2, 1, 18, 4, 8, 11, 17, 61]
x = chainer.Variable(np.asarray(test[test_ind]), volatile='on')
x1 = model(x)
x1 = model.decode(model.encode(x)[0])
save_image(x.data, filename=os.path.join(out_dir, 'test'))
save_image(x1.data,
filename=os.path.join(out_dir, 'test_reconstructed'))
# draw images from randomly sampled z
z = chainer.Variable(
np.random.normal(0, 1, (9, n_latent)).astype(np.float32))
x = model.decode(z)
save_image(x.data, filename=os.path.join(out_dir, 'sampled'))
trainer.extend(save_images)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
import chainer
import numpy as np
traint = np.load('birds_txt.npy')
train_ind = [0]
xx = np.asarray(traint[train_ind])
o = xx.reshape((20, 30))
x = chainer.Variable(xx)
import net
#model = netF.VAE(4000, 10, 2000, 800, 100)
model = net.VAE(600, 20, 300, 100)
chainer.serializers.load_npz('birds_txt.npz', model)
mu, ln_var = model.encode(x)
y = model.decode(mu)
y = y.reshape((20, 30))
#yy.shape
from gensim.models import word2vec
w2v = word2vec.Word2Vec.load('birds_txt.model')
for w in y:
reconst = w2v.similar_by_vector(w.data, topn=1)
print(reconst)
print("================")
"""
reconst_words = [w2v.similar_by_vector(yy.data, topn=1)[0][0] for yy in y]
print(reconst_words)
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--epoch',
'-e',
default=100,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare VAE model, defined in net.py
model = net.VAE(784, args.dimz, 500)
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# Initialize
if args.initmodel:
chainer.serializers.load_npz(args.initmodel, model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist(withlabel=False)
if args.test:
train, _ = chainer.datasets.split_dataset(train, 100)
test, _ = chainer.datasets.split_dataset(test, 100)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up an updater. StandardUpdater can explicitly specify a loss function
# used in the training with 'loss_func' option
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)
trainer.extend(
extensions.Evaluator(test_iter,
model,
device=args.gpu,
eval_func=model.get_loss_func(k=10)))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/rec_loss',
'validation/main/rec_loss', 'elapsed_time'
]))
trainer.extend(extensions.ProgressBar())
@chainer.training.make_extension()
def out_generated_image(trainer):
train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
x = chainer.Variable(np.asarray(train[train_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
test_ind = [3, 2, 1, 18, 4, 8, 11, 17, 61]
x_test = chainer.Variable(np.asarray(test[test_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1_test = model(x)
# draw images from randomly sampled z
z = chainer.Variable(
np.random.normal(0, 1, (9, args.dimz)).astype(np.float32))
x_sampled = model.decode(z)
epoch = trainer.updater.epoch
iteration = trainer.updater.iteration
with summary.reporter(epoch=epoch, iteration=iteration) as r:
r.image(x.reshape(len(train_ind), 28, 28), 'train', row=3)
r.image(x1.reshape(len(train_ind), 28, 28),
'train_reconstructed',
row=3)
r.image(x_test.reshape(len(test_ind), 28, 28), 'test', row=3)
r.image(x1_test.reshape(len(test_ind), 28, 28),
'test_reconstructed',
row=3)
r.image(x_sampled.reshape(9, 28, 28), 'sampled', row=3)
trainer.extend(out_generated_image, trigger=(5, 'epoch'))
summary.set_out(args.out)
save_args(args, args.out)
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def get_my_train_set():
with open('data/arrays/X_fraud.pkl', 'rb') as f:
X_fraud = pickle.load(f)
print(X_fraud[0:2])
return X_fraud[0:200]
def get_normal_user():
with open('data/arrays/X_normal.pkl', 'rb') as f:
X_normal = pickle.load(f)
print(sum(X_normal))
return X_normal[0:200]
if __name__ == '__main__':
model = net.VAE()
checkpoint = torch.load('./model_file/VAE/autoencoder.t7')
model.load_state_dict(checkpoint['state'])
X_fraud = get_my_train_set()
#X_fraud = get_normal_user()
X_fraud = torch.FloatTensor(X_fraud)
mu, log = model.encode(X_fraud.view(-1, 42))
vec = model.reparametrize(mu, log)
vec = vec.detach().numpy()
fig = plt.figure()
ax1 = plt.axes(projection='3d')
ax1.scatter3D(vec[:, 0], vec[:, 1], vec[:, 2], cmap='Blue')
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--gpu',
default=0,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result/',
help='Directory to output the result')
parser.add_argument(
'--epoch_labelled',
'-e',
default=100,
type=int,
help='Number of epochs to learn only with labelled data')
parser.add_argument(
'--epoch_unlabelled',
'-u',
default=100,
type=int,
help='Number of epochs to learn with labelled and unlabelled data')
parser.add_argument('--dimz',
'-z',
default=2,
type=int,
help='Dimention of encoded vector')
parser.add_argument('--batchsize',
'-batch',
type=int,
default=128,
help='Learning minibatch size')
parser.add_argument('--data',
'-d',
default='sprites',
help='Name of the dataset to be used for experiments')
parser.add_argument('--model',
'-m',
default='conv',
help='Convolutional or linear model')
parser.add_argument('--beta',
'-b',
default=100,
help='Beta coefficient for the KL loss')
parser.add_argument('--gamma',
'-g',
default=100000,
help='Gamma coefficient for the classification loss')
parser.add_argument(
'--labels',
'-l',
default="composite",
help='Determined how to treat the labels for the different images')
parser.add_argument(
'--freq',
'-f',
default=10,
help='Frequency at which snapshots of the model are saved.')
parser.add_argument(
'--mode',
default="weakly",
help='Mode of training - weakly supervised or unsupervised')
args = parser.parse_args()
print('\n###############################################')
print('# GPU: \t\t\t{}'.format(args.gpu))
print('# dim z: \t\t{}'.format(args.dimz))
print('# Minibatch-size: \t{}'.format(args.batchsize))
print('# Epochs Labelled: \t{}'.format(args.epoch_labelled))
print('# Epochs Unabelled: \t{}'.format(args.epoch_unlabelled))
print('# Dataset: \t\t{}'.format(args.data))
print('# Model Architecture: \t{}'.format(args.model))
print('# Beta: \t\t{}'.format(args.beta))
print('# Gamma: \t\t{}'.format(args.gamma))
print('# Frequency: \t\t{}'.format(args.freq))
print('# Trainign model: \t{}'.format(args.model))
print('# Out Folder: \t\t{}'.format(args.out))
print('###############################################\n')
stats = {'train_loss': [], 'train_accs': [], 'valid_loss': [], 'valid_rec_loss': [], 'valid_label_loss': [],\
'valid_label_acc': [], 'valid_kl': []}
models_folder = os.path.join(args.out, "models")
manifold_gif = os.path.join(args.out, "gifs/manifold_gif")
scatter_gif = os.path.join(args.out, "gifs/scatter_gif")
scatter_folder = os.path.join(args.out, "scatter")
eval_folder = os.path.join(args.out, "eval")
shutil.rmtree(os.path.join(args.out, "models"))
os.mkdir(os.path.join(args.out, "models"))
if args.mode == "unsupervised":
ignore = []
else:
ignore = ["unlabelled"]
generator = data_generator.DataGenerator()
train, train_labels, train_concat, train_vectors, test, test_labels, test_concat, test_vectors, unseen,\
unseen_labels, unseen_concat, unseen_vectors, groups = generator.generate_dataset(ignore=ignore, args=args)
data_dimensions = train.shape
print('\n###############################################')
print("DATA_LOADED")
print("# Training: \t\t{0}".format(train.shape))
print("# Training labels: \t{0}".format(set(train_labels)))
print("# Training labels: \t{0}".format(train_labels.shape))
print("# Training vectors: \t{0}".format(train_vectors.shape))
print("# Testing: \t\t{0}".format(test.shape))
print("# Testing labels: \t{0}".format(set(test_labels)))
print("# Testing labels: \t{0}".format(test_labels.shape))
print("# Testing vectors: \t{0}".format(test_vectors.shape))
print("# Unseen: \t\t{0}".format(unseen.shape))
print("# Unseen labels: \t{0}".format(set(unseen_labels)))
print('###############################################\n')
train_iter = chainer.iterators.SerialIterator(train_concat, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_concat,
args.batchsize,
repeat=False,
shuffle=False)
# Prepare VAE model, defined in net.py
if args.model == "conv":
if args.data == "sprites":
model = net.Conv_VAE(train.shape[1],
n_latent=args.dimz,
groups=groups,
beta=args.beta,
gamma=args.gamma)
else:
model = net.Conv_VAE_MNIST(train.shape[1],
args.dimz,
beta=args.beta)
else:
model = net.VAE(train.shape[1], args.dimz, 500)
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
lf = model.get_loss_func()
stats, model, optimizer, epochs_so_far = training_loop(
model=model,
optimizer=optimizer,
stats=stats,
epochs=args.epoch_labelled,
train_iter=train_iter,
test_iter=test_iter,
lf=lf,
models_folder=models_folder,
args=args)
print("Save Model\n")
serializers.save_npz(os.path.join(models_folder, 'final.model'), model)
print("Save Optimizer\n")
serializers.save_npz(os.path.join(models_folder, 'final.state'), optimizer)
print("Clear Images from Last experiment\n")
clear_last_results(folder_name=args.out)
if args.mode == "weakly":
model.to_cpu()
config_parser = ConfigParser("config/config.json")
groups = config_parser.parse_groups()
# calculate manifold boundaries
latent = model.get_latent(test).data
mean = np.mean(latent, axis=0)
cov = np.cov(latent.T)
no_std = 2
# boundaries are [[min_x, min_y],[max_x, max_y]]
boundaries = np.array(
[mean - no_std * cov.diagonal(), mean + no_std * cov.diagonal()])
# assign colors to each label for plotting purposes
all_labels = np.append(test_labels, unseen_labels, axis=0)
colors = attach_colors(labels=all_labels)
# visualise the learnt data manifold in the latent space
print("Plot Reconstructed images sampeld from a standart Normal\n")
data = np.repeat(np.append(test, unseen, axis=0), 2, axis=0)
figure_title = "Manifold Visualisation"
plot_sampled_images(model=model,
data=data,
boundaries=boundaries,
image_size=data_dimensions[-1],
image_channels=data_dimensions[1],
filename=os.path.join(args.out, "manifold"),
figure_title=figure_title)
print("Performing Reconstructions\n")
perform_reconstructions(model=model,
train=train,
test=test,
unseen=unseen,
no_images=25,
name_suffix="supervised",
args=args)
os.mkdir(os.path.join(scatter_folder, "supervised"))
print("Plot Latent Testing Distribution for Singular Labels\n")
data = np.repeat(test, 2, axis=0)
plot_labels = test_labels
plot_separate_distributions(data=data,
labels=plot_labels,
groups=groups,
boundaries=boundaries,
colors=colors["singular"],
model=model,
filename=os.path.join(
scatter_folder, "supervised",
"singular_separate"))
plot_overall_distribution(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["singular"],
model=model,
filename=os.path.join(
scatter_folder, "supervised",
"singular_together"))
generator = data_generator.DataGenerator()
train, train_labels, train_concat, train_vectors, test, test_labels, test_concat, test_vectors, unseen,\
unseen_labels, unseen_concat, unseen_vectors, groups = generator.generate_dataset(args=args)
data_dimensions = train.shape
print('\n###############################################')
print("DATA_LOADED")
print("# Training: \t\t{0}".format(train.shape))
print("# Training labels: \t{0}".format(set(train_labels)))
print("# Training labels: \t{0}".format(train_labels.shape))
print("# Training vectors: \t{0}".format(train_vectors.shape))
print("# Testing: \t\t{0}".format(test.shape))
print("# Testing labels: \t{0}".format(set(test_labels)))
print("# Testing labels: \t{0}".format(test_labels.shape))
print("# Testing vectors: \t{0}".format(test_vectors.shape))
print("# Unseen: \t\t{0}".format(unseen.shape))
print("# Unseen labels: \t{0}".format(set(unseen_labels)))
print('###############################################\n')
train_iter = chainer.iterators.SerialIterator(train_concat,
args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_concat,
args.batchsize,
repeat=False,
shuffle=False)
model = net.Conv_VAE(train.shape[1],
n_latent=args.dimz,
groups=groups,
beta=args.beta,
gamma=args.gamma)
serializers.load_npz("result/models/final.model", model)
model.gamma = 10000
# model.beta = 1
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
lf = model.get_loss_func()
stats, model, optimizer, _ = training_loop(
model=model,
optimizer=optimizer,
stats=stats,
epochs=args.epoch_unlabelled,
train_iter=train_iter,
test_iter=test_iter,
lf=lf,
models_folder=models_folder,
epochs_so_far=epochs_so_far,
args=args)
########################################
########### RESULTS ANALYSIS ###########
########################################
model.to_cpu()
config_parser = ConfigParser("config/config.json")
groups = config_parser.parse_groups()
# calculate manifold boundaries
latent = model.get_latent(test).data
mean = np.mean(latent, axis=0)
cov = np.cov(latent.T)
# boundaries are [[min_x, min_y],[max_x, max_y]]
boundaries = np.array(
[mean - no_std * cov.diagonal(), mean + no_std * cov.diagonal()])
# assign colors to each label for plotting purposes
all_labels = np.append(test_labels, unseen_labels, axis=0)
colors = attach_colors(labels=all_labels)
# visualise the learnt data manifold in the latent space
print("Plot Reconstructed images sampeld from a standart Normal\n")
data = np.repeat(np.append(test, unseen, axis=0), 2, axis=0)
figure_title = "Manifold Visualisation"
plot_sampled_images(model=model,
data=data,
boundaries=boundaries,
image_size=data_dimensions[-1],
image_channels=data_dimensions[1],
filename=os.path.join(args.out, "manifold_1"),
figure_title=figure_title)
print("Test time Classification\n")
tmp_labels = test_time_classification(data_test=np.repeat(test, 2, axis=0),
data_all=np.append(test,
unseen,
axis=0),
labels=test_labels,
unseen_labels=unseen_labels,
groups=groups,
boundaries=boundaries,
model=model,
colors=colors,
folder_name=eval_folder)
print("Label Analisys\n")
true_labels = np.append(test_labels, unseen_labels, axis=0)
label_analysis(labels=true_labels,
predictions=tmp_labels,
groups=groups,
model=model,
folder_name=eval_folder)
print("Saving the loss plots\n")
plot_loss_curves(stats=stats, args=args)
print("Evaluate Axes Alignment\n")
data = np.repeat(np.append(test, unseen, axis=0), 2, axis=0)
plot_labels = np.append(test_labels, unseen_labels, axis=0)
axes_alignment(data=data,
labels=plot_labels,
model=model,
folder_name=eval_folder)
print("Performing Reconstructions\n")
perform_reconstructions(model=model,
train=train,
test=test,
unseen=unseen,
no_images=25,
name_suffix="weakly_supervised",
args=args)
print("Plot Latent Testing Distribution for Singular Labels\n")
data = np.repeat(test, 2, axis=0)
plot_labels = test_labels
plot_separate_distributions(data=data,
labels=plot_labels,
groups=groups,
boundaries=boundaries,
colors=colors["singular"],
model=model,
filename=os.path.join(scatter_folder,
"singular_separate"))
plot_overall_distribution(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["singular"],
model=model,
filename=os.path.join(scatter_folder,
"singular_together"))
print(
"Plot Latent Testing Distribution for Singular Labels + Unseen Distribution\n"
)
data = np.repeat(np.append(test, unseen, axis=0), 2, axis=0)
plot_labels = np.append(test_labels, unseen_labels, axis=0)
plot_separate_distributions(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["singular"],
model=model,
filename=os.path.join(
scatter_folder,
"singular_separate_unseen"))
plot_overall_distribution(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["singular"],
model=model,
filename=os.path.join(
scatter_folder, "singular_together_unseen"))
if args.labels == "composite":
print("Plot Latent Testing Distribution for Composite Labels\n")
# compose the composite labels
data = test
test_labels_tmp = test_labels.reshape(len(test_labels) / 2, 2)
plot_labels = np.array(["_".join(x) for x in test_labels_tmp])
plot_separate_distributions(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["composite"],
model=model,
filename=os.path.join(
scatter_folder, "composite_separate"))
plot_overall_distribution(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["composite"],
model=model,
filename=os.path.join(
scatter_folder, "composite_together"))
print(
"Plot Latent Testing Distribution for Composite Labels + Unseen Distribution\n"
)
data = np.append(test, unseen, axis=0)
test_labels_tmp = np.append(test_labels, unseen_labels, axis=0)
test_labels_tmp = test_labels_tmp.reshape(len(test_labels_tmp) / 2, 2)
plot_labels = np.array(["_".join(x) for x in test_labels_tmp])
plot_separate_distributions(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["composite"],
model=model,
filename=os.path.join(
scatter_folder,
"composite_separate_unseen"))
plot_overall_distribution(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["composite"],
model=model,
filename=os.path.join(
scatter_folder,
"composite_together_unseen"))
print("Generating data for retrospective model evaluation\n")
for model_name in list(
filter(lambda name: "final" not in name,
os.listdir(models_folder))):
serializers.load_npz(os.path.join(models_folder, model_name), model)
filename = model_name.replace(".model", "")
figure_title = "Manifold Visualisation for epoch {0}".format(filename)
data = np.repeat(np.append(test, unseen, axis=0), 2, axis=0)
plot_sampled_images(model=model,
data=data,
boundaries=boundaries,
image_size=data_dimensions[-1],
image_channels=data_dimensions[1],
filename=os.path.join(manifold_gif, filename),
figure_title=figure_title)
data = np.repeat(np.append(test, unseen, axis=0), 2, axis=0)
plot_labels = np.append(test_labels, unseen_labels, axis=0)
for key in groups:
if not os.path.exists(os.path.join(scatter_gif, key)):
os.mkdir(os.path.join(scatter_gif, key))
plot_group_distribution(data=data,
labels=plot_labels,
boundaries=boundaries,
colors=colors["singular"],
model=model,
group_id=key,
filename=os.path.join(
scatter_gif, key, filename))
print("Making the Latent Manifold GIF\n")
samples = [x.split('_')[0] for x in os.listdir(manifold_gif)]
rests = ['_'.join(x.split('_')[1:]) for x in os.listdir(manifold_gif)]
samples.sort(key=int)
samples = [
os.path.join(manifold_gif, x + "_" + rest)
for (x, rest) in zip(samples, rests)
]
result_name = os.path.join(manifold_gif, "samples_animation.gif")
subprocess.call(["convert", "-loop", "5", "-delay", "50"] + samples +
[result_name])
for key in groups:
print("Making the Composite Label Distribution GIF for group" + key +
"\n")
folder_name = os.path.join(scatter_gif, key)
distr = [x.replace(".png", "") for x in os.listdir(folder_name)]
distr.sort(key=int)
distr = [os.path.join(folder_name, x + ".png") for x in distr]
result_name = os.path.join(folder_name, "distr_animation.gif")
subprocess.call(["convert", "-loop", "5", "-delay", "50"] + distr +
[result_name])
def main():
parser = argparse.ArgumentParser(description='Chainer: VAE')
parser.add_argument('--initmodel', '-m', default='',
help='Initialize the model from given file')
parser.add_argument('--resume', '-r', default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu', '-g', default=0, type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='path/to/output',
help='Directory to output the result')
parser.add_argument('--epoch', '-e', default=100, type=int,
help='number of epochs to learn')
parser.add_argument('--dimz', '-z', default=20, type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize', '-b', type=int, default=25,
help='learning minibatch size')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# net内VAEオブジェクトの生成
model = net.VAE(600, args.dimz,300,100)
if 0 <= args.gpu:
cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # GPUを使うための処理
# optimizer(パラメータ更新用)
optimizer = chainer.optimizers.Adam()
# optimizer = chainer.optimizers.MomentumSGD()
optimizer.setup(model)
# モデルの読み込み npzはnumpy用
if args.initmodel:
chainer.serializers.load_npz(args.initmodel, model)
train = np.load('birds_txt.npy')
train, test = train_test_split(train, test_size=0.2)
#------------------イテレーターによるデータセットの設定-----------------------------------
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
#---------------------------------------------------------------
# Set up an updater. StandardUpdater can explicitly specify a loss function
# used in the training with 'loss_func' option
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)
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu,
eval_func=model.get_loss_func(k=1)))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.LogReport(log_name='my_log_data'))
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/rec_loss', 'validation/main/rec_loss', 'elapsed_time']))
# trainer.extend(extensions.ProgressBar())
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# トレーナーの実行
trainer.run()
#結合加重の表示させて、（上位何個かでもいい。） んで、ロードの時の上位と比べてちゃんと保存復元されてるかみてみる。
#https://qiita.com/mitmul/items/1e35fba085eb07a92560
serializers.save_npz("birds_txt.npz", model)
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--epoch',
'-e',
default=100,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# net内VAEオブジェクトの生成
model = net.VAE(784, args.dimz, 500)
if 0 <= args.gpu:
cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # GPUを使うための処理
xp = np if args.gpu < 0 else cuda.cupy
# optimizer(パラメータ更新用)
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# モデルの読み込み npzはnumpy用
if args.initmodel:
chainer.serializers.load_npz(args.initmodel, model)
# Load the MNIST dataset 訓練とテストのデータセット
train, test = chainer.datasets.get_mnist(withlabel=False)
if args.test:
train, _ = chainer.datasets.split_dataset(train, 100)
test, _ = chainer.datasets.split_dataset(test, 100)
#------------------イテレーターによるデータセットの設定-----------------------------------
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
#---------------------------------------------------------------
# Set up an updater. StandardUpdater can explicitly specify a loss function
# used in the training with 'loss_func' option
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)
trainer.extend(
extensions.Evaluator(test_iter,
model,
device=args.gpu,
eval_func=model.get_loss_func(k=10)))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/rec_loss',
'validation/main/rec_loss', 'elapsed_time'
]))
trainer.extend(extensions.ProgressBar())
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# トレーナーの実行
trainer.run()
# Visualize the results
def save_images(x, filename):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(3, 3, figsize=(9, 9), dpi=100)
for ai, xi in zip(ax.flatten(), x): #zip内のaxとxの要素を取り出す。
ai.imshow(xi.reshape(28, 28))
fig.savefig(filename)
train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
x = chainer.Variable(xp.asarray(train[train_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
print(args.out)
save_images(x.array, os.path.join(args.out, 'train'))
save_images(x1.array, os.path.join(args.out, 'train_reconstructed'))
test_ind = [3, 2, 1, 18, 4, 8, 11, 17, 61]
x = chainer.Variable(xp.asarray(test[test_ind]))
with chainer.using_config('train', False), chainer.no_backprop_mode():
x1 = model(x)
save_images(x.array, os.path.join(args.out, 'test'))
save_images(x1.array, os.path.join(args.out, 'test_reconstructed'))
# draw images from randomly sampled z
z = chainer.Variable(
xp.random.normal(0, 1, (9, args.dimz)).astype(xp.float32))
x = model.decode(z)
save_images(x.array, os.path.join(args.out, 'sampled'))
import chainer
import numpy as np
import argparse
import os
import chainer
from chainer import training
from chainer.training import extensions
from chainer.backends import cuda
from chainer import serializers
import numpy as np
from sklearn.model_selection import train_test_split
import net
model = net.VAE(784, 20, 500, 250)
chainer.serializers.load_npz('sample.npz', model)
train, test = chainer.datasets.get_mnist(withlabel=False)
result = 'result'
def save_images(x, filename):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(3, 3, figsize=(9, 9), dpi=100)
for ai, xi in zip(ax.flatten(), x):
ai.imshow(xi.reshape(28, 28))
fig.savefig(filename)
train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
