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)