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 run_op_node(input_data, op_fun, *args):
"""Run computation on node performing `op_fun`.
`op_fun` have to needs to accept a node as an argument.
:param input_data: The input data for performed computation.
:param op_fun: The function handler for operation we want to carry out.
:param args: The arguments passed to operation we want to carry out.
:return: The result from computations.
"""
runtime = get_runtime()
comp_args = []
op_fun_args = []
comp_inputs = []
for idx, data in enumerate(input_data):
if np.isscalar(data):
op_fun_args.append(ng.constant(data, _get_numpy_dtype(data)))
else:
node = ng.parameter(data.shape, name=ascii_uppercase[idx], dtype=data.dtype)
op_fun_args.append(node)
comp_args.append(node)
comp_inputs.append(data)
op_fun_args.extend(args)
node = op_fun(*op_fun_args)
computation = runtime.computation(node, *comp_args)
return computation(*comp_inputs)
def test_function_call():
runtime = get_runtime()
dtype = int
shape = [2, 2]
parameter_a = ng.parameter(shape, dtype=dtype, name='A')
parameter_b = ng.parameter(shape, dtype=dtype, name='B')
parameter_c = ng.parameter(shape, dtype=dtype, name='C')
parameter_list = [parameter_a, parameter_b, parameter_c]
ops = ((parameter_a + parameter_b) * parameter_c)
func = Function(NodeVector([ops]), parameter_list, 'addmul')
fc = ng.function_call(func, NodeVector(parameter_list))
computation = runtime.computation(fc, parameter_a, parameter_b, parameter_c)
value_a = np.array([[1, 2], [3, 4]], dtype=dtype)
value_b = np.array([[5, 6], [7, 8]], dtype=dtype)
value_c = np.array([[9, 10], [11, 12]], dtype=dtype)
result = computation(value_a, value_b, value_c)
assert np.allclose(result, np.array([[54, 80], [110, 144]], dtype=dtype))
def test_simple_computation_on_ndarrays(dtype):
runtime = get_runtime()
shape = [2, 2]
parameter_a = ng.parameter(shape, dtype=dtype, name='A')
parameter_b = ng.parameter(shape, dtype=dtype, name='B')
parameter_c = ng.parameter(shape, dtype=dtype, name='C')
model = (parameter_a + parameter_b) * parameter_c
computation = runtime.computation(model, parameter_a, parameter_b, parameter_c)
value_a = np.array([[1, 2], [3, 4]], dtype=dtype)
value_b = np.array([[5, 6], [7, 8]], dtype=dtype)
value_c = np.array([[9, 10], [11, 12]], dtype=dtype)
result = computation(value_a, value_b, value_c)
assert np.allclose(result, np.array([[54, 80], [110, 144]], dtype=dtype))
value_a = np.array([[13, 14], [15, 16]], dtype=dtype)
value_b = np.array([[17, 18], [19, 20]], dtype=dtype)
value_c = np.array([[21, 22], [23, 24]], dtype=dtype)
result = computation(value_a, value_b, value_c)
assert np.allclose(result, np.array([[630, 704], [782, 864]], dtype=dtype))
def test_serialization():
dtype = np.float32
backend_name = pytest.config.getoption('backend', default='CPU')
shape = [2, 2]
parameter_a = ng.parameter(shape, dtype=dtype, name='A')
parameter_b = ng.parameter(shape, dtype=dtype, name='B')
parameter_c = ng.parameter(shape, dtype=dtype, name='C')
model = (parameter_a + parameter_b) * parameter_c
runtime = ng.runtime(backend_name=backend_name)
computation = runtime.computation(model, parameter_a, parameter_b, parameter_c)
serialized = computation.serialize(2)
serial_json = json.loads(serialized)
assert serial_json[0]['name'] != ''
assert 10 == len(serial_json[0]['ops'])
input_data = np.array([1, 2, 3])
new_shape = [3, 3]
expected = [[1, 2, 3],
[1, 2, 3],
[1, 2, 3]]
result = run_op_node([input_data], ng.broadcast, new_shape)
assert np.allclose(result, expected)
axis = 0
expected = [[1, 1, 1],
[2, 2, 2],
[3, 3, 3]]
result = run_op_node([input_data], ng.broadcast, new_shape, axis)
assert np.allclose(result, expected)
input_data = np.arange(4)
new_shape = [3, 4, 2, 4]
expected = np.broadcast_to(input_data, new_shape)
result = run_op_node([input_data], ng.broadcast, new_shape)
assert np.allclose(result, expected)
def test_gemm_operator():
runtime = get_runtime()
shape_a = [3, 2]
shape_b = [3, 2]
shape_c = [2, 1]
value_a = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
value_b = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
value_c = np.array([[13], [14]], dtype=np.float32)
parameter_a = ng.parameter(shape_a, name='A', dtype=np.float32)
parameter_b = ng.parameter(shape_b, name='B', dtype=np.float32)
parameter_c = ng.parameter(shape_c, name='C', dtype=np.float32)
alpha_value = np.float32(3)
beta_value = np.float32(3)
transA = True
transB = False
model = ng.gemm(parameter_a, parameter_b, parameter_c, alpha_value,
beta_value, transA, transB)
computation = runtime.computation(model, parameter_a, parameter_b,
parameter_c)
result = computation(value_a, value_b, value_c)
# expected = value_alpha * value_a' * value_b + value_beta * value_c
value_a = value_a.transpose()
a_mul_a = np.multiply(alpha_value, value_a)
aa_mul_b = np.dot(a_mul_a, value_b)
b_mul_c = np.dot(beta_value, value_c)
expected = np.add(aa_mul_b, b_mul_c)
assert np.allclose(result, expected)
def run_op_node(input_data, op_fun, *args):
# type: (NumericData, Callable, *Any) -> List[NumericData]
"""Run computation on node performing `op_fun`.
`op_fun` has to accept a node as an argument.
This function converts passed raw input data to nGraph Constant Node and that form is passed
to `op_fun`.
:param input_data: The input data for performed computation.
:param op_fun: The function handler for operation we want to carry out.
:param args: The arguments passed to operation we want to carry out.
:return: The result from computations.
"""
runtime = get_runtime()
comp_args = []
op_fun_args = []
comp_inputs = []
for idx, data in enumerate(input_data):
node = None
if np.isscalar(data):
node = ng.parameter([],
name=ascii_uppercase[idx],
dtype=_get_numpy_dtype(data))
else:
node = ng.parameter(data.shape,
name=ascii_uppercase[idx],
dtype=data.dtype)
op_fun_args.append(node)
comp_args.append(node)
comp_inputs.append(data)
op_fun_args.extend(args)
node = op_fun(*op_fun_args)
computation = runtime.computation(node, *comp_args)
return computation(*comp_inputs)
def test_group_convolution_backprop_data_output_shape():
runtime = get_runtime()
data_shape = [1, 1, 1, 10]
filters_shape = [1, 1, 1, 1, 5]
strides = [1, 1]
data_node = ng.parameter(data_shape, name="Data", dtype=np.float32)
filters_node = ng.parameter(filters_shape,
name="Filters",
dtype=np.float32)
output_shape_node = ng.constant(np.array([1, 14], dtype=np.int64))
model = ng.group_convolution_backprop_data(data_node,
filters_node,
strides,
output_shape_node,
auto_pad="same_upper")
data_value = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],
dtype=np.float32).reshape(data_shape)
filters_value = np.array([1.0, 2.0, 3.0, 2.0, 1.0],
dtype=np.float32).reshape(filters_shape)
computation = runtime.computation(model, data_node, filters_node)
result = computation(data_value, filters_value)
expected = np.array(
[
0.0, 1.0, 4.0, 10.0, 18.0, 27.0, 36.0, 45.0, 54.0, 63.0, 62.0,
50.0, 26.0, 9.0
],
dtype=np.float32,
).reshape(1, 1, 1, 14)
assert np.allclose(result, expected)
def test_binary_logical_op_with_scalar(ng_api_helper, numpy_function):
runtime = get_runtime()
value_a = np.array([[True, False], [False, False]], dtype=np.bool)
value_b = np.array([[False, True], [False, True]], dtype=np.bool)
shape = [2, 2]
parameter_a = ng.parameter(shape, name='A', dtype=np.bool)
model = ng_api_helper(parameter_a, value_b)
computation = runtime.computation(model, parameter_a)
result = computation(value_a)
expected = numpy_function(value_a, value_b)
assert np.allclose(result, expected)
def test_node_factory_topk():
dtype = np.int32
data = ng.parameter([2, 10], dtype=dtype, name="A")
k = ng.constant(3, dtype=dtype, name="B")
factory = _NodeFactory("opset1")
arguments = NodeFactory._arguments_as_outputs([data, k])
node = factory.create("TopK", arguments, {
"axis": 1,
"mode": "max",
"sort": "value"
})
assert node.get_type_name() == "TopK"
assert node.get_output_size() == 2
assert list(node.get_output_shape(0)) == [2, 3]
def test_binary_op_with_scalar(ng_api_helper, numpy_function):
runtime = get_runtime()
value_a = np.array([[1, 2], [3, 4]], dtype=np.float32)
value_b = np.array([[5, 6], [7, 8]], dtype=np.float32)
shape = [2, 2]
parameter_a = ng.parameter(shape, name='A', dtype=np.float32)
model = ng_api_helper(parameter_a, value_b)
computation = runtime.computation(model, parameter_a)
result = computation(value_a)
expected = numpy_function(value_a, value_b)
assert np.allclose(result, expected)
def test_elu_operator_with_scalar():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
alpha_value = np.float32(3)
data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
model = ng.elu(parameter_data, alpha_value)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.array([[-2.9797862, 1.], [-2.5939941, 3.]], dtype=np.float32)
assert np.allclose(result, expected)
def test_gelu_tanh_operator_with_parameters():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.gelu(parameter_data, "tanh")
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.array([[0.0, 0.841192], [-0.04540223, 2.9963627]],
dtype=np.float32)
assert np.allclose(result, expected, 1e-6, 1e-6)
def test_scale_shift_operator():
runtime = get_runtime()
data_shape = [3, 6]
scale_shape = [3, 6]
shift_shape = [1]
data_value = np.arange(start=19.0, stop=1.0, step=-1.0,
dtype=np.float32).reshape(data_shape)
scale_value = np.arange(start=19.0, stop=1.0, step=-1.0,
dtype=np.float32).reshape(scale_shape)
shift_value = [2.0]
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
parameter_scale = ng.parameter(scale_shape, name='Scale', dtype=np.float32)
parameter_shift = ng.parameter(shift_shape, name='Shift', dtype=np.float32)
model = ng.scale_shift(parameter_data, parameter_scale, parameter_shift)
computation = runtime.computation(model, parameter_data, parameter_scale,
parameter_shift)
result = computation(data_value, scale_value, shift_value)
expected = np.add(np.multiply(data_value, scale_value), shift_value)
assert np.allclose(result, expected)
def test_serialization():
dtype = np.float32
backend_name = pytest.config.getoption('backend', default='CPU')
shape = [2, 2]
parameter_a = ng.parameter(shape, dtype=dtype, name='A')
parameter_b = ng.parameter(shape, dtype=dtype, name='B')
parameter_c = ng.parameter(shape, dtype=dtype, name='C')
model = (parameter_a + parameter_b) * parameter_c
runtime = ng.runtime(backend_name=backend_name)
computation = runtime.computation(model, parameter_a, parameter_b,
parameter_c)
serialized = computation.serialize(2)
serial_json = json.loads(serialized)
assert serial_json[0]['name'] != ''
assert 10 == len(serial_json[0]['ops'])
input_data = np.array([1, 2, 3])
new_shape = [3, 3]
expected = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
result = run_op_node([input_data], ng.broadcast_to, new_shape)
assert np.allclose(result, expected)
axis = 0
expected = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
result = run_op_node([input_data], ng.broadcast_to, new_shape, axis)
assert np.allclose(result, expected)
input_data = np.arange(4)
new_shape = [3, 4, 2, 4]
expected = np.broadcast_to(input_data, new_shape)
result = run_op_node([input_data], ng.broadcast_to, new_shape)
assert np.allclose(result, expected)
def test_binary_operators(operator, numpy_function):
runtime = get_runtime()
value_a = np.array([[1, 2], [3, 4]], dtype=np.float32)
value_b = np.array([[4, 5], [1, 7]], dtype=np.float32)
shape = [2, 2]
parameter_a = ng.parameter(shape, name='A', dtype=np.float32)
model = operator(parameter_a, value_b)
computation = runtime.computation(model, parameter_a)
result = computation(value_a)
expected = numpy_function(value_a, value_b)
assert np.allclose(result, expected)
def create_function_with_memory(input_shape, data_type):
import ngraph as ng
from ngraph.impl import Function, Type
input_data = ng.parameter(input_shape, name="input_data", dtype=data_type)
rv = ng.read_value(input_data, "var_id_667")
add = ng.add(rv, input_data, name="MemoryAdd")
node = ng.assign(add, "var_id_667")
res = ng.result(add, "res")
func = Function(results=[res],
sinks=[node],
parameters=[input_data],
name="name")
caps = Function.to_capsule(func)
return caps
def test_round_away():
float_dtype = np.float32
data = ng.parameter(Shape([3, 10]), dtype=float_dtype, name="data")
node = ng.round(data, "HALF_AWAY_FROM_ZERO")
assert node.get_type_name() == "Round"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [3, 10]
assert node.get_output_element_type(0) == Type.f32
input_tensor = np.array([-2.5, -1.5, -0.5, 0.5, 0.9, 1.5, 2.3, 2.5, 3.5], dtype=np.float32)
expected = [-3.0, -2.0, -1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 4.0]
result = run_op_node([input_tensor], ng.round, "HALF_AWAY_FROM_ZERO")
assert np.allclose(result, expected)
def test_reduction_ops(ng_api_helper, numpy_function, reduction_axes):
manager_name = pytest.config.getoption('backend', default='CPU')
runtime = ng.runtime(manager_name=manager_name)
shape = [2, 4, 3, 2]
parameter_a = ng.parameter(shape, name='A', dtype=np.float32)
model = ng_api_helper(parameter_a, reduction_axes)
computation = runtime.computation(model, parameter_a)
value_a = np.random.randn(*shape).astype(np.float32)
result = computation(value_a)
expected = numpy_function(value_a, axis=reduction_axes)
assert np.allclose(result, expected)
def test_gelu_operator_with_parameters():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
model = ng.gelu(parameter_data)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.array([[-1.4901161e-06, 8.4134471e-01], [-4.5500278e-02, 2.9959502]],
dtype=np.float32)
assert np.allclose(result, expected, .007, .007)
def test_deformable_psroi_pooling(dtype):
output_dim = 8
spatial_scale = 0.0625
group_size = 7
mode = "bilinear_deformable"
spatial_bins_x = 4
spatial_bins_y = 4
trans_std = 0.1
part_size = 7
input0_shape = [1, 392, 38, 63]
input1_shape = [300, 5]
input2_shape = [300, 2, 7, 7]
expected_shape = [300, 8, 7, 7]
parameter_input0 = ng.parameter(input0_shape, name="Input0", dtype=dtype)
parameter_input1 = ng.parameter(input1_shape, name="Input1", dtype=dtype)
parameter_input2 = ng.parameter(input2_shape, name="Input2", dtype=dtype)
node = ng.deformable_psroi_pooling(
parameter_input0,
parameter_input1,
output_dim,
spatial_scale,
group_size,
mode,
spatial_bins_x,
spatial_bins_y,
trans_std,
part_size,
offsets=parameter_input2,
)
assert node.get_type_name() == "DeformablePSROIPooling"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == expected_shape
def einsum_op_exec(input_shapes: list,
equation: str,
data_type: np.dtype,
with_value=False,
seed=202104):
"""Test Einsum operation for given input shapes, equation, and data type.
It generates input data of given shapes and type, receives reference results using numpy,
and tests IE implementation by matching with reference numpy results.
:param input_shapes: a list of tuples with shapes
:param equation: Einsum equation
:param data_type: a type of input data
:param with_value: if True - tests output data shape and type along with its value,
otherwise, tests only the output shape and type
:param seed: a seed for random generation of input data
"""
np.random.seed(seed)
num_inputs = len(input_shapes)
runtime = get_runtime()
# set absolute tolerance based on the data type
atol = 0.0 if np.issubdtype(data_type, np.integer) else 1e-04
# generate input tensors
ng_inputs = []
np_inputs = []
for i in range(num_inputs):
input_i = np.random.random_integers(
10, size=input_shapes[i]).astype(data_type)
np_inputs.append(input_i)
ng_inputs.append(ng.parameter(input_i.shape, dtype=data_type))
expected_result = np.einsum(equation, *np_inputs)
einsum_model = ng.einsum(ng_inputs, equation)
# check the output shape and type
assert einsum_model.get_type_name() == "Einsum"
assert einsum_model.get_output_size() == 1
assert list(einsum_model.get_output_shape(0)) == list(
expected_result.shape)
assert einsum_model.get_output_element_type(0) == get_element_type(
data_type)
# check inference result
if with_value:
computation = runtime.computation(einsum_model, *ng_inputs)
actual_result = computation(*np_inputs)
np.allclose(actual_result, expected_result, atol=atol)
def test_avg_pooling_3d():
manager_name = pytest.config.getoption('backend', default='CPU')
rt = ng.runtime(manager_name=manager_name)
data = np.arange(11, 27, dtype=np.float32)
data = data.reshape((1, 1, 4, 4))
data = np.broadcast_to(data, (1, 1, 4, 4, 4))
param = ng.parameter(data.shape)
avgpool = ng.avg_pool(param, [2, 2, 2], [2, 2, 2])
comp = rt.computation(avgpool, param)
result = comp(data)
result_ref = [[[[[13.5, 15.5], [21.5, 23.5]], [[13.5, 15.5], [21.5,
23.5]]]]]
np.testing.assert_allclose(result, result_ref, rtol=0.001)
def test_region_yolo():
data = ng.parameter([1, 125, 13, 13], name="input", dtype=np.float32)
num_coords = 4
num_classes = 80
num_regions = 1
mask = [6, 7, 8]
axis = 0
end_axis = 3
do_softmax = False
node = ng.region_yolo(data, num_coords, num_classes, num_regions, do_softmax, mask, axis, end_axis)
assert node.get_type_name() == "RegionYolo"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [1, (80 + 4 + 1) * 3, 13, 13]
assert node.get_output_element_type(0) == Type.f32
def test_selu_operator():
runtime = get_runtime()
data_shape = [4, 2, 3, 1]
data = np.arange(start=1.0, stop=25.0, dtype=np.float32).reshape(data_shape)
alpha = np.array(1.6733, dtype=np.float32)
lambda_value = np.array(1.0507, dtype=np.float32)
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.selu(parameter_data, alpha, lambda_value)
computation = runtime.computation(model, parameter_data)
result = computation(data)
expected = lambda_value * ((data > 0) * data + (data <= 0) * (alpha * np.exp(data) - alpha))
assert np.allclose(result, expected)
def test_binary_op_with_scalar(ng_api_helper, numpy_function):
manager_name = pytest.config.getoption('backend', default='CPU')
runtime = ng.runtime(manager_name=manager_name)
value_a = np.array([[1, 2], [3, 4]], dtype=np.float32)
value_b = np.array([[5, 6], [7, 8]], dtype=np.float32)
shape = [2, 2]
parameter_a = ng.parameter(shape, name='A', dtype=np.float32)
model = ng_api_helper(parameter_a, value_b)
computation = runtime.computation(model, parameter_a)
result = computation(value_a)
expected = numpy_function(value_a, value_b)
assert np.allclose(result, expected)
def test_node_factory_empty_topk_with_args_and_attrs():
dtype = np.int32
data = ng.parameter([2, 10], dtype=dtype, name="A")
k = ng.constant(3, dtype=dtype, name="B")
factory = NodeFactory("opset1")
arguments = NodeFactory._arguments_as_outputs([data, k])
node = factory.create("TopK", None, None)
node.set_arguments(arguments)
node.set_attribute("axis", 1)
node.set_attribute("mode", "max")
node.set_attribute("sort", "value")
node.validate()
assert node.get_type_name() == "TopK"
assert node.get_output_size() == 2
assert list(node.get_output_shape(0)) == [2, 3]
def test_clamp_operator():
runtime = get_runtime()
data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
min_value = np.float32(3)
max_value = np.float32(12)
model = ng.clamp(parameter_data, min_value, max_value)
computation = runtime.computation(model, parameter_data)
data_value = np.array([[-5, 9], [45, 3]], dtype=np.float32)
result = computation(data_value)
expected = np.clip(data_value, min_value, max_value)
assert np.allclose(result, expected)
def test_gru_cell_operator():
batch_size = 1
input_size = 16
hidden_size = 128
X_shape = [batch_size, input_size]
H_t_shape = [batch_size, hidden_size]
W_shape = [3 * hidden_size, input_size]
R_shape = [3 * hidden_size, hidden_size]
B_shape = [3 * hidden_size]
parameter_X = ng.parameter(X_shape, name="X", dtype=np.float32)
parameter_H_t = ng.parameter(H_t_shape, name="H_t", dtype=np.float32)
parameter_W = ng.parameter(W_shape, name="W", dtype=np.float32)
parameter_R = ng.parameter(R_shape, name="R", dtype=np.float32)
parameter_B = ng.parameter(B_shape, name="B", dtype=np.float32)
expected_shape = [1, 128]
node_default = ng.gru_cell(
parameter_X, parameter_H_t, parameter_W, parameter_R, parameter_B, hidden_size
)
assert node_default.get_type_name() == "GRUCell"
assert node_default.get_output_size() == 1
assert list(node_default.get_output_shape(0)) == expected_shape
activations = ["tanh", "relu"]
activations_alpha = [1.0, 2.0]
activations_beta = [1.0, 2.0]
clip = 0.5
linear_before_reset = True
# If *linear_before_reset* is set True, then B tensor shape must be [4 * hidden_size]
B_shape = [4 * hidden_size]
parameter_B = ng.parameter(B_shape, name="B", dtype=np.float32)
node_param = ng.gru_cell(
parameter_X,
parameter_H_t,
parameter_W,
parameter_R,
parameter_B,
hidden_size,
activations,
activations_alpha,
activations_beta,
clip,
linear_before_reset,
)
assert node_param.get_type_name() == "GRUCell"
assert node_param.get_output_size() == 1
assert list(node_param.get_output_shape(0)) == expected_shape
def test_avg_pooling_3d(_ndarray_1x1x4x4):
rt = get_runtime()
data = _ndarray_1x1x4x4
data = np.broadcast_to(data, (1, 1, 4, 4, 4))
param = ng.parameter(list(data.shape))
kernel_shape = [2, 2, 2]
strides = [2, 2, 2]
spatial_dim_count = len(kernel_shape)
pads_begin = [0] * spatial_dim_count
pads_end = [0] * spatial_dim_count
exclude_pad = True
avgpool = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad)
comp = rt.computation(avgpool, param)
result = comp(data)
result_ref = [[[[[13.5, 15.5], [21.5, 23.5]], [[13.5, 15.5], [21.5, 23.5]]]]]
assert np.allclose(result, result_ref)
def test_interpolate(dtype):
image_shape = [1, 3, 1024, 1024]
output_shape = [64, 64]
attributes = {
"attrs.axes": [2, 3],
"attrs.mode": "cubic",
"attrs.pads_begin": np.array([2, 2], dtype=dtype),
}
image_node = ng.parameter(image_shape, dtype, name="Image")
node = ng.interpolate(image_node, output_shape, attributes)
expected_shape = [1, 3, 64, 64]
assert node.get_type_name() == "Interpolate"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == expected_shape
def test_pad_edge():
input_data = np.arange(1, 13).reshape([3, 4])
pads_begin = np.array([0, 1], dtype=np.int32)
pads_end = np.array([2, 3], dtype=np.int32)
input_param = ng.parameter(input_data.shape, name='input', dtype=np.int32)
model = ng.pad(input_param, pads_begin, pads_end, 'edge')
runtime = get_runtime()
computation = runtime.computation(model, input_param)
result = computation(input_data)
expected = np.array([[1, 1, 2, 3, 4, 4, 4, 4], [5, 5, 6, 7, 8, 8, 8, 8],
[9, 9, 10, 11, 12, 12, 12, 12],
[9, 9, 10, 11, 12, 12, 12, 12],
[9, 9, 10, 11, 12, 12, 12, 12]])
assert np.allclose(result, expected)
def test_avg_pool_2d(_ndarray_1x1x4x4):
runtime = get_runtime()
input_data = _ndarray_1x1x4x4
param = ng.parameter(input_data.shape, name='A', dtype=np.float32)
window_shape = [2, 2]
strides = [2, 2]
expected = [[[[13.5, 15.5],
[21.5, 23.5]]]]
avg_pool_node = ng.avg_pool(param, window_shape, strides)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
expected = [[[[13.5, 14.5, 15.5],
[17.5, 18.5, 19.5],
[21.5, 22.5, 23.5]]]]
avg_pool_node = ng.avg_pool(param, window_shape)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
padding_below = [1, 1]
padding_above = [1, 1]
strides = [2, 2]
include_pad = False
expected = [[[[11.0, 12.5, 14.0],
[17.0, 18.5, 20.0],
[23.0, 24.5, 26.0]]]]
avg_pool_node = ng.avg_pool(param, window_shape, strides, padding_below, padding_above,
include_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
include_pad = True
expected = [[[[2.75, 6.25, 3.5],
[8.5, 18.5, 10.0],
[5.75, 12.25, 6.5]]]]
avg_pool_node = ng.avg_pool(param, window_shape, strides, padding_below, padding_above,
include_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
def test_avg_pooling_3d(_ndarray_1x1x4x4):
rt = get_runtime()
data = _ndarray_1x1x4x4
data = np.broadcast_to(data, (1, 1, 4, 4, 4))
param = ng.parameter(list(data.shape))
window_shape = [2, 2, 2]
strides = [2, 2, 2]
avgpool = ng.avg_pool(param, window_shape, strides)
comp = rt.computation(avgpool, param)
result = comp(data)
result_ref = [[[[[13.5, 15.5],
[21.5, 23.5]],
[[13.5, 15.5],
[21.5, 23.5]]]]]
assert np.allclose(result, result_ref)
def test_avg_pool_2d(_ndarray_1x1x4x4):
runtime = get_runtime()
input_data = _ndarray_1x1x4x4
param = ng.parameter(input_data.shape, name="A", dtype=np.float32)
kernel_shape = [2, 2]
spatial_dim_count = len(kernel_shape)
pads_begin = [0] * spatial_dim_count
pads_end = [0] * spatial_dim_count
strides = [2, 2]
exclude_pad = True
expected = [[[[13.5, 15.5], [21.5, 23.5]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
expected = [[[[13.5, 14.5, 15.5], [17.5, 18.5, 19.5], [21.5, 22.5, 23.5]]]]
strides = [1, 1]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
pads_begin = [1, 1]
pads_end = [1, 1]
strides = [2, 2]
exclude_pad = True
expected = [[[[11.0, 12.5, 14.0], [17.0, 18.5, 20.0], [23.0, 24.5, 26.0]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
exclude_pad = False
expected = [[[[2.75, 6.25, 3.5], [8.5, 18.5, 10.0], [5.75, 12.25, 6.5]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
def test_hard_sigmoid_operator():
runtime = get_runtime()
data_shape = [3]
alpha = np.float32(0.5)
beta = np.float32(0.6)
data_value = np.array([-1, 0, 1], dtype=np.float32)
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
model = ng.hard_sigmoid(parameter_data, alpha, beta)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = [0.1, 0.6, 1.]
assert np.allclose(result, expected)
def test_mutiple_outputs():
input_shape = [4, 4]
input_data = np.arange(-8, 8).reshape(input_shape)
expected_output = np.split(input_data, 2, axis=1)[0]
expected_output[expected_output < 0] = 0
test_param = ng.parameter(input_shape, dtype=np.float32, name="A")
split = ng.split(test_param, axis=1, num_splits=2)
split_first_output = split.output(0)
relu = ng.relu(split_first_output)
runtime = get_runtime()
computation = runtime.computation(relu, test_param)
output = computation(input_data)
assert np.equal(output, expected_output).all()
# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ****************************************************************************** """Usage example for the ngraph Pythonic API.""" import numpy as np import ngraph as ng A = ng.parameter(shape=[2, 2], name='A', dtype=np.float32) B = ng.parameter(shape=[2, 2], name='B') C = ng.parameter(shape=[2, 2], name='C') # >>> print(A) # <Parameter: 'A' ([2, 2], float)> model = (A + B) * C # >>> print(model) # <Multiply: 'Multiply_14' ([2, 2])> runtime = ng.runtime(backend_name='CPU') # >>> print(runtime) # <Runtime: Backend='CPU'> computation = runtime.computation(model, A, B, C) # >>> print(computation)