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}