def test_elementwiselinear(self):
X = np.random.randn(4, 2, 5, 7, 3).astype(np.float32)
W = np.random.randn(21).astype(np.float32)
B = np.random.randn(21).astype(np.float32)
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-elementwiselinear-net'
predict_net.external_input[:] = ['X', 'W', 'B']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'ElementwiseLinear',
inputs=['X', 'W', 'B'],
outputs=['Y'],
axis=3,
),
])
ws, c2_outputs = c2_native_run_net(init_net=None,
predict_net=predict_net,
inputs=[X, W, B])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape),
'W': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[W.dtype], W.shape),
'B': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[B.dtype], B.shape),
})
onnx_outputs = c2.run_model(onnx_model, inputs=[X, W, B])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def _test_net(self,
net_name,
input_blob_dims=(1, 3, 224, 224),
decimal=7):
np.random.seed(seed=0)
model_dir = self._model_dir(net_name)
if not os.path.exists(model_dir):
self._download(net_name)
c2_predict_pb = os.path.join(model_dir, 'predict_net.pb')
c2_predict_net = caffe2_pb2.NetDef()
with open(c2_predict_pb, 'rb') as f:
c2_predict_net.ParseFromString(f.read())
c2_predict_net.name = net_name
c2_init_pb = os.path.join(model_dir, 'init_net.pb')
c2_init_net = caffe2_pb2.NetDef()
with open(c2_init_pb, 'rb') as f:
c2_init_net.ParseFromString(f.read())
c2_init_net.name = net_name + '_init'
n, c, h, w = input_blob_dims
data = np.random.randn(n, c, h, w).astype(np.float32)
inputs = [data]
_, c2_outputs = c2_native_run_net(c2_init_net, c2_predict_net, inputs)
del _
model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=c2_predict_net,
init_net=c2_init_net,
value_info=json.load(open(os.path.join(model_dir, 'value_info.json'))))
c2_ir = c2.prepare(model)
onnx_outputs = c2_ir.run(inputs)
self.assertSameOutputs(c2_outputs, onnx_outputs, decimal=decimal)
def test_cast(self):
X = np.random.randn(1, 2, 3).astype(np.float32)
for to_type in ['INT8', caffe2_pb2.TensorProto.INT8,
'DOUBLE', caffe2_pb2.TensorProto.DOUBLE]:
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-cast-net'
predict_net.external_input[:] = ['X']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'Cast',
inputs=['X'],
outputs=['Y'],
to=to_type,
),
])
ws, c2_outputs = c2_native_run_net(
init_net=None,
predict_net=predict_net,
inputs=[X])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape)
})
onnx_outputs = c2.run_model(onnx_model, inputs=[X])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def test_slice(self):
X = np.random.randn(1, 2, 3).astype(np.float32)
starts = np.array([0, 1, 0], dtype=np.int32)
ends = np.array([-1, 2, 3], dtype=np.int32)
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-slice-net'
predict_net.external_input[:] = ['X']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'Slice',
inputs=['X'],
outputs=['Y'],
starts=starts,
ends=ends,
),
])
ws, (Y,) = c2_native_run_net(
init_net=None,
predict_net=predict_net,
inputs=[X])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape)
})
Y, = c2.run_model(onnx_model, inputs=[X])
np.testing.assert_almost_equal(Y, X[:, 1:2, :])
def test_slice(self):
X = np.random.randn(1, 2, 3).astype(np.float32)
starts = np.array([0, 1, 0], dtype=np.int32)
ends = np.array([-1, 2, 3], dtype=np.int32)
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-slice-net'
predict_net.external_input[:] = ['X']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'Slice',
inputs=['X'],
outputs=['Y'],
starts=starts,
ends=ends,
),
])
ws, (Y,) = c2_native_run_net(
init_net=None,
predict_net=predict_net,
inputs=[X])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape)
})
Y, = c2.run_model(onnx_model, inputs=[X])
np.testing.assert_almost_equal(Y, X[:, 1:2, :])
def _test_net(self,
net_name,
input_blob_dims=(1, 3, 224, 224),
decimal=7):
np.random.seed(seed=0)
model_dir = self._model_dir(net_name)
if not os.path.exists(model_dir):
self._download(net_name)
c2_predict_pb = os.path.join(model_dir, 'predict_net.pb')
c2_predict_net = caffe2_pb2.NetDef()
with open(c2_predict_pb, 'rb') as f:
c2_predict_net.ParseFromString(f.read())
c2_predict_net.name = net_name
c2_init_pb = os.path.join(model_dir, 'init_net.pb')
c2_init_net = caffe2_pb2.NetDef()
with open(c2_init_pb, 'rb') as f:
c2_init_net.ParseFromString(f.read())
c2_init_net.name = net_name + '_init'
n, c, h, w = input_blob_dims
data = np.random.randn(n, c, h, w).astype(np.float32)
inputs = [data]
_, c2_outputs = c2_native_run_net(c2_init_net, c2_predict_net, inputs)
del _
model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=c2_predict_net,
init_net=c2_init_net,
value_info=json.load(open(os.path.join(model_dir, 'value_info.json'))))
c2_ir = c2.prepare(model)
onnx_outputs = c2_ir.run(inputs)
self.assertSameOutputs(c2_outputs, onnx_outputs, decimal=decimal)
def caffe2_to_onnx(caffe2_net,
caffe2_net_name,
caffe2_init_net,
value_info,
output):
c2_net_proto = caffe2_pb2.NetDef()
c2_net_proto.ParseFromString(caffe2_net.read())
if not c2_net_proto.name and not caffe2_net_name:
raise click.BadParameter(
'The input caffe2 net does not have name, '
'--caffe2-net-name must be provided')
c2_net_proto.name = caffe2_net_name or c2_net_proto.name
if caffe2_init_net:
c2_init_net_proto = caffe2_pb2.NetDef()
c2_init_net_proto.ParseFromString(caffe2_init_net.read())
c2_init_net_proto.name = '{}_init'.format(caffe2_net_name)
else:
c2_init_net_proto = None
if value_info:
value_info = json.loads(value_info)
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=c2_net_proto,
init_net=c2_init_net_proto,
value_info=value_info)
output.write(onnx_model.SerializeToString())
def test_cast(self):
X = np.random.randn(1, 2, 3).astype(np.float32)
for to_type in ['INT8', caffe2_pb2.TensorProto.INT8,
'DOUBLE', caffe2_pb2.TensorProto.DOUBLE]:
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-cast-net'
predict_net.external_input[:] = ['X']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'Cast',
inputs=['X'],
outputs=['Y'],
to=to_type,
),
])
ws, c2_outputs = c2_native_run_net(
init_net=None,
predict_net=predict_net,
inputs=[X])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape)
})
onnx_outputs = c2.run_model(onnx_model, inputs=[X])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def test_mergedim(self):
X = np.random.randn(2, 3, 1, 5).astype(np.float32)
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-mergedim-net'
predict_net.external_input[:] = ['X']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'MergeDim',
inputs=['X'],
outputs=['Y'],
),
])
ws, c2_outputs = c2_native_run_net(init_net=None,
predict_net=predict_net,
inputs=[X])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape),
})
onnx_outputs = c2.run_model(onnx_model, inputs=[X])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def test_concat(self):
I0 = np.random.randn(20, 4).astype(np.float32)
I1 = np.random.randn(20, 4).astype(np.float32)
for i in range(2):
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-concat-net'
predict_net.external_input[:] = ['I0', 'I1']
predict_net.external_output[:] = ['Y', 'output_dim']
predict_net.op.extend([
core.CreateOperator(
'Concat',
inputs=['I0', 'I1'],
outputs=['Y', 'output_dim'],
axis=1,
add_axis=(1 if i == 0 else 0),
),
])
ws, c2_outputs = c2_native_run_net(init_net=None,
predict_net=predict_net,
inputs=[I0, I1])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'I0':
(onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[I0.dtype], I0.shape),
'I1':
(onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[I1.dtype], I1.shape),
})
onnx_outputs = c2.run_model(onnx_model, inputs=[I0, I1])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def test_fc(self):
X_fake = np.zeros((3, 1, 3, 1, 7), dtype=np.float32)
X = np.random.randn(5, 2, 3, 1, 7).astype(np.float32)
W = np.random.randn(11, 21).astype(np.float32)
B = np.random.randn(11).astype(np.float32)
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-fc-net'
predict_net.external_input[:] = ['X', 'W', 'B']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'FC',
inputs=['X', 'W', 'B'],
outputs=['Y'],
axis=2,
),
])
ws, c2_outputs = c2_native_run_net(init_net=None,
predict_net=predict_net,
inputs=[X, W, B])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X':
(onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X_fake.shape),
'W': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[W.dtype], W.shape),
'B': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[B.dtype], B.shape),
})
onnx_outputs = c2.run_model(onnx_model, inputs=[X, W, B])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def test_upsample(self):
X = np.random.randn(1, 1, 2, 2).astype(np.float32)
width_scale = 2.0
height_scale = 2.0
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-upsample-net'
predict_net.external_input[:] = ['X']
predict_net.external_output[:] = ['Y']
predict_net.op.extend([
core.CreateOperator(
'ResizeNearest',
inputs=['X'],
outputs=['Y'],
width_scale=width_scale,
height_scale=height_scale,
),
])
ws, c2_outputs = c2_native_run_net(init_net=None,
predict_net=predict_net,
inputs=[X])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape)
})
onnx_outputs = c2.run_model(onnx_model, inputs=[X])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def caffe2_to_onnx(caffe2_net,
caffe2_net_name,
caffe2_init_net,
value_info,
output):
c2_net_proto = caffe2_pb2.NetDef()
c2_net_proto.ParseFromString(caffe2_net.read())
if not c2_net_proto.name and not caffe2_net_name:
raise click.BadParameter(
'The input caffe2 net does not have name, '
'--caffe2-net-name must be provided')
c2_net_proto.name = caffe2_net_name or c2_net_proto.name
if caffe2_init_net:
c2_init_net_proto = caffe2_pb2.NetDef()
c2_init_net_proto.ParseFromString(caffe2_init_net.read())
c2_init_net_proto.name = '{}_init'.format(caffe2_net_name)
else:
c2_init_net_proto = None
if value_info:
value_info = json.loads(value_info)
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=c2_net_proto,
init_net=c2_init_net_proto,
value_info=value_info)
output.write(onnx_model.SerializeToString())
def _test_net(self,
net_name,
input_blob_dims=(1, 3, 224, 224),
decimal=7):
np.random.seed(seed=0)
try:
c2_init_net, c2_predict_net, value_info, debug_str = self.model_downloader.get_c2_model_dbg(net_name)
except (OSError, IOError) as e:
# catch IOError/OSError that is caused by FileNotFoundError and PermissionError
# This is helpful because sometimes we get errors due to gfs not available
print("\n_test_net exception: ", e)
self.skipTest(str(e))
# start to run the model and compare outputs
n, c, h, w = input_blob_dims
data = np.random.randn(n, c, h, w).astype(np.float32)
inputs = [data]
_, c2_outputs = c2_native_run_net(c2_init_net, c2_predict_net, inputs, debug_str)
del _
model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=c2_predict_net,
init_net=c2_init_net,
value_info=value_info,
)
c2_ir = c2.prepare(model)
onnx_outputs = c2_ir.run(inputs)
self.assertSameOutputs(c2_outputs, onnx_outputs, decimal=decimal)
def test_reducemean(self):
X = np.random.randn(4, 6, 10, 5, 3).astype(np.float32)
predict_net = caffe2_pb2.NetDef()
predict_net.name = 'test-reducemean-net'
predict_net.external_input[:] = ['X']
predict_net.external_output[:] = [
'reduce_front_mean',
'reduce_back_mean',
'reduce_mean_0',
'reduce_mean_1',
]
predict_net.op.extend([
core.CreateOperator(
'ReduceFrontMean',
inputs=['X'],
outputs=['reduce_front_mean'],
num_reduce_dim=2,
),
core.CreateOperator(
'ReduceBackMean',
inputs=['X'],
outputs=['reduce_back_mean'],
num_reduce_dim=2,
),
core.CreateOperator(
'ReduceMean',
inputs=['X'],
outputs=['reduce_mean_0'],
axes=[1, 3],
keepdims=0,
),
core.CreateOperator(
'ReduceMean',
inputs=['X'],
outputs=['reduce_mean_1'],
axes=[1, 3],
keepdims=1,
),
])
ws, c2_outputs = c2_native_run_net(
init_net=None,
predict_net=predict_net,
inputs=[X])
onnx_model = c2_onnx.caffe2_net_to_onnx_model(
predict_net=predict_net,
value_info={
'X': (onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[X.dtype], X.shape)
})
onnx_outputs = c2.run_model(onnx_model, inputs=[X])
self.assertSameOutputs(c2_outputs, onnx_outputs)
def compile_source(source: CaffeModelFile, config: Config) -> OnnxModel:
predict_net = parse_caffe_net(
caffe2_pb2.NetDef(), os.path.join(source.model_path, 'predict_net.pb'))
predict_net.name = "model" if predict_net.name == "" else predict_net.name # pylint: disable=no-member
init_net = parse_caffe_net(caffe2_pb2.NetDef(),
os.path.join(source.model_path, 'init_net.pb'))
value_info = {}
for i, input_shape in enumerate(config.input_shapes):
input_shape.insert(0, config.max_batch_size)
value_info[config.input_names[i]] = (config.input_type, input_shape)
from caffe2.python.onnx.frontend import caffe2_net_to_onnx_model # pylint: disable=import-outside-toplevel
onnx_model = caffe2_net_to_onnx_model(predict_net, init_net, value_info)
graph = onnx_model.graph # pylint: disable=no-member
return OnnxModel(
model_proto=onnx_model,
input_data_formats=utilities.get_onnx_model_input_data_formats(
graph, config.input_formats))
import onnx
import caffe2.python.onnx.backend as backend
import caffe2.python.onnx.frontend as frontend
import numpy as np
import onnx
model = onnx.load("swiftnet.onnx")
onnx.checker.check_model(model)
onnx.helper.printable_graph(model.graph)
caffe2Rep_model = backend.prepare(model, device="CUDA:0") # or "CPU"
print(type(caffe2Rep_model))
outputs = caffe2Rep_model.run(
np.random.randn(1, 3, 1024, 2048).astype(np.float32))
data_type = onnx.TensorProto.FLOAT
data_shape = (1, 3, 1024, 2048)
value_info = {'data': (data_type, data_shape)}
# import pdb; pdb.set_trace()
print(caffe2Rep_model.predict_net.external_input)
onnx_model = frontend.caffe2_net_to_onnx_model(
caffe2Rep_model.predict_net,
caffe2Rep_model.init_net,
{},
#value_info,
)
def convert_model(self, request):
self._dst_type = request.args.get('destination_type')
if self._dst_type == 'caffe2':
dst_predict_net = request.args.get('predict_net')
dst_init_net = request.args.get('init_net')
logger.warn(dst_init_net)
logger.warn(dst_predict_net)
else:
destination_path = request.args.get('destination_path')
logger.warn(destination_path)
if self._dst_type == 'onnx':
if self._src_type == 'caffe2':
data_type = onnx.TensorProto.FLOAT
# data_shape = (1, 3, 299, 299) if model is inceptionv3/4
tensor_size_list = self.input_tensor_size.split(',')
data_shape = tuple(map(int, tensor_size_list))
print(data_shape)
value_info = {
'data': (data_type, data_shape)
}
predict_net = caffe2_pb2.NetDef()
with open(self.src_predict_net, 'rb') as f:
predict_net.ParseFromString(f.read())
init_net = caffe2_pb2.NetDef()
with open(self.src_init_net, 'rb') as f:
init_net.ParseFromString(f.read())
# if self._src_tb_graph._predict_net.name == '':
# self._src_tb_graph._predict_net.name = 'modelName'
onnx_model = c2_onnx.caffe2_net_to_onnx_model(predict_net,
init_net,
value_info)
with open(destination_path, 'wb') as f:
f.write(onnx_model.SerializeToString())
self._dst_tb_graph = onnx_util.OnnxGraph(destination_path, "onnx")
elif self._src_type == 'torch':
# TODO: choose input_net
tensor_size_list = self.input_tensor_size.split(',')
logger.warn(destination_path)
x = torch.randn(tuple(map(int, tensor_size_list)))
if self.model_file in ['inception_v3', 'googlenet']:
model = globals().get(self.model_file)(pretrained=True, aux_logits=False ,transform_input=False)
else:
model = globals().get(self.model_file)(pretrained=True)
torch.onnx.export(model, x, destination_path, verbose=True)
self._dst_tb_graph = onnx_util.OnnxGraph(destination_path, "onnx")
elif self._dst_type == 'caffe2':
if self._src_type == 'onnx':
onnx_model_proto = ModelProto()
with open(self.model_file, "rb") as onnx_model_path:
onnx_model_proto.ParseFromString(onnx_model_path.read())
init_net_model, predict_net_model = c2.onnx_graph_to_caffe2_net(onnx_model_proto)
with open(dst_predict_net, 'wb') as f_pre:
f_pre.write(predict_net_model.SerializeToString())
with open(dst_init_net, 'wb') as f_init:
f_init.write(init_net_model.SerializeToString())
self._dst_tb_graph = c2graph_util.C2Graph(dst_predict_net, dst_init_net, "pb")
logger.warn('Converting completed.')
self._dst_tb_graph.ConvertNet()
graph = self._dst_tb_graph.GetTBGraph()
# count the number of nodes in the output model
self.d_node_count = 0
for node in graph.node:
self.d_node_count += 1
return http_util.Respond(request, str(graph), 'text/x-protobuf')
