def main_impl(args):
# Set up a neural network to train
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
model = MLP(args.unit, 10)
# classifier = L.Classifier(model)
classifier = MyClassifier(model, compute_accuracy=args.run_training)
model = classifier
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
if args.run_training:
run_training(args, model)
return
out_dir = 'out/backprop_test_mnist_mlp'
x = np.random.random((args.batchsize, 784)).astype(np.float32)
y = (np.random.random(args.batchsize) * 10).astype(np.int32)
onehot = np.eye(10, dtype=x.dtype)[y]
x = chainer.Variable(x, name='input')
onehot = chainer.Variable(onehot, name='onehot')
chainer.disable_experimental_feature_warning = True
shutil.rmtree(out_dir, ignore_errors=True)
onnx_chainer.export_testcase(model, (x, onehot),
out_dir,
output_grad=True,
output_names='loss')
def export_onnx(input_image_path, output_path, gpu, only_output=True):
"""Export ResNet50 model to ONNX graph
'model.onnx' file will be exported under ``output_path``.
"""
model = C.ResNet50(pretrained_model='imagenet', arch='fb')
input_image = read_image(input_image_path)
input_image = scale(input_image, 256)
input_image = center_crop(input_image, (224, 224))
input_image -= model.mean
input_image = input_image[None, :]
if gpu >= 0:
model.to_gpu()
input_image = chainer.cuda.to_gpu(input_image)
if only_output:
os.makedirs(output_path, exist_ok=True)
name = os.path.join(output_path, 'model.onnx')
export(model, input_image, filename=name)
else:
# an input and output given by Chainer will be also emitted
# for using as test dataset
export_testcase(model, input_image, output_path)
def export_onnx(input_image_path, output_path, gpu, only_output=True):
"""Export YOLOv2 Tiny model to ONNX graph
'model.onnx' file will be exported under ``output_path``.
"""
model = YOLOv2Tiny(pretrained_model='voc0712')
input_image = read_image(input_image_path)
input_image = input_image[None, :]
if gpu >= 0:
model.to_gpu()
input_image = chainer.cuda.to_gpu(input_image)
if only_output:
os.makedirs(output_path, exist_ok=True)
name = os.path.join(output_path, 'model.onnx')
export(
model, input_image, filename=name,
output_names=('locs', 'objs', 'confs'))
else:
# an input and output given by Chainer will be also emitted
# for using as test dataset
export_testcase(
model, input_image, output_path,
output_names=('locs', 'objs', 'confs'))
def main_impl(args, model_cls):
model = model_cls(compute_accuracy=args.run_training)
insize = model.insize
replace_id(model)
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
if args.run_training:
run_training(args, model)
return
out_dir = 'out/backprop_test_%s' % args.arch
xp = model.xp
x = xp.random.random(
(args.batchsize, 3, insize, insize)).astype(np.float32)
y = (xp.random.random(args.batchsize) * 1000).astype(np.int32)
onehot = xp.eye(1000, dtype=x.dtype)[y]
x = chainer.Variable(x, name='input')
y = chainer.Variable(y, name='y')
onehot = chainer.Variable(onehot, name='onehot')
chainer.disable_experimental_feature_warning = True
shutil.rmtree(out_dir, ignore_errors=True)
onnx_chainer.export_testcase(model, (x, onehot),
out_dir,
output_grad=True,
output_names='loss')
def fn(test_name):
np.random.seed(42)
x = np.random.rand(1, 3, 224, 224).astype(np.float32)
test_dir = os.path.join('out', test_name)
shutil.rmtree(test_dir, ignore_errors=True)
onnx_chainer.export_testcase(model, [x],
test_dir,
opset_version=9)
def gen_test_data_set(model, args, name, opset_version, **kwargs):
model.xp.random.seed(42)
test_path = os.path.join(TEST_OUT_DIR, 'opset{}'.format(opset_version),
name)
onnx_chainer.export_testcase(model,
args,
test_path,
opset_version=opset_version,
**kwargs)
return test_path
def test_export_external_converters_custom_op(tmpdir, domain, version):
path = str(tmpdir)
class Dummy(chainer.FunctionNode):
def forward_cpu(self, inputs):
self.x = inputs[0]
return np.ones_like(inputs[0]),
def backward(self, indexes, grad_outputs):
return chainer.Variable(np.zeros_like(self.x)),
def dummy_function(x):
return Dummy().apply((x, ))[0]
model = chainer.Sequential(dummy_function)
x = input_generator.increasing(2, 5)
def custom_converter(params):
return onnx_helper.make_node('Dummy',
params.input_names,
params.output_names,
domain=domain),
addon_converters = {'Dummy': custom_converter}
# warnings list
# 1. `external_converter` is experimental feature
# 2. `return_named_inout` which is used internally is experimental feature
expected_warning_num = 2
external_opset_imports = {}
if domain is not None:
external_opset_imports[domain] = version
# 3. `external_opset_imports` is experimental feature
expected_warning_num += 1
if not onnx_helper.is_support_non_standard_domain():
# 4. ValidationError is ignored
expected_warning_num += 1
else:
# 3. ValidationError is ignored
expected_warning_num += 1
with warnings.catch_warnings(record=True) as w:
export_testcase(model,
x,
path,
external_converters=addon_converters,
external_opset_imports=external_opset_imports)
assert len(w) == expected_warning_num
output_path = os.path.join(path, 'test_data_set_0', 'output_0.pb')
assert os.path.isfile(output_path)
output = onnx.numpy_helper.to_array(onnx.load_tensor(output_path))
expected_output = np.ones_like(x)
np.testing.assert_allclose(output, expected_output, rtol=1e-5, atol=1e-5)
def create_backprop_test(test_name, fn, dtype=np.float32, **kwargs):
test_dir = 'out/backprop_test_oc_%s' % test_name
params = {}
for name, value in kwargs.items():
params[name] = np.array(value, dtype)
model = AnyModel(fn, params)
chainer.disable_experimental_feature_warning = True
onnx_chainer.export_testcase(model, (),
test_dir,
output_grad=True,
output_names='loss')
def create_test(test_name, get_fun, dtype):
np.random.seed(314)
chainer.config.dtype = dtype
model, inputs = get_fun(dtype)
output_grad = 'backprop' in test_name
test_dir = 'out/%s' % test_name
chainer.disable_experimental_feature_warning = True
onnx_chainer.export_testcase(model,
inputs,
test_dir,
output_grad=output_grad,
train=True,
output_names='loss')
def test_export_external_converters_custom_op(tmpdir, domain, version):
path = str(tmpdir)
class Dummy(chainer.FunctionNode):
def forward_cpu(self, inputs):
self.x = inputs[0]
return np.ones_like(inputs[0]),
def backward(self, indexes, grad_outputs):
return chainer.Variable(np.zeros_like(self.x)),
def dummy_function(x):
return Dummy().apply((x, ))[0]
model = chainer.Sequential(dummy_function)
x = input_generator.increasing(2, 5)
def custom_converter(params):
return onnx_helper.make_node('Dummy',
params.input_names,
params.output_names,
domain=domain),
addon_converters = {'Dummy': custom_converter}
external_opset_imports = {}
is_set_domain = domain is not None
if is_set_domain:
external_opset_imports[domain] = version
if is_set_domain and onnx_helper.is_support_non_standard_domain():
export_testcase(model,
x,
path,
external_converters=addon_converters,
external_opset_imports=external_opset_imports)
else:
with testing.assert_warns(UserWarning):
export_testcase(model,
x,
path,
external_converters=addon_converters,
external_opset_imports=external_opset_imports)
output_path = os.path.join(path, 'test_data_set_0', 'output_0.pb')
assert os.path.isfile(output_path)
output = onnx.numpy_helper.to_array(onnx.load_tensor(output_path))
expected_output = np.ones_like(x)
np.testing.assert_allclose(output, expected_output, rtol=1e-5, atol=1e-5)
def test_export_testcase(
tmpdir, model, x, disable_experimental_warning, in_names, out_names):
# Just check the existence of pb files
path = str(tmpdir)
export_testcase(model, (x,), path,
input_names=in_names, output_names=out_names)
assert os.path.isfile(os.path.join(path, 'model.onnx'))
input_pb_path = os.path.join(path, 'test_data_set_0', 'input_0.pb')
assert os.path.isfile(input_pb_path)
input_tensor = onnx.load_tensor(input_pb_path)
assert input_tensor.name == (in_names[0] if in_names else 'Input_0')
output_pb_path = os.path.join(path, 'test_data_set_0', 'output_0.pb')
assert os.path.isfile(output_pb_path)
output_tensor = onnx.load_tensor(output_pb_path)
assert output_tensor.name == (
out_names[0] if out_names else 'LinearFunction_1')
def test_export_external_converters_overwrite(tmpdir, check_model_expect):
path = str(tmpdir)
model = chainer.Sequential(chainer.functions.sigmoid)
x = input_generator.positive_increasing(2, 5)
def custom_converter(params):
return onnx_helper.make_node('Tanh', params.input_names,
params.output_names),
addon_converters = {'Sigmoid': custom_converter}
export_testcase(model, x, path, external_converters=addon_converters)
tanh_outputs = chainer.functions.tanh(x).array
output_path = os.path.join(path, 'test_data_set_0', 'output_0.pb')
onnx_helper.write_tensor_pb(output_path, '', tanh_outputs) # overwrite
check_model_expect(path)
def test_replace_func_collection_return(tmpdir, return_type):
path = str(tmpdir)
class Model(chainer.Chain):
def __init__(self, return_type):
super().__init__()
self.return_type = return_type
def tiled_array(self, xs, n=5):
if self.return_type == 'list':
return [xs.array * i for i in range(1, 1+n)]
else:
assert self.return_type == 'dict'
return {str(i): xs.array * i for i in range(1, 1+n)}
def __call__(self, xs):
return self.tiled_array(xs)
model = Model(return_type)
x = input_generator.increasing(1, 5)
with warnings.catch_warnings(record=True):
model.tiled_array = fake_as_funcnode(model.tiled_array, 'xTiledArray')
def tiled_array_converter(params):
return onnx_helper.make_node(
'xTiledArray', params.input_names, params.output_names),
addon_converters = {'xTiledArray': tiled_array_converter}
with testing.assert_warns(UserWarning):
export_testcase(model, x, path, external_converters=addon_converters)
model_filepath = os.path.join(path, 'model.onnx')
assert os.path.isfile(model_filepath)
onnx_model = onnx.load(model_filepath)
node_names = [n.name for n in onnx_model.graph.node]
assert len(node_names) == 1
assert node_names[0] == 'xTiledArray_0'
output_names = [n.name for n in onnx_model.graph.output]
assert len(output_names) == 5
for i, name in enumerate(output_names):
assert name == 'xTiledArray_0_{:d}'.format(i)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--model', choices=('yolo_v2', 'yolo_v2_tiny', 'yolo_v3'),
default='yolo_v2')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model', default='voc0712')
parser.add_argument('--export', action='store_true')
parser.add_argument('image')
args = parser.parse_args()
if args.model == 'yolo_v2':
model = YOLOv2(
n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'yolo_v2_tiny':
model = YOLOv2Tiny(
n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'yolo_v3':
model = YOLOv3(
n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
img = utils.read_image(args.image, color=True)
if args.export:
import onnx_chainer
x = model.xp.stack([img])
onnx_chainer.export_testcase(model, x, args.model)
return
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
vis_bbox(
img, bbox, label, score, label_names=voc_bbox_label_names)
plt.show()
def create_test(test_name, get_fun, dtype):
np.random.seed(314)
chainer.config.dtype = dtype
model, inputs = get_fun(dtype)
if chainer.cuda.available:
model.to_gpu()
inputs = [chainer.cuda.to_gpu(i) for i in inputs]
output_grad = 'backprop' in test_name
test_dir = 'out/%s' % test_name
chainer.disable_experimental_feature_warning = True
shutil.rmtree(test_dir, ignore_errors=True)
onnx_chainer.export_testcase(model,
inputs,
test_dir,
output_grad=output_grad,
train=True,
output_names='loss')
def test_output(self, tmpdir):
# first, make expected gradients to temp directory
expected_result_path = str(tmpdir)
model = self.get_model()
x = input_generator.increasing(2, 5)
export_testcase(model, x, expected_result_path, output_grad=True)
data_set_name = 'test_data_set_0'
expected_gradients = [
os.path.join(expected_result_path, data_set_name,
'gradient_{}.pb').format(i) for i in range(2)
]
assert all([os.path.isfile(path) for path in expected_gradients])
# model.half returns chainer.Variable and enabled backward
# regardless using replacing
model.half = fake_as_funcnode(model.half, 'MulConstant')
x = input_generator.increasing(2, 5)
def gradient_check(model, path):
actual_gradients = [
os.path.join(path, data_set_name, 'gradient_{}.pb').format(i)
for i in range(2)
]
assert all([os.path.isfile(path) for path in actual_gradients])
def load_tensor(path):
tensor = onnx.load_tensor(path)
return onnx.numpy_helper.to_array(tensor)
for e_path, a_path in zip(expected_gradients, actual_gradients):
expected = load_tensor(e_path)
actual = load_tensor(a_path)
np.testing.assert_allclose(expected, actual)
self.expect(model,
x,
output_grad=True,
custom_model_test_func=gradient_check)
def test_output_grad(tmpdir, model, x, disable_experimental_warning):
path = str(tmpdir)
export_testcase(model, (x,), path, output_grad=True, train=True)
model_filename = os.path.join(path, 'model.onnx')
assert os.path.isfile(model_filename)
assert os.path.isfile(os.path.join(path, 'test_data_set_0', 'input_0.pb'))
assert os.path.isfile(os.path.join(path, 'test_data_set_0', 'output_0.pb'))
onnx_model = onnx.load(model_filename)
initializer_names = {i.name for i in onnx_model.graph.initializer}
# 10 gradient files should be there
for i in range(10):
tensor_filename = os.path.join(
path, 'test_data_set_0', 'gradient_{}.pb'.format(i))
assert os.path.isfile(tensor_filename)
tensor = onnx.load_tensor(tensor_filename)
assert tensor.name.startswith('param_')
assert tensor.name in initializer_names
assert not os.path.isfile(
os.path.join(path, 'test_data_set_0', 'gradient_10.pb'))
def test_fake_as_funcnode_keep_structure(tmpdir):
path = str(tmpdir)
class Model(chainer.Chain):
def __init__(self):
super().__init__()
def f(self, x):
return {'a': (x, x+1), 'b': [x+2, x+3, x+4]}
def __call__(self, x):
ret = self.f(x)
return ret['a'][0] + ret['b'][1]
model = Model()
x = input_generator.increasing(2, 3)
with warnings.catch_warnings(record=True):
model.f = fake_as_funcnode(model.f, 'xF')
def f_converter(params):
return onnx_helper.make_node(
'xF', params.input_names, params.output_names),
addon_converters = {'xF': f_converter}
with testing.assert_warns(UserWarning):
export_testcase(model, x, path, external_converters=addon_converters)
export_testcase(model, x, ".", external_converters=addon_converters)
model_filepath = os.path.join(path, 'model.onnx')
assert os.path.isfile(model_filepath)
onnx_model = onnx.load(model_filepath)
node_names = [n.name for n in onnx_model.graph.node]
assert len(node_names) == 2
assert node_names[0] == 'xF_0'
assert len(onnx_model.graph.node[0].output) == 5
assert len(onnx_model.graph.output) == 1
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('yolo_v2', 'yolo_v2_tiny', 'yolo_v3'),
default='yolo_v2')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model', default='voc0712')
parser.add_argument('--export', action='store_true')
parser.add_argument('image')
args = parser.parse_args()
if args.model == 'yolo_v2':
model = YOLOv2(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'yolo_v2_tiny':
model = YOLOv2Tiny(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'yolo_v3':
model = YOLOv3(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
img = utils.read_image(args.image, color=True)
if args.export:
import onnx_chainer
x = model.xp.stack([img])
onnx_chainer.export_testcase(model, x, args.model)
return
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
vis_bbox(img, bbox, label, score, label_names=voc_bbox_label_names)
plt.show()
def gen(name, target_mflops, params):
iw = params['width']
k = params['ksize']
s = params['stride']
g = params['groups']
d = params['dilate']
nc_flops = non_channel_flops(params)
sqch = target_mflops * 1000 * 1000 / nc_flops
if 'ichan2' in params:
oc = decide_channel(sqch / 2, g)
ic = oc * 2
elif 'ochan2' in params:
oc = decide_channel(sqch / 2, g)
ic = oc * 2
elif 'dwise' in params:
ic = round(sqch)
oc = ic
g = ic
elif 'dwise2' in params:
ic = near_even(sqch / 2)
oc = ic
g = ic // 2
else:
ic = decide_channel(sqch, g)
oc = ic
p = (k // 2) * d
print(ic, oc, g)
conv = L.Convolution2D(ic, oc, k, s, p, nobias=True, dilate=d, groups=g)
x = np.random.rand(1, ic, iw, iw).astype(np.float32)
name = 'conv_%dmflops_%d_%s' % (target_mflops, iw, name)
onnx_chainer.export_testcase(conv, x, name)
import onnx_chainer
from chainercv2.model_provider import get_model as chcv2_get_model
parser = argparse.ArgumentParser(description='Export ChainerCV2 model')
parser.add_argument('name')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--shape', default='1,3,224,224')
parser.add_argument('--image', type=str)
args = parser.parse_args()
model = chcv2_get_model(args.name, pretrained=True)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
shape = tuple(map(int, args.shape.split(',')))
if args.image is None:
x = model.xp.random.rand(*shape).astype(model.xp.float32)
else:
from PIL import Image
img = Image.open(args.image)
img = img.resize(shape[2:])
x = model.xp.array(np.asarray(img))
x = x / 256.0
x = x.astype(model.xp.float32)
x = x.reshape(shape)
sizestr = 'x'.join(map(str, shape[2:]))
onnx_chainer.export_testcase(model, x, '%s_%s' % (args.name, sizestr))
#!/usr/bin/env python
import argparse
import chainer
import numpy as np
import chainercv.links as C
import onnx_chainer
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--size', type=int, default=224)
parser.add_argument('--model', default='ResNet50')
parser.add_argument('--pretrained-model', type=str)
parser.add_argument('--kwargs', default='{}')
args = parser.parse_args()
kwargs = eval(args.kwargs)
if args.pretrained_model is not None:
kwargs['pretrained_model'] = args.pretrained_model
model = getattr(C, args.model)(**kwargs)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# Pseudo input
x = model.xp.zeros((1, 3, args.size, args.size), dtype=np.float32)
onnx_chainer.export_testcase(model, x, '%s_%d' % (args.model, args.size))
def fn(test_name):
np.random.seed(42)
x = np.random.rand(1, 3, 224, 224).astype(np.float32)
onnx_chainer.export_testcase(model, [x],
os.path.join('out', test_name),
opset_version=9)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import argparse
import chainer
import numpy as np
import chainercv.links as C
import onnx_chainer
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--size', type=int, default=224)
args = parser.parse_args()
model = C.ResNet50()
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# Pseudo input
x = model.xp.zeros((1, 3, args.size, args.size), dtype=np.float32)
onnx_chainer.export_testcase(model, x, 'resnet50_%d' % args.size)
import chainer
import chainer.functions as F
import numpy as np
import onnx
import onnx_chainer
from onnx_chainer.replace_func import as_funcnode
class Sign(chainer.Chain):
def forward(self, x):
y = F.relu(x)
y = F.sign(y)
y = F.relu(y)
return y
F.sign = as_funcnode('Sign')(F.sign)
def convert_sign(param):
return onnx.helper.make_node('Sign', param.input_names,
param.output_names),
external_converters = {'Sign': convert_sign}
model = Sign()
onnx_chainer.export_testcase(model, [np.array(3.14)],
'sign',
external_converters=external_converters)
