def main(self, units, epoch, batchsize): model = L.Classifier(Network(units, 10)) gpu = -1 if is_backend_gpu(): gpu = 0 chainer.cuda.get_device_from_id(gpu).use() model.to_gpu() elif is_backend_ideep(): model.to_intel64() optimizer = chainer.optimizers.MomentumSGD() optimizer.setup(model) train, test = chainer.datasets.get_mnist() train_iter = chainer.iterators.SerialIterator(train, batchsize) test_iter = chainer.iterators.SerialIterator(test, batchsize, repeat=False, shuffle=False) updater = training.updater.StandardUpdater(train_iter, optimizer, device=gpu) trainer = training.Trainer(updater, (epoch, 'epoch')) trainer.extend(extensions.Evaluator(test_iter, model, device=gpu)) trainer.run()
def __init__(self, units): self.model = L.Classifier(Network(units, 10)) self.gpu = -1 if is_backend_gpu(): self.gpu = 0 chainer.cuda.get_device_from_id(self.gpu).use() self.model.to_gpu() elif is_backend_ideep(): self.model.to_intel64()
def __init__(self, unit=1024, layer=3, train_batchsize=64, train_epoch=3, dummy_data=None): # Setup dummy data generator if dummy_data is None: dummy_data = {} generator = DummyDataGenerator(**dummy_data) vocab_size = generator.get_vocab_size() # Setup model model = Seq2seq(layer, vocab_size, vocab_size, unit) gpu = -1 if is_backend_gpu(): gpu = 0 chainer.cuda.get_device_from_id(gpu).use() model.to_gpu() elif is_backend_ideep(): model.to_intel64() # Generate dummy data for training and validation xp = model.xp train_data = generator.generate_training_data(xp) validate_data = generator.generate_validation_data(xp) # Setup optimizer optimizer = chainer.optimizers.Adam() optimizer.setup(model) # Setup iterator train_iter = chainer.iterators.SerialIterator(train_data, train_batchsize) # Setup updater and trainer updater = training.updaters.StandardUpdater(train_iter, optimizer, converter=_convert, device=gpu) trainer = training.Trainer(updater, (train_epoch, 'epoch')) # Add extensions (for debugging) trainer.extend(training.extensions.LogReport(trigger=(1, 'epoch'))) trainer.extend(training.extensions.PrintReport( ['epoch', 'iteration', 'main/loss', 'main/perp', 'elapsed_time']), trigger=(1, 'epoch')) # Variables to be used in the benchmark. self.trainer = trainer self.model = model self.validate_data = validate_data
def setup(self, arch, batchsize): xp = self.xp if arch == 'alexnet': from benchmarks.convnet.nets import alex model = alex.Alex() elif arch == 'googlenet': from benchmarks.convnet.nets import googlenet model = googlenet.GoogLeNet() elif arch == 'vgga': from benchmarks.convnet.nets import vgga model = vgga.vgga() elif arch == 'overfeat': from benchmarks.convnet.nets import overfeat model = overfeat.overfeat() else: raise ValueError('Invalid architecture name') if is_backend_gpu(): model.to_gpu() elif is_backend_ideep(): model.to_intel64() # Setup optimizer optimizer = optimizers.SGD(lr=0.01) optimizer.setup(model) # Set cuDNN workspace size workspace_size = int(1 * 2**30) chainer.cuda.set_max_workspace_size(workspace_size) chainer.config.train = True x = xp.ndarray((batchsize, 3, model.insize, model.insize), dtype=xp.float32) x.fill(33333) if arch == 'googlenet': out1, out2, out3 = model.forward(x) out = out1 + out2 + out3 else: out = model.forward(x) out.zerograd() out.grad.fill(3) model.cleargrads() self._x = x self._model = model self._out = out
def setup(self, count): shape = (5000, 5000) dtype = numpy.float32 size = functools.reduce(operator.mul, shape) inputs = [ self.xp.arange(size, dtype=dtype).reshape(shape) + 1 for _ in range(count) ] grad_outputs = self.xp.ones(shape, dtype=dtype) if is_backend_ideep(): inputs = [intel64.ideep.array(x) for x in inputs] grad_outputs = intel64.ideep.array(grad_outputs) self.setup_benchmark(F.add, inputs, grad_outputs)