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()
