[Python API] Move samples and docs to the new directory (#7851)
* [Python API] Move samples and docs to the new directory * move samples to the new directory * try to fix build and pychecks * fix links * fix pychecks * fix cmake * fix cpack installation * Update inference-engine/ie_bridges/python/CMakeLists.txt Co-authored-by: Sergey Lyubimtsev <sergey.lyubimtsev@intel.com> Co-authored-by: Sergey Lyubimtsev <sergey.lyubimtsev@intel.com>
This commit is contained in:
Anastasia Kuporosova
committed by
GitHub
GitHub
parent
eb838d5699
commit
799be77e33
159
samples/python/ngraph_function_creation_sample/README.md
Normal file
159
samples/python/ngraph_function_creation_sample/README.md
Normal file
@@ -0,0 +1,159 @@
|
||||
# nGraph Function Creation Python* Sample {#openvino_inference_engine_ie_bridges_python_sample_ngraph_function_creation_sample_README}
|
||||
|
||||
This sample demonstrates how to execute an inference using [nGraph function feature](../../../docs/nGraph_DG/build_function.md) to create a network that uses weights from LeNet classification network, which is known to work well on digit classification tasks. So you don't need an XML file, the model will be created from the source code on the fly.
|
||||
|
||||
In addition to regular grayscale images with a digit, the sample also supports single-channel `ubyte` images as an input.
|
||||
|
||||
The following Inference Engine Python API is used in the application:
|
||||
|
||||
| Feature | API | Description |
|
||||
| :----------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------- |
|
||||
| Network Operations | [IENetwork], [IENetwork.batch_size] | Managing of network |
|
||||
| nGraph Functions | [ngraph.impl.Function], [ngraph.parameter], [ngraph.constant], [ngraph.convolution], [ngraph.add], [ngraph.max_pool], [ngraph.reshape], [ngraph.matmul], [ngraph.relu], [ngraph.softmax], [ngraph.result], ngraph.impl.Function.to_capsule | Description of a network using nGraph Python API |
|
||||
|
||||
Basic Inference Engine API is covered by [Hello Classification Python* Sample](../hello_classification/README.md).
|
||||
|
||||
| Options | Values |
|
||||
| :------------------------- | :---------------------------------------------------------------------- |
|
||||
| Validated Models | LeNet |
|
||||
| Model Format | Network weights file (\*.bin) |
|
||||
| Validated images | The sample uses OpenCV\* to [read input grayscale image](https://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56) (\*.bmp, \*.png) or single-channel `ubyte` image |
|
||||
| Supported devices | [All](../../../docs/IE_DG/supported_plugins/Supported_Devices.md) |
|
||||
| Other language realization | [C++](../../../inference-engine/samples/ngraph_function_creation_sample/README.md) |
|
||||
|
||||
## How It Works
|
||||
|
||||
At startup, the sample application reads command-line parameters, prepares input data, creates a network using [nGraph function feature](../../../docs/nGraph_DG/build_function.md) and passed weights file, loads the network and image(s) to the Inference Engine plugin, performs synchronous inference, and processes output data, logging each step in a standard output stream.
|
||||
|
||||
You can see the explicit description of
|
||||
each sample step at [Integration Steps](../../../docs/IE_DG/Integrate_with_customer_application_new_API.md) section of "Integrate the Inference Engine with Your Application" guide.
|
||||
|
||||
## Running
|
||||
|
||||
Run the application with the `-h` option to see the usage message:
|
||||
|
||||
```
|
||||
python <path_to_sample>/ngraph_function_creation_sample.py -h
|
||||
```
|
||||
|
||||
Usage message:
|
||||
|
||||
```
|
||||
usage: ngraph_function_creation_sample.py [-h] -m MODEL -i INPUT [INPUT ...]
|
||||
[-d DEVICE] [--labels LABELS]
|
||||
[-nt NUMBER_TOP]
|
||||
|
||||
Options:
|
||||
-h, --help Show this help message and exit.
|
||||
-m MODEL, --model MODEL
|
||||
Required. Path to a file with network weights.
|
||||
-i INPUT [INPUT ...], --input INPUT [INPUT ...]
|
||||
Required. Path to an image file.
|
||||
-d DEVICE, --device DEVICE
|
||||
Optional. Specify the target device to infer on; CPU,
|
||||
GPU, MYRIAD, HDDL or HETERO: is acceptable. The sample
|
||||
will look for a suitable plugin for device specified.
|
||||
Default value is CPU.
|
||||
--labels LABELS Optional. Path to a labels mapping file.
|
||||
-nt NUMBER_TOP, --number_top NUMBER_TOP
|
||||
Optional. Number of top results.
|
||||
```
|
||||
|
||||
To run the sample, you need specify a model weights and image:
|
||||
|
||||
- you can use images from the media files collection available at https://storage.openvinotoolkit.org/data/test_data.
|
||||
|
||||
> **NOTE**:
|
||||
>
|
||||
> - This sample supports models with FP32 weights only.
|
||||
>
|
||||
> - The `lenet.bin` weights file was generated by the [Model Optimizer](../../../docs/MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md) tool from the public LeNet model with the `--input_shape [64,1,28,28]` parameter specified.
|
||||
>
|
||||
> - The original model is available in the [Caffe* repository](https://github.com/BVLC/caffe/tree/master/examples/mnist) on GitHub\*.
|
||||
>
|
||||
> - The white over black images will be automatically inverted in color for a better predictions.
|
||||
|
||||
For example, you can do inference of `3.png` using the pre-trained model on a `GPU`:
|
||||
|
||||
```
|
||||
python <path_to_sample>/ngraph_function_creation_sample.py -m <path_to_sample>/lenet.bin -i <path_to_image>/3.png -d GPU
|
||||
```
|
||||
|
||||
## Sample Output
|
||||
|
||||
The sample application logs each step in a standard output stream and outputs top-10 inference results.
|
||||
|
||||
```
|
||||
[ INFO ] Creating Inference Engine
|
||||
[ INFO ] Loading the network using ngraph function with weights from c:\openvino\samples\python\ngraph_function_creation_sample\lenet.bin
|
||||
[ INFO ] Configuring input and output blobs
|
||||
[ INFO ] Loading the model to the plugin
|
||||
[ WARNING ] Image c:\images\3.png is inverted to white over black
|
||||
[ WARNING ] Image c:\images\3.png is resized from (351, 353) to (28, 28)
|
||||
[ INFO ] Starting inference in synchronous mode
|
||||
[ INFO ] Image path: c:\images\3.png
|
||||
[ INFO ] Top 10 results:
|
||||
[ INFO ] classid probability
|
||||
[ INFO ] -------------------
|
||||
[ INFO ] 3 1.0000000
|
||||
[ INFO ] 9 0.0000000
|
||||
[ INFO ] 8 0.0000000
|
||||
[ INFO ] 7 0.0000000
|
||||
[ INFO ] 6 0.0000000
|
||||
[ INFO ] 5 0.0000000
|
||||
[ INFO ] 4 0.0000000
|
||||
[ INFO ] 2 0.0000000
|
||||
[ INFO ] 1 0.0000000
|
||||
[ INFO ] 0 0.0000000
|
||||
[ INFO ]
|
||||
[ INFO ] This sample is an API example, for any performance measurements please use the dedicated benchmark_app tool
|
||||
```
|
||||
|
||||
## Deprecation Notice
|
||||
|
||||
<table>
|
||||
<tr>
|
||||
<td><strong>Deprecation Begins</strong></td>
|
||||
<td>June 1, 2020</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><strong>Removal Date</strong></td>
|
||||
<td>December 1, 2020</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
*Starting with the OpenVINO™ toolkit 2020.2 release, all of the features previously available through nGraph have been merged into the OpenVINO™ toolkit. As a result, all the features previously available through ONNX RT Execution Provider for nGraph have been merged with ONNX RT Execution Provider for OpenVINO™ toolkit.*
|
||||
|
||||
*Therefore, ONNX RT Execution Provider for nGraph will be deprecated starting June 1, 2020 and will be completely removed on December 1, 2020. Users are recommended to migrate to the ONNX RT Execution Provider for OpenVINO™ toolkit as the unified solution for all AI inferencing on Intel® hardware.*
|
||||
|
||||
## See Also
|
||||
|
||||
- [Integrate the Inference Engine with Your Application](../../../docs/IE_DG/Integrate_with_customer_application_new_API.md)
|
||||
- [Using Inference Engine Samples](../../../docs/IE_DG/Samples_Overview.md)
|
||||
- [Model Downloader](@ref omz_tools_downloader)
|
||||
- [Model Optimizer](../../../docs/MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md)
|
||||
|
||||
[IECore]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1IECore.html
|
||||
[IENetwork]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1IENetwork.html
|
||||
[IENetwork.batch_size]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1IENetwork.html#a79a647cb1b49645616eaeb2ca255ef2e
|
||||
[IENetwork.input_info]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1IENetwork.html#data_fields
|
||||
[IENetwork.outputs]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1IENetwork.html#data_fields
|
||||
[InputInfoPtr.precision]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1InputInfoPtr.html#data_fields
|
||||
[DataPtr.precision]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1DataPtr.html#data_fields
|
||||
[IECore.load_network]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1IECore.html#ac9a2e043d14ccfa9c6bbf626cfd69fcc
|
||||
[InputInfoPtr.input_data.shape]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1InputInfoPtr.html#data_fields
|
||||
[ExecutableNetwork.infer]:https://docs.openvinotoolkit.org/latest/ie_python_api/classie__api_1_1ExecutableNetwork.html#aea96e8e534c8e23d8b257bad11063519
|
||||
|
||||
<!-- TODO: Replace the link by another one pointing to the Python API, if available -->
|
||||
[ngraph.impl.Function]:https://docs.openvinotoolkit.org/latest/ngraph_cpp_api/classngraph_1_1Function.html
|
||||
<!-- [ngraph.impl.Function.to_capsule]: -->
|
||||
[ngraph.parameter]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a709acd09288f5a76ed8d07492efc3d13
|
||||
[ngraph.constant]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a5b6c4e416026e007a4107b3f510d0c27
|
||||
[ngraph.convolution]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a3143ff55f68428afc1b6c802ee9381e8
|
||||
[ngraph.add]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#abfa0373c10ced1b1f129594d9bd8a159
|
||||
[ngraph.max_pool]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#ac60b4459ad23b296086925abce6acd2d
|
||||
[ngraph.reshape]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a38e1ead9435c4b75c1d891ba2dd6a62e
|
||||
[ngraph.matmul]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a403b5e10e1f75aeb7569024237e85071
|
||||
[ngraph.relu]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a70b9b3faf58d85e43d27fef5028117e3
|
||||
[ngraph.softmax]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a632cc9a31ecaefa2a982d039ecad8d26
|
||||
[ngraph.result]:https://docs.openvinotoolkit.org/latest/ngraph_python_api/namespacengraph_1_1opset1_1_1ops.html#a94f8bf6ab8910dfd461d09cb6c6edd11
|
||||
BIN
samples/python/ngraph_function_creation_sample/lenet.bin
Normal file
BIN
samples/python/ngraph_function_creation_sample/lenet.bin
Normal file
Binary file not shown.
@@ -0,0 +1,262 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright (C) 2018-2021 Intel Corporation
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
import argparse
|
||||
import logging as log
|
||||
import struct as st
|
||||
import sys
|
||||
import typing
|
||||
from functools import reduce
|
||||
|
||||
import cv2
|
||||
import ngraph
|
||||
from ngraph.opset1 import max_pool
|
||||
import numpy as np
|
||||
from openvino.inference_engine import IECore, IENetwork
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
"""Parse and return command line arguments"""
|
||||
parser = argparse.ArgumentParser(add_help=False)
|
||||
args = parser.add_argument_group('Options')
|
||||
# fmt: off
|
||||
args.add_argument('-h', '--help', action='help', help='Show this help message and exit.')
|
||||
args.add_argument('-m', '--model', required=True, type=str,
|
||||
help='Required. Path to a file with network weights.')
|
||||
args.add_argument('-i', '--input', required=True, type=str, nargs='+', help='Required. Path to an image file.')
|
||||
args.add_argument('-d', '--device', default='CPU', type=str,
|
||||
help='Optional. Specify the target device to infer on; CPU, GPU, MYRIAD, HDDL or HETERO: '
|
||||
'is acceptable. The sample will look for a suitable plugin for device specified. '
|
||||
'Default value is CPU.')
|
||||
args.add_argument('--labels', default=None, type=str, help='Optional. Path to a labels mapping file.')
|
||||
args.add_argument('-nt', '--number_top', default=10, type=int, help='Optional. Number of top results.')
|
||||
# fmt: on
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def read_image(image_path: str) -> np.ndarray:
|
||||
"""Read and return an image as grayscale (one channel)"""
|
||||
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
|
||||
|
||||
# Try to open image as ubyte
|
||||
if image is None:
|
||||
with open(image_path, 'rb') as f:
|
||||
st.unpack('>4B', f.read(4)) # need to skip 4 bytes
|
||||
nimg = st.unpack('>I', f.read(4))[0] # number of images
|
||||
nrow = st.unpack('>I', f.read(4))[0] # number of rows
|
||||
ncolumn = st.unpack('>I', f.read(4))[0] # number of column
|
||||
nbytes = nimg * nrow * ncolumn * 1 # each pixel data is 1 byte
|
||||
|
||||
if nimg != 1:
|
||||
raise Exception('Sample supports ubyte files with 1 image inside')
|
||||
|
||||
image = np.asarray(st.unpack('>' + 'B' * nbytes, f.read(nbytes))).reshape((nrow, ncolumn))
|
||||
|
||||
return image
|
||||
|
||||
|
||||
def create_ngraph_function(args: argparse.Namespace) -> ngraph.impl.Function:
|
||||
"""Create a network on the fly from the source code using ngraph"""
|
||||
|
||||
def shape_and_length(shape: list) -> typing.Tuple[list, int]:
|
||||
length = reduce(lambda x, y: x * y, shape)
|
||||
return shape, length
|
||||
|
||||
weights = np.fromfile(args.model, dtype=np.float32)
|
||||
weights_offset = 0
|
||||
padding_begin = padding_end = [0, 0]
|
||||
|
||||
# input
|
||||
input_shape = [64, 1, 28, 28]
|
||||
param_node = ngraph.parameter(input_shape, np.float32, 'Parameter')
|
||||
|
||||
# convolution 1
|
||||
conv_1_kernel_shape, conv_1_kernel_length = shape_and_length([20, 1, 5, 5])
|
||||
conv_1_kernel = ngraph.constant(weights[0:conv_1_kernel_length].reshape(conv_1_kernel_shape))
|
||||
weights_offset += conv_1_kernel_length
|
||||
conv_1_node = ngraph.convolution(param_node, conv_1_kernel, [1, 1], padding_begin, padding_end, [1, 1])
|
||||
|
||||
# add 1
|
||||
add_1_kernel_shape, add_1_kernel_length = shape_and_length([1, 20, 1, 1])
|
||||
add_1_kernel = ngraph.constant(
|
||||
weights[weights_offset : weights_offset + add_1_kernel_length].reshape(add_1_kernel_shape),
|
||||
)
|
||||
weights_offset += add_1_kernel_length
|
||||
add_1_node = ngraph.add(conv_1_node, add_1_kernel)
|
||||
|
||||
# maxpool 1
|
||||
maxpool_1_node = max_pool(add_1_node, [2, 2], padding_begin, padding_end, [2, 2], 'ceil')
|
||||
|
||||
# convolution 2
|
||||
conv_2_kernel_shape, conv_2_kernel_length = shape_and_length([50, 20, 5, 5])
|
||||
conv_2_kernel = ngraph.constant(
|
||||
weights[weights_offset : weights_offset + conv_2_kernel_length].reshape(conv_2_kernel_shape),
|
||||
)
|
||||
weights_offset += conv_2_kernel_length
|
||||
conv_2_node = ngraph.convolution(maxpool_1_node, conv_2_kernel, [1, 1], padding_begin, padding_end, [1, 1])
|
||||
|
||||
# add 2
|
||||
add_2_kernel_shape, add_2_kernel_length = shape_and_length([1, 50, 1, 1])
|
||||
add_2_kernel = ngraph.constant(
|
||||
weights[weights_offset : weights_offset + add_2_kernel_length].reshape(add_2_kernel_shape),
|
||||
)
|
||||
weights_offset += add_2_kernel_length
|
||||
add_2_node = ngraph.add(conv_2_node, add_2_kernel)
|
||||
|
||||
# maxpool 2
|
||||
maxpool_2_node = max_pool(add_2_node, [2, 2], padding_begin, padding_end, [2, 2], 'ceil')
|
||||
|
||||
# reshape 1
|
||||
reshape_1_dims, reshape_1_length = shape_and_length([2])
|
||||
# workaround to get int64 weights from float32 ndarray w/o unnecessary copying
|
||||
dtype_weights = np.frombuffer(
|
||||
weights[weights_offset : weights_offset + 2 * reshape_1_length],
|
||||
dtype=np.int64,
|
||||
)
|
||||
reshape_1_kernel = ngraph.constant(dtype_weights)
|
||||
weights_offset += 2 * reshape_1_length
|
||||
reshape_1_node = ngraph.reshape(maxpool_2_node, reshape_1_kernel, True)
|
||||
|
||||
# matmul 1
|
||||
matmul_1_kernel_shape, matmul_1_kernel_length = shape_and_length([500, 800])
|
||||
matmul_1_kernel = ngraph.constant(
|
||||
weights[weights_offset : weights_offset + matmul_1_kernel_length].reshape(matmul_1_kernel_shape),
|
||||
)
|
||||
weights_offset += matmul_1_kernel_length
|
||||
matmul_1_node = ngraph.matmul(reshape_1_node, matmul_1_kernel, False, True)
|
||||
|
||||
# add 3
|
||||
add_3_kernel_shape, add_3_kernel_length = shape_and_length([1, 500])
|
||||
add_3_kernel = ngraph.constant(
|
||||
weights[weights_offset : weights_offset + add_3_kernel_length].reshape(add_3_kernel_shape),
|
||||
)
|
||||
weights_offset += add_3_kernel_length
|
||||
add_3_node = ngraph.add(matmul_1_node, add_3_kernel)
|
||||
|
||||
# ReLU
|
||||
relu_node = ngraph.relu(add_3_node)
|
||||
|
||||
# reshape 2
|
||||
reshape_2_kernel = ngraph.constant(dtype_weights)
|
||||
reshape_2_node = ngraph.reshape(relu_node, reshape_2_kernel, True)
|
||||
|
||||
# matmul 2
|
||||
matmul_2_kernel_shape, matmul_2_kernel_length = shape_and_length([10, 500])
|
||||
matmul_2_kernel = ngraph.constant(
|
||||
weights[weights_offset : weights_offset + matmul_2_kernel_length].reshape(matmul_2_kernel_shape),
|
||||
)
|
||||
weights_offset += matmul_2_kernel_length
|
||||
matmul_2_node = ngraph.matmul(reshape_2_node, matmul_2_kernel, False, True)
|
||||
|
||||
# add 4
|
||||
add_4_kernel_shape, add_4_kernel_length = shape_and_length([1, 10])
|
||||
add_4_kernel = ngraph.constant(
|
||||
weights[weights_offset : weights_offset + add_4_kernel_length].reshape(add_4_kernel_shape),
|
||||
)
|
||||
weights_offset += add_4_kernel_length
|
||||
add_4_node = ngraph.add(matmul_2_node, add_4_kernel)
|
||||
|
||||
# softmax
|
||||
softmax_axis = 1
|
||||
softmax_node = ngraph.softmax(add_4_node, softmax_axis)
|
||||
|
||||
# result
|
||||
result_node = ngraph.result(softmax_node)
|
||||
return ngraph.impl.Function(result_node, [param_node], 'lenet')
|
||||
|
||||
|
||||
def main():
|
||||
log.basicConfig(format='[ %(levelname)s ] %(message)s', level=log.INFO, stream=sys.stdout)
|
||||
args = parse_args()
|
||||
|
||||
# ---------------------------Step 1. Initialize inference engine core--------------------------------------------------
|
||||
log.info('Creating Inference Engine')
|
||||
ie = IECore()
|
||||
|
||||
# ---------------------------Step 2. Read a model in OpenVINO Intermediate Representation------------------------------
|
||||
log.info(f'Loading the network using ngraph function with weights from {args.model}')
|
||||
ngraph_function = create_ngraph_function(args)
|
||||
net = IENetwork(ngraph.impl.Function.to_capsule(ngraph_function))
|
||||
|
||||
# ---------------------------Step 3. Configure input & output----------------------------------------------------------
|
||||
log.info('Configuring input and output blobs')
|
||||
# Get names of input and output blobs
|
||||
input_blob = next(iter(net.input_info))
|
||||
out_blob = next(iter(net.outputs))
|
||||
|
||||
# Set input and output precision manually
|
||||
net.input_info[input_blob].precision = 'U8'
|
||||
net.outputs[out_blob].precision = 'FP32'
|
||||
|
||||
# Set a batch size to a equal number of input images
|
||||
net.batch_size = len(args.input)
|
||||
|
||||
# ---------------------------Step 4. Loading model to the device-------------------------------------------------------
|
||||
log.info('Loading the model to the plugin')
|
||||
exec_net = ie.load_network(network=net, device_name=args.device)
|
||||
|
||||
# ---------------------------Step 5. Create infer request--------------------------------------------------------------
|
||||
# load_network() method of the IECore class with a specified number of requests (default 1) returns an ExecutableNetwork
|
||||
# instance which stores infer requests. So you already created Infer requests in the previous step.
|
||||
|
||||
# ---------------------------Step 6. Prepare input---------------------------------------------------------------------
|
||||
n, c, h, w = net.input_info[input_blob].input_data.shape
|
||||
input_data = np.ndarray(shape=(n, c, h, w))
|
||||
|
||||
for i in range(n):
|
||||
image = read_image(args.input[i])
|
||||
|
||||
light_pixel_count = np.count_nonzero(image > 127)
|
||||
dark_pixel_count = np.count_nonzero(image < 127)
|
||||
is_light_image = (light_pixel_count - dark_pixel_count) > 0
|
||||
|
||||
if is_light_image:
|
||||
log.warning(f'Image {args.input[i]} is inverted to white over black')
|
||||
image = cv2.bitwise_not(image)
|
||||
|
||||
if image.shape != (h, w):
|
||||
log.warning(f'Image {args.input[i]} is resized from {image.shape} to {(h, w)}')
|
||||
image = cv2.resize(image, (w, h))
|
||||
|
||||
input_data[i] = image
|
||||
|
||||
# ---------------------------Step 7. Do inference----------------------------------------------------------------------
|
||||
log.info('Starting inference in synchronous mode')
|
||||
res = exec_net.infer(inputs={input_blob: input_data})
|
||||
|
||||
# ---------------------------Step 8. Process output--------------------------------------------------------------------
|
||||
# Generate a label list
|
||||
if args.labels:
|
||||
with open(args.labels, 'r') as f:
|
||||
labels = [line.split(',')[0].strip() for line in f]
|
||||
|
||||
res = res[out_blob]
|
||||
|
||||
for i in range(n):
|
||||
probs = res[i]
|
||||
# Get an array of args.number_top class IDs in descending order of probability
|
||||
top_n_idexes = np.argsort(probs)[-args.number_top :][::-1]
|
||||
|
||||
header = 'classid probability'
|
||||
header = header + ' label' if args.labels else header
|
||||
|
||||
log.info(f'Image path: {args.input[i]}')
|
||||
log.info(f'Top {args.number_top} results: ')
|
||||
log.info(header)
|
||||
log.info('-' * len(header))
|
||||
|
||||
for class_id in top_n_idexes:
|
||||
probability_indent = ' ' * (len('classid') - len(str(class_id)) + 1)
|
||||
label_indent = ' ' * (len('probability') - 8) if args.labels else ''
|
||||
label = labels[class_id] if args.labels else ''
|
||||
log.info(f'{class_id}{probability_indent}{probs[class_id]:.7f}{label_indent}{label}')
|
||||
log.info('')
|
||||
|
||||
# ----------------------------------------------------------------------------------------------------------------------
|
||||
log.info('This sample is an API example, for any performance measurements please use the dedicated benchmark_app tool\n')
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user