def test_concat():
element_type = Type.f32
A = Parameter(element_type, Shape([1, 2]))
B = Parameter(element_type, Shape([1, 2]))
C = Parameter(element_type, Shape([1, 2]))
parameter_list = [A, B, C]
axis = 0
function = Function([ng.concat([A, B, C], axis)], parameter_list, 'test')
backend = Backend.create(test.BACKEND_NAME)
a = backend.create_tensor(element_type, Shape([1, 2]))
b = backend.create_tensor(element_type, Shape([1, 2]))
c = backend.create_tensor(element_type, Shape([1, 2]))
result = backend.create_tensor(element_type, Shape([3, 2]))
a.write(util.numpy_to_c(np.array([1, 2], dtype=np.float32)), 8)
b.write(util.numpy_to_c(np.array([5, 6], dtype=np.float32)), 8)
c.write(util.numpy_to_c(np.array([7, 8], dtype=np.float32)), 8)
result_arr = np.zeros(6, dtype=np.float32).reshape(3, 2)
result.write(util.numpy_to_c(result_arr), 24)
handle = backend.compile(function)
handle.call([result], [a, b, c])
result.read(util.numpy_to_c(result_arr), 24)
a_arr = np.array([[1, 2]], dtype=np.float32)
b_arr = np.array([[5, 6]], dtype=np.float32)
c_arr = np.array([[7, 8]], dtype=np.float32)
result_arr_ref = np.concatenate((a_arr, b_arr, c_arr), axis)
assert np.allclose(result_arr, result_arr_ref)
def test_concat():
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
axis = 0
expected = np.concatenate((a, b), axis=0)
runtime = get_runtime()
parameter_a = ng.parameter(list(a.shape), name="A", dtype=np.float32)
parameter_b = ng.parameter(list(b.shape), name="B", dtype=np.float32)
node = ng.concat([parameter_a, parameter_b], axis)
computation = runtime.computation(node, parameter_a, parameter_b)
result = computation(a, b)
assert np.allclose(result, expected)
def test_concat():
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
axis = 0
expected = np.concatenate((a, b), axis=0)
runtime = get_runtime()
parameter_a = ng.parameter(list(a.shape), name='A', dtype=np.float32)
parameter_b = ng.parameter(list(b.shape), name='B', dtype=np.float32)
node = ng.concat([parameter_a, parameter_b], axis)
computation = runtime.computation(node, parameter_a, parameter_b)
result = computation(a, b)
assert np.allclose(result, expected)
def Concat(onnx_node, ng_inputs): # type: (NodeWrapper, List[NgraphNode]) -> NgraphNode
"""Concatenate a list of tensors into a single tensor."""
axis = onnx_node.get_attribute_value('axis')
if axis is None:
raise ValueError('Concat node (%s): requires "axis" attribute', onnx_node.name)
if len(ng_inputs) < 2:
raise ValueError('Concat node (%s): requires at least 2 inputs, %d given.',
onnx_node.name, len(ng_inputs))
unique_input_ranks = {len(node.shape) for node in ng_inputs}
if len(unique_input_ranks) != 1:
raise ValueError('Concat node (%s): input tensors must be of equal rank.', onnx_node.name)
if axis >= unique_input_ranks.pop() or axis < 0:
raise ValueError('Concat node (%s): `axis` attribute is out of range.', onnx_node.name)
return ng.concat(ng_inputs, axis)
def test_concat():
element_type = Type.f32
A = Parameter(element_type, Shape([1, 2]))
B = Parameter(element_type, Shape([1, 2]))
C = Parameter(element_type, Shape([1, 2]))
parameter_list = [A, B, C]
axis = 0
function = Function([ng.concat([A, B, C], axis)], parameter_list, "test")
a_arr = np.array([[1, 2]], dtype=np.float32)
b_arr = np.array([[5, 6]], dtype=np.float32)
c_arr = np.array([[7, 8]], dtype=np.float32)
runtime = get_runtime()
computation = runtime.computation(function, *parameter_list)
result = computation(a_arr, b_arr, c_arr)[0]
expected = np.concatenate((a_arr, b_arr, c_arr), axis)
assert np.allclose(result, expected)
def make_convolution_op(onnx_node, ng_inputs):
# type: (NodeWrapper, List[NgraphNode]) -> NgraphNode
"""
Create an ngraph convolution Op based on an ONNX node.
:param onnx_node: wrapped ONNX node for Conv of ConvTranspose op
:param ng_inputs: ngraph TensorOp input tensors
:return: ngraph Op for convolution or deconvolution
"""
if len(ng_inputs) == 3:
data, weights, bias = ng_inputs
elif len(ng_inputs) == 2:
data, weights = ng_inputs
bias = ng.constant(0, dtype=get_dtype(data.get_element_type()))
else:
raise ValueError(
'Conv node (%s): unexpected number of input values: %d.',
onnx_node.name, len(ng_inputs))
groups = onnx_node.get_attribute_value('group', 1)
strides = get_strides(onnx_node)
dilation = get_dilations(onnx_node)
padding_below, padding_above = get_pads(onnx_node)
if groups != 1:
# Split one convolution op to N ops where N is the number of groups and concat results after computation.
# reference: https://github.com/NervanaSystems/ngraph-mxnet/blob/fdd692/src/ngraph/ngraph_emitter.cc#L822-L856
data_shape = list(data.shape)
weights_shape = list(weights.shape)
convolutions_nodes = []
# initial bounds for splice
data_lower_part = len(data_shape) * [0]
data_upper_part = copy(data_shape)
weights_lower_part = len(weights_shape) * [0]
weights_upper_part = copy(weights_shape)
for group in range(groups):
# update bounds for splice
data_lower_part[1] = group * int((data_shape[1] / groups))
data_upper_part[1] = (group + 1) * int((data_shape[1] / groups))
sliced_data = ng.slice(data, data_lower_part, data_upper_part)
# update bounds for splice
weights_lower_part[0] = group * int((weights_shape[0] / groups))
weights_upper_part[0] = max((group + 1) * int(
(weights_shape[0] / groups)), 1)
sliced_weights = ng.slice(weights, weights_lower_part,
weights_upper_part)
convolutions_nodes.append(
ng.convolution(sliced_data, sliced_weights, strides, dilation,
padding_below, padding_above))
conv = ng.concat(convolutions_nodes, axis=1)
else:
conv = ng.convolution(data, weights, strides, dilation, padding_below,
padding_above)
if len(bias.shape) > 0:
return conv + ng.broadcast_to(bias, conv.shape, 1)
else:
return conv
