Merge branch 'openvinotoolkit:master' into master

Author: ieliz

CONTRIBUTING.md

@@ -6,6 +6,7 @@ Frameworks supported by the Open Model Zoo:
 * Caffe\*
 * TensorFlow\*
 * PyTorch\* (via conversion to ONNX\*)
+* PaddlePaddle\*
 * MXNet\*
 
 Open Model Zoo also supports models already in the ONNX format.

ci/dependencies.yml

@@ -1,2 +1,4 @@
-openvino_linux: '2021.4.752'
-openvino_windows: '2021.4.752'
+openvino_linux: '2022.1.0.518'
+openvino_windows: '2022.1.0.518'
+wheel_linux: '2022.1.0.dev20220117-6152'
+wheel_windows: '2022.1.0.dev20220117-6152'

ci/requirements-conversion.txt

@@ -4,6 +4,8 @@ absl-py==0.13.0
     # via
     #   tensorboard
     #   tensorflow
+astor==0.8.1
+    # via paddlepaddle
 astunparse==1.6.3
     # via tensorflow
 cachetools==4.2.2
@@ -85,6 +87,9 @@ onnx==1.10.1
     #   -r tools/model_tools/requirements-pytorch.in
 opt-einsum==3.3.0
     # via tensorflow
+paddlepaddle==2.1.3
+    # via
+    #   -r tools/model_tools/requirements-paddle.in
 pillow==8.3.2
     # via torchvision
 protobuf==3.17.3

ci/update-requirements.py

@@ -87,7 +87,7 @@ def pc(target, *sources):
     pc('ci/requirements-check-basics.txt',
        'ci/requirements-check-basics.in', 'ci/requirements-documentation.in')
     pc('ci/requirements-conversion.txt',
-        *(f'tools/model_tools/requirements-{suffix}.in' for suffix in ['pytorch', 'tensorflow']),
+        *(f'tools/model_tools/requirements-{suffix}.in' for suffix in ['paddle', 'pytorch', 'tensorflow']),
         *(openvino_dir / f'deployment_tools/model_optimizer/requirements_{suffix}.txt'
             for suffix in ['caffe', 'mxnet', 'onnx', 'tf2']))
     pc('ci/requirements-demos.txt',

demos/action_recognition_demo/python/README.md

@@ -75,7 +75,7 @@ usage: action_recognition_demo.py [-h] -i INPUT [--loop] [-o OUTPUT]
                                   [-limit OUTPUT_LIMIT] -at
                                   {en-de,en-mean,i3d-rgb} -m_en M_ENCODER
                                   [-m_de M_DECODER | --seq DECODER_SEQ_SIZE]
-                                  [-l CPU_EXTENSION] [-d DEVICE] [-lb LABELS]
+                                  [-d DEVICE] [-lb LABELS]
                                   [--no_show] [-s LABEL_SMOOTHING]
                                   [-u UTILIZATION_MONITORS]
                                   [-r RAW_OUTPUT_MESSAGE]
@@ -101,9 +101,6 @@ Options:
   --seq DECODER_SEQ_SIZE
                         Optional. Length of sequence that decoder takes as
                         input.
-  -l CPU_EXTENSION, --cpu_extension CPU_EXTENSION
-                        Optional. For CPU custom layers, if any. Absolute path
-                        to a shared library with the kernels implementation.
   -d DEVICE, --device DEVICE
                         Optional. Specify a target device to infer on. CPU,
                         GPU, HDDL or MYRIAD is acceptable. The demo will

demos/action_recognition_demo/python/action_recognition_demo.py

@@ -20,7 +20,7 @@
 from argparse import ArgumentParser, SUPPRESS
 from os import path
 
-from openvino.inference_engine import IECore, get_version
+from openvino.runtime import Core, get_version
 
 from action_recognition_demo.models import IEModel, DummyDecoder
 from action_recognition_demo.result_renderer import ResultRenderer
@@ -57,9 +57,6 @@ def build_argparser():
     decoder_args.add_argument('--seq', dest='decoder_seq_size',
                               help='Optional. Length of sequence that decoder takes as input.',
                               default=16, type=int)
-    args.add_argument('-l', '--cpu_extension',
-                      help='Optional. For CPU custom layers, if any. Absolute path to a shared library with the '
-                           'kernels implementation.', type=str, default=None)
     args.add_argument('-d', '--device',
                       help='Optional. Specify a target device to infer on. CPU, GPU, HDDL or MYRIAD is '
                            'acceptable. The demo will look for a suitable plugin for the device specified. '
@@ -88,34 +85,31 @@ def main():
 
     log.info('OpenVINO Inference Engine')
     log.info('\tbuild: {}'.format(get_version()))
-    ie = IECore()
+    core = Core()
 
     if 'MYRIAD' in args.device:
         myriad_config = {'VPU_HW_STAGES_OPTIMIZATION': 'YES'}
-        ie.set_config(myriad_config, 'MYRIAD')
-
-    if args.cpu_extension and 'CPU' in args.device:
-        ie.add_extension(args.cpu_extension, 'CPU')
+        core.set_config(myriad_config, 'MYRIAD')
 
     decoder_target_device = 'CPU'
     if args.device != 'CPU':
         encoder_target_device = args.device
     else:
         encoder_target_device = decoder_target_device
 
-    models = [IEModel(args.m_encoder, ie, encoder_target_device, model_type='Action Recognition Encoder',
+    models = [IEModel(args.m_encoder, core, encoder_target_device, model_type='Action Recognition Encoder',
                       num_requests=(3 if args.device == 'MYRIAD' else 1))]
 
     if args.architecture_type == 'en-de':
         if args.m_decoder is None:
             raise RuntimeError('No decoder for encoder-decoder model type (-m_de) provided')
-        models.append(IEModel(args.m_decoder, ie, decoder_target_device, model_type='Action Recognition Decoder', num_requests=2))
-        seq_size = models[1].input_size[1]
+        models.append(IEModel(args.m_decoder, core, decoder_target_device, model_type='Action Recognition Decoder', num_requests=2))
+        seq_size = models[1].input_shape[1]
     elif args.architecture_type == 'en-mean':
         models.append(DummyDecoder(num_requests=2))
         seq_size = args.decoder_seq_size
     elif args.architecture_type == 'i3d-rgb':
-        seq_size = models[0].input_size[2]
+        seq_size = models[0].input_shape[1]
 
     presenter = monitors.Presenter(args.utilization_monitors, 70)
     result_presenter = ResultRenderer(no_show=args.no_show, presenter=presenter, output=args.output, limit=args.output_limit, labels=labels,

demos/action_recognition_demo/python/action_recognition_demo/models.py

@@ -16,6 +16,7 @@
 
 from collections import deque
 from itertools import cycle
+import sys
 
 import logging as log
 import cv2
@@ -42,19 +43,20 @@ def adaptive_resize(frame, dst_size):
         return frame
     return cv2.resize(frame, (ow, oh))
 
-def preprocess_frame(frame, size=224, crop_size=224):
+
+def preprocess_frame(frame, size=224, crop_size=224, chw_layout=True):
     frame = adaptive_resize(frame, size)
     frame = center_crop(frame, (crop_size, crop_size))
-    frame = frame.transpose((2, 0, 1))  # HWC -> CHW
+    if chw_layout:
+        frame = frame.transpose((2, 0, 1))  # HWC -> CHW
 
     return frame
 
 
 class AsyncWrapper:
     def __init__(self, ie_model, num_requests):
-        self.net = ie_model
+        self.model = ie_model
         self.num_requests = num_requests
-
         self._result_ready = False
         self._req_ids = cycle(range(num_requests))
         self._result_ids = cycle(range(num_requests))
@@ -63,7 +65,7 @@ def __init__(self, ie_model, num_requests):
     def infer(self, model_input, frame=None):
         """Schedule current model input to infer, return last result"""
         next_req_id = next(self._req_ids)
-        self.net.async_infer(model_input, next_req_id)
+        self.model.async_infer(model_input, next_req_id)
 
         last_frame = self._frames[0] if self._frames else frame
 
@@ -73,41 +75,39 @@ def infer(self, model_input, frame=None):
 
         if self._result_ready:
             result_req_id = next(self._result_ids)
-            result = self.net.wait_request(result_req_id)
+            result = self.model.wait_request(result_req_id)
             return result, last_frame
         else:
             return None, None
 
 
 class IEModel:
-    def __init__(self, model_path, ie_core, target_device, num_requests, model_type, batch_size=1):
+    def __init__(self, model_path, core, target_device, num_requests, model_type):
         log.info('Reading {} model {}'.format(model_type, model_path))
-        self.net = ie_core.read_network(model_path)
-        self.net.batch_size = batch_size
-        assert len(self.net.input_info) == 1, "One input is expected"
-        assert len(self.net.outputs) == 1, "One output is expected"
-
-        self.exec_net = ie_core.load_network(network=self.net, device_name=target_device, num_requests=num_requests)
-        self.input_name = next(iter(self.net.input_info))
-        self.output_name = next(iter(self.net.outputs))
-        self.input_size = self.net.input_info[self.input_name].input_data.shape
-        self.output_size = self.exec_net.requests[0].output_blobs[self.output_name].buffer.shape
+        self.model = core.read_model(model_path)
+        if len(self.model.inputs) != 1:
+            log.error("Demo supports only models with 1 input")
+            sys.exit(1)
+
+        if len(self.model.outputs) != 1:
+            log.error("Demo supports only models with 1 output")
+            sys.exit(1)
+
+        self.compiled_model = core.compile_model(self.model, target_device)
+        self.input_name = self.model.inputs[0].get_any_name()
+        self.input_shape = self.model.inputs[0].shape
+
         self.num_requests = num_requests
+        self.infer_requests = [self.compiled_model.create_infer_request() for _ in range(self.num_requests)]
         log.info('The {} model {} is loaded to {}'.format(model_type, model_path, target_device))
 
-    def infer(self, frame):
-        input_data = {self.input_name: frame}
-        infer_result = self.exec_net.infer(input_data)
-        return infer_result[self.output_name]
-
     def async_infer(self, frame, req_id):
         input_data = {self.input_name: frame}
-        self.exec_net.start_async(request_id=req_id, inputs=input_data)
-        pass
+        self.infer_requests[req_id].start_async(inputs=input_data)
 
     def wait_request(self, req_id):
-        self.exec_net.requests[req_id].wait()
-        return self.exec_net.requests[req_id].output_blobs[self.output_name].buffer
+        self.infer_requests[req_id].wait()
+        return next(iter(self.infer_requests[req_id].results.values()))
 
 
 class DummyDecoder:
@@ -122,21 +122,6 @@ def _average(model_input):
     def async_infer(self, model_input, req_id):
         self.requests[req_id] = self._average(model_input)
 
-    def infer(self, model_input):
-        return self._average(model_input)
-
     def wait_request(self, req_id):
         assert req_id in self.requests
         return self.requests.pop(req_id)
-
-
-class ActionRecognitionSequential:
-    def __init__(self, encoder, decoder=None):
-        self.encoder = encoder
-        self.decoder = decoder
-
-    def infer(self, input):
-        if self.decoder is not None:
-            embeddigns = self.encoder.infer(input[0])
-            decoder_input = embeddigns.reshape(1, 16, 512)
-            return self.decoder.infer(decoder_input)

demos/action_recognition_demo/python/action_recognition_demo/steps.py

@@ -43,8 +43,13 @@ def run_pipeline(capture, model_type, model, render_fn, raw_output, seq_size=16,
     pipeline.print_statistics()
 
 
-class I3DRGBModelStep(PipelineStep):
+def softmax(x, axis=None):
+    """Normalizes logits to get confidence values along specified axis"""
+    exp = np.exp(x)
+    return exp / np.sum(exp, axis=axis)
+
 
+class I3DRGBModelStep(PipelineStep):
     def __init__(self, model, sequence_size, frame_size, crop_size):
         super().__init__()
         self.model = model
@@ -57,11 +62,10 @@ def __init__(self, model, sequence_size, frame_size, crop_size):
 
     def process(self, frame):
         preprocessed = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        preprocessed = preprocess_frame(preprocessed, self.size, self.crop_size)
+        preprocessed = preprocess_frame(preprocessed, self.size, self.crop_size, chw_layout=False)
         self.input_seq.append(preprocessed)
         if len(self.input_seq) == self.sequence_size:
             input_blob = np.array(self.input_seq)
-            input_blob = np.transpose(input_blob, (1, 0, 2, 3))
             input_blob = np.expand_dims(input_blob, axis=0)
             output, next_frame = self.async_model.infer(input_blob, frame)
 
@@ -74,7 +78,6 @@ def process(self, frame):
 
 
 class DataStep(PipelineStep):
-
     def __init__(self, capture):
         super().__init__()
         self.cap = capture
@@ -93,7 +96,6 @@ def end(self):
 
 
 class EncoderStep(PipelineStep):
-
     def __init__(self, encoder):
         super().__init__()
         self.encoder = encoder
@@ -111,7 +113,6 @@ def process(self, frame):
 
 
 class DecoderStep(PipelineStep):
-
     def __init__(self, decoder, sequence_size=16):
         super().__init__()
         assert sequence_size > 0
@@ -143,10 +144,6 @@ def process(self, item):
         return frame, None, timers
 
 
-def softmax(x, axis=None):
-    """Normalizes logits to get confidence values along specified axis"""
-    exp = np.exp(x)
-    return exp / np.sum(exp, axis=axis)
 
 
 class RenderStep(PipelineStep):

demos/colorization_demo/python/colorization_demo.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
- Copyright (c) 2018-2020 Intel Corporation
+ Copyright (c) 2018-2021 Intel Corporation
 
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
  limitations under the License.
 """
 
-from openvino.inference_engine import IECore, get_version
+from openvino.runtime import Core, get_version
 import cv2 as cv
 import numpy as np
 import logging as log
@@ -60,33 +60,28 @@ def build_arg():
                          help="Optional. List of monitors to show initially.")
     return parser
 
-
-if __name__ == '__main__':
-    args = build_arg().parse_args()
-
+def main(args):
     cap = open_images_capture(args.input, args.loop)
 
     log.info('OpenVINO Inference Engine')
     log.info('\tbuild: {}'.format(get_version()))
-    ie = IECore()
+    core = Core()
 
     log.info('Reading model {}'.format(args.model))
-    load_net = ie.read_network(args.model, args.model.with_suffix(".bin"))
-    load_net.batch_size = 1
+    model = core.read_model(args.model, args.model.with_suffix(".bin"))
 
-    input_blob = next(iter(load_net.input_info))
-    input_shape = load_net.input_info[input_blob].input_data.shape
+    input_tensor_name = 'data_l'
+    input_shape = model.input(input_tensor_name).shape
     assert input_shape[1] == 1, "Expected model input shape with 1 channel"
 
     inputs = {}
-    for input_name in load_net.input_info:
-        inputs[input_name] = np.zeros(load_net.input_info[input_name].input_data.shape)
+    for input in model.inputs:
+        inputs[input.get_any_name()] = np.zeros(input.shape)
 
-    assert len(load_net.outputs) == 1, "Expected number of outputs is equal 1"
-    output_blob = next(iter(load_net.outputs))
-    output_shape = load_net.outputs[output_blob].shape
+    assert len(model.outputs) == 1, "Expected number of outputs is equal 1"
 
-    exec_net = ie.load_network(network=load_net, device_name=args.device)
+    compiled_model = core.compile_model(model, device_name=args.device)
+    infer_request = compiled_model.create_infer_request()
     log.info('The model {} is loaded to {}'.format(args.model, args.device))
 
     _, _, h_in, w_in = input_shape
@@ -118,11 +113,12 @@ def build_arg():
         img_rgb = frame.astype(np.float32) / 255
         img_lab = cv.cvtColor(img_rgb, cv.COLOR_RGB2Lab)
         img_l_rs = cv.resize(img_lab.copy(), (w_in, h_in))[:, :, 0]
-        inputs[input_blob] = img_l_rs
 
-        res = exec_net.infer(inputs=inputs)
+        inputs[input_tensor_name] = np.expand_dims(img_l_rs, axis=[0, 1])
 
-        update_res = np.squeeze(res[output_blob])
+        res = next(iter(infer_request.infer(inputs).values()))
+
+        update_res = np.squeeze(res)
 
         out = update_res.transpose((1, 2, 0))
         out = cv.resize(out, (w_orig, h_orig))
@@ -166,3 +162,7 @@ def build_arg():
     metrics.log_total()
     for rep in presenter.reportMeans():
         log.info(rep)
+
+if __name__ == "__main__":
+    args = build_arg().parse_args()
+    sys.exit(main(args) or 0)