def evaluate(): tf.reset_default_graph() val_image, val_label = load_tfrecord(shuffle=False, path="test.tfrecords", batch_size=BATCH_SIZE) logits = net.CNN(val_image, N_CLASSES, is_pretrain=True) correct = tools.num_correct_prediction(logits, val_label) saver = tf.train.Saver(tf.global_variables()) with tf.Session() as sess: # ============================================================================= # tf.get_variable_scope().reuse_variables() # ============================================================================= print("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(train_log_dir) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split( '-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) print('Loading success, global_step is %s' % global_step) else: print('No checkpoint file found') return coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) try: print('\nEvaluating......') num_step = int(math.floor(n_test / BATCH_SIZE)) num_sample = num_step * BATCH_SIZE step = 0 total_correct = 0 while step < num_step and not coord.should_stop(): batch_correct = sess.run(correct) total_correct += np.sum(batch_correct) step += 1 print('Total testing samples: %d' % num_sample) print('Total correct predictions: %d' % total_correct) print('Average accuracy: %.2f%%' % (100 * total_correct / num_sample)) except tf.errors.OutOfRangeError: print('Done reading') finally: coord.request_stop() coord.request_stop() coord.join(threads)
def main(args): if args.model == 'cnn': net = net_module.CNN() else: net = net_module.MLP(28 * 28, 10, 100) gpu_device = args.gpu if gpu_device >= 0: chainer.cuda.get_device(gpu_device).use() net.to_gpu(gpu_device) xp = cuda.cupy else: xp = np serializers.load_npz(args.model_file, net) image = Image.open(args.image_file).convert('L').resize((28, 28), Image.BILINEAR) # 学習データは値の範囲が0~1なのでそれに合わせるために255で割る # 学習データは背景が0なので反転する image = 1 - xp.asarray(image).astype(np.float32) / 255 image = image.reshape((1, -1)) probs = cuda.to_cpu(predict(net, image))[0] results = sorted(zip(six.moves.range(10), probs), key=lambda x: -x[1]) for n, p in results: print('{0:d}: {1:.4f}'.format(n, p))
[transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]) train_dataset = datasets.MNIST(root='./data', train=True, transform=data_tf, download=False) test_dataset = datasets.MNIST(root='/data', train=False, transform=data_tf, download=False) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) model = net.CNN(1, 10) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=learning_rate) for e in range(num_epoches): print('epoch {}\n*******'.format(e)) acc = 0 for i, data in enumerate(train_loader, 1): img, label = data img = Variable(img) label = Variable(label) out = model(img) loss = criterion(out, label) _, pred = torch.max(out, 1) num_correct = (pred == label).sum() acc += num_correct.data[0]
def main(): parser = argparse.ArgumentParser(description='Chainer test:') parser.add_argument('--initmodel', '-m', default='', help='Initialize the model from given file') parser.add_argument('--resume', '-r', default='', help='Resume the optimization from snapshot') parser.add_argument('--gpu', '-g', default=-1, type=int, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--epoch', '-e', default=100, type=int, help='number of epochs to learn') parser.add_argument('--dimz', '-z', default=20, type=int, help='dimention of encoded vector') parser.add_argument('--batchsize', '-b', type=int, default=100, help='learning minibatch size') parser.add_argument('--test', action='store_true', help='Use tiny datasets for quick tests') parser.add_argument('--vae', action='store_true', help='pre-training vae') args = parser.parse_args() train, test = chainer.datasets.get_mnist(ndim=3) print('before:data: {0}, test: {1}'.format(np.shape(train), len(test))) if args.vae: model = net.VAE(784, args.dimz, 500) serializers.load_npz('model/vae.npz', model) datas, _ = chainer.datasets.get_mnist(withlabel=False) print('datas: {0}, train: {1}'.format(datas.ndim, np.shape(train))) x = chainer.Variable(np.asarray(datas)) with chainer.using_config('train', False), chainer.no_backprop_mode(): train = model.forward(x) train = np.reshape(train, (len(x), 2)) print('after:train: {0}, test: {1}'.format(np.shape(train), len(test))) # sys.exit() # モデルの生成 model = net.CNN() optimizer = optimizers.Adam() optimizer.setup(model) # パラメータの更新 iterator = iterators.SerialIterator(train, 1000) updater = training.StandardUpdater(iterator, optimizer) trainer = training.Trainer(updater, (10, 'epoch')) trainer.run() # 評価 ok = 0 for i in range(len(test)): x = Variable(np.array([test[i][0]], dtype=np.float32)) t = test[i][1] out = model.fwd(x) ans = np.argmax(out.data) if (ans == t): ok += 1 print((ok * 1.0) / len(test))
else: train_index = index[:-5000] valid_index = index[-5000:] valid_x = images['train'][valid_index].reshape((-1, 3, 32, 32)) valid_y = labels['train'][valid_index] valid_data = CifarDataset(valid_x, valid_y, augment=None) train_x = images['train'][train_index].reshape((-1, 3, 32, 32)) train_y = labels['train'][train_index] train_data = CifarDataset(train_x, train_y, augment=augmentation) test_x = images['test'].reshape((-1, 3, 32, 32)) test_y = labels['test'] test_data = CifarDataset(test_x, test_y, augment=None) print('start training') if args.model == 'cnn': cifar_net = net.CNN() elif args.model == 'cnnbn': cifar_net = net.CNNBN() elif args.model == 'cnnwn': cifar_net = net.CNNWN() elif args.model == 'residual': cifar_net = net.ResidualNet(args.res_depth, swapout=args.swapout, skip=args.skip_depth) elif args.model == 'identity_mapping': cifar_net = net.IdentityMapping(args.res_depth, swapout=args.swapout, skip=args.skip_depth) elif args.model == 'vgg_no_fc': cifar_net = net.VGGNoFC() elif args.model == 'vgg_wide': cifar_net = net.VGGWide() elif args.model == 'vgg_crelu': cifar_net = net.VGGCReLU() elif args.model == 'inception':
def main(): parser = argparse.ArgumentParser(description='Chainer CIFAR example:') parser.add_argument('--train', default='train.txt', type=str, help='File name of train data') parser.add_argument('--test', default='validation.txt', type=str, help='File name of validation data') parser.add_argument('--root', '-R', default='.', help='Root directory path of image files') 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=20, 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('--mean', default=None, help='mean file (computed by compute_mean.py)') 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. train = image_dataset.ImageDataset(args.train, args.root, max_size=32, mean=args.mean) test = image_dataset.ImageDataset(args.test, args.root, max_size=32, mean=args.mean) model = L.Classifier(net.CNN(outputSize=1), lossfun=F.mean_squared_error) model.compute_accuracy = False 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.Adam() 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)) # 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')) trainer.extend(extensions.snapshot_object( model, 'model_iter_{.updater.iteration}'), 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', '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 load_model(): model = L.Classifier(net.CNN(), lossfun=F.mean_squared_error) model.predictor.train = False serializers.load_npz('model.npz', model) return model
parser = argparse.ArgumentParser(description='MNIST training') parser.add_argument('--model', '-m', type=str, default='mlp', choices=['mlp', 'cnn'], help='Neural network model') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU device index, -1 indicates CPU') parser.add_argument('--epoch', '-e', type=int, default=100, help='Number of epochs') parser.add_argument('--batch-size', '-b', type=int, default=100, help='Mini batch size') parser.add_argument('--prefix', '-p', type=str, default=None, help='prefix of saved file name') args = parser.parse_args() n_epoch = args.epoch batch_size = args.batch_size if args.prefix is None: prefix = args.model else: prefix = args.prefix if args.model == 'cnn': net = net_module.CNN() else: net = net_module.MLP(28 * 28, 10, 100) gpu_device = args.gpu if gpu_device >= 0: chainer.cuda.get_device(gpu_device).use() net.to_gpu(gpu_device) xp = cuda.cupy else: xp = np optimizer = optimizers.Adam() optimizer.setup(net) # MNISTデータセットを読み込む # get_mnistはMNISTデータセットファイルがなければダウンロードを行うので # 初回実行時は時間がかかる
shuffle=True, **kwargs) print('start to load test dataset') testset = datasets.CIFAR10(root=data_dir, train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=test_bach_size, shuffle=False, **kwargs) print('finish loading dataset') # net = net.Net().to(device) net = net.CNN().to(device) print('finish loading NN') # optimizer = optim.SGD(net.parameters(), lr=lr, momentum=momentum) optimizer = optim.Adam(net.parameters()) print('finish loading optimizer') criterion = nn.CrossEntropyLoss() print('finish loading criterion') logger = logger.TrainLogger(out_dir, epochs, prefix) print('finish loading logger') r = run.NNRun(net, optimizer, criterion, logger, device, log_interval, out_dir)
parser.add_argument('-n', type=int, default=None, help='sample numbers') parser.add_argument('-s', '--step', type=int, default=1, help='step') parser.add_argument('--mean', type=str, default=None, help='mean file (computed by compute_mean.py)') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') args = parser.parse_args() # load model model = L.Classifier(net.CNN(), lossfun=F.mean_squared_error) model.predictor.train = False serializers.load_npz(args.model, model) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() if args.mean: mean = np.load(args.mean) def predict(x): y = model.predictor(x) pred = y.data
word = "" for j in range(config.C_LEN): word += config.DICTSET[random.randint(0, config.NUM_CLASSES - 1)] cap.write(word, os.path.join(config.IMAGE_DIR, '%d.png' % i)) f.write(word + "\n") f.close() # 是否进行训练 if TRAIN_FLAG: train_set = am.CapDataset(root=config.DATASET_ROOT, flag=1) transform_test = data.vision.transforms.Compose([am.g_totensor]) train_iter = data.DataLoader(train_set.transform_first(transform_test), config.BATCH_SIZE, shuffle=False, last_batch='keep') net = anet.CNN(config.NUM_CLASSES, config.C_LEN).get_net() loss = gluon.loss.SoftmaxCrossEntropyLoss() ctx, num_epochs, lr, wd = am.try_gpu(), 30, 1e-4, 5e-4 net.initialize(ctx=ctx, init=init.Xavier()) # trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr, 'momentum': 0.9, 'wd': wd}) trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr}) print("train begin") for epoch in range(num_epochs): train_l_sum, train_acc_sum, n, timer = 0.0, 0.0, 0, time.time() for X, y in train_iter: X = X.as_in_ctx(ctx) y = y.as_in_ctx(ctx) l = [] with autograd.record(): y_hat = net(X)