def get_C10_plus():
"""CIFAR-10 dataset with data augmentaion"""
train, test = cifar.get_cifar10()
train_dataset = CIFARDataset(train, C10_MEAN, C10_STD, True)
test_dataset = CIFARDataset(test, C10_MEAN, C10_STD, False)
return train_dataset, test_dataset
def read_dataset(self):
print('load cifar100 dataset')
cifar100_train, cifar100_test = cifar.get_cifar10()
# Create train data
self.x_train = []
self.y_train = []
for i in cifar100_train:
self.x_train.append(i[0])
self.y_train.append(i[1])
self.x_train = np.array(self.x_train)
self.y_train = np.array(self.y_train)
# Create test data
self.x_test = []
self.y_test = []
for i in cifar100_test:
self.x_test.append(i[0])
self.y_test.append(i[1])
self.x_test = np.array(self.x_test)
self.y_test = np.array(self.y_test)
# Size of datasets
self.N = self.y_train.size
self.N_test = self.y_test.size
print(self.x_train.shape)
def __init__(self,
root=os.path.join("~", ".chainer", "datasets", "cifar10"),
mode="train",
transform=None):
assert (root is not None)
self.transform = transform
train_ds, test_ds = get_cifar10()
self.base = train_ds if mode == "train" else test_ds
def __init__(self,
train,
mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010)):
train_ds, test_ds = cifar.get_cifar10()
self.base = train_ds if train else test_ds
self.mean = np.array(mean, np.float32)[:, np.newaxis, np.newaxis]
self.std = np.array(std, np.float32)[:, np.newaxis, np.newaxis]
def predict(net, image_id):
_, test = cifar.get_cifar10()
x, t = test[image_id]
y = net.predictor(x[None, ...]).data.argmax(axis=1)[0]
print('predicted_label:', cls_names[y])
print('answer:', cls_names[t])
plt.imshow(x.transpose(1, 2, 0))
plt.show()
def get_data():
(train, test) = cifar.get_cifar10()
x_train, y_train = process_data(train)
x_test, y_test = process_data(test)
# img=np.reshape(x_train[123],(3,32,32))
# img=img.transpose(1,2,0)
# plt.imshow(img)
# plt.show()
# print(y_train[123])
return x_train, y_train, x_test, y_test
def train(network_object,
batchsize=128,
gpu_id=0,
max_epoch=20,
train_dataset=None,
test_dataset=None,
postfix='',
base_lr=0.01,
lr_decay=None):
#1. Dataset
if train_dataset is None and test_dataset is None:
train, test = cifar.get_cifar10()
else:
train, test = train_dataset, test_dataset
#2. Iterator
train_iter = iterators.MultiprocessIterator(train, batchsize)
test_iter = iterators.MultiprocessIterator(test, batchsize, False, False)
#3. Model
net = L.Classifier(network_object)
#4. Optimizer
optimizer = optimizers.MomentumSGD(lr=base_lr)
optimizer.setup(net)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005))
#5. Updater
updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id)
#6. Trainer
trainer = training.Trainer(updater, (max_epoch, 'epoch'), out='{}_cifar10_{}result'.format(network_object.__class__.__name__, postfix))
#7. Trainer extensions
trainer.extend(extensions.LogReport())
trainer.extend(extensions.observe_lr())
trainer.extend(extensions.Evaluator(test_iter, net, device=gpu_id), name='val')
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'main/accuracy', 'val/main/loss', 'val/main/accuracy', 'elapsed_time', 'lr']))
trainer.extend(extensions.PlotReport(['main/loss', 'val/main/loss'], x_key='epoch', file_name='loss.png'))
trainer.extend(extensions.PlotReport(['main/accuracy', 'val/main/accuracy'], x_key='epoch', file_name='accuracy.png'))
if lr_decay is not None:
trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=lr_decay)
trainer.run()
del trainer
return net
def get_val_data_iterator(batch_size,
num_workers):
_, test_ds = cifar.get_cifar10()
val_dataset = test_ds
val_dataset_len = len(val_dataset)
val_iterator = iterators.MultiprocessIterator(
dataset=val_dataset,
batch_size=batch_size,
repeat=False,
shuffle=False,
n_processes=num_workers,
shared_mem=300000000)
return val_iterator, val_dataset_len
def train_CNN(network_object, batchsize=128, gpu_id=-1, max_epoch=20, train_dataset=None, test_dataset=None, postfix='', base_lr=0.01, lr_decay=None,number = 11):
number = str(number)
# 1. Dataset
if train_dataset is None and test_dataset is None:
train, test = cifar.get_cifar10()
else:
train, test = train_dataset, test_dataset
if gpu_id >= 0:
network_object.to_gpu(gpu_id)
# 2. Iterator
train_iter = iterators.MultiprocessIterator(train, batchsize)
test_iter = iterators.MultiprocessIterator(test, batchsize, False, False)
# 3. Model
net = L.Classifier(network_object)
# 4. Optimizer
optimizer = optimizers.MomentumSGD()
optimizer.setup(net)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005))
# 5. Updater
updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id)
# 6. Trainer
trainer = training.Trainer(updater, (max_epoch, 'epoch'), out='{}_crack_{}result'.format(network_object.__class__.__name__, postfix))
# 7. Trainer extensions
trainer.extend(extensions.LogReport(trigger=(1, 'epoch'), log_name="log_"+number))
trainer.extend(extensions.snapshot(filename=number+'snapshot_epoch-{.updater.epoch}'),trigger=(5, 'epoch'))
# trainer.extend(extensions.snapshot(), trigger=(10, 'epoch'))
trainer.extend(extensions.ParameterStatistics(net.predictor.conv1, {'std': np.std}))
trainer.extend(extensions.observe_lr())
trainer.extend(extensions.Evaluator(test_iter, net, device=gpu_id), name='val')
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'main/accuracy', 'val/main/loss', 'val/main/accuracy', 'elapsed_time', 'lr']))
trainer.extend(extensions.PlotReport(['main/loss', 'val/main/loss'], x_key='epoch', file_name='loss'+number+'.png'))
trainer.extend(extensions.PlotReport(['main/accuracy', 'val/main/accuracy'], x_key='epoch', file_name='accuracy'+number+'.png'))
trainer.extend(extensions.PlotReport(['l1/W/data/std'], x_key='epoch', file_name='std'+number+'.png'))
if lr_decay is not None:
trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=lr_decay)
trainer.run()
del trainer
return net
def get_val_data_iterator(dataset_name, batch_size, num_workers):
if dataset_name == "CIFAR10":
_, test_ds = cifar.get_cifar10()
elif dataset_name == "CIFAR100":
_, test_ds = cifar.get_cifar100()
elif dataset_name == "SVHN":
_, test_ds = svhn.get_svhn()
else:
raise Exception('Unrecognized dataset: {}'.format(dataset_name))
val_dataset = test_ds
val_dataset_len = len(val_dataset)
val_iterator = iterators.MultiprocessIterator(dataset=val_dataset,
batch_size=batch_size,
repeat=False,
shuffle=False,
n_processes=num_workers,
shared_mem=300000000)
return val_iterator, val_dataset_len
stride,
0,
initialW=w,
nobias=True)
self.bn_r = L.BatchNormalization(n_number)
self.proj = proj
def __call__(self, x):
h = F.relu(self.bn_a(self.conva(x)))
h = self.bn_b(self.convb(h))
if self.proj:
x = self.bn_r(self.convr(x))
return F.relu(h + x)
train, test = cifar.get_cifar10()
train_iter = iterators.SerialIterator(train, 128)
test_iter = iterators.SerialIterator(test, 2000, repeat=False, shuffle=False)
gpu_id = 0
Itrain, Ttrain = concat_examples(train, gpu_id)
Train_mean = cp.mean(Itrain)
Train_std = cp.std(Itrain)
model = ResNet34().to_gpu(gpu_id)
optimizer = optimizers.MomentumSGD(lr=0.1, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
def main(args):
assert((args.depth - args.block - 1) % args.block == 0)
n_layer = int((args.depth - args.block - 1) / args.block)
if args.dataset == 'cifar10':
train, test = cifar.get_cifar10()
n_class = 10
elif args.dataset == 'cifar100':
train, test = cifar.get_cifar100()
n_class = 100
elif args.dataset == 'SVHN':
raise NotImplementedError()
images = convert.concat_examples(train)[0]
mean = images.mean(axis=(0, 2, 3))
std = images.std(axis=(0, 2, 3))
train = PreprocessedDataset(train, mean, std, random=args.augment)
test = PreprocessedDataset(test, mean, std)
train_iter = chainer.iterators.SerialIterator(
train, args.batchsize / args.split_size)
test_iter = chainer.iterators.SerialIterator(
test, args.batchsize / args.split_size, repeat=False, shuffle=False)
model = chainer.links.Classifier(DenseNet(
n_layer, args.growth_rate, n_class, args.drop_ratio, 16, args.block))
if args.init_model:
serializers.load_npz(args.init_model, model)
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
optimizer = chainer.optimizers.NesterovAG(lr=args.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
updater = StandardUpdater(
train_iter, optimizer, (args.split_size, 'mean'), device=args.gpu)
trainer = training.Trainer(updater, (300, 'epoch'), out=args.dir)
val_interval = (1, 'epoch')
log_interval = (1, 'epoch')
def lr_shift(): # DenseNet specific!
if updater.epoch == 150 or updater.epoch == 225:
optimizer.lr *= 0.1
return optimizer.lr
trainer.extend(Evaluator(
test_iter, model, device=args.gpu), trigger=val_interval)
trainer.extend(extensions.observe_value(
'lr', lambda _: lr_shift()), trigger=(1, 'epoch'))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot_object(
model, 'epoch_{.updater.epoch}.model'), trigger=val_interval)
trainer.extend(extensions.snapshot_object(
optimizer, 'epoch_{.updater.epoch}.state'), trigger=val_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
start_time = time.time()
trainer.extend(extensions.observe_value(
'time', lambda _: time.time() - start_time), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'time', 'epoch', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'lr',
]), trigger=log_interval)
trainer.extend(extensions.observe_value(
'graph', lambda _: create_fig(args.dir)),
trigger=(1, 'epoch'), priority=50)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.run()
from chainer.datasets import cifar, split_dataset_random
import numpy as np
from utils import create_model
from distill.utils import generate_softlabel, save_softlabels
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--teacher_file', type=str, default=None)
parser.add_argument('--teacher_name', type=str, default=None)
parser.add_argument('--teacher_model', type=str, default=None)
parser.add_argument('--softlabels_path', type=str, default=None)
args = parser.parse_args()
train_val, test = cifar.get_cifar10(scale=255.)
train_size = int(len(train_val) * 0.9)
train, valid = split_dataset_random(train_val, train_size, seed=0)
mean = np.mean([x for x, _ in train], axis=(0, 2, 3))
std = np.std([x for x, _ in train], axis=(0, 2, 3))
n_class = 10
teacher = create_model(args.teacher_file, args.teacher_name, n_class)
serializers.load_npz(args.teacher_model,
teacher,
path='updater/model:main/predictor/')
teacher.to_gpu()
fun_generate_soft = partial(generate_softlabel,
model=teacher,
# Load model
ext = os.path.splitext(args.model_file)[1]
mod_path = '.'.join(os.path.split(args.model_file)).replace(ext, '')
mod = import_module(mod_path)
net = getattr(mod, args.model_name)(10)
# create result dir
result_dir = create_result_dir(args.model_name)
shutil.copy(args.model_file, os.path.join(
result_dir, os.path.basename(args.model_file)))
with open(os.path.join(result_dir, 'args'), 'w') as fp:
fp.write(json.dumps(vars(args)))
print(json.dumps(vars(args), sort_keys=True, indent=4))
train, valid = cifar.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))
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)
run_training(
net, train, valid, result_dir, args.batchsize, args.gpus,
args.training_epoch, args.initial_lr, args.lr_decay_rate,
# Set the random seeds
random.seed(args.seed)
np.random.seed(args.seed)
if len(args.gpus) > 1 or args.gpus[0] >= 0:
chainer.cuda.cupy.random.seed(args.seed)
gpus = {'main': args.gpus[0]}
if len(args.gpus) > 1:
gpus.update({'gpu{}'.format(i): i for i in args.gpus[1:]})
args.gpus = gpus
# print gpus
with cp.cuda.Device(gpus['main']):
if args.dataset == 'cifar10':
train, valid = cifar.get_cifar10(scale=255.)
n_class = 10
elif args.dataset == 'cifar100':
train, valid = cifar.get_cifar100(scale=255.)
n_class = 100
# Enable autotuner of cuDNN
chainer.config.autotune = True
# Load model
ext = os.path.splitext(args.model_file)[1]
mod_path = '.'.join(os.path.split(args.model_file.replace(ext, '')))
mod = import_module(mod_path)
net = getattr(mod, args.model_name)(n_class=n_class)
# create result dir
result_dir = create_result_dir(args.model_name)
def main():
parser = argparse.ArgumentParser(
description='Shake-shake resularization CIFAR10 w/ Chainer')
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('--lr',
'-l',
type=float,
default=0.1,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=1800,
help='Number of sweeps over the dataset to train')
parser.add_argument('--base_width',
'-w',
type=int,
default=64,
help='Base width parameter for Shake-Shake model')
parser.add_argument('--gpu',
'-g',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='run_0',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--nobar',
dest='bar',
action='store_false',
help='Disable ProgressBar extension')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
log_dir = os.path.join("results", args.out)
writer = SummaryWriter(log_dir=log_dir)
# 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 = cifar.get_cifar10(scale=255.)
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = cifar.get_cifar100(scale=255.)
else:
raise RuntimeError('Invalid dataset choice.')
# Data preprocess
mean = np.mean([x for x, _ in train], axis=(0, 2, 3))
std = np.std([x for x, _ in train], axis=(0, 2, 3))
train_transfrom = partial(transform, mean=mean, std=std, train=True)
test_transfrom = partial(transform, mean=mean, std=std, train=False)
train = TransformDataset(train, train_transfrom)
test = TransformDataset(test, test_transfrom)
print('Finised data preparation. Preparing for model training...')
# Model and optimizer configuration
model = L.Classifier(ShakeResNet(class_labels, base_width=args.base_width))
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.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(1e-4))
# Set up a trainer
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
updater = training.updaters.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=log_dir)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Decrease learning rate with cosine annealing
trainer.extend(LrSceduler_CosineAnneal(args.lr, args.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(filename='training_chekpoint'))
# Take a snapshot of the current best model
trigger_save_model = triggers.MaxValueTrigger('validation/main/accuracy')
trainer.extend(extensions.snapshot_object(model, filename='best_model'),
trigger=trigger_save_model)
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Monitor learning rate at every iteration
trainer.extend(extensions.observe_lr(), trigger=(1, 'iteration'))
# Save two plot images to the result dir
if 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.PlotReport(['lr'], 'epoch', file_name='lr.png'))
# 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', 'lr', 'elapsed_time'
]))
if args.bar:
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# Write training log to TensorBoard log file
trainer.extend(
TensorboardLogger(writer, [
'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'lr'
]))
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
print("Finished preparation. Starting model training...")
print()
# Run the training
trainer.run()
def main(args):
assert ((args.depth - args.block - 1) % args.block == 0)
n_layer = (args.depth - args.block - 1) / args.block
if args.dataset == 'cifar10':
train, test = cifar.get_cifar10()
n_class = 10
elif args.dataset == 'cifar100':
train, test = cifar.get_cifar100()
n_class = 100
elif args.dataset == 'SVHN':
raise NotImplementedError()
mean = numpy.zeros((3, 32, 32), dtype=numpy.float32)
for image, _ in train:
mean += image / len(train)
train = PreprocessedDataset(train, mean, random=True)
test = PreprocessedDataset(test, mean)
train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize)
test_iter = chainer.iterators.MultiprocessIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
model = chainer.links.Classifier(
DenseNet(n_layer, args.growth_rate, n_class, args.drop_ratio, 16,
args.block))
if args.init_model:
serializers.load_npz(args.init_model, model)
optimizer = chainer.optimizers.MomentumSGD(lr=args.lr / len(args.gpus),
momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
devices = {'main': args.gpus[0]}
if len(args.gpus) > 2:
for gid in args.gpus[1:]:
devices['gpu%d' % gid] = gid
updater = training.ParallelUpdater(train_iter, optimizer, devices=devices)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.dir)
val_interval = (1, 'epoch')
log_interval = (1, 'epoch')
eval_model = model.copy()
eval_model.train = False
trainer.extend(extensions.Evaluator(test_iter,
eval_model,
device=args.gpus[0]),
trigger=val_interval)
trainer.extend(extensions.ExponentialShift('lr', args.lr_decay_ratio),
trigger=(args.lr_decay_freq, 'epoch'))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot_object(model,
'epoch_{.updater.epoch}.model'),
trigger=val_interval)
trainer.extend(extensions.snapshot_object(optimizer,
'epoch_{.updater.epoch}.state'),
trigger=val_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
start_time = time.time()
trainer.extend(extensions.observe_value(
'time', lambda _: time.time() - start_time),
trigger=log_interval)
trainer.extend(extensions.PrintReport([
'time',
'epoch',
'iteration',
'main/loss',
'validation/main/loss',
'main/accuracy',
'validation/main/accuracy',
'lr',
]),
trigger=log_interval)
trainer.extend(extensions.observe_value('graph',
lambda _: create_fig(args.dir)),
trigger=(2, 'epoch'))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.run()
def train(model_object, train_dataset=None, test_dataset=None):
# define options
parser = argparse.ArgumentParser(
description='Training script of Tiny Model on CIFAR-10 dataset')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of epochs to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--initmodel',
help='Initialize the model from given file')
parser.add_argument('--resume', '-r', default='',
help='Initialize the trainer from given file')
parser.add_argument('--out', '-o', default='result',
help='Output directory')
parser.add_argument('--batchsize', '-b', type=int, default=64,
help='Validation minibatch size')
parser.add_argument('--numlayers', '-L', type=int, default=40,
help='Number of layers')
parser.add_argument('--growth', '-G', type=int, default=12,
help='Growth rate parameter')
parser.add_argument('--dropout', '-D', type=float, default=0.2,
help='Dropout ratio')
parser.add_argument('--dataset', type=str, default='cifar10',
choices=('cifar10', 'cifar100'),
help='Dataset used for training (Default is cifar10)')
args = parser.parse_args()
# 1. Dataset
if args.dataset == 'cifar10':
train, test = cifar.get_cifar10()
elif args.dataset == 'cifar10':
train, test = cifar.get_cifar100()
# 2. Iterator
train_iter = iterators.SerialIterator(train, args.batchsize)
test_iter = iterators.SerialIterator(test, args.batchsize, False, False)
# 3. Model
model = L.Classifier(model_object)
if args.gpu >= 0:
model.to_gpu(args.gpu)
# 4. Optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)
# 5. Updater
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
# 6. Trainer
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# 7. Evaluator
class TestModeEvaluator(extensions.Evaluator):
def evaluate(self):
model = self.get_target('main')
model.train = False
ret = super(TestModeEvaluator, self).evaluate()
model.train = True
return ret
trainer.extend(extensions.LogReport())
trainer.extend(TestModeEvaluator(test_iter, model, device=args.gpu))
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'main/accuracy', 'validation/main/loss', 'validation/main/accuracy', 'elapsed_time']))
trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], x_key='epoch', file_name='loss.png'))
trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'], x_key='epoch', file_name='accuracy.png'))
trainer.extend(extensions.snapshot(), trigger=(10, 'epoch'))
trainer.extend(extensions.snapshot_object(
model, 'model_{.updater.epoch}.npz'))
trainer.run()
del trainer
return model
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import partial
import os
import numpy as np
from chainer.datasets import TransformDataset
from chainer.datasets import cifar
import matplotlib.pyplot as plt
import train as train_module
train_orig, _ = cifar.get_cifar10(scale=255.)
mean = np.mean([x for x, _ in train_orig], axis=(0, 2, 3))
std = np.std([x for x, _ in train_orig], axis=(0, 2, 3))
print('mean:', mean)
print('std:', std)
random_angle = 45.0
pca_sigma = 25.5
expand_ratio = 1.5
crop_size = [28, 28]
train_transform = partial(
train_module.transform, mean=mean, std=std, random_angle=random_angle,
pca_sigma=pca_sigma, expand_ratio=expand_ratio, crop_size=crop_size,
train=True)
train = TransformDataset(train_orig, train_transform)
out_dir = 'test_images'
