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)