def test_using_device_with_name(device_instance1, device_instance2): if device_instance1 == device_instance2: return device1 = device_instance1 device2 = device_instance2 chainerx.set_default_device(device1) with chainerx.using_device(device2.name) as scope: assert chainerx.get_default_device() == device2 assert scope.device is device2 with chainerx.using_device(device2.backend.name, device2.index) as scope: assert chainerx.get_default_device() == device2 assert scope.device is device2
def test_using_device(device_instance1, device_instance2): if device_instance1 == device_instance2: return device1 = device_instance1 device2 = device_instance2 chainerx.set_default_device(device1) with chainerx.using_device(device2) as scope: assert chainerx.get_default_device() is device2 assert scope.device is device2 scope = chainerx.using_device(device2) assert chainerx.get_default_device() == device1 assert scope.device is device2 with scope: assert chainerx.get_default_device() == device2 assert scope.device is device2 assert chainerx.get_default_device() == device1 assert scope.device is device2
def main(): 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('--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( '--iteration', '-I', type=int, default=None, help='Number of iterations to train. Epoch is ignored if specified.') 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('--root', '-R', default='.', help='Root directory path of image files') parser.add_argument('--val_batchsize', '-b', type=int, default=250, help='Validation minibatch size') parser.set_defaults(test=False) parser.add_argument('--device', '-d', default='native', help='Device to use') args = parser.parse_args() chx.set_default_device(args.device) batch_size = args.batchsize eval_size = args.val_batchsize # Prepare model model = resnet50.ResNet50() # Prepare datasets and mean file mean = np.load(args.mean) train = PreprocessedDataset(args.train, args.root, mean, model.insize) test = PreprocessedDataset(args.val, args.root, mean, model.insize, False) train_iter = chainer.iterators.MultiprocessIterator( train, batch_size, n_processes=args.loaderjob) test_iter = chainer.iterators.MultiprocessIterator( test, eval_size, n_processes=args.loaderjob) N = len(train) # Train model.require_grad() it = 0 epoch = 0 is_finished = False start = time.time() while not is_finished: for i in range(0, N // batch_size): x, t = get_imagenet(train_iter) y = model(x) loss = compute_loss(y, t) loss.backward() model.update(lr=0.01) it += 1 if args.iteration is not None: x_test, t_test = get_imagenet(test_iter) mean_loss, accuracy = evaluate(model, x_test, t_test, eval_size, batch_size) elapsed_time = time.time() - start print( 'iteration {}... loss={},\taccuracy={},\telapsed_time={}'. format(it, mean_loss, accuracy, elapsed_time)) if it >= args.iteration: is_finished = True break epoch += 1 if args.iteration is None: x_test, t_test = get_imagenet(test_iter) mean_loss, accuracy = evaluate(model, x_test, t_test, eval_size, batch_size) elapsed_time = time.time() - start print('epoch {}... loss={},\taccuracy={},\telapsed_time={}'.format( epoch, mean_loss, accuracy, elapsed_time)) if epoch >= args.epoch: is_finished = True
def global_set_gpu(): mxnet.test_utils.set_default_context(mxnet.gpu(0)) chainerx.set_default_device('cuda:0')
def global_set_cpu(): mxnet.test_utils.set_default_context(mxnet.cpu()) chainerx.set_default_device('native')
def main(): parser = argparse.ArgumentParser('Train a neural network on MNIST dataset') parser.add_argument('--batchsize', '-B', type=int, default=100, help='Batch size') parser.add_argument('--epoch', '-E', type=int, default=20, help='Number of epochs to train') parser.add_argument( '--iteration', '-I', type=int, default=None, help='Number of iterations to train. Epoch is ignored if specified.') parser.add_argument( '--data', '-p', default='mnist', help='Path to the directory that contains MNIST dataset') parser.add_argument('--device', '-d', default='native', help='Device to use') parser.add_argument( '--eval-size', default=None, type=int, help='Number of samples to use from the test set for evaluation. ' 'None to use all.') args = parser.parse_args() chx.set_default_device(args.device) # Prepare dataset X, Y = get_mnist(args.data, 'train') X_test, Y_test = get_mnist(args.data, 't10k') # Prepare model model = MLP() # Training N = X.shape[0] # TODO(beam2d): implement len # TODO(beam2d): support int32 indexing all_indices_np = np.arange(N, dtype=np.int64) batch_size = args.batchsize eval_size = args.eval_size # Train model.require_grad() it = 0 epoch = 0 is_finished = False start = time.time() while not is_finished: # TODO(beam2d): not suupported in chx np.random.shuffle(all_indices_np) all_indices = chx.array(all_indices_np) for i in range(0, N, batch_size): indices = all_indices[i:i + batch_size] x = X.take(indices, axis=0) t = Y.take(indices, axis=0) y = model.forward(x) loss = compute_loss(y, t) loss.backward() model.update(lr=0.01) it += 1 if args.iteration is not None: mean_loss, accuracy = evaluate(model, X_test, Y_test, eval_size, batch_size) elapsed_time = time.time() - start print( 'iteration {}... loss={},\taccuracy={},\telapsed_time={}'. format(it, mean_loss, accuracy, elapsed_time)) if it >= args.iteration: is_finished = True break epoch += 1 if args.iteration is None: # stop based on epoch, instead of iteration mean_loss, accuracy = evaluate(model, X_test, Y_test, eval_size, batch_size) elapsed_time = time.time() - start print('epoch {}... loss={},\taccuracy={},\telapsed_time={}'.format( epoch, mean_loss, accuracy, elapsed_time)) if epoch >= args.epoch: is_finished = True
def use(self): chainerx.set_default_device(self.device)
def main(): parser = argparse.ArgumentParser('Train a neural network on MNIST dataset') parser.add_argument( '--batchsize', '-B', type=int, default=100, help='Batch size') parser.add_argument( '--epoch', '-E', type=int, default=20, help='Number of epochs to train') parser.add_argument( '--iteration', '-I', type=int, default=None, help='Number of iterations to train. Epoch is ignored if specified.') parser.add_argument( '--data', '-p', default='mnist', help='Path to the directory that contains MNIST dataset') parser.add_argument( '--device', '-d', default='native', help='Device to use') parser.add_argument( '--eval-size', default=None, type=int, help='Number of samples to use from the test set for evaluation. ' 'None to use all.') args = parser.parse_args() chx.set_default_device(args.device) # Prepare dataset X, Y = get_mnist(args.data, 'train') X_test, Y_test = get_mnist(args.data, 't10k') # Prepare model model = MLP() # Training N = X.shape[0] # TODO(beam2d): implement len # TODO(beam2d): support int32 indexing all_indices_np = np.arange(N, dtype=np.int64) batch_size = args.batchsize eval_size = args.eval_size # Train model.require_grad() it = 0 epoch = 0 is_finished = False start = time.time() while not is_finished: # TODO(beam2d): not suupported in chx np.random.shuffle(all_indices_np) all_indices = chx.array(all_indices_np) for i in range(0, N, batch_size): indices = all_indices[i:i + batch_size] x = X.take(indices, axis=0) t = Y.take(indices, axis=0) y = model.forward(x) loss = compute_loss(y, t) loss.backward() model.update(lr=0.01) it += 1 if args.iteration is not None: mean_loss, accuracy = evaluate( model, X_test, Y_test, eval_size, batch_size) elapsed_time = time.time() - start print( 'iteration {}... loss={},\taccuracy={},\telapsed_time={}' .format(it, mean_loss, accuracy, elapsed_time)) if it >= args.iteration: is_finished = True break epoch += 1 if args.iteration is None: # stop based on epoch, instead of iteration mean_loss, accuracy = evaluate( model, X_test, Y_test, eval_size, batch_size) elapsed_time = time.time() - start print( 'epoch {}... loss={},\taccuracy={},\telapsed_time={}' .format(epoch, mean_loss, accuracy, elapsed_time)) if epoch >= args.epoch: is_finished = True
def test_default_device_with_name(device_instance1): device = device_instance1 chainerx.set_default_device(device.name) assert chainerx.get_default_device() is device
def restore_device(): chainerx.set_default_device(device)
def restore_context(): chainerx.set_global_default_context(global_context) chainerx.set_default_context(context) chainerx.set_default_device(device)
def main(): parser = argparse.ArgumentParser(description='Compare chainer vs chainerx') parser.add_argument('--batchsize', '-b', type=int, default=100) parser.add_argument('--epoch', '-e', type=int, default=10) parser.add_argument('--gpu', '-g', type=int, default=0, choices=[-1, 0, 1, 2, 3]) parser.add_argument('--chxon', '-c', type=int, default=1) args = parser.parse_args() # setup start = time.time() chx.available = True if args.chxon == 1 else False batch_size = args.batchsize # get MNIST train, test = chainer.datasets.get_mnist() if chx_available == True: device_name = 'cuda:{}'.format(args.gpu) # data with chx.using_device(device_name): train_images, train_labels = map(lamda d:chx.asarray(d), train._datasets) test_images, test_labels = map(lamda d:chx.asarray(d), test._datasets) # model chx.set_default_device(device_name) model = MLP(n_units=1000, n_out=10) optimizer = SGD(lr=0.01) else: device_name = args.gpu # data train_iter = chainer.iterators.SerialIterator(train, batch_size) test_iter = chainer.iterators.SerialIterator(train, batch_size, repeat=False, shuffle=False) # model model = MLP_chain(n_units=1000, n_out=10) model.to_gpu() chainer.cuda.get_device_from_id(device_name).use() optimizer = chainer.optimizers.SGD(lr=0.01) optimizer.setup(model) N_train, N_test = len(train), len(test) all_indices_np = np.arange(N_train, dtype=np.int64) # for chainerx epoch = 0 while epoch <= args.epoch: epoch += 1 if chx_available == True: np.random.shuffle(all_indices_np) all_indices = chx.array(all_indices_np) for i in range(0, N_train, batch_size): # time 1 if chx_available == True: indices = all_indices[i: i + batch_size] x = train_images.take(indices, axis=0) t = train_labels.take(indices, axis=0) else: batch = train_iter.next() x, t = convert.concat_examples(batch, device=device_name) y = model.forward(x) # time 2 # time 3 if chx_available == True: loss = compute_loss(y, t) else: loss = F.softmax_cross_entropy(y, t) model.cleargrads() loss.backward() # time 4 optimizer.update() # time 5 if chx_available == True: with chx.no_backprop_mode(): total_loss = chx.array(0, dtype=chx.float32) num_correct = chx.array(0, dtype=chx.int64) for i in range(0, N_test, batch_size): x = test_images[i:min(i + batch_size, N_test)] x = test_labels[i:min(i + batch_size, N_test)] y = model.forward(x) total_loss += compute_loss(y, t) * len(t) num_correct += (y.argmax(axis=1).astype(t.dtype) == t).astype(chx.int32).sum() else: test_iter.reset() with chainer.using_config('enable_backprop', False): total_loss = 0 num_correct = 0 for batch in test_iter: x, t = convert.concat_examples(batch, device=device_name) y = model.forward(x) total_loss += float(F.softmax_cross_entropy(y, t).array) * len(t) num_correct += float(F.accuracy(y, t).array) * len(t) mean_loss = float(total_loss) / N_test accuracy = int(num_correct) / N_test elapsed_time = time.time() - start print('epoch {} ... loss={}, accuracy, elapsed_time={}'.format( epoch, mean_loss, accuracy, elapsed_time))