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'