def get_dataset(dataset):
if dataset == "mnist":
# label 0 ~ 10
n_class = 10
# mnistのロード
train, test = get_mnist(ndim=3)
# 本来ならiteratorで回すがわかりやすようにデータとラベルで分割
train_dataset, test_dataset = split_dataset(train, test)
elif dataset == "cifar10":
# label
n_class = 10
# cifar10のロード
train, test = get_cifar10()
# 本来ならiteratorで回すがわかりやすようにデータとラベルで分割
train_dataset, test_dataset = split_dataset(train, test)
elif dataset == "cifar100":
# label
n_class = 100
# cifar100
train, test = get_cifar100()
# 本来ならiteratorで回すがわかりやすようにデータとラベルで分割
train_dataset, test_dataset = split_dataset(train, test)
else:
raise RuntimeError('Invalid dataset choice.')
return n_class, train_dataset, test_dataset
def main():
# define options
parser = argparse.ArgumentParser(
description='Training script of DenseNet on CIFAR-10 dataset')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Output directory')
parser.add_argument('--numlayers', '-L', type=int, default=40,
help='Number of layers')
args = parser.parse_args()
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
# setup model
model = L.Classifier(MyModel(10))
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
# そのオブジェクトに保存済みパラメータをロードする
serializers.load_npz('result/model_20.npz', model)
for i in range(10, 15):
predict(model, i, test)
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset', '-d', default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize', '-b', type=int, default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate', '-l', type=float, default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch', '-e', type=int, default=300,
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('--test', action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.test:
train = train[:200]
test = test[:200]
train_count = len(train)
test_count = len(test)
model = L.Classifier(models.VGG.VGG(class_labels))
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
sum_accuracy = 0
sum_loss = 0
while train_iter.epoch < args.epoch:
batch = train_iter.next()
# Reduce learning rate by 0.5 every 25 epochs.
if train_iter.epoch % 25 == 0 and train_iter.is_new_epoch:
optimizer.lr *= 0.5
print('Reducing learning rate to: ', optimizer.lr)
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
optimizer.update(model, x, t)
sum_loss += float(model.loss.data) * len(t.data)
sum_accuracy += float(model.accuracy.data) * len(t.data)
if train_iter.is_new_epoch:
print('epoch: ', train_iter.epoch)
print('train mean loss: {}, accuracy: {}'.format(
sum_loss / train_count, sum_accuracy / train_count))
# evaluation
sum_accuracy = 0
sum_loss = 0
model.predictor.train = False
for batch in test_iter:
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
loss = model(x, t)
sum_loss += float(loss.data) * len(t.data)
sum_accuracy += float(model.accuracy.data) * len(t.data)
test_iter.reset()
model.predictor.train = True
print('test mean loss: {}, accuracy: {}'.format(
sum_loss / test_count, sum_accuracy / test_count))
sum_accuracy = 0
sum_loss = 0
# Save the model and the optimizer
print('save the model')
serializers.save_npz('mlp.model', model)
print('save the optimizer')
serializers.save_npz('mlp.state', optimizer)
if dataset == "mnist":
# label 0 ~ 10
n_class = 10
# mnistのロード
train, test = get_mnist(ndim=3)
# 本来ならiteratorで回すがわかりやすようにデータとラベルで分割
train_dataset, test_dataset = split_dataset(train, test)
train_x = np.array(train_dataset[0])
train_y = np.array(train_dataset[1])
elif dataset == "cifar10":
# label
n_class = 10
# cifar10のロード
train, test = get_cifar10()
# 本来ならiteratorで回すがわかりやすようにデータとラベルで分割
train_dataset, test_dataset = split_dataset(train, test)
train_x = np.array(train_dataset[0])
train_y = np.array(train_dataset[1])
elif dataset == "cifar100":
# label
n_class = 100
# cifar100
train, test = get_cifar100()
# 本来ならiteratorで回すがわかりやすようにデータとラベルで分割
train_dataset, test_dataset = split_dataset(train, test)
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset',
'-d',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate',
'-l',
type=float,
default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
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('--early-stopping',
type=str,
help='Metric to watch for early stopping')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
model = L.Classifier(models.VGG.VGG(class_labels))
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(5e-4))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
stop_trigger = (args.epoch, 'epoch')
# Early stopping option
if args.early_stopping:
stop_trigger = triggers.EarlyStoppingTrigger(
monitor=args.early_stopping,
verbose=True,
max_trigger=(args.epoch, 'epoch'))
# Set up a trainer
updater = training.updaters.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = training.Trainer(updater, stop_trigger, out=args.out)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Reduce the learning rate by half every 25 epochs.
trainer.extend(extensions.ExponentialShift('lr', 0.5),
trigger=(25, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# 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', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def get_dataset(dataset_name):
if dataset_name == 'mnist':
return get_mnist(ndim=3)
if dataset_name == 'cifar10':
return get_cifar10(ndim=3)
raise NameError('{}'.format(dataset_name))
return canvas
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--nb_samples', type=int, default=1000)
parser.add_argument('--nn_jobs', type=int, default=12)
parser.add_argument('--k', type=int, default=10)
parser.add_argument('--seed', type=int, default=1701)
args = parser.parse_args()
logger.info(__file__)
logger.info(vars(args))
start = time.time()
np.random.seed(args.seed)
train, _ = get_cifar10()
if args.nb_samples != -1:
choice = np.random.choice(len(train), args.nb_samples, replace=False)
data, label = train[choice, ...]
else:
data, label = train[range(len(train)), ...]
nn = NearestNeighbors(n_neighbors=args.k,
algorithm="ball_tree",
n_jobs=args.nn_jobs)
neighbors = nn.fit(data.reshape((len(data), -1)))
nn_result = neighbors.kneighbors(data.reshape((len(data), -1)))
canvas = plot_nn(data, label, nn_result, args.k)
cv2.imwrite("nn.jpg", canvas)
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset',
'-d',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate',
'-l',
type=float,
default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
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('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.test:
train = train[:200]
test = test[:200]
train_count = len(train)
test_count = len(test)
model = L.Classifier(models.VGG.VGG(class_labels))
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
sum_accuracy = 0
sum_loss = 0
while train_iter.epoch < args.epoch:
batch = train_iter.next()
# Reduce learning rate by 0.5 every 25 epochs.
if train_iter.epoch % 25 == 0 and train_iter.is_new_epoch:
optimizer.lr *= 0.5
print('Reducing learning rate to: ', optimizer.lr)
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
optimizer.update(model, x, t)
sum_loss += float(model.loss.data) * len(t.data)
sum_accuracy += float(model.accuracy.data) * len(t.data)
if train_iter.is_new_epoch:
print('epoch: ', train_iter.epoch)
print('train mean loss: {}, accuracy: {}'.format(
sum_loss / train_count, sum_accuracy / train_count))
# evaluation
sum_accuracy = 0
sum_loss = 0
model.predictor.train = False
for batch in test_iter:
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
loss = model(x, t)
sum_loss += float(loss.data) * len(t.data)
sum_accuracy += float(model.accuracy.data) * len(t.data)
test_iter.reset()
model.predictor.train = True
print('test mean loss: {}, accuracy: {}'.format(
sum_loss / test_count, sum_accuracy / test_count))
sum_accuracy = 0
sum_loss = 0
# Save the model and the optimizer
print('save the model')
serializers.save_npz('mlp.model', model)
print('save the optimizer')
serializers.save_npz('mlp.state', optimizer)
from lib.datasets import get_celeba
from lib.extensions import GeneratorSampler
from lib.iterators import RandomNoiseIterator
from lib.iterators import UniformNoiseGenerator
from lib.models import Discriminator
from lib.models import Generator
from lib.updater import BEGANUpdater
if __name__ == '__main__':
args = config.parse_args()
if args.dataset == 'celeba':
train = get_celeba(args.celeba_root, args.celeba_scale, crop='face')
elif args.dataset == 'cifar10':
train, _ = get_cifar10(withlabel=False, scale=2.0)
train -= 1.0
train_iter = iterators.SerialIterator(train, args.batch_size)
z_iter = RandomNoiseIterator(UniformNoiseGenerator(-1, 1, args.n_z),
args.batch_size)
g = Generator(
n=args.g_n,
out_size=train[0].shape[1],
out_channels=train[0].shape[0],
block_size=args.g_block_size,
embed_size=args.g_embed_size)
d = Discriminator(
n=args.d_n,
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--model', '-m', type=str, default=None)
parser.add_argument('--opt', type=str, default=None)
parser.add_argument('--epoch', '-e', type=int, default=20)
parser.add_argument('--lr', '-l', type=float, default=0.001)
parser.add_argument('--batch', '-b', type=int, default=32)
parser.add_argument('--noplot', dest='plot', action='store_false')
args = parser.parse_args()
# Set up a neural network to train.
train_x, test_x = get_cifar10(withlabel=False, ndim=3)
train = LoadDataset(train_x)
test = LoadDataset(test_x)
train_iter = iterators.SerialIterator(train,
batch_size=args.batch,
shuffle=True)
test_iter = iterators.SerialIterator(test,
batch_size=args.batch,
repeat=False,
shuffle=False)
# Define model
model = network.CAE(3, 3)
# Load weight
if args.model != None:
print("loading model from " + args.model)
serializers.load_npz(args.model, model)
if args.gpu >= 0:
cuda.get_device_from_id(0).use()
model.to_gpu()
# Define optimizer
opt = optimizers.Adam(alpha=args.lr)
opt.setup(model)
if args.opt != None:
print("loading opt from " + args.opt)
serializers.load_npz(args.opt, opt)
# Set up a trainer
updater = training.StandardUpdater(train_iter, opt, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out='results')
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
trainer.extend(extensions.LogReport(trigger=(10, 'iteration')))
if args.plot and extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',
file_name='loss.png'))
trainer.extend(
extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss']))
trainer.extend(extensions.ProgressBar(update_interval=1))
# Train
trainer.run()
# Save results
modelname = "./results/model"
print("saving model to " + modelname)
serializers.save_npz(modelname, model)
optname = "./results/opt"
print("saving opt to " + optname)
serializers.save_npz(optname, opt)
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--model', default='c3f2')
parser.add_argument('--batchsize', '-b', type=int, default=64)
parser.add_argument('--learnrate', '-l', type=float, default=0.05)
parser.add_argument('--epoch', '-e', type=int, default=300)
parser.add_argument('--gpu', '-g', type=int, default=0)
parser.add_argument('--N', type=int, default=9)
parser.add_argument('--k', type=int, default=10)
parser.add_argument('--nb_valid', type=int, default=10000)
parser.add_argument('--seed', type=int, default=1701)
parser.add_argument('--out', '-o', default='result')
parser.add_argument('--debug', action='store_true')
parser.add_argument('--test', action='store_true')
parser.add_argument('--resume', '-r', default='')
args = parser.parse_args()
start = time.time()
logger.initialize("outputs_" + args.model)
logger.info(vars(args))
np.random.seed(args.seed)
save_dir = logger.get_savedir()
logger.info("Written to {}".format(save_dir))
logger.info('GPU: {}'.format(args.gpu))
logger.info('# Minibatch-size: {}'.format(args.batchsize))
logger.info('# epoch: {}'.format(args.epoch))
logger.info('')
train_all, test = get_cifar10()
if args.debug:
train, valid, test = train_all[:200], train_all[200:400], test[:200]
batchsize = 20
else:
valid_choice = np.random.choice(range(len(train_all)),
args.nb_valid,
replace=False)
train = [
x for idx, x in enumerate(train_all) if idx not in valid_choice
]
valid = [x for idx, x in enumerate(train_all) if idx in valid_choice]
batchsize = args.batchsize
#import pdb;pdb.set_trace()
train_cnt, valid_cnt, test_cnt = len(train), len(valid), len(test)
print(train_cnt, valid_cnt, test_cnt)
model = get_model(args.model, args.gpu, args.resume)
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
train_iter = chainer.iterators.SerialIterator(train, batchsize)
valid_iter = chainer.iterators.SerialIterator(valid,
batchsize,
repeat=False,
shuffle=False)
sum_accuracy = 0
sum_loss = 0
st = time.time()
iter_cnt = 0
chainer.config.train = True
chainer.config.enable_backprop = True
logger.info("Training...")
while train_iter.epoch < args.epoch:
batch = train_iter.next()
if train_iter.epoch % 60 == 0 and train_iter.is_new_epoch:
optimizer.lr *= 0.2
logger.info('Reducing learning rate to: {}'.format(optimizer.lr))
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
model.cleargrads()
loss = model(x, t)
loss.backward()
loss.unchain_backward()
optimizer.update()
sum_loss += float(model.loss.data) * len(t.data)
sum_accuracy += float(model.accuracy.data) * len(t.data)
if train_iter.is_new_epoch:
train_loss = sum_loss / train_cnt
train_acc = sum_accuracy / train_cnt
# validation
sum_accuracy = 0
sum_loss = 0
chainer.config.train = False
chainer.config.enable_backprop = False
for batch in valid_iter:
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
loss = model(x, t)
sum_loss += float(loss.data) * len(t.data)
sum_accuracy += float(model.accuracy.data) * len(t.data)
valid_iter.reset()
valid_loss = sum_loss / valid_cnt
valid_acc = sum_accuracy / valid_cnt
message_str = "Epoch {}: train loss={:.4f}, acc={:.4f}, valid loss={:.4f}, acc={:.4f}, elapsed={}"
logger.info(
message_str.format(train_iter.epoch, train_loss, train_acc,
valid_loss, valid_acc,
time.time() - st))
st = time.time()
chainer.config.train = True
chainer.config.enable_backprop = True
sum_accuracy = 0
sum_loss = 0
if not args.debug:
serializers.save_npz(
os.path.join(
save_dir,
"model_holdout_ep_{}.npz".format(train_iter.epoch)),
model)
iter_cnt += 1
if not test:
print(time.time() - start)
exit(1)
logger.info("Test...")
test_iter = chainer.iterators.SerialIterator(test,
batchsize,
repeat=False,
shuffle=False)
sum_accuracy = 0
sum_loss = 0
chainer.config.train = False
chainer.config.enable_backprop = False
st = time.time()
for batch in test_iter:
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
loss = model(x, t)
sum_loss += float(loss.data) * len(t.data)
sum_accuracy += float(model.accuracy.data) * len(t.data)
test_loss = sum_loss / test_cnt
test_acc = sum_accuracy / test_cnt
message_str = "test loss={:.4f}, acc={:.4f}, elapsed={}"
logger.info(message_str.format(test_loss, test_acc, time.time() - st))
print(time.time() - start)
def load_dataset(batchsize,
dataset,
augment=False,
fast=False,
old_test_method=False):
scale = 255.0 if augment else 1.0
if dataset == 'cifar10':
train, test = get_cifar10(scale=scale)
class_labels = 10
elif dataset == 'cifar100':
train, test = get_cifar100(scale=scale)
class_labels = 100
else:
raise RuntimeError('Invalid dataset choice.')
if augment:
#mean = np.mean(train._datasets[0], axis=(0, 2, 3))
#std = np.std(train._datasets[0], axis=(0, 2, 3))
# Pre calculated from above
mean = np.array([125.30690002, 122.95014954, 113.86599731])
std = np.array([62.9932518, 62.08860397, 66.70500946])
train = normalize_dataset(train, mean, std)
test = normalize_dataset(test, mean, std)
# Previously pca was 25.5 or 10% of 255
# Now we normalize, so to keep PCA at 10% of the range we use the min and max of the
# normalized datasets
#pca_sigma = 0.2 * (np.max(train._datasets[0] - np.min(train._datasets[0])
# Pre calculated from above
pca_sigma = 0.1 * ((2.126797) - (-1.9892114)) # = 0.4116
slow_augment = dict(crop_size=(32, 32),
expand_ratio=1.2,
pca_sigma=pca_sigma,
random_angle=15.0,
train=True)
fast_augment = dict(crop_size=(32, 32), cutout=8, flip=True)
if fast:
train = pad_dataset(train, pad=4)
train_transform = partial(transform_fast, **fast_augment)
test_transform = lambda x: x # No augmentation
else:
train_transform = partial(transform, **slow_augment)
test_transform = partial(transform,
train=False,
old_test_method=old_test_method)
train = TransformDataset(train, train_transform)
test = TransformDataset(test, test_transform)
train_iter = chainer.iterators.SerialIterator(train, batchsize)
test_iter = chainer.iterators.SerialIterator(test,
batchsize,
repeat=False,
shuffle=False)
return train_iter, test_iter, class_labels
def main():
parser = argparse.ArgumentParser(description='Chainer: WGAN-GP ciafr10')
parser.add_argument('--batchsize',
'-b',
type=int,
default=50,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--n_hidden',
'-n',
type=int,
default=100,
help='Number of hidden dim of units (z)')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed of z at visualization stage')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
parser.add_argument('--lam',
type=int,
default=10,
help='lambda of gp in critic')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# n_hidden: {}'.format(args.n_hidden))
print('# epoch: {}'.format(args.epoch))
print('')
train, _ = datasets.get_cifar10(withlabel=False, ndim=3,
scale=1.) # ndim=3 : (ch,width,height)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
#z_iter = RandomNoiseIterator(GaussianNoiseGenerator(0, 1, args.n_hidden), args.batchsize)
z_iter = RandomNoiseIterator(UniformNoiseGenerator(-1, 1, args.n_hidden),
args.batchsize)
# make the model
gen = Generator(n_hidden=args.n_hidden)
critic = Critic()
if args.gpu >= 0:
# make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
gen.to_gpu() # copy the model to the GPU
critic.to_gpu()
# make the optimizer
optimizer_generator = optimizers.Adam(alpha=0.0001, beta1=0.5, beta2=0.9)
optimizer_critic = optimizers.Adam(alpha=0.0001, beta1=0.5, beta2=0.9)
optimizer_generator.setup(gen)
optimizer_critic.setup(critic)
updater = WGANGPUpdater(iterator=train_iter,
noise_iterator=z_iter,
optimizer_generator=optimizer_generator,
optimizer_critic=optimizer_critic,
device=args.gpu,
batch_size=args.batchsize,
lam=args.lam)
epoch_interval = (1, 'epoch')
display_interval = (10, 'iteration')
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(
extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
gen, 'gen_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.snapshot_object(
critic, 'critic_epoch_{.updater.epoch}.npz'),
trigger=epoch_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'critic/loss', 'critic/loss/real',
'critic/loss/fake', 'critic/loss/gp', 'generator/loss', 'wasserstein'
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_generated_image(gen, 10, 10, args.seed, args.out,
args.n_hidden),
trigger=epoch_interval)
trainer.run()
def get_chainer_cifar10():
raw_train, raw_test = datasets.get_cifar10(withlabel=True, ndim=3, scale=1.)
return process_data(raw_train, raw_test)
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset', '-d', default='cifar100',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--model', '-m', default='VGG16',
help='The model to use: VGG16 or PreResNet110'
' or WideResNet28x10')
parser.add_argument('--batchsize', '-b', type=int, default=128,
help='Number of images in each mini-batch')
parser.add_argument('--lr_init', '-l', type=float, default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch', '-e', type=int, default=200,
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('--wd', type=float, default=1e-4,
help='weight decay')
parser.add_argument('--swa', action='store_true',
help='swa usage flag')
parser.add_argument('--swa_start', type=float, default=161,
help='SWA start epoch number')
parser.add_argument('--swa_lr', type=float, default=0.05,
help='SWA LR')
parser.add_argument('--swa_c_epochs', type=int, default=1,
help='SWA model collection frequency length in epochs')
args = parser.parse_args()
if args.dataset.lower() == 'cifar10':
print('Using CIFAR10 dataset')
class_labels = 10
train, test = get_cifar10()
elif args.dataset.lower() == 'cifar100':
print('Using CIFAR100 dataset')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
print('Using %s model' % args.model)
if args.model == 'VGG16':
model_cls = VGG16
elif args.model == 'PreResNet110':
model_cls = PreResNet110
elif args.model == 'WideResNet28x10':
model_cls = WideResNet28x10
else:
raise RuntimeError('Invalid model choice.')
model = L.Classifier(model_cls(class_labels))
if args.swa:
swa_model = L.Classifier(model_cls(class_labels))
swa_n = 0
if args.gpu >= 0:
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
if args.swa:
swa_model.to_gpu()
# Data augmentation / preprocess
train = TransformDataset(train, partial(transform, train=True))
test = TransformDataset(test, partial(transform, train=False))
optimizer = chainer.optimizers.MomentumSGD(args.lr_init, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(args.wd))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
swa_train_iter = chainer.iterators.SerialIterator(
train, args.batchsize, repeat=False, shuffle=False)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
stop_trigger = (args.epoch, 'epoch')
# Set up a trainer
updater = training.updaters.StandardUpdater(
train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, stop_trigger, out=args.out)
# Learning rate adjustment (this function is called every epoch)
def lr_schedule(trainer):
epoch = trainer.updater.epoch
t = epoch / (args.swa_start if args.swa else args.epoch)
lr_ratio = args.swa_lr / args.lr_init if args.swa else 0.01
if t <= 0.5:
factor = 1.0
elif t <= 0.9:
factor = 1.0 - (1.0 - lr_ratio) * (t - 0.5) / 0.4
else:
factor = lr_ratio
trainer.updater.get_optimizer('main').lr = factor * args.lr_init
# The main function for SWA (this function is called every epoch)
def avg_weight(trainer):
epoch = trainer.updater.epoch
if args.swa and (epoch + 1) >= args.swa_start and \
(epoch + 1 - args.swa_start) % args.swa_c_epochs == 0:
nonlocal swa_n
# moving average
alpha = 1.0 / (swa_n + 1)
for param1, param2 in zip(swa_model.params(), model.params()):
param1.data *= (1.0 - alpha)
param1.data += param2.data * alpha
swa_n += 1
# This funtion is called before evaluating SWA model
# for fixing batchnorm's running mean and variance
def fix_swa_batchnorm(evaluator):
# Check batchnorm layer
bn_flg = False
for l in swa_model.links():
if type(l) == L.normalization.batch_normalization.BatchNormalization:
bn_flg = True
break
# Fix batchnorm's running mean and variance
if bn_flg:
swa_train_iter.reset()
with chainer.using_config('train', True):
for batch in swa_train_iter:
in_arrays = evaluator.converter(batch, evaluator.device)
with function.no_backprop_mode():
swa_model(*in_arrays)
# Set up extentions
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu),
trigger=(5, 'epoch'))
if args.swa:
eval_points = [x for x in range(args.epoch + 1)
if x > args.swa_start and x % 5 == 0]
trainer.extend(SwaEvaluator(test_iter, swa_model, device=args.gpu, eval_hook=fix_swa_batchnorm),
trigger=triggers.ManualScheduleTrigger(eval_points, 'epoch'))
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(lr_schedule, trigger=triggers.IntervalTrigger(1, 'epoch'))
trainer.extend(avg_weight, trigger=triggers.IntervalTrigger(1, 'epoch'))
trainer.extend(extensions.observe_lr())
trainer.extend(extensions.LogReport())
cols = ['epoch', 'lr', 'main/loss', 'main/accuracy',
'validation/main/loss', 'validation/main/accuracy', 'elapsed_time']
if args.swa:
cols = cols[:-1] + ['swa/main/loss', 'swa/main/accuracy'] + cols[-1:]
trainer.extend(extensions.PrintReport(cols))
trainer.extend(extensions.ProgressBar())
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset', default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize', '-b', type=int, default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate', '-l', type=float, default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch', '-e', type=int, default=300,
help='Number of sweeps over the dataset to train')
parser.add_argument('--device', '-d', type=str, default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--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('--early-stopping', type=str,
help='Metric to watch for early stopping')
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu', '-g', dest='device',
type=int, nargs='?', const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
device = chainer.get_device(args.device)
device.use()
print('Device: {}'.format(device))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
model = L.Classifier(models.VGG.VGG(class_labels))
model.to_device(device)
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(5e-4))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
stop_trigger = (args.epoch, 'epoch')
# Early stopping option
if args.early_stopping:
stop_trigger = triggers.EarlyStoppingTrigger(
monitor=args.early_stopping, verbose=True,
max_trigger=(args.epoch, 'epoch'))
# Set up a trainer
updater = training.updaters.StandardUpdater(
train_iter, optimizer, device=device)
trainer = training.Trainer(updater, stop_trigger, out=args.out)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=device))
# Reduce the learning rate by half every 25 epochs.
trainer.extend(extensions.ExponentialShift('lr', 0.5),
trigger=(25, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
# TODO(imanishi): Support for ChainerX
if not isinstance(device, backend.ChainerxDevice):
trainer.extend(extensions.DumpGraph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(
filename='snaphot_epoch_{.updater.epoch}'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# 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',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset',
'-d',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate',
'-l',
type=float,
default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=150,
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('--augmentation',
action='store_true',
help='Apply augmentation.')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
chainer.cuda.set_max_workspace_size(512 * 1024 * 1024)
chainer.config.autotune = True
chainer.config.cudnn_fast_batch_normalization = True
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
model = L.Classifier(ResNet(class_labels, augmentation=args.augmentation))
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(5e-4))
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.updaters.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))
# Reduce the learning rate by 0.2 every 60 epochs.
trainer.extend(extensions.ExponentialShift('lr', 0.2),
trigger=(60, 'epoch'))
# Take a snapshot at every 50 epochs
trainer.extend(
extensions.snapshot(filename='snaphot_epoch_{.updater.epoch}'),
trigger=(50, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# 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', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate',
'-l',
type=float,
default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
help='Number of sweeps over the dataset to train')
parser.add_argument('--device',
'-d',
type=str,
default='0',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu',
'-g',
dest='device',
type=int,
nargs='?',
const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
if chainer.get_dtype() == numpy.float16:
warnings.warn('This example may cause NaN in FP16 mode.',
RuntimeWarning)
device = chainer.get_device(args.device)
print('Device: {}'.format(device))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
device.use()
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.test:
train = train[:200]
test = test[:200]
test_count = len(test)
model = L.Classifier(models.VGG.VGG(class_labels))
model.to_device(device)
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
if device.xp is not chainerx:
run_train_loop(optimizer, train_iter, test_iter, test_count,
args.epoch, device)
else:
warnings.warn(
'Static subgraph optimization does not support ChainerX and will'
' be disabled.', UserWarning)
with chainer.using_config('use_static_graph', False):
run_train_loop(optimizer, train_iter, test_iter, test_count,
args.epoch, device)
# Save the model and the optimizer
print('save the model')
serializers.save_npz('mlp.model', model)
print('save the optimizer')
serializers.save_npz('mlp.state', optimizer)
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate',
'-l',
type=float,
default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
help='Number of sweeps over the dataset to train')
parser.add_argument('--device',
'-d',
type=str,
default='0',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu',
'-g',
dest='device',
type=int,
nargs='?',
const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
if chainer.get_dtype() == numpy.float16:
warnings.warn('This example may cause NaN in FP16 mode.',
RuntimeWarning)
device = chainer.get_device(args.device)
if device.xp is chainerx:
sys.stderr.write('This example does not support ChainerX devices.\n')
sys.exit(1)
print('Device: {}'.format(device))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
device.use()
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.test:
train = train[:200]
test = test[:200]
train_count = len(train)
test_count = len(test)
model = L.Classifier(models.VGG.VGG(class_labels))
model.to_device(device)
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
sum_accuracy = 0
sum_loss = 0
while train_iter.epoch < args.epoch:
batch = train_iter.next()
# Reduce learning rate by 0.5 every 25 epochs.
if train_iter.epoch % 25 == 0 and train_iter.is_new_epoch:
optimizer.lr *= 0.5
print('Reducing learning rate to: {}'.format(optimizer.lr))
x_array, t_array = convert.concat_examples(batch, device)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array, requires_grad=False)
optimizer.update(model, x, t)
sum_loss += float(model.loss.array) * len(t)
sum_accuracy += float(model.accuracy.array) * len(t)
if train_iter.is_new_epoch:
print('epoch: {}'.format(train_iter.epoch))
print('train mean loss: {}, accuracy: {}'.format(
sum_loss / train_count, sum_accuracy / train_count))
# evaluation
sum_accuracy = 0
sum_loss = 0
model.predictor.train = False
# It is good practice to turn off train mode during evaluation.
with configuration.using_config('train', False):
for batch in test_iter:
x_array, t_array = convert.concat_examples(batch, device)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array, requires_grad=False)
loss = model(x, t)
sum_loss += float(loss.array) * len(t)
sum_accuracy += float(model.accuracy.array) * len(t)
test_iter.reset()
model.predictor.train = True
print('test mean loss: {}, accuracy: {}'.format(
sum_loss / test_count, sum_accuracy / test_count))
sum_accuracy = 0
sum_loss = 0
# Save the model and the optimizer
print('save the model')
serializers.save_npz('mlp.model', model)
print('save the optimizer')
serializers.save_npz('mlp.state', optimizer)
try:
cc.remove_experiment("ResNet train")
cc.remove_experiment("ResNet test")
except:
pass
# create a new experiment
try:
tb_res_train = cc.create_experiment("ResNet train")
tb_res_test = cc.create_experiment("ResNet test")
except:
tb_res_train = cc.open_experiment("ResNet train")
tb_res_test = cc.open_experiment("ResNet test")
# x_train: 32*32*3
train, test = get_cifar10()
x_train, t_train = train._datasets
x_test, t_test = test._datasets
# 学習データサイズ
input_size = 32
# 学習データ数
train_size = len(x_train)
# テストデータ数
test_size = len(x_test)
# エポック数
epoch_n = 400
# バッチサイズ
batch_size = 128
# for plot
loss_list = []
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset',
'-d',
default='cifar100',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--model',
'-m',
default='VGG16',
help='The model to use: VGG16 or PreResNet110'
' or WideResNet28x10')
parser.add_argument('--batchsize',
'-b',
type=int,
default=128,
help='Number of images in each mini-batch')
parser.add_argument('--lr_init',
'-l',
type=float,
default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
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('--wd', type=float, default=1e-4, help='weight decay')
parser.add_argument('--se',
action='store_true',
help='snapshot ensemble usage flag')
parser.add_argument('--se_cycle',
type=int,
default=5,
help='split the training process into N cycles, '
'each of which starts with a large LR')
args = parser.parse_args()
if args.dataset.lower() == 'cifar10':
print('Using CIFAR10 dataset')
class_labels = 10
train, test = get_cifar10()
elif args.dataset.lower() == 'cifar100':
print('Using CIFAR100 dataset')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
print('Using %s model' % args.model)
if args.model == 'VGG16':
model_cls = VGG16
elif args.model == 'PreResNet110':
model_cls = PreResNet110
elif args.model == 'WideResNet28x10':
model_cls = WideResNet28x10
else:
raise RuntimeError('Invalid model choice.')
model = L.Classifier(model_cls(class_labels))
if args.gpu >= 0:
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = chainer.optimizers.MomentumSGD(args.lr_init, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(args.wd))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
stop_trigger = (args.epoch, 'epoch')
# Set up a trainer
updater = training.updaters.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = training.Trainer(updater, stop_trigger, out=args.out)
# Learning rate adjustment (this function is called every epoch)
def baseline_lr_schedule(trainer):
epoch = trainer.updater.epoch
t = epoch / args.epoch
factor = 1.0
if t >= 0.5:
factor = 0.1
elif t >= 0.75:
factor = 0.01
trainer.updater.get_optimizer('main').lr = factor * args.lr_init
total_iter = len(train) * args.epoch // args.batchsize
cycle_iter = math.floor(total_iter / args.se_cycle)
# Learning rate adjustment (this function is called every epoch)
def cycle_lr_schedule(trainer):
iter = trainer.updater.iteration
lr = args.lr_init * 0.5
lr *= math.cos(math.pi * ((iter - 1) % cycle_iter) / cycle_iter) + 1
trainer.updater.get_optimizer('main').lr = lr
# Set up extentions
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
if args.se:
trainer.extend(extensions.snapshot(),
trigger=(cycle_iter, 'iteration'))
trainer.extend(cycle_lr_schedule,
trigger=triggers.IntervalTrigger(1, 'iteration'))
else:
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(baseline_lr_schedule,
trigger=triggers.IntervalTrigger(1, 'epoch'))
trainer.extend(extensions.observe_lr())
trainer.extend(extensions.LogReport())
cols = [
'epoch', 'lr', 'main/loss', 'main/accuracy', 'validation/main/loss',
'validation/main/accuracy', 'elapsed_time'
]
trainer.extend(extensions.PrintReport(cols))
trainer.extend(extensions.ProgressBar())
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset', default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize', '-b', type=int, default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate', '-l', type=float, default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch', '-e', type=int, default=300,
help='Number of sweeps over the dataset to train')
parser.add_argument('--device', '-d', type=str, default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--test', action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--resume', '-r', type=str,
help='Directory that has `vgg.model` and `vgg.state`')
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu', '-g', dest='device',
type=int, nargs='?', const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
device = chainer.get_device(args.device)
device.use()
print('Device: {}'.format(device))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.test:
train = train[:200]
test = test[:200]
train_count = len(train)
test_count = len(test)
model = L.Classifier(models.VGG.VGG(class_labels))
model.to_device(device)
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
if args.resume is not None:
resume = args.resume
if os.path.exists(resume):
serializers.load_npz(os.path.join(resume, 'vgg.model'), model)
serializers.load_npz(os.path.join(resume, 'vgg.state'), optimizer)
else:
raise ValueError(
'`args.resume` ("{}") is specified,'
' but it does not exist.'.format(resume)
)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
sum_acc = 0
sum_loss = 0
while train_iter.epoch < args.epoch:
batch = train_iter.next()
# Reduce learning rate by 0.5 every 25 epochs.
if train_iter.epoch % 25 == 0 and train_iter.is_new_epoch:
optimizer.lr *= 0.5
print('Reducing learning rate to: {}'.format(optimizer.lr))
x, t = convert.concat_examples(batch, device)
optimizer.update(model, x, t)
sum_loss += float(model.loss.array) * len(t)
sum_acc += float(model.accuracy.array) * len(t)
if train_iter.is_new_epoch:
print('epoch: {}'.format(train_iter.epoch))
print('train mean loss: {}, accuracy: {}'.format(
sum_loss / train_count, sum_acc / train_count))
sum_acc = 0
sum_loss = 0
# Enable evaluation mode.
with configuration.using_config('train', False):
# This is optional but can reduce computational overhead.
with chainer.using_config('enable_backprop', False):
for batch in test_iter:
x, t = convert.concat_examples(batch, device)
loss = model(x, t)
sum_loss += float(loss.array) * len(t)
sum_acc += float(model.accuracy.array) * len(t)
test_iter.reset()
print('test mean loss: {}, accuracy: {}'.format(
sum_loss / test_count, sum_acc / test_count))
sum_acc = 0
sum_loss = 0
# Save the model and the optimizer
out = args.out
if not os.path.exists(out):
os.makedirs(out)
print('save the model')
serializers.save_npz(os.path.join(out, 'vgg.model'), model)
print('save the optimizer')
serializers.save_npz(os.path.join(out, 'vgg.state'), optimizer)
def train(opts):
args = get_args()
bs = args.bs
epoch = args.epoch
gpu = args.gpu
output_dirname = args.output_dirname
optimizer = opts['optimizer']
model = opts['model']()
xp = model.check_gpu(gpu)
optimizer.setup(model)
train, test = datasets.get_cifar10()
train_x = xp.array([x[0] for x in train])
train_t = xp.array([x[1] for x in train])
test_x = xp.array([x[0] for x in test])
test_t = xp.array([x[1] for x in test])
train_n = len(train_t)
test_n = len(test_t)
train_loss_log = Log()
test_loss_log = Log()
test_acc_log = Log()
for _ in tqdm(range(epoch)):
order = np.random.permutation(train_n)
train_x_iter = Iterator(train_x, bs, order, shuffle=False)
train_t_iter = Iterator(train_t, bs, order, shuffle=False)
loss_sum = 0
for x, t in zip(train_x_iter, train_t_iter):
model.cleargrads()
x_n = len(x)
x = model.prepare_input(x, dtype=xp.float32, xp=xp)
t = model.prepare_input(t, dtype=xp.int32, xp=xp)
loss, _ = model(x, t, train=True)
loss_sum += loss.data * x_n
loss.backward()
optimizer.update()
loss_mean = float(loss_sum / train_n)
train_loss_log.add(loss_mean)
print('train loss: {}'.format(loss_mean))
order = np.random.permutation(test_n)
test_x_iter = Iterator(test_x, bs, order)
test_t_iter = Iterator(test_t, bs, order)
loss_sum = 0
acc_sum = 0
for x, t in zip(test_x_iter, test_t_iter):
model.cleargrads()
x_n = len(x)
x = model.prepare_input(x, dtype=xp.float32, xp=xp)
t = model.prepare_input(t, dtype=xp.int32, xp=xp)
loss, acc = model(x, t, train=False)
loss_sum += loss.data * x_n
acc_sum += acc.data * x_n
loss_mean = float(loss_sum / test_n)
acc_mean = float(acc_sum / test_n)
test_loss_log.add(loss_mean)
test_acc_log.add(acc_mean)
print('test loss: {}'.format(loss_mean))
print('test acc: {}'.format(acc_mean))
output_path = './results/{}'.format(output_dirname)
if not os.path.exists(output_path):
os.mkdir(output_path)
train_loss_log.save('{}/train_loss_log'.format(output_path))
test_loss_log.save('{}/test_loss_log'.format(output_path))
test_acc_log.save('{}/test_acc_log'.format(output_path))
def main():
parser = argparse.ArgumentParser(description='noisy CIFAR-10 training:')
parser.add_argument('--batchsize', type=int, default=128,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate', type=float, default=0.1,
help='Learning rate for SGD')
parser.add_argument('--weight', type=float, default=1e-4,
help='Weight decay parameter')
parser.add_argument('--epoch', type=int, default=200,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', default='result',
help='Directory to output the result')
parser.add_argument('--mean', default='mean.npy',
help='Mean image file')
parser.add_argument('--percent', type=float, default=0,
help='Percentage of noise')
parser.add_argument('--begin', type=int, default=70,
help='When to begin updating labels')
parser.add_argument('--alpha', type=float, default=1.0,
help='Hyper parameter alpha of loss function')
parser.add_argument('--beta', type=float, default=0.5,
help='Hyper parameter beta of loss function')
parser.add_argument('--asym', action='store_true',
help='Asymmetric noise')
parser.add_argument('--seed', type=int, default=0,
help='Random Seed')
args = parser.parse_args()
np.random.seed(args.seed)
train_val_d, _ = get_cifar10()
train_d, val_d = train_val_split(train_val_d, int(len(train_val_d)*0.9))
if os.path.exists(args.mean):
mean = np.load(args.mean)
else:
mean = np.mean([x for x, _ in train_d], axis=0)
np.save(args.mean, mean)
model = TrainChain(length=len(train_d), alpha=args.alpha, beta=args.beta)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
train = TrainData(train_d, mean, args)
val = ValData(val_d, mean)
if args.asym:
train.asymmetric_noise()
else:
train.symmetric_noise()
optimizer = chainer.optimizers.MomentumSGD(lr=args.learnrate, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
val_iter = chainer.iterators.SerialIterator(val, args.batchsize, repeat=False, shuffle=False)
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Updating Labels
trainer.extend(LabelUpdate(train), trigger=(1, 'epoch'))
trainer.extend(extensions.Evaluator(val_iter, model, device=args.gpu))
trainer.extend(extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}'), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss','main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
trainer.extend(extensions.ProgressBar())
trainer.run()
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 11 13:40:00 2017
"""
from chainer import datasets
import cv2
import numpy as np
from tqdm import tqdm
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.svm import LinearSVC
# データの読み込み
train, test = datasets.get_cifar10()
# image = train[i][0] # trainのi番目の画像
# label = train[i][1] # trainのi番目のラベル
# サンプリングと記述
## SIFT特徴
def sampling_descriptor(data):
images_des = [] # 特徴量のリスト
images_labels = [] # 特徴量を得られた画像のラベル郡
for i in tqdm(range(len(data))):
image = data[i][0]
# 画素が0～1に正規化されているので255倍
image_rollaxis = np.uint8(np.rollaxis(image, 0, 3) * 255)
image_rollaxis_gray = cv2.cvtColor(image_rollaxis, cv2.COLOR_BGR2GRAY)
sift = cv2.xfeatures2d.SIFT_create()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset', '-d', default='cifar100',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--model', '-m', default='VGG16',
help='The model to use: VGG16 or PreResNet110'
' or WideResNet28x10')
parser.add_argument('--batchsize', '-b', type=int, default=128,
help='Number of images in each mini-batch')
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 from which read the snapshot files')
args = parser.parse_args()
if args.dataset.lower() == 'cifar10':
print('Using CIFAR10 dataset')
class_labels = 10
train, test = get_cifar10()
elif args.dataset.lower() == 'cifar100':
print('Using CIFAR100 dataset')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
print('Using %s model' % args.model)
if args.model == 'VGG16':
model_cls = VGG16
elif args.model == 'PreResNet110':
model_cls = PreResNet110
elif args.model == 'WideResNet28x10':
model_cls = WideResNet28x10
else:
raise RuntimeError('Invalid model choice.')
model = model_cls(class_labels)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
t = np.array([data[1] for data in test], np.int32)
if args.gpu >= 0:
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
t = cuda.cupy.array(t)
def predict(model, test_iter):
probs = []
test_iter.reset()
for batch in test_iter:
in_arrays = convert.concat_examples(batch, args.gpu)
with chainer.using_config('train', False), \
chainer.using_config('enable_backprop', False):
y = model(in_arrays[0])
prob = chainer.functions.softmax(y)
probs.append(prob.data)
return concat_arrays(probs)
# gather each model's softmax outputs
results = []
for snapshot_path in glob.glob(args.out + '/*snapshot*'):
serializers.load_npz(snapshot_path, model,
path='updater/model:main/predictor/')
y = predict(model, test_iter)
acc = F.accuracy(y, t)
results.append(y[None])
print('accuracy:', acc.data)
# compute the average
results = concat_arrays(results)
y = results.mean(axis=0)
acc = F.accuracy(y, t)
print('-'*50)
print('ensemble accuray:', acc.data)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--dataset',
'-d',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--model', '-m', type=str, default=None)
parser.add_argument('--opt', type=str, default=None)
parser.add_argument('--epoch', '-e', type=int, default=40)
parser.add_argument('--looptimes', '-t', type=int, default=5)
parser.add_argument('--lr', '-l', type=float, default=0.01)
parser.add_argument('--batch', '-b', type=int, default=128)
parser.add_argument('--noplot',
dest='plot',
action='store_false',
help='Disable PlotReport extension')
args = parser.parse_args()
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
# Set up a neural network to train.
model = L.Classifier(
network.LocalPCN(class_labels=class_labels, LoopTimes=args.looptimes))
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = optimizers.NesterovAG(lr=args.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(1e-3))
num_train_samples = 45000
train_iter = iterators.SerialIterator(train[:num_train_samples],
batch_size=args.batch,
shuffle=True)
test_iter = iterators.SerialIterator(train[num_train_samples:],
batch_size=args.batch,
repeat=False,
shuffle=False)
if args.model != None:
print("loading model from " + args.model)
serializers.load_npz(args.model, model)
if args.opt != None:
print("loading opt from " + args.opt)
serializers.load_npz(args.opt, optimizer)
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out='results')
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
trainer.extend(extensions.LogReport(trigger=(10, 'iteration')))
trainer.extend(extensions.observe_lr(), trigger=(10, 'iteration'))
# Schedule of a learning rate (LinearShift)
trainer.extend(
extensions.LinearShift('lr', (args.lr, args.lr * 0.1),
(args.epoch * 0.5, args.epoch * 0.5 + 1)),
trigger=(1, 'epoch'))
# Save two plot images to the result dir
if args.plot and extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',
file_name='loss.png'))
trainer.extend(
extensions.PlotReport(
['main/accuracy', 'validation/main/accuracy'],
'epoch',
file_name='accuracy.png'))
trainer.extend(extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'lr', 'elapsed_time'
]),
trigger=(1, 'iteration'))
trainer.extend(extensions.ProgressBar(update_interval=1))
#Plot computation graph
trainer.extend(extensions.dump_graph('main/loss'))
# Train
trainer.run()
# Save results
modelname = "./results/model"
print("saving model to " + modelname)
serializers.save_npz(modelname, model)
optimizername = "./results/optimizer"
print("saving optimizer to " + optimizername)
serializers.save_npz(optimizername, optimizer)
def main():
parser = argparse.ArgumentParser(description="Chainer CIFAR example:")
parser.add_argument("--dataset", "-d", default="cifar10", help="The dataset to use: cifar10 or cifar100")
parser.add_argument("--batchsize", "-b", type=int, default=128, help="Number of images in each mini-batch")
parser.add_argument("--epoch", "-e", type=int, default=300, 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")
args = parser.parse_args()
print("GPU: {}".format(args.gpu))
print("# Minibatch-size: {}".format(args.batchsize))
print("# epoch: {}".format(args.epoch))
print("")
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == "cifar10":
print("Using CIFAR10 dataset.")
class_labels = 10
train, test = get_cifar10()
elif args.dataset == "cifar100":
print("Using CIFAR100 dataset.")
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError("Invalid dataset choice.")
model = L.Classifier(models.VGG.VGG(class_labels))
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(0.1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
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(TestModeEvaluator(test_iter, model, device=args.gpu))
# Reduce the learning rate by half every 25 epochs.
trainer.extend(extensions.ExponentialShift("lr", 0.5), trigger=(25, "epoch"))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph("main/loss"))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(), trigger=(args.epoch, "epoch"))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# 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", "main/accuracy", "validation/main/accuracy", "elapsed_time"]
)
)
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset',
'-d',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize',
'-b',
type=int,
default=128,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--pretrain',
default=0,
help='Pretrain (w/o VD) or not (w/ VD).' +
' default is not (0).')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--resume-opt',
'-ro',
default='',
help='Resume optimizer the training from snapshot')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
print('# train:', len(train))
print('# test :', len(test))
if args.pretrain:
model = nets.VGG16(class_labels)
def calc_loss(x, t):
model.y = model(x)
model.loss = F.softmax_cross_entropy(model.y, t)
reporter.report({'loss': model.loss}, model)
model.accuracy = F.accuracy(model.y, t)
reporter.report({'accuracy': model.accuracy}, model)
return model.loss
model.calc_loss = calc_loss
model.use_raw_dropout = True
elif args.resume:
model = nets.VGG16VD(class_labels, warm_up=1.)
model(train[0][0][None, ]) # for setting in_channels automatically
model.to_variational_dropout()
chainer.serializers.load_npz(args.resume, model)
else:
model = nets.VGG16VD(class_labels, warm_up=0.0001)
model(train[0][0][None, ]) # for setting in_channels automatically
model.to_variational_dropout()
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
if args.pretrain:
# Original Torch code (http://torch.ch/blog/2015/07/30/cifar.html)
# uses lr=1. However, it doesn't work well as people say in the post.
# This follows a version of Chainer example using lr=0.1.
optimizer = chainer.optimizers.MomentumSGD(0.1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
elif args.resume:
optimizer = chainer.optimizers.Adam(1e-5)
optimizer.setup(model)
else:
optimizer = chainer.optimizers.Adam(1e-4)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.GradientClipping(10.))
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
if args.resume:
classifier = L.Classifier(model.copy())
accuracy = extensions.Evaluator(test_iter, classifier,
device=args.gpu)()['main/accuracy']
print('test accuracy VD:', accuracy)
# Set up a trainer
updater = training.StandardUpdater(train_iter,
optimizer,
device=args.gpu,
loss_func=model.calc_loss)
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, L.Classifier(model), device=args.gpu))
if args.pretrain:
trainer.extend(extensions.ExponentialShift('lr', 0.5),
trigger=(25, 'epoch'))
elif not args.resume:
trainer.extend(
extensions.LinearShift(
'alpha', (1e-4, 0.),
(0, args.epoch * len(train) // args.batchsize)))
# Take a snapshot at each epoch
# trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
if args.pretrain:
trainer.extend(extensions.snapshot_object(
model, 'model_snapshot_{.updater.epoch}'),
trigger=(10, 'epoch'))
# Write a log of evaluation statistics for each epoch
# trainer.extend(extensions.LogReport())
per = min(len(train) // args.batchsize // 2, 1000)
trainer.extend(extensions.LogReport(trigger=(per, 'iteration')))
# 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', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'main/class',
'main/kl', 'main/mean_p', 'main/sparsity', 'main/W/Wnz',
'main/kl_coef', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# Run the training
trainer.run()
print('Measure inference speeds for 1 sample inference...')
test_iter = chainer.iterators.SerialIterator(test,
1,
repeat=False,
shuffle=False)
if not args.pretrain:
if args.gpu >= 0:
classifier = L.Classifier(model.copy())
start = time.time()
accuracy = extensions.Evaluator(test_iter,
classifier,
device=args.gpu)()['main/accuracy']
print('dense Gpu:',
time.time() - start, 's/{} imgs'.format(len(test)))
model.to_cpu()
classifier = L.Classifier(model.copy())
start = time.time()
accuracy = extensions.Evaluator(test_iter, classifier,
device=-1)()['main/accuracy']
print('dense Cpu:', time.time() - start, 's/{} imgs'.format(len(test)))
model.to_cpu_sparse()
model.name = None
classifier = L.Classifier(copy.deepcopy(model))
start = time.time()
accuracy = extensions.Evaluator(test_iter, classifier,
device=-1)()['main/accuracy']
print('sparse Cpu:',
time.time() - start, 's/{} imgs'.format(len(test)))
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset', '-d', default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize', '-b', type=int, default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate', '-l', type=float, default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch', '-e', type=int, default=300,
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('--test', action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--resume', '-r', type=str,
help='Directory that has `vgg.model` and `vgg.state`')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.test:
train = train[:200]
test = test[:200]
train_count = len(train)
test_count = len(test)
model = L.Classifier(models.VGG.VGG(class_labels))
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
if args.resume is not None:
resume = args.resume
if os.path.exists(resume):
serializers.load_npz(os.path.join(resume, 'vgg.model'), model)
serializers.load_npz(os.path.join(resume, 'vgg.state'), optimizer)
else:
raise ValueError(
'`args.resume` ("{}") is specified,'
' but it does not exist.'.format(resume)
)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
sum_acc = 0
sum_loss = 0
while train_iter.epoch < args.epoch:
batch = train_iter.next()
# Reduce learning rate by 0.5 every 25 epochs.
if train_iter.epoch % 25 == 0 and train_iter.is_new_epoch:
optimizer.lr *= 0.5
print('Reducing learning rate to: {}'.format(optimizer.lr))
x_array, t_array = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x_array)
t = chainer.Variable(t_array)
optimizer.update(model, x, t)
sum_loss += float(model.loss.array) * len(t)
sum_acc += float(model.accuracy.array) * len(t)
if train_iter.is_new_epoch:
print('epoch: {}'.format(train_iter.epoch))
print('train mean loss: {}, accuracy: {}'.format(
sum_loss / train_count, sum_acc / train_count))
sum_acc = 0
sum_loss = 0
# Enable evaluation mode.
with configuration.using_config('train', False):
# This is optional but can reduce computational overhead.
with chainer.using_config('enable_backprop', False):
for batch in test_iter:
x, t = convert.concat_examples(batch, args.gpu)
x = chainer.Variable(x)
t = chainer.Variable(t)
loss = model(x, t)
sum_loss += float(loss.array) * len(t)
sum_acc += float(model.accuracy.array) * len(t)
test_iter.reset()
print('test mean loss: {}, accuracy: {}'.format(
sum_loss / test_count, sum_acc / test_count))
sum_acc = 0
sum_loss = 0
# Save the model and the optimizer
out = args.out
if not os.path.exists(out):
os.makedirs(out)
print('save the model')
serializers.save_npz(os.path.join(out, 'vgg.model'), model)
print('save the optimizer')
serializers.save_npz(os.path.join(out, 'vgg.state'), optimizer)
parser.add_argument('--batch-size', type=int, default=128)
parser.add_argument('--lambda-denoise', type=float, default=1.0)
parser.add_argument('--lambda-adv', type=float, default=0.03)
return parser.parse_args()
if __name__ == '__main__':
args = parse_args()
nz = args.nz
batch_size = args.batch_size
epochs = args.epochs
gpu = args.gpu
lambda_denoise = args.lambda_denoise
lambda_adv = args.lambda_adv
train, _ = datasets.get_cifar10(withlabel=False, ndim=3)
train_iter = iterators.SerialIterator(train, batch_size)
z_iter = iterators.RandomNoiseIterator(UniformNoiseGenerator(-1, 1, nz),
batch_size)
optimizer_generator = optimizers.Adam(alpha=1e-4, beta1=0.5)
optimizer_discriminator = optimizers.Adam(alpha=1e-4, beta1=0.5)
optimizer_denoiser = optimizers.Adam(alpha=1e-4, beta1=0.5)
optimizer_generator.setup(Generator())
optimizer_discriminator.setup(Discriminator())
optimizer_denoiser.setup(Denoiser())
updater = updater.GenerativeAdversarialUpdater(
iterator=train_iter,
noise_iterator=z_iter,
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--dataset', '-d', default='cifar10',
help='The dataset to use: cifar10 or cifar100')
parser.add_argument('--batchsize', '-b', type=int, default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate', '-l', type=float, default=0.05,
help='Learning rate for SGD')
parser.add_argument('--epoch', '-e', type=int, default=300,
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')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
model = L.Classifier(models.VGG.VGG(class_labels))
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
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(TestModeEvaluator(test_iter, model, device=args.gpu))
# Reduce the learning rate by half every 25 epochs.
trainer.extend(extensions.ExponentialShift('lr', 0.5),
trigger=(25, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# 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',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def run(params, exp_info, args):
random.seed(args.seed)
np.random.seed(args.seed)
chainer.cuda.cupy.random.seed(args.seed)
# Prepare ChainerMN communicator.
if args.communicator == 'naive':
print("Error: 'naive' communicator does not support GPU.\n")
exit(-1)
comm = chainermn.create_communicator(args.communicator, mpi_comm)
device = comm.intra_rank
if comm.rank == 0:
print('==========================================')
print('Experiment Info: {}'.format(exp_info))
print('Num process (COMM_WORLD): {}'.format(comm.size))
print('Using GPUs')
print('Using {} communicator'.format(args.communicator))
print('Num Minibatch-size: {}'.format(args.batchsize))
print('Num epoch: {}'.format(args.epoch))
print('==========================================')
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
class_labels = 10
model = L.Classifier(ARCHS[args.arch](class_labels))
if device >= 0:
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
arg_params = {i: params[i] for i in params if i not in OMIT_ARG_PARAMS}
optimizer = chainermn.create_multi_node_optimizer(
OPTIMIZERS[args.optimizer_name](**arg_params), comm)
optimizer.setup(model)
optimizer.add_hook(
chainer.optimizer_hooks.WeightDecay(params['weight_decay']))
if comm.rank == 0:
train, valid = get_cifar10(scale=255.)
mean = np.mean([x for x, _ in train], axis=(0, 2, 3))
std = np.std([x for x, _ in train], axis=(0, 2, 3))
else:
train, valid, mean, std = None, None, None, None
train = chainermn.scatter_dataset(train, comm, shuffle=True)
valid = chainermn.scatter_dataset(valid, comm, shuffle=True)
mean = mpi_comm.bcast(mean, root=0)
std = mpi_comm.bcast(std, root=0)
train_transform = partial(transform,
mean=mean,
std=std,
random_angle=args.random_angle,
pca_sigma=args.pca_sigma,
expand_ratio=args.expand_ratio,
crop_size=args.crop_size,
train=True)
valid_transform = partial(transform, mean=mean, std=std, train=False)
train = TransformDataset(train, train_transform)
valid = TransformDataset(valid, valid_transform)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(valid,
args.batchsize,
repeat=False,
shuffle=True)
updater = training.StandardUpdater(train_iter, optimizer, device=device)
stop_trigger = (args.epoch, 'epoch')
trainer = training.Trainer(updater, stop_trigger, out=args.out)
# Create a multi node evaluator from a standard Chainer evaluator.
evaluator = extensions.Evaluator(test_iter, model, device=device)
evaluator = chainermn.create_multi_node_evaluator(evaluator, comm)
trainer.extend(evaluator)
if comm.rank == 0:
# Some display and output extensions are necessary only for one worker.
# (Otherwise, there would just be repeated outputs.)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
trainer.extend(extensions.ProgressBar())
if args.optimizer_name != 'adam':
trainer.extend(extensions.ExponentialShift('lr',
params['lr_decay_rate']),
trigger=(params['lr_decay_epoch'], 'epoch'))
# Run the training
trainer.run()
if comm.rank == 0:
print('========== Done ===========')
loss = trainer.observation['validation/main/loss']
loss = chainer.cuda.to_cpu(loss)
if np.isnan(loss):
return {'status': STATUS_FAILURE}
else:
return {'loss': loss, 'status': STATUS_SUCCESS}
