def onnx_to_singa(niter, use_cpu=False): if use_cpu: print("Using CPU") dev = device.get_default_device() else: print("Using GPU") dev = device.create_cuda_gpu() model = sonnx.load("mlp.onnx") backend = sonnx.prepare(model, device=dev) sgd = opt.SGD(0.1) inputs = Tensor( data=data, device=dev, requires_grad=False, stores_grad=False, name="input", ) target = Tensor( data=label, device=dev, requires_grad=False, stores_grad=False, name="target", ) for i in range(100): y = backend.run([inputs])[0] loss = autograd.softmax_cross_entropy(y, target) for p, gp in autograd.backward(loss): sgd.update(p, gp) loss_rate = tensor.to_numpy(loss)[0] accuracy_rate = accuracy(tensor.to_numpy(y), label) print("Iter {}, accurate={}, loss={}".format(i, accuracy_rate, loss_rate))
def test_sigmoid(self): X = np.array([[-1, 0, 1]]).astype(np.float32) x = tensor.from_numpy(X) x.to_device(gpu_dev) y = autograd.Sigmoid()(x)[0] # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_max_pool(self): x = tensor.Tensor(shape=(2, 3, 4, 4), device=gpu_dev) x.gaussian(0.0, 1.0) y = autograd.MaxPool2d(2, 2, 0)(x) # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_linear(self): x = tensor.Tensor(shape=(2, 20), device=gpu_dev) x.gaussian(0.0, 1.0) x1 = x.clone() y = autograd.Linear(20, 1, bias=False)(x) # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x1]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_inference(self): x = tensor.Tensor(shape=(2, 3, 3, 3), device=gpu_dev) x.gaussian(0.0, 1.0) x1 = autograd.Conv2d(3, 1, 2)(x) y = autograd.Conv2d(1, 1, 2)(x1) # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x], last_layers=-1) np.testing.assert_array_almost_equal(tensor.to_numpy(x1), tensor.to_numpy(y_t[0]), decimal=5)
def test_Sqrt(self): x = np.array([0.1, 1.0, 0.4, 4.0, 0.9, 9.0]).reshape(3, 2).astype(np.float32) x = tensor.from_numpy(x) y = autograd.sqrt(x) # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_relu(self): X = np.array([0.8, -1.2, 3.3, -3.6, -0.5, 0.5]).reshape(3, 2).astype(np.float32) XT = np.array([0.8, 0, 3.3, 0, 0, 0.5]).reshape(3, 2).astype(np.float32) x = tensor.from_numpy(X) x.to_device(gpu_dev) y = autograd.ReLU()(x)[0] # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_transpose(self): x = np.random.randn(3, 2, 1) y = x.transpose(1, 2, 0) x = tensor.from_numpy(x) x.to_device(cpu_dev) y = autograd.transpose(x, (1, 2, 0)) # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_concat(self): X1 = np.random.randn(3, 4, 5).astype(np.float32) X2 = np.random.randn(3, 4, 5).astype(np.float32) x1 = tensor.from_numpy(X1) x2 = tensor.from_numpy(X2) x1.to_device(gpu_dev) x2.to_device(gpu_dev) y = autograd.Concat()(x1, x2)[0] # frontend model = sonnx.to_onnx([x1, x2], [y]) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x1, x2]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_HardSigmoid(self): x = np.array([-0.9, -0.3, -0.1, 0.1, 0.5, 0.9]).reshape(3, 2).astype(np.float32) a = 0.2 g = 0.5 x = tensor.from_numpy(x) x.to_device(gpu_dev) y = autograd.hardsigmoid(x, a, g) # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_ELu(self): x = np.array([-0.9, -0.3, -0.1, 0.1, 0.5, 0.9]).reshape(3, 2).astype(np.float32) #y = gamma * (alpha * e^x - alpha) for x <= 0, y = gamma * x for x > 0 a = 1. x = tensor.from_numpy(x) x.to_device(gpu_dev) y = autograd.elu(x, a) # frontend model = sonnx.to_onnx([x], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_matmul(self): X1 = np.random.randn(4, 5).astype(np.float32) X2 = np.random.randn(5, 4).astype(np.float32) x1 = tensor.from_numpy(X1) x2 = tensor.from_numpy(X2) x1.to_device(gpu_dev) x2.to_device(gpu_dev) y = autograd.Matmul()(x1, x2)[0] # frontend model = sonnx.to_onnx([x1, x2], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x1, x2]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_min(self): X0 = np.array([0.1, 0.2, 2.0, 0.0, 0.1, 0.2]).reshape(3, 2).astype(np.float32) X1 = np.array([1.0, 2.0, 1.0, 2.1, 0.0, 2.0]).reshape(3, 2).astype(np.float32) x0 = tensor.from_numpy(X0) x1 = tensor.from_numpy(X1) x0.to_device(gpu_dev) x1.to_device(gpu_dev) y = autograd.min(x0, x1) # frontend model = sonnx.to_onnx([x0, x1], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x0, x1]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def test_Greater(self): x0 = np.array([-0.9, -0.3, -0.1, 0.1, 0.5, 0.9]).reshape(3, 2).astype(np.float32) x1 = np.array([0, -0.3, 0, 0.1, 0, 0.9]).reshape(3, 2).astype(np.float32) x0 = tensor.from_numpy(x0) x1 = tensor.from_numpy(x1) x0.to_device(cpu_dev) x1.to_device(cpu_dev) y = autograd.greater(x0, x1) # frontend model = sonnx.to_onnx([x0, x1], [y]) # print('The model is:\n{}'.format(model)) # backend sg_ir = sonnx.prepare(model, device=gpu_dev) y_t = sg_ir.run([x0, x1]) np.testing.assert_array_almost_equal(tensor.to_numpy(y), tensor.to_numpy(y_t[0]), decimal=5)
def onnx_to_singa(epochs, use_cpu=False, batchsize=32): (x_train, y_train), (x_test, y_test), dev = common(use_cpu) model = sonnx.load("cnn.onnx") backend = sonnx.prepare(model, dev) autograd.training = True sgd = opt.SGD(lr=0.01) niter = x_train.shape[0] // batchsize for epoch in range(epochs): accuracy_rate = 0.0 loss_rate = 0.0 for i in range(niter): inputs = tensor.Tensor( device=dev, data=x_train[i * batchsize : (i + 1) * batchsize], stores_grad=False, name="input", ) targets = tensor.Tensor( device=dev, data=y_train[i * batchsize : (i + 1) * batchsize], requires_grad=False, stores_grad=False, name="target", ) y = backend.run([inputs])[0] loss = autograd.softmax_cross_entropy(y, targets) accuracy_rate += accuracy( tensor.to_numpy(y), y_train[i * batchsize : (i + 1) * batchsize] ) loss_rate += tensor.to_numpy(loss)[0] for p, gp in autograd.backward(loss): sgd.update(p, gp) print("accuracy is {}, loss is {}".format(accuracy_rate / niter, loss_rate / niter))
epochs = 1 sgd = opt.SGD(lr=0.00) x_train = preprocess(train[0]) y_train = to_categorical(train[1], num_classes) x_test = preprocess(test[0]) y_test = to_categorical(test[1], num_classes) print('the shape of training data is', x_train.shape) print('the shape of training label is', y_train.shape) print('the shape of testing data is', x_test.shape) print('the shape of testing label is', y_test.shape) model = onnx.load('cnn.onnx') rep = sonnx.prepare(model, dev) print('finish init') autograd.training = True # training process for epoch in range(1): inputs = tensor.Tensor(device=dev, data=x_train[0:100], stores_grad=False) targets = tensor.Tensor(device=dev, data=y_train[0:100], requires_grad=False, stores_grad=False) y0 = rep.run([inputs])[0] loss = autograd.softmax_cross_entropy(y0, targets) print('outputs', tensor.to_numpy(loss)[0])
tmp_dict = {} for idx in range(0, n): logging.info("starting infer sample {}...".format(idx)) item = eval_examples[idx] inputs = [ np.array([item.qas_id], dtype=np.int32), segment_ids[idx:idx + bs].astype(np.int32), input_mask[idx:idx + bs].astype(np.int32), input_ids[idx:idx + bs].astype(np.int32), ] if sg_ir is None: # prepare the model logging.info("model is none, prepare model...") sg_ir = sonnx.prepare(onnx_model, device=dev, init_inputs=inputs, keep_initializers_as_inputs=False) model = Infer(sg_ir) x_batch = [] for inp in inputs: tmp_tensor = tensor.from_numpy(inp) tmp_tensor.to_device(dev) x_batch.append(tmp_tensor) logging.info("model running for sample {}...".format(idx)) outputs = model.forward(x_batch) logging.info("hanlde the result of sample {}...".format(idx)) result = [] for outp in outputs:
url = 'https://s3.amazonaws.com/onnx-model-zoo/resnet/resnet18v1/resnet18v1.tar.gz' download_dir = '/tmp/' model_path = os.path.join(download_dir, 'resnet18v1', 'resnet18v1.onnx') logging.info("onnx load model...") download_model(url) onnx_model = onnx.load(model_path) # set batch size onnx_model = update_batch_size(onnx_model, 1) # prepare the model logging.info("prepare model...") dev = device.create_cuda_gpu() sg_ir = sonnx.prepare(onnx_model, device=dev) autograd.training = False model = Infer(sg_ir) # verifty the test # from utils import load_dataset # inputs, ref_outputs = load_dataset(os.path.join('/tmp', 'resnet18v1', 'test_data_set_0')) # x_batch = tensor.Tensor(device=dev, data=inputs[0]) # outputs = model.forward(x_batch) # for ref_o, o in zip(ref_outputs, outputs): # np.testing.assert_almost_equal(ref_o, tensor.to_numpy(o), 4) # inference logging.info("preprocessing...") img, labels = get_image_labe() img = preprocess(img)
# under the License. # # load and run the onnx model exported from pytorch # https://github.com/onnx/tutorials/blob/master/tutorials/PytorchOnnxExport.ipynb import argparse from singa import device from singa import sonnx from singa import tensor if __name__ == "__main__": parser = argparse.ArgumentParser(description="Load model from pytorch") parser.add_argument("--use_cpu", action="store_true") args = parser.parse_args() if args.use_cpu: print("Using CPU") dev = device.get_default_device() else: print("Using GPU") dev = device.create_cuda_gpu() model = sonnx.load("alexnet.onnx") backend = sonnx.prepare(model, dev) input_name = model.graph.inputs[0].name inputs = tensor.Tensor(shape=(2, 3, 224, 224), device=dev, name=input_name) inputs.gaussian(0, 0.01) y = backend.run([inputs])[0]