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]