OpenVINO Samples¶

The OpenVINO™ samples are simple console applications that show how to utilize specific OpenVINO API capabilities within an application. They can assist you in executing specific tasks such as loading a model, running inference, querying specific device capabilities, etc.

If you installed OpenVINO Runtime via archive files, sample applications for С, and C++, and Python are created in the following directories:

<INSTALL_DIR>/samples/c
<INSTALL_DIR>/samples/cpp
<INSTALL_DIR>/samples/python

If you installed OpenVINO via PyPI, download the OpenVINO repository and use samples from samples/python.

The applications include:

Speech Sample - Acoustic model inference based on Kaldi neural networks and speech feature vectors:
- Automatic Speech Recognition C++ Sample
- Automatic Speech Recognition Python Sample
Hello Classification Sample – Inference of image classification networks, such as AlexNet and GoogLeNet, using Synchronous Inference Request API. Input of any size and layout can be set to an infer request which will be pre-processed automatically during inference (the sample supports only images as inputs and supports Unicode paths):
Hello NV12 Input Classification Sample – Input of any size and layout can be provided to an infer request. The sample transforms the input to the NV12 color format and pre-process it automatically during inference. The sample supports only images as inputs:
- Hello NV12 Input Classification C++ Sample
- Hello NV12 Input Classification C Sample
Hello Query Device Sample – Query of available OpenVINO devices and their metrics, configuration values:
- Hello Query Device C++ Sample
- Hello Query Device Python Sample
Hello Reshape SSD Sample – Inference of SSD networks resized by ShapeInfer API according to an input size:
- Hello Reshape SSD C++ Sample
- Hello Reshape SSD Python Sample
Image Classification Sample Async – Inference of image classification networks, such as AlexNet and GoogLeNet, using Asynchronous Inference Request API (the sample supports only images as inputs):
- Image Classification Async C++ Sample
- Image Classification Async Python Sample
OpenVINO Model Creation Sample – Construction of the LeNet model using the OpenVINO model creation sample:
- OpenVINO Model Creation C++ Sample
- OpenVINO Model Creation Python Sample
Benchmark Application – Estimates deep learning inference performance on supported devices for synchronous and asynchronous modes:
- Benchmark C++ Tool

Keep in mind that the Python version of the benchmark tool is currently available only through the OpenVINO Development Tools installation. It is not created in the samples directory but can be launched with the following command:

benchmark_app -m <model> -i <input> -d <device>

For more information, see the Benchmark Python Tool documentation.

Note

All C++ samples support input paths that contain only ASCII characters, except for the Hello Classification Sample (it supports Unicode).

Media Files Available for Samples¶

To run the sample applications, use images and videos available online in the test data storage.

Samples that Support Pre-Trained Models¶

To run the sample, use public or Intel’s pre-trained models from Open Model Zoo. The models can be downloaded using Model Downloader.

Build the Sample Applications¶

Build the Sample Applications on Linux¶

The supported Linux build environment includes

Ubuntu 18.04 LTS 64-bit or Ubuntu 20.04 LTS 64-bit,
GCC 7.5.0 (for Ubuntu 18.04) or GCC 9.3.0 (for Ubuntu 20.04),
CMake version 3.10 or higher.

Note

For building samples from the open source version of OpenVINO™ toolkit, see the build instructions on GitHub.

To build the C or C++ sample applications for Linux, go to the <INSTALL_DIR>/samples/c or <INSTALL_DIR>/samples/cpp directory, respectively, and run the build_samples.sh script:

build_samples.sh

Once the build has been completed, sample binaries will be in the following folders:

C samples - ~/inference_engine_c_samples_build/intel64/Release
C++ samples - ~/inference_engine_cpp_samples_build/intel64/Release

Also, sample applications can be built manually:

Note

If you have installed the product as a root user, switch to root mode (sudo -i) before you continue.

Navigate to a directory that you have write access to and create a samples build directory. This example uses a directory named build :
```
mkdir build
```
Note

If you run the Image Classification verification script during the installation, the C++ samples build directory is created in your home directory - ~/inference_engine_cpp_samples_build/.
Go to the newly created directory:
```
cd build
```
Run CMake to generate the Make files for release or debug configuration. For example, for C++ samples:
- For release configuration:
```
cmake -DCMAKE_BUILD_TYPE=Release <INSTALL_DIR>/samples/cpp
```
- For debug configuration:
```
cmake -DCMAKE_BUILD_TYPE=Debug <INSTALL_DIR>/samples/cpp
```
Run make to build the samples:
```
make
```

The sample application binaries can be found in:

For release configuration - <path_to_build_directory>/intel64/Release/
For debug configuration - <path_to_build_directory>/intel64/Debug/

Build the Sample Applications on Microsoft Windows¶

The recommended Windows build environment is the following:

Microsoft Windows 10
Microsoft Visual Studio 2019
CMake version 3.10 or higher

Note

Microsoft Visual Studio 2019 requires installation of CMake 3.14 or higher.

To build C or C++ sample applications on Windows, go to the <INSTALL_DIR>\samples\c or <INSTALL_DIR>\samples\cpp directory, respectively, and run the build_samples_msvc.bat batch file:

build_samples_msvc.bat

By default, the script automatically detects the highest Microsoft Visual Studio version installed on the machine and uses it to create and build a solution for a sample code.

Once the build has been completed, sample binaries will be in the following folders:

C samples - C:\Users\<user>\Documents\Intel\OpenVINO\inference_engine_c_samples_build\intel64\Release
C++ samples - C:\Users\<user>\Documents\Intel\OpenVINO\inference_engine_cpp_samples_build\intel64\Release

A generated solution can also be built manually. For example, to build C++ sample binaries in Debug configuration, run the suitable version of the Microsoft Visual Studio and open the generated solution file from the C:\Users\<user>\Documents\Intel\OpenVINO\inference_engine_cpp_samples_build\Samples.sln directory.

Build the Sample Applications on macOS*¶

The officially supported macOS build environment is the following:

macOS 10.15 64-bit or higher
Clang compiler from Xcode 10.1 or higher
CMake version 3.13 or higher

Note

To learn how to build samples from the open-source version of OpenVINO™ toolkit, see the build instructions on GitHub.

To build C or C++ sample applications for macOS, go to the <INSTALL_DIR>/samples/c or <INSTALL_DIR>/samples/cpp directory, respectively, and run the build_samples.sh script:

build_samples.sh

Once the build has been completed, sample binaries will be in the following folders:

C samples - ~/inference_engine_c_samples_build/intel64/Release
C++ samples - ~/inference_engine_cpp_samples_build/intel64/Release

The sample applications can also be built manually:

Note

If you have installed the product as a root user, switch to root mode (sudo -i) before you continue.

Note

Before proceeding, make sure that you have OpenVINO environment set correctly. This can be done manually by

cd <INSTALL_DIR>/
source setupvars.sh

Navigate to a directory that you have write access to and create a samples build directory. This example uses a directory named build :
```
mkdir build
```
Note

If you ran the Image Classification verification script during the installation, the C++ samples build directory was already created in your home directory: ~/inference_engine_cpp_samples_build/
Go to the newly created directory:
```
cd build
```
Run CMake to generate the Make files for release or debug configuration. For example, for C++ samples:
- For release configuration:
```
cmake -DCMAKE_BUILD_TYPE=Release <INSTALL_DIR>/samples/cpp
```
- For debug configuration:
```
cmake -DCMAKE_BUILD_TYPE=Debug <INSTALL_DIR>/samples/cpp
```
Run make to build the samples:
```
make
```

The sample application binaries can be find in:

For release configuration - <path_to_build_directory>/intel64/Release/
For debug configuration - <path_to_build_directory>/intel64/Debug/

Get Ready for Running the Sample Applications¶

Get Ready for Running the Sample Applications on Linux¶

Before running compiled binary files, check if your application can find the OpenVINO Runtime libraries. Run the setupvars script to set all necessary environment variables:

source <INSTALL_DIR>/setupvars.sh

Optional : The OpenVINO environment variables are removed when you close the shell. Optionally, you can permanently set the environment variables as follows:

Open the .bashrc file in <user_home_directory> :
```
vi <user_home_directory>/.bashrc
```
Append the file with the following command-line:
```
source /opt/intel/openvino_2022/setupvars.sh
```
Press the Esc key, type :wq and press the Enter key to save and close the file.
To test change, open a new terminal. You will see [setupvars.sh] OpenVINO environment initialized.

Sample applications are ready to start. To learn how to run a particular sample, go to the documentation by clicking the name of a chosen sample from the list above.

Get Ready for Running the Sample Applications on Windows¶

Before running compiled binary files, check if your application can find the OpenVINO Runtime libraries. Use the setupvars script, which sets all necessary environment variables:

<INSTALL_DIR>\setupvars.bat

To debug or run the samples on Windows in Microsoft Visual Studio, make sure you have properly configured Debugging environment settings for the Debug and Release configurations. Set correct paths to the OpenCV libraries, and debug and release versions of the OpenVINO Runtime libraries. For example, for the Debug configuration, go to Configuration Properties of the project, then select the Debugging category and set the PATH variable in the Environment field to the following:

PATH=<INSTALL_DIR>\runtime\bin;%PATH%

where <INSTALL_DIR> is the installation directory of OpenVINO toolkit.

You are ready to run sample applications. To learn how to run a particular sample, read the sample documentation by clicking the sample name in the samples list above.

Additional Resources¶

OpenVINO™ Runtime User Guide

Prev Next