def test_ngraph_preprocess_set_from_tensor():
shape = [1, 224, 224, 3]
inp_shape = [1, 480, 640, 3]
parameter_a = ops.parameter(shape, dtype=np.float32, name="A")
parameter_a.set_layout(ov.Layout("NHWC"))
model = parameter_a
function = Model(model, [parameter_a], "TestFunction")
input_data = ov.Tensor(Type.i32, inp_shape)
p = PrePostProcessor(function)
inp = p.input()
inp.tensor().set_from(input_data)
inp.preprocess().resize(ResizeAlgorithm.RESIZE_LINEAR)
function = p.build()
assert function.input().shape == ov.Shape(inp_shape)
assert function.input().element_type == Type.i32
assert function.output().shape == ov.Shape(shape)
assert function.output().element_type == Type.f32
pass
if model.output(0).partial_shape[1].is_dynamic():
# 1-st dimension of output is dynamic
pass
#! [detect_dynamic]
executable = core.compile_model(model)
infer_request = executable.create_infer_request()
#! [set_input_tensor]
# The first inference call
# Create tensor compatible to the model input
# Shape {1, 128} is compatible with any reshape statements made in previous examples
input_tensor1 = ov.Tensor(model.input().element_type, [1, 128])
# ... write values to input_tensor_1
# Set the tensor as an input for the infer request
infer_request.set_input_tensor(input_tensor1)
# Do the inference
infer_request.infer()
# Or pass a tensor in infer to set the tensor as a model input and make the inference
infer_request.infer([input_tensor1])
# Or pass the numpy array to set inputs of the infer request
input_data = np.ones(shape=[1, 128])
infer_request.infer([input_data])
input_a = ov.opset8.parameter([8]) res = ov.opset8.absolute(input_a) model = ov.Model(res, [input_a]) compiled = core.compile_model(model, "CPU") print(model.inputs) print(model.outputs) print(compiled.inputs) print(compiled.outputs) #! [properties_example] #! [tensor_basics] data_float64 = np.ones(shape=(2, 8)) tensor = ov.Tensor(data_float64) assert tensor.element_type == ov.Type.f64 data_int32 = np.ones(shape=(2, 8), dtype=np.int32) tensor = ov.Tensor(data_int32) assert tensor.element_type == ov.Type.i32 #! [tensor_basics] #! [tensor_shared_mode] data_to_share = np.ones(shape=(2, 8)) shared_tensor = ov.Tensor(data_to_share, shared_memory=True) # Editing of the numpy array affects Tensor's data data_to_share[0][2] = 6.0
input_a = ov.opset8.parameter([8]) res = ov.opset8.absolute(input_a) model = ov.Model(res, [input_a]) compiled = core.compile_model(model, "CPU") print(model.inputs) print(model.outputs) print(compiled.inputs) print(compiled.outputs) #! [properties_example] #! [tensor_basics] data_float64 = np.ones(shape=(2, 8)) tensor = ov.Tensor(data_float64) assert tensor.element_type == ov.Type.f64 data_int32 = np.ones(shape=(2, 8), dtype=np.int32) tensor = ov.Tensor(data_int32) assert tensor.element_type == ov.Type.i32 #! [tensor_basics] #! [tensor_shared_mode] data_to_share = np.ones(shape=(2, 8)) shared_tensor = ov.Tensor(data_to_share, shared_memory=True) # Editing of the numpy array affects Tensor's data data_to_share[0][2] = 6.0
res = ov.opset8.result(data)
return ov.Model([res], [data], "model")
model = create_model()
compiled_model = core.compile_model(model, "AUTO")
#! [part2_4]
#! [part3]
infer_request = compiled_model.create_infer_request()
#! [part3]
memory = np.array([1, 2, 3, 4])
#! [part4]
# Create tensor from external memory
input_tensor = ov.Tensor(array=memory, shared_memory=True)
# Set input tensor for model with one input
infer_request.set_input_tensor(input_tensor)
#! [part4]
#! [part5]
infer_request.start_async()
infer_request.wait()
#! [part5]
#! [part6]
# Get output tensor for model with one output
output = infer_request.get_output_tensor()
output_buffer = output.data
# output_buffer[] - accessing output tensor data
#! [part6]
output_tensor = infer_request.get_output_tensor()
#! [get_set_one_tensor]
#! [get_set_index_tensor]
input_tensor = infer_request.get_input_tensor(0)
output_tensor = infer_request.get_output_tensor(1)
#! [get_set_index_tensor]
#! [get_set_name_tensor]
input_tensor = infer_request.get_tensor("input_name")
output_tensor = infer_request.get_tensor("output_name")
#! [get_set_name_tensor]
#! [get_set_tensor]
tensor1 = infer_request.get_tensor("tensor_name1")
tensor2 = ov.Tensor()
infer_request.set_tensor("tensor_name2", tensor2)
#! [get_set_tensor]
#! [get_set_tensor_by_port]
input_port = model.input(0)
output_port = model.input("tensor_name")
input_tensor = ov.Tensor()
infer_request.set_tensor(input_port, input_tensor)
output_tensor = infer_request.get_tensor(output_port)
#! [get_set_tensor_by_port]
infer_request1 = compiled_model.create_infer_request()
infer_request2 = compiled_model.create_infer_request()
#! [cascade_models]
# Copyright (C) 2022 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import openvino.runtime as ov
#! [dynamic_batch]
core = ov.Core()
C = 3
H = 224
W = 224
model = core.read_model("model.xml")
model.reshape([(1, 10), C, H, W])
# compile model and create infer request
compiled_model = core.compile_model(model, "GPU")
infer_request = compiled_model.create_infer_request()
# create input tensor with specific batch size
input_tensor = ov.Tensor(model.input().element_type, [2, C, H, W])
# ...
infer_request.infer([input_tensor])
#! [dynamic_batch]