動的形状#

core = ov.Core() 

# 最初の次元を動的に設定し他の次元は静的のまま残す 
model.reshape([-1, 3, 224, 224]) 

# または、3 番目と 4 番目の次元を動的として設定 
model.reshape([1, 3, -1, -1])

ov::Core core; 
auto model = core.read_model("model.xml"); 

// 最初の次元を動的 (ov::Dimension()) として設定し残りの次元を静的として設定 
model->reshape({{ov::Dimension(), 3, 224, 224}}); // {?,3,224,224} 

// または、3 番目と 4 番目の次元を動的として設定 
model->reshape({{1, 3, ov::Dimension(), ov::Dimension()}}); // {1,3,?,?}

ov_core_t* core = NULL; 
ov_core_create(&core); 

ov_model_t* model = NULL; 
ov_core_read_model(core, "model.xml", NULL, &model); 

// 最初の次元を動的 ({-1, -1}) に設定し、残りの次元を静的に設定 
{ 
ov_partial_shape_t partial_shape; 
ov_dimension_t dims[4] = {{-1, -1}, {3, 3}, {224, 224}, {224, 224}}; 
ov_partial_shape_create(4, dims, &partial_shape); 
ov_model_reshape_single_input(model, partial_shape); // {?,3,224,224} 
ov_partial_shape_free(&partial_shape); 
} 

// または、3 次元目と 4 次元目を動的に設定 
{ 
ov_partial_shape_t partial_shape; 
ov_dimension_t dims[4] = {{1, 1}, {3, 3}, {-1, -1}, {-1, -1}}; 
ov_partial_shape_create(4, dims, &partial_shape); 
ov_model_reshape_single_input(model, partial_shape); // {1,3,?,?} 
ov_partial_shape_free(&partial_shape); }

// すべての入力レイヤーの 2 番目の次元に動的形状を割り当てる 
std::map<ov::Output<ov::Node>, ov::PartialShape> port_to_shape; 
for (const ov::Output<ov::Node>& input : model->inputs()) { 
    ov::PartialShape shape = input.get_partial_shape(); 
    shape[1] = -1; 
    port_to_shape[input] = shape; 
} 
model->reshape(port_to_shape);

// 最初の推論呼び出し 

// モデル入力と互換性のあるテンソルを作成します 
// Shape {1, 128} は、前の例で行われたすべての reshape ステートメントと互換性があります 
auto input_tensor_1 = ov::Tensor(model->input().get_element_type(), {1, 128}); 
// ... Input_tensor_1 に値を書き込む 

// テンソルを推論リクエストの入力として設定 
infer_request.set_input_tensor(input_tensor_1); 

// 推論を実行 
infer_request.infer(); 

// 出力データを表すテンソルを取得 
ov::Tensor output_tensor = infer_request.get_output_tensor(); 

// 動的モデルの場合、出力形状は通常入力形状に依存します。 
// つまり、出力テンソルの形状は最初の推論後にのみ初期化され、 
// 推論要求ごとに照会する必要があります。 
auto output_shape_1 = output_tensor.get_shape(); 

// テンソルデータへの適切な型のポインタを取り、形状に応じて要素を読み取り 
// モデル出力が f32 データタイプであると仮定 
auto data_1 = output_tensor.data<float>(); 
// ... 値を読みとり 

// 2 回目の推論呼び出しでは、手順を繰り返します: 
// 別のテンソルを作成 (前のテンソルが利用できない場合) 
// input_tensor_1 とは形状が異なることに注意 
auto input_tensor_2 = ov::Tensor(model->input().get_element_type(), {1, 200}); 
// ... 値を input_tensor_2 へ書き込み 

infer_request.set_input_tensor(input_tensor_2); 

infer_request.infer(); 

// infer_request.get_output_tensor() を再度呼び出す必要なし 
// 上記の最初の推論呼び出しの後に照会された Output_tensor は、ここでは有効です。
// ただし、形状が変化したため、下のメモリーには当てはまらない可能性があるため、ポインターを再取得: 
auto data_2 = output_tensor.data<float>(); 

// 新しい形状 
auto output_shape_2 = output_tensor.get_shape(); 

// ... 形状 output_shape_2 に従って data_2 の値を読み取り

ov_output_port_t* input_port = NULL; 
ov_element_type_e* type = NULL; 
ov_shape_t input_shape_1; ov_tensor_t* input_tensor_1 = NULL; 
ov_tensor_t* output_tensor = NULL; 
ov_shape_t output_shape_1; 
void* data_1 = NULL; 
ov_shape_t input_shape_2; 
ov_tensor_t* input_tensor_2 = NULL; 
ov_shape_t output_shape_2; 
void* data_2 = NULL; 
// 最初の推論呼び出し 

// モデル入力と互換性のあるテンソルを作成します 
// Shape {1, 128} は、前の例で行われたすべての reshape ステートメントと互換性があります 
{ 
ov_model_input(model, &input_port); 
ov_port_get_element_type(input_port, type); 
int64_t dims[2] = {1, 128}; 
ov_shape_create(2, dims, &input_shape_1); 
ov_tensor_create(type, input_shape_1, &input_tensor_1); 
// ... Input_tensor に値を書き込む 
} 

// テンソルを推論リクエストの入力として設定 
ov_infer_request_set_input_tensor(infer_request, input_tensor_1); 

// 推論を実行 
ov_infer_request_infer(infer_request); 

// 出力データを表すテンソルを取得 
ov_infer_request_get_output_tensor(infer_request, &output_tensor); 

// 動的モデルの場合、出力形状は通常入力形状に依存します。 
// つまり、出力テンソルの形状は最初の推論後にのみ初期化され、 
// 推論要求ごとに照会する必要があります。 
ov_tensor_get_shape(output_tensor, &output_shape_1); 

// テンソルデータへの適切な型のポインタを取り、形状に応じて要素を読み取り 
// モデル出力が f32 データタイプであると仮定 
ov_tensor_data(output_tensor, &data_1); 
// ... 値を読みとり 

// 2 回目の推論呼び出しでは、手順を繰り返します: 
// 別のテンソルを作成 (前のテンソルが利用できない場合) 
// input_tensor_1 とは形状が異なることに注意してください。 
{ 
int64_t dims[2] = {1, 200}; 
ov_shape_create(2, dims, &input_shape_2); 
ov_tensor_create(type, input_shape_2, &input_tensor_2); 
// ... input_tensor_2 に値を書き込み 
} 

ov_infer_request_set_input_tensor(infer_request, input_tensor_2); 
ov_infer_request_infer(infer_request); 

// infer_request.get_output_tensor() を再度呼び出す必要はありません 
// 上記の最初の推論呼び出しの後に照会された Output_tensor は、ここでは有効です。
// ただし、形状が変化したため、下のメモリーには当てはまらない可能性があるため、ポインターを再取得: 
ov_tensor_data(output_tensor, &data_2); 

// 新しい形状 
ov_tensor_get_shape(output_tensor, &output_shape_2); 
// ... 形状 output_shape_2 に従って data_2 の値を読み取り 

// リソースを解放 
ov_output_port_free(input_port); 
ov_shape_free(&input_shape_1); 
ov_tensor_free(input_tensor_1); 
ov_shape_free(&output_shape_1); 
ov_shape_free(&input_shape_2); 
ov_tensor_free(input_tensor_2); 
ov_shape_free(&output_shape_2); 
ov_tensor_free(output_tensor);

// 出力部分形状をプリント 
std::cout << model->output().get_partial_shape() << "\n"; 

// 入力部分形状をプリント 
std::cout << model->input().get_partial_shape() << "\n";

ov_output_port_t* output_port = NULL; 
ov_output_port_t* input_port = NULL; 
ov_partial_shape_t partial_shape; 
char * str_partial_shape = NULL; 

// 出力部分形状のプリント 
{ 
ov_model_output(model, &output_port); 
ov_port_get_partial_shape(output_port, &partial_shape); 
str_partial_shape = ov_partial_shape_to_string(partial_shape); 
printf("The output partial shape: %s", str_partial_shape); 
} 

// 入力部分形状のプリント { 
ov_model_input(model, &input_port); 
ov_port_get_partial_shape(input_port, &partial_shape); 
str_partial_shape = ov_partial_shape_to_string(partial_shape); 
printf("The input partial shape: %s", str_partial_shape); } 

// 割り当てられたリソースを解放 
ov_free(str_partial_shape); 
ov_partial_shape_free(&partial_shape); 
ov_output_port_free(output_port); 
ov_output_port_free(input_port);

auto model = core.read_model("model.xml"); 

if (model->input(0).get_partial_shape().is_dynamic()) { 
    // 入力は動的 
} 

if (model->output(0).get_partial_shape().is_dynamic()) { 
    // 出力は動的 
} 

if (model->output(0).get_partial_shape()[1].is_dynamic()) { 
    // 出力の 1 次元目は動的 
}

ov_model_t* model = NULL; 
ov_output_port_t* input_port = NULL; 
ov_output_port_t* output_port = NULL; 
ov_partial_shape_t partial_shape; 

ov_core_read_model(core, "model.xml", NULL, &model); 

// 入力 
{ 
ov_model_input_by_index(model, 0, &input_port); 
ov_port_get_partial_shape(input_port, &partial_shape); 
if (ov_partial_shape_is_dynamic(partial_shape)) { 
    // 入力は動的 
} 
} 

// 出力 
{ 
ov_model_output_by_index(model, 0, &output_port); 
ov_port_get_partial_shape(output_port, &partial_shape); 
if (ov_partial_shape_is_dynamic(partial_shape)) { 
    // 出力は動的 
} 
} 

// 割り当てられたリソースを解放 
ov_partial_shape_free(&partial_shape); 
ov_output_port_free(input_port); 
ov_output_port_free(output_port);