def convert_average_pool_2d(onnx_graph, node):
parser = oc.NodeParse()
parser.add_def('x', oc.ParseType.In)
parser.add_def('ksize', oc.ParseType.AttPad)
parser.add_def('stride', oc.ParseType.AttPad)
parser.add_def('pad', oc.ParseType.AttPad)
parser.parse(onnx_graph, node)
kwargs = {}
kwargs['kernel_shape'] = parser.get('ksize')
if parser.get('stride') is not None:
kwargs['strides'] = parser.get('stride')
else:
kwargs['strides'] = parser.get('ksize')
if parser.get('pad') is not None:
kwargs['pads'] = parser.get('pad') * 2
else:
kwargs['pads'] = _pair(0)
kwargs['count_include_pad'] = 1
onnx_graph.add_node(
"AveragePool",
[node.inputs[0]],
[node.outputs[0]],
name=str(node.lineprop),
**kwargs,
)
def parse_args(self, onnx_graph, node):
assert hasattr(self, 'expected_args'), 'BaseConverter subclass must have `expected_args`'
parser = oc.NodeParse()
for arg_def in self.expected_args:
parser.add_def(*arg_def)
parser.parse(onnx_graph, node)
return parser
def convert_hstack(onnx_graph, node):
parser = oc.NodeParse()
parser.add_def('xs', oc.ParseType.In)
parser.parse(onnx_graph, node)
onnx_graph.add_node("ChainerSequenceConcat",
[parser.get('xs').create_sequence()],
[node.outputs[0]],
name=str(node.lineprop),
axis=1)
def convert_separate(onnx_graph, node):
parser = oc.NodeParse()
parser.add_def('x', oc.ParseType.In)
parser.add_def('axis', oc.ParseType.Att)
parser.parse(onnx_graph, node)
onnx_graph.add_node("ChainerSequenceSeparate",
[parser.get('x').create_tensor(node.lineprop)],
[node.outputs[0]],
name=str(node.lineprop),
axis=parser.get('axis'))
def convert_squeeze(onnx_graph, node):
parser = oc.NodeParse()
parser.add_def('x', oc.ParseType.In)
parser.add_def('axis', oc.ParseType.Att)
parser.parse(onnx_graph, node)
kwargs = {}
if parser.get('axis') is not None:
kwargs['axes'] = _list(parser.get('axis'))
onnx_graph.add_node("Squeeze",
[parser.get('x').create_tensor(node.lineprop)],
[node.outputs[0]],
name=str(node.lineprop),
**kwargs)
def convert_matmul(onnx_graph, node):
parser = oc.NodeParse()
parser.add_def('a', oc.ParseType.In)
parser.add_def('b', oc.ParseType.In)
parser.add_def('transa', oc.ParseType.Att, False)
parser.add_def('transb', oc.ParseType.Att, False)
parser.parse(onnx_graph, node)
onnx_graph.add_node(
"MatMul",
[
parser.get('a').create_tensor(node.lineprop),
parser.get('b').create_tensor(node.lineprop)
],
node.outputs,
str(node.lineprop),
)
def convert_onnx_chainer_EmbedID(onnx_graph: 'ONNXGraph',
node: 'nodes.NodeCall'):
chainer_inst = node.func.owner.inst # type: chainer.links.EmbedID
n_vocab = chainer_inst.W.shape[0]
n_out = chainer_inst.W.shape[1]
w = oc.ONNXValue(onnx_graph, chainer_inst.W)
parser = oc.NodeParse()
parser.add_def('x', oc.ParseType.In)
parser.parse(onnx_graph, node)
x = parser.get('x').create_tensor(node.lineprop)
onnx_graph.add_node('Gather', [w, x], [node.outputs[0]],
str(node.lineprop))
def convert_sum(onnx_graph, node):
parser = oc.NodeParse()
parser.add_def('x', oc.ParseType.In)
parser.add_def('axis', oc.ParseType.Att)
parser.add_def('keepdims', oc.ParseType.Att)
parser.parse(onnx_graph, node)
kwargs = {}
axis = parser.get('axis')
if isinstance(axis, int):
kwargs['axes'] = [axis]
elif axis is not None:
kwargs['axes'] = list(axis)
onnx_graph.add_node("ReduceSum", [node.inputs[0]], [node.outputs[0]],
str(node.lineprop),
keepdims=parser.get('keepdims'),
**kwargs)
def convert_onnx_chainer_NStepBiLSTM(onnx_graph: 'ONNXGraph',
node: 'nodes.NodeCall'):
chainer_inst = node.func.owner.inst # type: chainer.links.NStepBiLSTM
hd = chainer_inst.children().__next__()
if not (hd.w0 is None):
n_in = hd.w0.shape[1]
else:
n_in = None
out_size = chainer_inst.out_size
n_layers = chainer_inst.n_layers
dropout = chainer_inst.dropout
self_ws = []
self_bs = []
for i in range(n_layers * 2):
ws_ = []
bs_ = []
for j in range(8):
ws_.append(oc.ONNXValue(onnx_graph, chainer_inst.ws[i][j]))
bs_.append(oc.ONNXValue(onnx_graph, chainer_inst.bs[i][j]))
self_ws.append(ws_)
self_bs.append(bs_)
parser = oc.NodeParse()
parser.add_def('hx', oc.ParseType.Att, None)
parser.add_def('cx', oc.ParseType.Att, None)
parser.add_def('xs', oc.ParseType.In)
parser.parse(onnx_graph, node)
xs = parser.get('xs').create_sequence()
# disolve nstep into 1step
(ilens, ) = onnx_graph.add_node('ChainerSequenceLengths', [xs], [None],
str(node.lineprop))
(tilens, ) = onnx_graph.add_node('ChainerSequenceStack', [ilens], [None],
str(node.lineprop))
v = xs
def lstm_param(ps):
(p, ) = onnx_graph.add_node("Concat", [v_ for v_ in ps], [None],
str(node.lineprop),
axis=0)
return onnx_graph.add_node("Unsqueeze", [p], [None],
str(node.lineprop),
axes=[0])[0]
wst = []
rst = []
bst = []
for w in self_ws:
wst.append(lstm_param([w[0], w[3], w[1], w[2]]))
rst.append(lstm_param([w[4], w[7], w[5], w[6]]))
for b in self_bs:
bst.append(lstm_param([b[0], b[3], b[1], b[2], b[4], b[7], b[5],
b[6]]))
ws = []
rs = []
bs = []
for i in range(n_layers):
for s, t in [(ws, wst), (rs, rst), (bs, bst)]:
(temp, ) = onnx_graph.add_node("Concat", [t[i * 2], t[i * 2 + 1]],
[None],
str(node.lineprop),
axis=0)
s.append(temp)
hs = []
cs = []
(v, ) = onnx_graph.add_node("ChainerSequencePad", [v], [None],
str(node.lineprop))
(v, ) = onnx_graph.add_node(
"Transpose",
[v],
[None],
str(node.lineprop),
perm=(1, 0, 2),
)
(sequence_length, ) = onnx_graph.add_node(
"ChainerGenericLen",
[v],
[None],
str(node.lineprop),
)
minus1 = oc.ONNXValue(onnx_graph, np.array(-1), [node, '/Minus1'])
out_size2 = oc.ONNXValue(onnx_graph, np.array(out_size * 2),
[node, '/Outputs'])
(sout_shape, ) = onnx_graph.add_node(
"ChainerSequenceCreate",
[sequence_length, minus1, out_size2],
[None],
str(node.lineprop),
)
sout_shape.onnx_type = oc.ONNXValueType.Sequence
out_shape = sout_shape.create_tensor(node.lineprop)
for i in range(n_layers):
h = oc.ONNXValue(onnx_graph, np.float32, [node, '/h'])
c = oc.ONNXValue(onnx_graph, np.float32, [node, '/c'])
ys = oc.ONNXValue(onnx_graph, np.float32, [node, '/ys'])
onnx_graph.add_node(
"LSTM",
[v, ws[i], rs[i], bs[i], tilens],
[ys, h, c],
str(node.lineprop),
direction='bidirectional',
hidden_size=out_size,
# sequence_lens=[ilens.name]
)
hs.append(h)
cs.append(c)
# ys :: [seqlen x 2 x batchsize x hiddensize]
(v, ) = onnx_graph.add_node("Transpose", [ys], [None],
str(node.lineprop),
perm=(0, 2, 1, 3))
(v, ) = onnx_graph.add_node("Reshape", [v, out_shape], [None],
str(node.lineprop))
(v, ) = onnx_graph.add_node("Transpose", [v.name], [None],
str(node.lineprop),
perm=(1, 0, 2))
(v, ) = onnx_graph.add_node("ChainerSequenceUnpad", [v.name, ilens.name],
[None], str(node.lineprop))
v.onnx_type = oc.ONNXValueType.Sequence
v = v.create_sequence()
onnx_graph.add_node(
"Concat",
hs,
[node.outputs[0]],
str(node.lineprop),
axis=0,
)
onnx_graph.add_node(
"Concat",
cs,
[node.outputs[1]],
str(node.lineprop),
axis=0,
)
onnx_graph.add_node('Identity', [v], [node.outputs[2]], str(node.lineprop))
def convert_onnx_chainer_NStepLSTM(onnx_graph: 'ONNXGraph',
node: 'nodes.NodeCall'):
chainer_inst = node.func.owner.inst # type: chainer.links.NStepLSTM
hd = chainer_inst.children().__next__()
if not (hd.w0 is None):
n_in = hd.w0.shape[1]
else:
n_in = None
out_size = chainer_inst.out_size
n_layers = chainer_inst.n_layers
dropout = chainer_inst.dropout
self_ws = []
self_bs = []
for i in range(n_layers):
ws_ = []
bs_ = []
for j in range(8):
ws_.append(oc.ONNXValue(onnx_graph, chainer_inst.ws[i][j]))
bs_.append(oc.ONNXValue(onnx_graph, chainer_inst.bs[i][j]))
self_ws.append(ws_)
self_bs.append(bs_)
parser = oc.NodeParse()
parser.add_def('hx', oc.ParseType.Att, None)
parser.add_def('cx', oc.ParseType.Att, None)
parser.add_def('xs', oc.ParseType.In)
parser.parse(onnx_graph, node)
xs = parser.get('xs').create_sequence()
# disolve nstep into 1step
(ilens, ) = onnx_graph.add_node('ChainerSequenceLengths', [xs], [None],
str(node.lineprop))
(tilens, ) = onnx_graph.add_node('ChainerSequenceStack', [ilens], [None],
str(node.lineprop))
(v, ) = onnx_graph.add_node("ChainerSequencePad", [xs], [None],
str(node.lineprop))
(v, ) = onnx_graph.add_node(
"Transpose",
[v],
[None],
str(node.lineprop),
perm=(1, 0, 2),
)
def lstm_param(ps):
(p, ) = onnx_graph.add_node("Concat", [v_ for v_ in ps], [None],
str(node.lineprop),
axis=0)
return onnx_graph.add_node("Unsqueeze", [p], [None],
str(node.lineprop),
axes=[0])[0]
ws = []
rs = []
bs = []
for w in self_ws:
ws.append(lstm_param([w[0], w[3], w[1], w[2]]))
rs.append(lstm_param([w[4], w[7], w[5], w[6]]))
for b in self_bs:
bs.append(lstm_param([b[0], b[3], b[1], b[2], b[4], b[7], b[5], b[6]]))
hs = []
cs = []
for i in range(n_layers):
h = oc.ONNXValue(onnx_graph, np.float32, [node, '/h'])
c = oc.ONNXValue(onnx_graph, np.float32, [node, '/c'])
ys = oc.ONNXValue(onnx_graph, np.float32, [node, '/ys'])
onnx_graph.add_node(
"LSTM",
[v, ws[i], rs[i], bs[i], tilens],
[ys, h, c],
str(node.lineprop),
direction='forward',
hidden_size=out_size,
# sequence_lens=[ilens.name]
)
hs.append(h)
cs.append(c)
(yys, ) = onnx_graph.add_node("Squeeze", [ys], [None],
str(node.lineprop),
axes=[1])
v = yys
onnx_graph.add_node(
"Concat",
hs,
[node.outputs[0]],
str(node.lineprop),
axis=0,
)
onnx_graph.add_node(
"Concat",
cs,
[node.outputs[1]],
str(node.lineprop),
axis=0,
)
(tv, ) = onnx_graph.add_node(
"Transpose",
[v],
[None],
str(node.lineprop),
perm=(1, 0, 2),
)
v = tv
onnx_graph.add_node(
"ChainerSequenceUnpad",
[v, ilens],
[node.outputs[2]],
str(node.lineprop),
)
