def test_operations():
data = ops.parameter([2])
split = ops.split(data, 0, 2)
outputs = split.outputs()
assert outputs[0] < outputs[1]
assert outputs[0] == split.output(0)
assert hash(outputs[0]) == hash(split.output(0))
assert hash(outputs[0]) != hash(outputs[0].node)
def test_get_results(device):
core = Core()
data = ops.parameter([10], np.float64)
model = Model(ops.split(data, 0, 5), [data])
compiled = core.compile_model(model, device)
request = compiled.create_infer_request()
inputs = [np.random.normal(size=list(compiled.input().shape))]
results = request.infer(inputs)
for output in compiled.outputs:
assert np.array_equal(results[output], request.results[output])
def test_split():
runtime = get_runtime()
input_tensor = ov.constant(np.array([0, 1, 2, 3, 4, 5], dtype=np.int32))
axis = ov.constant(0, dtype=np.int64)
splits = 3
split_node = ov.split(input_tensor, axis, splits)
computation = runtime.computation(split_node)
split_results = computation()
expected_results = np.array([[0, 1], [2, 3], [4, 5]], dtype=np.int32)
assert np.allclose(split_results, expected_results)
def test_inputs_outputs_property(device):
num_inputs = 10
input_shape = [1]
params = [ops.parameter(input_shape, np.uint8) for _ in range(num_inputs)]
model = Model(ops.split(ops.concat(params, 0), 0, num_inputs), params)
core = Core()
compiled = core.compile_model(model, device)
request = compiled.create_infer_request()
data = [np.atleast_1d(i) for i in range(num_inputs)]
results = request.infer(data).values()
for result, output_tensor in zip(results, request.outputs):
assert np.array_equal(result, output_tensor.data)
for input_data, input_tensor in zip(data, request.inputs):
assert np.array_equal(input_data, input_tensor.data)
def test_multiple_outputs():
input_shape = [4, 4]
input_data = np.arange(-8, 8).reshape(input_shape).astype(np.float32)
expected_output = np.split(input_data, 2, axis=1)[0]
expected_output[expected_output < 0] = 0
test_param = ops.parameter(input_shape, dtype=np.float32, name="A")
split = ops.split(test_param, axis=1, num_splits=2)
split_first_output = split.output(0)
relu = ops.relu(split_first_output)
runtime = get_runtime()
computation = runtime.computation(relu, test_param)
output = computation(input_data)
assert np.equal(output, expected_output).all()
def test_node_output():
input_array = np.array([0, 1, 2, 3, 4, 5])
splits = 3
expected_shape = len(input_array) // splits
input_tensor = ops.constant(input_array, dtype=np.int32)
axis = ops.constant(0, dtype=np.int64)
split_node = ops.split(input_tensor, axis, splits)
split_node_outputs = split_node.outputs()
assert len(split_node_outputs) == splits
assert [output_node.get_index()
for output_node in split_node_outputs] == [0, 1, 2]
assert np.equal(
[output_node.get_element_type() for output_node in split_node_outputs],
input_tensor.get_element_type(),
).all()
assert np.equal(
[output_node.get_shape() for output_node in split_node_outputs],
Shape([expected_shape]),
).all()
assert np.equal(
[
output_node.get_partial_shape()
for output_node in split_node_outputs
],
PartialShape([expected_shape]),
).all()
output0 = split_node.output(0)
output1 = split_node.output(1)
output2 = split_node.output(2)
assert [output0.get_index(),
output1.get_index(),
output2.get_index()] == [0, 1, 2]
