def predict(enable_ideep): labels = load_label() model_dir = "result" epoch = find_max_epoch(model_dir) model = googlenet.GoogLeNet() mean = np.load("mean.npy") print("loading...", epoch) chainer.serializers.load_npz(os.path.join( model_dir, 'model_epoch_{}.npz'.format(epoch)), model) if enable_ideep: model.to_intel64() paths = glob("reshaped/buddha/image_*.jpg") accuracy_cnt = 0 for img_path in paths: image = imageio.imread(img_path) image = image.transpose(2, 0, 1).astype(np.float32) _, h, w = image.shape crop_size = model.insize top = (h - crop_size) // 2 left = (w - crop_size) // 2 bottom = top + crop_size right = left + crop_size image = image[:, top:bottom, left:right] image -= mean[:, top:bottom, left:right] image *= (1.0 / 255.0) # Scale to [0, 1] if enable_ideep: mode = "always" else: mode = "never" with chainer.using_config('train', False), chainer.using_config('enable_backprop', False), chainer.using_config('use_ideep', mode): y = model.predict(np.array([image])) idx = np.argmax(y.data[0]) if idx == 0: accuracy_cnt += 1 print("total accuracy rate = ", accuracy_cnt / len(paths))
parser.add_argument('--batchsize', '-B', type=int, default=128, help='minibatch size') parser.add_argument('--gpu', '-g', default=0, type=int, help='GPU ID (negative value indicates CPU)') args = parser.parse_args() xp = cuda.cupy if args.gpu >= 0 else np # Prepare model print(args.arch) if args.arch == 'alexnet': import alex model = alex.Alex() elif args.arch == 'googlenet': import googlenet model = googlenet.GoogLeNet() elif args.arch == 'vgga': import vgga model = vgga.vgga() elif args.arch == 'overfeat': import overfeat model = overfeat.overfeat() else: raise ValueError('Invalid architecture name') if args.gpu >= 0: cuda.get_device(args.gpu).use() model.to_gpu() # Setup optimizer optimizer = optimizers.SGD(lr=0.01)
num_workers=5, # subprocesses to use for sampling pin_memory=False, # whether to return an item pinned to GPU ) test_loader = data_utils.DataLoader( test, # dataset to load from batch_size=batch_size, # examples per batch (default: 1) shuffle=False, sampler=None, # if a sampling method is specified, `shuffle` must be False num_workers=5, # subprocesses to use for sampling pin_memory=False, # whether to return an item pinned to GPU ) print('=> Building model..') #enable gpu device = 'cuda' if torch.cuda.is_available() else 'cpu' net = googlenet.GoogLeNet() net = net.to(device) if device == 'cuda': net = torch.nn.DataParallel(net) cudnn.benchmark = True #optimizer #optimizer = optim.LBFGS(net.parameters()) optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9) #optimizer = optim.Adam(net.parameters(), lr = 0.1, eps = 1e-08) criterion = nn.CrossEntropyLoss() #reshape dataset add channel = 1, with seq_len def modify_data(data, seq_len): batch = 1
def main(): archs = { 'alex': alex.Alex, 'alex_fp16': alex.AlexFp16, 'googlenet': googlenet2.GoogLeNet, 'googlenetbn': googlenetbn.GoogLeNetBN, 'googlenetbn_fp16': googlenetbn.GoogLeNetBNFp16, 'nin': nin.NIN, 'resnet50': resnet50_2.ResNet50 } parser = argparse.ArgumentParser( description='Learning convnet from ILSVRC2012 dataset') parser.add_argument('train', help='Path to training image-label list file') parser.add_argument('val', help='Path to validation image-label list file') parser.add_argument('--arch', '-a', choices=archs.keys(), default='nin', help='Convnet architecture') parser.add_argument('--batchsize', '-B', type=int, default=32, help='Learning minibatch size') parser.add_argument('--epoch', '-E', type=int, default=10, 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('--loaderjob', '-j', type=int, help='Number of parallel data loading processes') parser.add_argument('--mean', '-m', default='mean.npy', help='Mean file (computed by compute_mean.py)') 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('--root', '-R', default='.', help='Root directory path of image files') parser.add_argument('--optimizer', default='adam', help='optimizer') parser.add_argument('--weight_decay', type=float, default=0.0001, help='weight decay') parser.add_argument('--learning_rate', type=float, default=1e-3, help='learning rate. if adam, it is mean alpha') parser.add_argument('--lr_shift', type=float, default=0.5, help='lr exponential shift. 0 mean not to shift') parser.add_argument('--val_batchsize', '-b', type=int, default=250, help='Validation minibatch size') parser.add_argument('--test', action='store_true') parser.add_argument('--aug', type=bool, default=False) parser.set_defaults(test=False) args = parser.parse_args() model_cls = archs[args.arch] # Load the datasets and mean file insize = model_cls.insize mean = np.load(args.mean) if args.aug: print('augmentation enabled') train = PreprocessedDataset(args.train, args.root, mean, insize, True, args.aug) val = PreprocessedDataset(args.val, args.root, mean, insize, False) outsize = len(set(pd.read_csv(args.train, sep=' ', header=None)[1])) # Initialize the model to train if args.arch == 'googlenet': model = model_cls(output_size=outsize) else: model = model_cls() if args.initmodel: print('Load model from', args.initmodel) try: chainer.serializers.load_npz(args.initmodel, model) except (ValueError, KeyError) as e: print('not match model. try default GoogLeNet. "{}"'.format(e)) src_model = googlenet.GoogLeNet() chainer.serializers.load_npz(args.initmodel, src_model) copy_model(src_model, model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() # Make the GPU current model.to_gpu() # These iterators load the images with subprocesses running in parallel to # the training/validation. train_iter = chainer.iterators.MultiprocessIterator( train, args.batchsize, n_processes=args.loaderjob) val_iter = chainer.iterators.MultiprocessIterator( val, args.val_batchsize, repeat=False, n_processes=args.loaderjob) # Set up an optimizer # optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9) print('set optimizer: {}, learning rate: {}'.format( args.optimizer, args.learning_rate)) if args.optimizer == 'adam': optimizer = chainer.optimizers.Adam(alpha=args.learning_rate) else: optimizer = chainer.optimizers.MomentumSGD(lr=args.learning_rate, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay)) # Set up a trainer updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.out) val_interval = (1 if args.test else 100000), 'iteration' log_interval = (1 if args.test else 1000), 'iteration' test_interval = 1, 'epoch' trainer.extend(extensions.Evaluator(val_iter, model, device=args.gpu), trigger=test_interval) trainer.extend(extensions.dump_graph('main/loss')) #trainer.extend(extensions.snapshot(), trigger=val_interval) #trainer.extend(extensions.snapshot_object( # model, 'model_iter_{.updater.iteration}'), trigger=val_interval) trainer.extend( extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}')) trainer.extend( extensions.snapshot_object(model, filename='model_epoch-{.updater.epoch}')) # Be careful to pass the interval directly to LogReport # (it determines when to emit log rather than when to read observations) trainer.extend(extensions.LogReport(trigger=test_interval)) trainer.extend(extensions.observe_lr(), trigger=test_interval) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'lr' ]), trigger=test_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) if args.lr_shift > 0: # Reduce the learning rate by half every 25 epochs. if args.optimizer == 'adam': trainer.extend(extensions.ExponentialShift('alpha', args.lr_shift), trigger=(25, 'epoch')) else: trainer.extend(extensions.ExponentialShift('lr', args.lr_shift), trigger=(25, 'epoch')) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()