IntenseWebs/openvino
3
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[DOCS] README files for Samples + name update for Get Started for master (#21157)

Browse Source
This commit is contained in:
Maciej Smyk authored and GitHub committed 2023-11-21 13:20:25 +01:00
1 parent 90437f7efa
commit 95accde9df
43 files changed
+688
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

samples/cpp/benchmark/sync_benchmark/README.md
+31
View File
@@ -0,0 +1,31 @@
# Sync Benchmark C++ Sample
This sample demonstrates how to estimate performance of a model using Synchronous Inference Request API. It makes sense to use synchronous inference only in latency oriented scenarios. Models with static input shapes are supported. Unlike [demos](https://docs.openvino.ai/2023.2/omz_demos.html) this sample doesn't have other configurable command line arguments. Feel free to modify sample's source code to try out different options.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_sync_benchmark_README.html)
## Requirements
| Options | Values |
| -------------------------------| -------------------------------------------------------------------------------------------------------------------------|
| Validated Models | [alexnet](https://docs.openvino.ai/nightly/omz_models_model_alexnet.html), |
| | [googlenet-v1](https://docs.openvino.ai/nightly/omz_models_model_googlenet_v1.html), |
| | [yolo-v3-tf](https://docs.openvino.ai/nightly/omz_models_model_yolo_v3_tf.html), |
| | [face-detection-0200](https://docs.openvino.ai/nightly/omz_models_model_face_detection_0200.html) |
| Model Format | OpenVINO™ toolkit Intermediate Representation |
| | (\*.xml + \*.bin), ONNX (\*.onnx) |
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [Python](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_python_sample_sync_benchmark_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| -------------------------| ---------------------------------------------|----------------------------------------------|
| OpenVINO Runtime Version | ``ov::get_openvino_version`` | Get Openvino API version. |
| Basic Infer Flow | ``ov::Core``, ``ov::Core::compile_model``, | Common API to do inference: compile a model, |
| | ``ov::CompiledModel::create_infer_request``, | create an infer request, |
| | ``ov::InferRequest::get_tensor`` | configure input tensors. |
| Synchronous Infer | ``ov::InferRequest::infer``, | Do synchronous inference. |
| Model Operations | ``ov::CompiledModel::inputs`` | Get inputs of a model. |
| Tensor Operations | ``ov::Tensor::get_shape``, | Get a tensor shape and its data. |
| | ``ov::Tensor::data`` | |
samples/cpp/benchmark/throughput_benchmark/README.md
+36
View File
@@ -0,0 +1,36 @@
# Throughput Benchmark C++ Sample
This sample demonstrates how to estimate performance of a model using Asynchronous Inference Request API in throughput mode. Unlike [demos](https://docs.openvino.ai/2023.2/omz_demos.html) this sample doesn't have other configurable command line arguments. Feel free to modify sample's source code to try out different options.
The reported results may deviate from what [benchmark_app](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_benchmark_app_README.html) reports. One example is model input precision for computer vision tasks. benchmark_app sets ``uint8``, while the sample uses default model precision which is usually ``float32``.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_throughput_benchmark_README.html)
## Requirements
| Options | Values |
| ----------------------------| -------------------------------------------------------------------------------------------------------------------------------|
| Validated Models | [alexnet](https://docs.openvino.ai/nightly/omz_models_model_alexnet.html), |
| | [googlenet-v1](https://docs.openvino.ai/nightly/omz_models_model_googlenet_v1.html), |
| | [yolo-v3-tf](https://docs.openvino.ai/nightly/omz_models_model_yolo_v3_tf.html), |
| | [face-detection-](https://docs.openvino.ai/nightly/omz_models_model_face_detection_0200.html) |
| Model Format | OpenVINO™ toolkit Intermediate Representation |
| | (\*.xml + \*.bin), ONNX (\*.onnx) |
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [Python](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_python_sample_throughput_benchmark_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| -------------------------| ---------------------------------------------|----------------------------------------------|
| OpenVINO Runtime Version | ``ov::get_openvino_version`` | Get Openvino API version. |
| Basic Infer Flow | ``ov::Core``, ``ov::Core::compile_model``, | Common API to do inference: compile a model, |
| | ``ov::CompiledModel::create_infer_request``, | create an infer request, |
| | ``ov::InferRequest::get_tensor`` | configure input tensors. |
| Asynchronous Infer | ``ov::InferRequest::start_async``, | Do asynchronous inference with callback. |
| | ``ov::InferRequest::set_callback`` | |
| Model Operations | ``ov::CompiledModel::inputs`` | Get inputs of a model. |
| Tensor Operations | ``ov::Tensor::get_shape``, | Get a tensor shape and its data. |
| | ``ov::Tensor::data`` | |
samples/cpp/benchmark_app/README.md
+15
View File
@@ -0,0 +1,15 @@
# Benchmark C++ Tool
This page demonstrates how to use the Benchmark C++ Tool to estimate deep learning inference performance on supported devices.
> **NOTE**: This page describes usage of the C++ implementation of the Benchmark Tool. For the Python implementation, refer to the [Benchmark Python Tool](https://docs.openvino.ai/2023.2/openvino_inference_engine_tools_benchmark_tool_README.html) page. The Python version is recommended for benchmarking models that will be used in Python applications, and the C++ version is recommended for benchmarking models that will be used in C++ applications. Both tools have a similar command interface and backend.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_benchmark_app_README.html)
## Requriements
To use the C++ benchmark_app, you must first build it following the [Build the Sample Applications](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_Samples_Overview.html) instructions and then set up paths and environment variables by following the [Get Ready for Running the Sample Applications](https://docs.openvino.ai/2023.2/openvino_docs_get_started_get_started_demos.html) instructions. Navigate to the directory where the benchmark_app C++ sample binary was built.
> **NOTE**: If you installed OpenVINO Runtime using PyPI or Anaconda Cloud, only the [Benchmark Python Tool](https://docs.openvino.ai/2023.2/openvino_inference_engine_tools_benchmark_tool_README.html) is available, and you should follow the usage instructions on that page instead.
The benchmarking application works with models in the OpenVINO IR, TensorFlow, TensorFlow Lite, PaddlePaddle, PyTorch and ONNX formats. If you need it, OpenVINO also allows you to [convert your models](https://docs.openvino.ai/2023.2/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html).
samples/cpp/classification_sample_async/README.md
+29
View File
@@ -0,0 +1,29 @@
# Image Classification Async C++ Sample
This sample demonstrates how to do inference of image classification models using Asynchronous Inference Request API.
Models with only one input and output are supported.
In addition to regular images, the sample also supports single-channel ``ubyte`` images as an input for LeNet model.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_classification_sample_async_README.html)
## Requirements
| Options | Values |
| ---------------------------| -------------------------------------------------------------------------------------------------------------------------------------|
| Validated Models | [alexnet](https://docs.openvino.ai/2023.2/omz_models_model_alexnet.html), |
| | [googlenet-v1](https://docs.openvino.ai/2023.2/omz_models_model_googlenet_v1.html) |
| Model Format | OpenVINO™ toolkit Intermediate Representation (\*.xml + \*.bin), ONNX (\*.onnx) |
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [Python](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_python_sample_classification_sample_async_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| -------------------------| ----------------------------------------------------------------------|----------------------------------------------------------------------------------------|
| Asynchronous Infer | ``ov::InferRequest::start_async``, ``ov::InferRequest::set_callback`` | Do asynchronous inference with callback. |
| Model Operations | ``ov::Output::get_shape``, ``ov::set_batch`` | Manage the model, operate with its batch size. Set batch size using input image count. |
| Infer Request Operations | ``ov::InferRequest::get_input_tensor`` | Get an input tensor. |
| Tensor Operations | ``ov::shape_size``, ``ov::Tensor::data`` | Get a tensor shape size and its data. |
samples/cpp/hello_classification/README.md
+40
View File
@@ -0,0 +1,40 @@
# Hello Classification C++ Sample
This sample demonstrates how to do inference of image classification models using Synchronous Inference Request API.
Models with only one input and output are supported.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_classification_README.html)
## Requirements
| Options | Values |
| ----------------------------| ------------------------------------------------------------------------------------------------------------------------------|
| Validated Models | [alexnet](https://docs.openvino.ai/2023.2/omz_models_model_alexnet.html), |
| | [googlenet-v1](https://docs.openvino.ai/2023.2/omz_models_model_googlenet_v1.html) |
| Model Format | OpenVINO™ toolkit Intermediate Representation (\*.xml + \*.bin), ONNX (\*.onnx) |
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [C](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_c_samples_hello_classification_README.html), |
| | [Python](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_python_sample_hello_classification_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| --------------------------| ---------------------------------------------------------------|----------------------------------------------------------------------------------------|
| OpenVINO Runtime Version | ``ov::get_openvino_version`` | Get Openvino API version |
| Basic Infer Flow | ``ov::Core::read_model``, | Common API to do inference: read and compile a model, create an infer request, |
| | ``ov::Core::compile_model``, | configure input and output tensors |
| | ``ov::CompiledModel::create_infer_request``, | |
| | ``ov::InferRequest::set_input_tensor``, | |
| | ``ov::InferRequest::get_output_tensor`` | |
| Synchronous Infer | ``ov::InferRequest::infer`` | Do synchronous inference |
| Model Operations | ``ov::Model::inputs``, | Get inputs and outputs of a model |
| | ``ov::Model::outputs`` | |
| Tensor Operations | ``ov::Tensor::get_shape`` | Get a tensor shape |
| Preprocessing | ``ov::preprocess::InputTensorInfo::set_element_type``, | Set image of the original size as input for a model with other input size. Resize |
| | ``ov::preprocess::InputTensorInfo::set_layout``, | and layout conversions are performed automatically by the corresponding plugin |
| | ``ov::preprocess::InputTensorInfo::set_spatial_static_shape``, | just before inference. |
| | ``ov::preprocess::PreProcessSteps::resize``, | |
| | ``ov::preprocess::InputModelInfo::set_layout``, | |
| | ``ov::preprocess::OutputTensorInfo::set_element_type``, | |
| | ``ov::preprocess::PrePostProcessor::build`` | |
samples/cpp/hello_nv12_input_classification/README.md
+31
View File
@@ -0,0 +1,31 @@
# Hello NV12 Input Classification C++ Sample
This sample demonstrates how to execute an inference of image classification models with images in NV12 color format using Synchronous Inference Request API.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_nv12_input_classification_README.html)
## Requirements
| Options | Values |
| ----------------------------| --------------------------------------------------------------------------------------------------------------------------------|
| Validated Models | [alexnet <omz_models_model_alexnet](https://docs.openvino.ai/2023.2/omz_models_model_alexnet.html) |
| Model Format | OpenVINO™ toolkit Intermediate Representation (\*.xml + \*.bin), ONNX (\*.onnx) |
| Validated images | An uncompressed image in the NV12 color format - \*.yuv |
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [C](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_c_samples_hello_nv12_input_classification_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| -------------------------| ------------------------------------------------------------|-------------------------------------------|
| Node Operations | ``ov::Output::get_any_name`` | Get a layer name |
| Infer Request Operations | ``ov::InferRequest::set_tensor``, | Operate with tensors |
| | ``ov::InferRequest::get_tensor`` | |
| Preprocessing | ``ov::preprocess::InputTensorInfo::set_color_format``, | Change the color format of the input data |
| | ``ov::preprocess::PreProcessSteps::convert_element_type``, | |
| | ``ov::preprocess::PreProcessSteps::convert_color`` | |
Basic OpenVINO™ Runtime API is covered by [Hello Classification C++ sample](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_classification_README.html).
samples/cpp/hello_query_device/README.md
+21
View File
@@ -0,0 +1,21 @@
# Hello Query Device C++ Sample
This sample demonstrates how to execute an query OpenVINO™ Runtime devices, prints their metrics and default configuration values, using [Properties API](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_query_api.html).
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_query_device_README.html)
## Requirements
| Options | Values |
| ------------------------------| ----------------------------------------------------------------------------------------------------------------------------|
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [Python](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_python_sample_hello_query_device_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| -------------------------| --------------------------------------|-------------------------------------------------------------------|
| Available Devices | ``ov::Core::get_available_devices``, | Get available devices information and configuration for inference |
| | ``ov::Core::get_property`` | |
Basic OpenVINO™ Runtime API is covered by [Hello Classification C++ sample](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_classification_README.html).
samples/cpp/hello_reshape_ssd/README.md
+32
View File
@@ -0,0 +1,32 @@
# Hello Reshape SSD C++ Sample
This sample demonstrates how to do synchronous inference of object detection models using [input reshape feature](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_ShapeInference.html).
Models with only one input and output are supported.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_reshape_ssd_README.html)
## Requirements
| Options | Values |
| ----------------------------| -----------------------------------------------------------------------------------------------------------------------------------------|
| Validated Models | [person-detection-retail-0013](https://docs.openvino.ai/nightly/omz_models_model_person_detection_retail_0013.html) |
| Model Format | OpenVINO™ toolkit Intermediate Representation (\*.xml + \*.bin), ONNX (\*.onnx) |
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [Python](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_python_sample_hello_reshape_ssd_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| -------------------------| ------------------------------------------------------------|------------------------------------------------|
| Node operations | ``ov::Node::get_type_info``, | Get a node info |
| | ``ngraph::op::DetectionOutput::get_type_info_static``, | |
| | ``ov::Output::get_any_name``, | |
| | ``ov::Output::get_shape`` | |
| Model Operations | ``ov::Model::get_ops``, | Get model nodes, reshape input |
| | ``ov::Model::reshape`` | |
| Tensor Operations | ``ov::Tensor::data`` | Get a tensor data |
| Preprocessing | ``ov::preprocess::PreProcessSteps::convert_element_type``, | Model input preprocessing |
| | ``ov::preprocess::PreProcessSteps::convert_layout`` | |
Basic OpenVINO™ Runtime API is covered by [Hello Classification C++ sample](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_classification_README.html).
samples/cpp/model_creation_sample/README.md
+46
View File
@@ -0,0 +1,46 @@
# Model Creation C++ Sample
This sample demonstrates how to execute an synchronous inference using [model](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_Model_Representation.html) built on the fly which uses weights from LeNet classification model, which is known to work well on digit classification tasks.
You do not need an XML file to create a model. The API of ov::Model allows creating a model on the fly from the source code.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_model_creation_sample_README.html)
## Requirements
| Options | Values |
| ----------------------------| -------------------------------------------------------------------------------------------------------------------------------|
| Validated Models | LeNet |
| Model Format | model weights file (\*.bin) |
| Validated images | single-channel ``MNIST ubyte`` images |
| Supported devices | [All](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
| Other language realization | [Python](https://docs.openvino.ai/2023.2/openvino_inference_engine_ie_bridges_python_sample_model_creation_sample_README.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| --------------------------| ----------------------------------------|---------------------------------------|
| OpenVINO Runtime Info | ``ov::Core::get_versions`` | Get device plugins versions |
| Shape Operations | ``ov::Output::get_shape``, | Operate with shape |
| | ``ov::Shape::size``, | |
| | ``ov::shape_size`` | |
| Tensor Operations | ``ov::Tensor::get_byte_size``, | Get tensor byte size and its data |
| | ``ov::Tensor:data`` | |
| Model Operations | ``ov::set_batch`` | Operate with model batch size |
| Infer Request Operations | ``ov::InferRequest::get_input_tensor`` | Get a input tensor |
| Model creation objects | ``ov::opset8::Parameter``, | Used to construct an OpenVINO model |
| | ``ov::Node::output``, | |
| | ``ov::opset8::Constant``, | |
| | ``ov::opset8::Convolution``, | |
| | ``ov::opset8::Add``, | |
| | ``ov::opset1::MaxPool``, | |
| | ``ov::opset8::Reshape``, | |
| | ``ov::opset8::MatMul``, | |
| | ``ov::opset8::Relu``, | |
| | ``ov::opset8::Softmax``, | |
| | ``ov::descriptor::Tensor::set_names``, | |
| | ``ov::opset8::Result``, | |
| | ``ov::Model``, | |
| | ``ov::ParameterVector::vector`` | |
Basic OpenVINO™ Runtime API is covered by [Hello Classification C++ sample](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_classification_README.html).
samples/cpp/speech_sample/README.md
+38
View File
@@ -0,0 +1,38 @@
# Automatic Speech Recognition C++ Sample
> **NOTE**: This sample is being deprecated and will no longer be maintained after OpenVINO 2023.2 (LTS). The main reason for it is the outdated state of the sample and its extensive usage of GNA, which is not going to be supported by OpenVINO beyond 2023.2.
This sample demonstrates how to execute an Asynchronous Inference of acoustic model based on Kaldi\* neural networks and speech feature vectors.
The sample works with Kaldi ARK or Numpy* uncompressed NPZ files, so it does not cover an end-to-end speech recognition scenario (speech to text), requiring additional preprocessing (feature extraction) to get a feature vector from a speech signal, as well as postprocessing (decoding) to produce text from scores.
For more detailed information on how this sample works, check the dedicated [article](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_speech_sample_README.html)
## Requirements
| Options | Values |
| ---------------------------| -----------------------------------------------------------------------------------------------------------------------------------------|
| Validated Models | Acoustic model based on Kaldi\* neural networks (see |
| | [Model Preparation](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_speech_sample_README.html) |
| | section) |
| Model Format | OpenVINO™ toolkit Intermediate Representation (*.xml + *.bin) |
| Supported devices | See [Execution Modes](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_speech_sample_README.html#execution-modes) |
| | section below and [List Supported Devices](https://docs.openvino.ai/2023.2/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html) |
The following C++ API is used in the application:
| Feature | API | Description |
| -------------------------| ------------------------------------------------------------------------------|------------------------------------------------------------------------------|
| Available Devices | ``ov::Core::get_available_devices``, ``ov::Core::get_property`` | Get information of the devices for inference |
| Import/Export Model | ``ov::Core::import_model``, ``ov::CompiledModel::export_model`` | The GNA plugin supports loading and saving of the GNA-optimized model |
| Model Operations | ``ov::set_batch``, ``ov::Model::add_output``, ``ov::CompiledModel::inputs``, | |
| | ``ov::CompiledModel::outputs`` | Managing of model: configure batch_size, input and output tensors |
| Node Operations | ``ov::OutputVector::size``, ``ov::Output::get_shape`` | Get node shape |
| Asynchronous Infer | ``ov::InferRequest::start_async``, ``ov::InferRequest::wait`` | Do asynchronous inference and waits until inference result becomes available |
| InferRequest Operations | ``ov::InferRequest::query_state``, ``ov::VariableState::reset`` | Gets and resets CompiledModel state control |
| Tensor Operations | ``ov::Tensor::get_size``, ``ov::Tensor::data``, | |
| | ``ov::InferRequest::get_tensor`` | Get a tensor, its size and data |
| Profiling | ``ov::InferRequest::get_profiling_info`` | Get infer request profiling info |
Basic OpenVINO™ Runtime API is covered by [Hello Classification C++ sample](https://docs.openvino.ai/2023.2/openvino_inference_engine_samples_hello_classification_README.html).