### Get Help for YuNet Demo (C++)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_detection_yunet/README.md

Display all available command-line arguments and options for the C++ YuNet demo executable.

```shell
./build/demo -h
```

--------------------------------

### Build and Run C++ Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/image_classification_ppresnet/README.md

Compile and run the C++ image classification demo. Ensure OpenCV and CMake are installed. Specify the OpenCV installation path during CMake configuration.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
```

```shell
cmake --build build
```

```shell
./build/opencv_zoo_image_classification_ppresnet -i=/path/to/image
```

```shell
./build/opencv_zoo_image_classification_ppresnet -i=/path/to/image -k=N
```

```shell
./build/opencv_zoo_image_classification_ppresnet -h
```

--------------------------------

### Compile and Run Nanodet Demo in C++

Source: https://github.com/opencv/opencv_zoo/blob/main/models/object_detection_nanodet/README.md

Build and run the Nanodet object detection demo using C++. This requires OpenCV and CMake. Examples show detection on camera input, a specific image, and how to access help messages.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build

# detect on camera input
./build/opencv_zoo_object_detection_nanodet
# detect on an image
./build/opencv_zoo_object_detection_nanodet -i=/path/to/image
# get help messages
./build/opencv_zoo_object_detection_nanodet -h
```

--------------------------------

### Build and Run Youtu ReID Demo in C++

Source: https://github.com/opencv/opencv_zoo/blob/main/models/person_reid_youtureid/README.md

Compile and run the C++ demo for the Youtu ReID model. CMake is used for building. Specify OpenCV installation path and demo directories. Use --help for parameter details.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build
```

```shell
./build/demo --query_dir=/path/to/query --gallery_dir=/path/to/gallery -v
```

```shell
./build/demo --help
```

--------------------------------

### Basic CMake Configuration for PP-ResNet

Source: https://github.com/opencv/opencv_zoo/blob/main/models/image_classification_ppresnet/CMakeLists.txt

Sets up the minimum CMake version, project name, and OpenCV version. It then finds the OpenCV installation and defines the executable target.

```cmake
cmake_minimum_required(VERSION 3.24)
set(project_name "opencv_zoo_image_classification_ppresnet")

PROJECT (${project_name})

set(OPENCV_VERSION "4.10.0")
set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
# Find OpenCV, you may need to set OpenCV_DIR variable
# to the absolute path to the directory containing OpenCVConfig.cmake file
# via the command line or GUI

file(GLOB SourceFile
    "demo.cpp")
# If the package has been found, several variables will
# be set, you can find the full list with descriptions
# in the OpenCVConfig.cmake file.
# Print some message showing some of them
message(STATUS "OpenCV library status:")
message(STATUS "    config: ${OpenCV_DIR}")
message(STATUS "    version: ${OpenCV_VERSION}")
message(STATUS "    libraries: ${OpenCV_LIBS}")
message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")

# Declare the executable target built from your sources
add_executable(${project_name} ${SourceFile})

# Set C++ compilation standard to C++11
set(CMAKE_CXX_STANDARD 11)

# Link your application with OpenCV libraries
target_link_libraries(${project_name} PRIVATE ${OpenCV_LIBS})
```

--------------------------------

### Build and Run C++ Pose Estimation Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/pose_estimation_mediapipe/README.md

Compile and run the C++ pose estimation demo. Ensure OpenCV and CMake are installed. Specify the OpenCV installation path during CMake configuration.

```bash
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build

# detect on camera input
./build/opencv_zoo_pose_estimation_mediapipe
# detect on an image
./build/opencv_zoo_pose_estimation_mediapipe -m=/path/to/model -i=/path/to/image -v
# get help messages
./build/opencv_zoo_pose_estimation_mediapipe -h
```

--------------------------------

### Build and Run PP-OCRv3 Text Detection Demo in C++

Source: https://github.com/opencv/opencv_zoo/blob/main/models/text_detection_ppocr/README.md

Compile and run the C++ text detection demo. Ensure you have OpenCV and CMake installed. Specify the OpenCV installation path during CMake configuration.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build
# detect on camera input
./build/opencv_zoo_text_detection_ppocr -m=/path/to/model
# detect on an image
./build/opencv_zoo_text_detection_ppocr -m=/path/to/model -i=/path/to/image -v
# get help messages
./build/opencv_zoo_text_detection_ppocr -h
```

--------------------------------

### Build and Run Person Detection Demo (C++)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/person_detection_mediapipe/README.md

Compile and run the C++ person detection demo. Ensure OpenCV and CMake are installed. The demo can detect on camera input or a specified image file, with model and image paths configurable.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build

# detect on camera input
./build/opencv_zoo_person_detection_mediapipe
# detect on an image
./build/opencv_zoo_person_detection_mediapipe -m=/path/to/model -i=/path/to/image -v
# get help messages
./build/opencv_zoo_person_detection_mediapipe -h
```

--------------------------------

### Build and Run DexiNed C++ Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/edge_detection_dexined/README.md

Compile the C++ demo using CMake, specifying the OpenCV installation path. Run the executable to perform edge detection on camera input or a specified image.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build

# detect on camera input
./build/demo
# detect on an image
./build/demo --input=/path/to/image
# get help messages
./build/demo -h
```

--------------------------------

### Get Help for C++ Image Classification Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/image_classification_mobilenet/README.md

Display help messages and available parameters for the C++ image classification demo executable.

```shell
./build/opencv_zoo_image_classification_mobilenet -h
```

--------------------------------

### Run Python Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/image_classification_ppresnet/README.md

Execute the Python demo script for image classification. Use the --input argument to specify the image path. Get help on parameters with --help.

```shell
python demo.py --input /path/to/image
```

```shell
python demo.py --help
```

--------------------------------

### Build and Run PPHumanSeg Demo (C++)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/human_segmentation_pphumanseg/README.md

Compile and run the C++ human segmentation demo. Ensure you have OpenCV and CMake installed. The executable can process camera input or a specified image.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build

# detect on camera input
./build/opencv_zoo_human_segmentation
# detect on an image
./build/opencv_zoo_human_segmentation -i=/path/to/image
# get help messages
./build/opencv_zoo_human_segmentation -h
```

--------------------------------

### Basic CMake Configuration

Source: https://github.com/opencv/opencv_zoo/blob/main/models/facial_expression_recognition/CMakeLists.txt

Sets the minimum CMake version, C++ standard, and project name. This is the standard starting point for most CMake projects.

```cmake
cmake_minimum_required(VERSION 3.24)
set(CMAKE_CXX_STANDARD 11)
set(project_name "opencv_zoo_face_expression_recognition")

PROJECT (${project_name})
```

--------------------------------

### Build and Run VIT Tracker Demo in C++

Source: https://github.com/opencv/opencv_zoo/blob/main/models/object_tracking_vittrack/README.md

Compile and run the VIT tracker demo using CMake. Specify your OpenCV installation path during CMake configuration. Use the -i flag for video input and -h for help.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build
```

```shell
./build/opencv_zoo_object_tracking_vittrack
```

```shell
./build/opencv_zoo_object_tracking_vittrack -i=/path/to/video
```

```shell
./build/opencv_zoo_object_tracking_vittrack -h
```

--------------------------------

### CMake Project Setup and OpenCV Configuration

Source: https://github.com/opencv/opencv_zoo/blob/main/models/object_tracking_vittrack/CMakeLists.txt

Sets the minimum CMake version, project name, and finds the required OpenCV installation. It's recommended to set the OpenCV_DIR path if OpenCV is not found automatically.

```cmake
cmake_minimum_required(VERSION 3.24)
set(project_name "opencv_zoo_object_tracking_vittrack")

PROJECT (${project_name})

set(OPENCV_VERSION "4.10.0")
set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
# Find OpenCV, you may need to set OpenCV_DIR variable
# to the absolute path to the directory containing OpenCVConfig.cmake file
# via the command line or GUI
```

--------------------------------

### Run YuNet Demo on Camera Input (C++)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_detection_yunet/README.md

Execute the built C++ demo executable to perform face detection on live camera feed.

```shell
./build/demo
```

--------------------------------

### Install opencv-python

Source: https://github.com/opencv/opencv_zoo/blob/main/README.md

Install or upgrade the opencv-python package using pip.

```shell
python3 -m pip install opencv-python
```

```shell
python3 -m pip install --upgrade opencv-python
```

--------------------------------

### Install Quantization Dependencies

Source: https://github.com/opencv/opencv_zoo/blob/main/tools/quantize/README.md

Installs necessary dependencies for quantization from the requirements.txt file.

```shell
pip install -r requirements.txt
```

--------------------------------

### ICDAR2003 Evaluation Example

Source: https://github.com/opencv/opencv_zoo/blob/main/tools/eval/README.md

Example commands for downloading, unzipping, and evaluating the ICDAR2003 dataset with the CRNN model.

```shell
download zip file from http://www.iapr-tc11.org/dataset/ICDAR2003_RobustReading/TrialTrain/word.zip
upzip file to /path/to/icdar
python eval.py -m crnn -d icdar -dr /path/to/icdar
```

--------------------------------

### Display eDifFIQA(T) Demo Help

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_image_quality_assessment_ediffiqa/README.md

View all available command-line arguments for the eDifFIQA(T) demo script to understand its configuration options.

```shell
python demo.py --help
```

--------------------------------

### Install Evaluation Dependencies

Source: https://github.com/opencv/opencv_zoo/blob/main/tools/eval/README.md

Install the required Python packages for running accuracy evaluations. Ensure you have the correct versions of scipy if specified.

```shell
pip install tqdm
pip install scikit-learn
pip install scipy==1.8.1
```

--------------------------------

### Run All Configs Benchmark (Linux)

Source: https://github.com/opencv/opencv_zoo/blob/main/benchmark/README.md

Execute benchmarks for all available configurations on Linux.

```shell
export PYTHONPATH=$PYTHONPATH:..

# All configs
python benchmark.py --all
```

--------------------------------

### Run YuNet Demo on Camera Input (Python)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_detection_yunet/README.md

Execute the Python demo script to perform face detection on live camera feed. No specific input file is required.

```shell
python demo.py
```

--------------------------------

### Build and Run C++ LaMa Inpainting Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/inpainting_lama/README.md

Compile and run the C++ demo for LaMa inpainting. Ensure OpenCV is installed and provide the installation path during CMake configuration.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build
```

```shell
./build/demo --input=/path/to/image
```

```shell
./build/demo -h
```

--------------------------------

### Run All FP32 Models Benchmark (Linux)

Source: https://github.com/opencv/opencv_zoo/blob/main/benchmark/README.md

Execute benchmarks for all configurations, focusing only on FP32 models on Linux.

```shell
export PYTHONPATH=$PYTHONPATH:..

# All configs but only fp32 models (--fp32, --fp16, --int8 --int8bq are available for now)
python benchmark.py --all --fp32
```

--------------------------------

### Install and Use Git LFS for Model Downloads

Source: https://github.com/opencv/opencv_zoo/wiki/Frequently-Asked-Problems

Install git-lfs to correctly clone and download large model files from the opencv_zoo repository. This is necessary because model weights are stored using LFS.

```shell
# Install git-lfs from https://git-lfs.github.com/
git clone https://github.com/opencv/opencv_zoo && cd opencv_zoo
git lfs install
git lfs pull
```

--------------------------------

### Download All Benchmark Data

Source: https://github.com/opencv/opencv_zoo/blob/main/benchmark/README.md

Download all necessary data for benchmarking.

```shell
python download_data.py
```

--------------------------------

### Run YuNet Demo on Image Input (C++)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_detection_yunet/README.md

Execute the built C++ demo executable to perform face detection on a specified image file. Use the -v flag for verbose output.

```shell
./build/demo -i=/path/to/image -v
```

--------------------------------

### Build and Run C++ Palm Detection Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/palm_detection_mediapipe/README.md

Compile and run the C++ demo for palm detection. Ensure OpenCV (with opencv_contrib) and CMake are installed. Specify the OpenCV installation path during CMake configuration. The demo supports camera input, image input (-i), and help messages (-h).

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build

# detect on camera input
./build/demo
# detect on an image
./build/demo -i=/path/to/image -v
# get help messages
./build/demo -h
```

--------------------------------

### Run PPHumanSeg Demo (Python)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/human_segmentation_pphumanseg/README.md

Execute the Python demo script to perform human segmentation on camera input or an image. Use the --help flag to see all available parameters.

```shell
python demo.py
python demo.py --input /path/to/image -v
python demo.py --help
```

--------------------------------

### Build and Run SFace Face Recognition Demo (C++)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_recognition_sface/README.md

Compile and run the SFace face recognition demo using C++. Requires OpenCV and CMake. Supports camera input or image files for comparison. Use -h for help.

```shell
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build
```

```shell
./build/demo -t=/path/to/target_face
```

```shell
./build/demo -t=/path/to/target_face -q=/path/to/query_face -v
```

```shell
./build/demo -h
```

--------------------------------

### CMake Project Configuration

Source: https://github.com/opencv/opencv_zoo/blob/main/models/pose_estimation_mediapipe/CMakeLists.txt

Sets the minimum CMake version, project name, and OpenCV version. It also specifies the path for finding the OpenCV installation.

```cmake
cmake_minimum_required(VERSION 3.24)
set(project_name "opencv_zoo_pose_estimation_mediapipe")

PROJECT (${project_name})

set(OPENCV_VERSION "4.10.0")
set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
```

--------------------------------

### Run SFace Face Recognition Demo (Python)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_recognition_sface/README.md

Execute the SFace face recognition demo using Python. Specify target and query images for comparison. Use --help for a list of available parameters.

```shell
python demo.py --target /path/to/image1 --query /path/to/image2
```

```shell
python demo.py --help
```

--------------------------------

### OpenCV Information Messages

Source: https://github.com/opencv/opencv_zoo/blob/main/models/facial_expression_recognition/CMakeLists.txt

Prints status messages about the found OpenCV installation, including its directory, version, libraries, and include paths. Useful for debugging.

```cmake
message(STATUS "OpenCV library status:")
message(STATUS "    config: ${OpenCV_DIR}")
message(STATUS "    version: ${OpenCV_VERSION}")
message(STATUS "    libraries: ${OpenCV_LIBS}")
message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
```

--------------------------------

### Run VIT Tracker Demo in Python

Source: https://github.com/opencv/opencv_zoo/blob/main/models/object_tracking_vittrack/README.md

Execute the VIT tracker demo script for real-time object tracking. Use the --input flag to specify a video file for tracking.

```bash
python demo.py
```

```bash
python demo.py --input /path/to/video
```

```bash
python demo.py --help
```

--------------------------------

### Run Single Config Benchmark (Windows CMD)

Source: https://github.com/opencv/opencv_zoo/blob/main/benchmark/README.md

Execute the benchmark for a single configuration file using Windows Command Prompt.

```shell
set PYTHONPATH=%PYTHONPATH%;..
python benchmark.py --cfg ./config/face_detection_yunet.yaml
```

--------------------------------

### Build C++ Demo for Facial Expression Recognition

Source: https://github.com/opencv/opencv_zoo/blob/main/models/facial_expression_recognition/README.md

Steps to build the C++ demo for facial expression recognition. This requires OpenCV and CMake. Specify your OpenCV installation path.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
cmake --build build
```

--------------------------------

### Run Single Config Benchmark (Linux)

Source: https://github.com/opencv/opencv_zoo/blob/main/benchmark/README.md

Execute the benchmark for a single configuration file on Linux.

```shell
export PYTHONPATH=$PYTHONPATH:..

# Single config
python benchmark.py --cfg ./config/face_detection_yunet.yaml
```

--------------------------------

### Configure OpenCV Build for C++ Demo

Source: https://github.com/opencv/opencv_zoo/blob/main/models/image_classification_mobilenet/README.md

Configure the CMake build for the C++ image classification demo, specifying the OpenCV installation path. Requires CMake version 3.24.0 or later.

```shell
# A typical and default installation path of OpenCV is /usr/local
cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
```

--------------------------------

### Benchmark All Models on CPU

Source: https://github.com/opencv/opencv_zoo/blob/main/benchmark/README.md

Execute a comprehensive benchmark of all available models on the CPU backend. Excludes models requiring specific configurations like 'wechat'.

```bash
$ python3 benchmark.py --all --cfg_exclude wechat
```

--------------------------------

### Source File Declaration and OpenCV Info

Source: https://github.com/opencv/opencv_zoo/blob/main/models/object_detection_nanodet/CMakeLists.txt

Declares the source files for the executable and prints status messages about the found OpenCV installation, including its directory, version, libraries, and include paths.

```cmake
file(GLOB SourceFile
    "demo.cpp")
# If the package has been found, several variables will
# be set, you can find the full list with descriptions
# in the OpenCVConfig.cmake file.
# Print some message showing some of them
message(STATUS "OpenCV library status:")
message(STATUS "    config: ${OpenCV_DIR}")
message(STATUS "    version: ${OpenCV_VERSION}")
message(STATUS "    libraries: ${OpenCV_LIBS}")
message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
```

--------------------------------

### Basic CMake Configuration

Source: https://github.com/opencv/opencv_zoo/blob/main/models/object_detection_nanodet/CMakeLists.txt

Sets the minimum CMake version, project name, and OpenCV version. It also finds the OpenCV package and provides instructions on setting the OpenCV installation path.

```cmake
cmake_minimum_required(VERSION 3.24)
set(project_name "opencv_zoo_object_detection_nanodet")

PROJECT (${project_name})

set(OPENCV_VERSION "4.10.0")
set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
# Find OpenCV, you may need to set OpenCV_DIR variable
# to the absolute path to the directory containing OpenCVConfig.cmake file
# via the command line or GUI
```

--------------------------------

### Run Person Detection Demo (Python)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/person_detection_mediapipe/README.md

Execute the Python demo script to perform person detection. Use the -i flag to specify an image file and -v for verbose output. The --help flag provides a full list of parameters.

```bash
# detect on camera input
python demo.py
# detect on an image
python demo.py -i /path/to/image -v

# get help regarding various parameters
python demo.py --help
```

--------------------------------

### Run Youtu ReID Demo in Python

Source: https://github.com/opencv/opencv_zoo/blob/main/models/person_reid_youtureid/README.md

Execute the Python demo script for the Youtu ReID model. Specify query and gallery directories. Use --help for parameter details.

```shell
python demo.py --query_dir /path/to/query --gallery_dir /path/to/gallery -v
```

```shell
python demo.py --help
```

--------------------------------

### Run YuNet Demo on Image Input (Python)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/face_detection_yunet/README.md

Execute the Python demo script to perform face detection on a specified image file. Use the -v flag for verbose output.

```shell
python demo.py --input /path/to/image -v
```

--------------------------------

### Run C++ Image Classification Demo on Camera Input

Source: https://github.com/opencv/opencv_zoo/blob/main/models/image_classification_mobilenet/README.md

Execute the built C++ image classification demo using live camera input. The default model and settings will be used.

```shell
./build/opencv_zoo_image_classification_mobilenet
```

--------------------------------

### Run CRNN Demo (C++ - English)

Source: https://github.com/opencv/opencv_zoo/blob/main/models/text_recognition_crnn/README.md

Execute the CRNN text recognition demo using C++. Supports camera input or image files. Ensure OpenCV and CMake are installed. Use --help for parameter details.

```shell
./build/opencv_zoo_text_recognition_crnn 
./build/opencv_zoo_text_recognition_crnn --input /path/to/image -v
./build/opencv_zoo_text_recognition_crnn --help
```

--------------------------------

### Benchmark Models on CPU

Source: https://github.com/opencv/opencv_zoo/blob/main/benchmark/README.md

Run benchmark for all models on CPU. Excludes 'wechat' configuration. Displays performance metrics, input sizes, and model names.

```bash
$ python3 benchmark.py --all --cfg_exclude wechat
Benchmarking ...
backend=cv.dnn.DNN_BACKEND_OPENCV
target=cv.dnn.DNN_TARGET_CPU
mean       median     min        input size   model
7.82       7.82       7.77       [160, 120]   YuNet with ['face_detection_yunet_2023mar.onnx']
8.57       8.77       7.77       [160, 120]   YuNet with ['face_detection_yunet_2023mar_int8.onnx']
92.21      92.11      91.87      [150, 150]   SFace with ['face_recognition_sface_2021dec.onnx']
122.07     126.02     91.87      [150, 150]   SFace with ['face_recognition_sface_2021dec_int8.onnx']
42.93      43.26      42.75      [112, 112]   FacialExpressionRecog with ['facial_expression_recognition_mobilefacenet_2022july.onnx']
55.91      57.40      42.75      [112, 112]   FacialExpressionRecog with ['facial_expression_recognition_mobilefacenet_2022july_int8.onnx']
67.85      67.91      67.47      [224, 224]   MPHandPose with ['handpose_estimation_mediapipe_2023feb.onnx']
70.06      70.21      67.47      [224, 224]   MPHandPose with ['handpose_estimation_mediapipe_2023feb_int8.onnx']
102.49     102.65     102.10     [192, 192]   PPHumanSeg with ['human_segmentation_pphumanseg_2023mar.onnx']
114.02     116.16     102.10     [192, 192]   PPHumanSeg with ['human_segmentation_pphumanseg_2023mar_int8.onnx']
92.66      92.49      92.36      [224, 224]   MobileNet with ['image_classification_mobilenetv1_2022apr.onnx']
79.39      80.75      68.47      [224, 224]   MobileNet with ['image_classification_mobilenetv2_2022apr.onnx']
89.66      68.66      68.47      [224, 224]   MobileNet with ['image_classification_mobilenetv1_2022apr_int8.onnx']
90.59      92.13      68.47      [224, 224]   MobileNet with ['image_classification_mobilenetv2_2022apr_int8.onnx']
499.55     500.15     498.36     [224, 224]   PPResNet with ['image_classification_ppresnet50_2022jan.onnx']
571.85     580.88     498.36     [224, 224]   PPResNet with ['image_classification_ppresnet50_2022jan_int8.onnx']
201.99     201.55     200.62     [320, 240]   LPD_YuNet with ['license_plate_detection_lpd_yunet_2023mar.onnx']
216.72     217.34     200.62     [320, 240]   LPD_YuNet with ['license_plate_detection_lpd_yunet_2023mar_int8.onnx']
313.66     313.85     312.13     [416, 416]   NanoDet with ['object_detection_nanodet_2022nov.onnx']
322.98     323.45     312.13     [416, 416]   NanoDet with ['object_detection_nanodet_2022nov_int8.onnx']
1875.33    1877.53    1871.26    [640, 640]   YoloX with ['object_detection_yolox_2022nov.onnx']
1989.04    2005.25    1871.26    [640, 640]   YoloX with ['object_detection_yolox_2022nov_int8.onnx']
143.62     143.19     137.16     [1280, 720]  VitTrack with ['object_tracking_vittrack_2023sep.onnx']
159.80     159.62     159.40     [192, 192]   MPPalmDet with ['palm_detection_mediapipe_2023feb.onnx']
152.18     152.86     145.56     [192, 192]   MPPalmDet with ['palm_detection_mediapipe_2023feb_int8.onnx']
145.83     145.77     145.45     [224, 224]   MPPersonDet with ['person_detection_mediapipe_2023mar.onnx']
521.46     521.66     520.28     [128, 256]   YoutuReID with ['person_reid_youtu_2021nov.onnx']
541.50     544.02     520.28     [128, 256]   YoutuReID with ['person_reid_youtu_2021nov_int8.onnx']
134.02     136.01     132.06     [256, 256]   MPPose with ['pose_estimation_mediapipe_2023mar.onnx']
360.26     360.82     359.13     [640, 480]   PPOCRDet with ['text_detection_cn_ppocrv3_2023may.onnx']
361.22     361.51     359.13     [640, 480]   PPOCRDet with ['text_detection_en_ppocrv3_2023may.onnx']
427.85     362.87     359.13     [640, 480]   PPOCRDet with ['text_detection_cn_ppocrv3_2023may_int8.onnx']
475.44     490.06     359.13     [640, 480]   PPOCRDet with ['text_detection_en_ppocrv3_2023may_int8.onnx']
285.19     284.91     284.69     [1280, 720]  CRNN with ['text_recognition_CRNN_CH_2021sep.onnx']
318.96     323.30     284.69     [1280, 720]  CRNN with ['text_recognition_CRNN_CN_2021nov.onnx']
289.82     360.87     244.07     [1280, 720]  CRNN with ['text_recognition_CRNN_EN_2021sep.onnx']
285.40     303.13     244.07     [1280, 720]  CRNN with ['text_recognition_CRNN_CH_2023feb_fp16.onnx']
274.67     244.47     243.87     [1280, 720]  CRNN with ['text_recognition_CRNN_EN_2023feb_fp16.onnx']
277.84     262.99     243.87     [1280, 720]  CRNN with ['text_recognition_CRNN_CH_2022oct_int8.onnx']
283.02     280.77     243.87     [1280, 720]  CRNN with ['text_recognition_CRNN_CN_2021nov_int8.onnx']
279.21     262.55     243.87     [1280, 720]  CRNN with ['text_recognition_CRNN_EN_2022oct_int8.onnx']
```