Model API improvements (#2900)

* Added factory method

* Add configurable model parameters

* Fix warnings

* Factory improvement - only non-abstract wrappers are available

* Factory create object now

* Detection demo refactoring

* Segmentation demo - applied factory and config

* Fixes after rebase

* Add configurable parameters to Bert* models and Bert* demos

* Update deblurring wrapper and demo

* Add WrapperError

* Update configurable values error handling

* Add description for configurable values (some of them)

* Add WrapperError

* Fix remarks

* Fix errors

* Update HPE demo and models

* Fixes

* Add preload option to model's ctors

* Apply remarks

* Fix

* Fix

* Fix error with pose-estimation wrappers

* Update classification demo and wrapper

* Fix

Co-authored-by: Anzhella Pankratova <[email protected]>

Author: eizamaliev

demos/bert_named_entity_recognition_demo/python/bert_named_entity_recognition_demo.py

@@ -114,7 +114,7 @@ def main():
         serving_config = {"address": "localhost", "port": 9000}
         model_adapter = RemoteAdapter(args.model, serving_config)
 
-    model = BertNamedEntityRecognition(model_adapter, vocab, args.input_names)
+    model = BertNamedEntityRecognition(model_adapter, {'vocab': vocab, 'input_names': args.input_names})
     if max_sentence_length > model.max_length:
         model.reshape(max_sentence_length)
     model.log_layers_info()

demos/bert_question_answering_demo/python/bert_question_answering_demo.py

@@ -172,8 +172,14 @@ def main():
         serving_config = {"address": "localhost", "port": 9000}
         model_adapter = RemoteAdapter(args.model, serving_config)
 
-    model = BertQuestionAnswering(model_adapter, vocab, args.input_names, args.output_names,
-                                  args.max_answer_token_num, args.model_squad_ver)
+    config = {
+        'vocab': vocab,
+        'input_names': args.input_names,
+        'output_names': args.output_names,
+        'max_answer_token_num': args.max_answer_token_num,
+        'squad_ver': args.model_squad_ver
+    }
+    model = BertQuestionAnswering(model_adapter, config)
     if args.reshape:
         # find the closest multiple of 64, if it is smaller than current network's sequence length, do reshape
         new_length = min(model.max_length, int(np.ceil((len(c_tokens[0]) + args.max_question_token_num) / 64) * 64))

demos/bert_question_answering_embedding_demo/python/bert_question_answering_embedding_demo.py

@@ -172,7 +172,7 @@ def main():
     plugin_config = get_user_config(args.device, args.num_streams, args.num_threads)
     model_emb_adapter = OpenvinoAdapter(ie, args.model_emb, device=args.device, plugin_config=plugin_config,
                                         max_num_requests=args.num_infer_requests)
-    model_emb = BertEmbedding(model_emb_adapter, vocab, args.input_names_emb)
+    model_emb = BertEmbedding(model_emb_adapter, {'vocab': vocab, 'input_names': args.input_names_emb})
     model_emb.log_layers_info()
 
     # reshape BertEmbedding model to infer short questions and long contexts
@@ -189,8 +189,14 @@ def main():
     if args.model_qa:
         model_qa_adapter = OpenvinoAdapter(ie, args.model_qa, device=args.device, plugin_config=plugin_config,
                                            max_num_requests=args.num_infer_requests)
-        model_qa = BertQuestionAnswering(model_qa_adapter, vocab, args.input_names_qa, args.output_names_qa,
-                                         args.max_answer_token_num, args.model_qa_squad_ver)
+        config = {
+            'vocab': vocab,
+            'input_names': args.input_names_qa,
+            'output_names': args.output_names_qa,
+            'max_answer_token_num': args.max_answer_token_num,
+            'squad_ver': args.model_qa_squad_ver
+        }
+        model_qa = BertQuestionAnswering(model_qa_adapter, config)
         model_qa.log_layers_info()
         qa_pipeline = AsyncPipeline(model_qa)
 

demos/classification_demo/python/classification_demo.py

@@ -26,7 +26,7 @@
 sys.path.append(str(Path(__file__).resolve().parents[2] / 'common/python'))
 sys.path.append(str(Path(__file__).resolve().parents[2] / 'common/python/openvino/model_zoo'))
 
-from model_api import models
+from model_api.models import Classification, OutputTransform
 from model_api.performance_metrics import put_highlighted_text, PerformanceMetrics
 from model_api.pipelines import get_user_config, AsyncPipeline
 from model_api.adapters import create_core, OpenvinoAdapter, RemoteAdapter
@@ -55,7 +55,7 @@ def build_argparser():
                            'Default value is CPU.')
 
     common_model_args = parser.add_argument_group('Common model options')
-    common_model_args.add_argument('--labels', help='Optional. Labels mapping file.', default=None, type=Path)
+    common_model_args.add_argument('--labels', help='Optional. Labels mapping file.', default=None, type=str)
     common_model_args.add_argument('-topk', help='Optional. Number of top results. Default value is 5. Must be from 1 to 10.', default=5,
                                    type=int, choices=range(1, 11))
 
@@ -166,8 +166,14 @@ def main():
         serving_config = {"address": "localhost", "port": 9000}
         model_adapter = RemoteAdapter(args.model, serving_config)
 
-    model = models.Classification(model_adapter, topk=args.topk, labels=args.labels)
-    model.set_inputs_preprocessing(args.reverse_input_channels, args.mean_values, args.scale_values)
+    config = {
+        'mean_values':  args.mean_values,
+        'scale_values': args.scale_values,
+        'reverse_input_channels': args.reverse_input_channels,
+        'topk': args.topk,
+        'path_to_labels': args.labels
+    }
+    model = Classification(model_adapter, config)
     model.log_layers_info()
 
     async_pipeline = AsyncPipeline(model)
@@ -223,7 +229,7 @@ def main():
                     raise ValueError("Can't read an image from the input")
                 break
             if next_frame_id == 0:
-                output_transform = models.OutputTransform(frame.shape[:2], args.output_resolution)
+                output_transform = OutputTransform(frame.shape[:2], args.output_resolution)
                 if args.output_resolution:
                     output_resolution = output_transform.new_resolution
                 else:

demos/common/python/openvino/model_zoo/model_api/models/__init__.py

@@ -19,10 +19,13 @@
 from .centernet import CenterNet
 from .classification import Classification
 from .deblurring import Deblurring
+from .detection_model import DetectionModel
 from .detr import DETR
 from .ctpn import CTPN
 from .faceboxes import FaceBoxes
 from .hpe_associative_embedding import HpeAssociativeEmbedding
+from .image_model import ImageModel
+from .model import Model
 from .monodepth import MonoDepthModel
 from .open_pose import OpenPose
 from .retinaface import RetinaFace, RetinaFacePyTorch
@@ -39,12 +42,15 @@
     'CenterNet',
     'Classification',
     'CTPN',
-    'DetectionWithLandmarks',
     'Deblurring',
+    'DetectionModel',
+    'DetectionWithLandmarks',
     'DETR',
     'FaceBoxes',
     'HpeAssociativeEmbedding',
+    'ImageModel',
     'InputTransform',
+    'Model',
     'MonoDepthModel',
     'OpenPose',
     'OutputTransform',

demos/common/python/openvino/model_zoo/model_api/models/bert.py

@@ -13,21 +13,33 @@
 
 import numpy as np
 
-from .model import Model
+from .model import Model, WrapperError
+from .types import DictValue, NumericalValue, StringValue
 
 
 class Bert(Model):
-    def __init__(self, model_adapter, vocab, input_names):
-        super().__init__(model_adapter)
-        self.token_cls = [vocab['[CLS]']]
-        self.token_sep = [vocab['[SEP]']]
-        self.token_pad = [vocab['[PAD]']]
-        self.input_names = [i.strip() for i in input_names.split(',')]
+    __model__ = 'bert'
+
+    def __init__(self, model_adapter, configuration, preload=False):
+        super().__init__(model_adapter, configuration, preload)
+        self.token_cls = [self.vocab['[CLS]']]
+        self.token_sep = [self.vocab['[SEP]']]
+        self.token_pad = [self.vocab['[PAD]']]
+        self.input_names = [i.strip() for i in self.input_names.split(',')]
         if self.inputs.keys() != set(self.input_names):
-            raise RuntimeError('The Bert model expects input names: {}, actual network input names: {}'.format(
+            raise WrapperError(self.__model__, 'The Wrapper expects input names: {}, actual network input names: {}'.format(
                 self.input_names, list(self.inputs.keys())))
         self.max_length = self.inputs[self.input_names[0]].shape[1]
 
+    @classmethod
+    def parameters(cls):
+        parameters = super().parameters()
+        parameters.update({
+            'vocab': DictValue(),
+            'input_names': StringValue(description='Comma-separated names of input layers'),
+        })
+        return parameters
+
     def preprocess(self, inputs):
         input_ids, attention_mask, token_type_ids = self.form_request(inputs)
 
@@ -71,12 +83,13 @@ def reshape(self, new_length):
 
 
 class BertNamedEntityRecognition(Bert):
-    def __init__(self, model_adapter, vocab, input_names):
-        super().__init__(model_adapter, vocab, input_names)
+    __model__ = 'bert-named-entity-recognition'
+
+    def __init__(self, model_adapter, configuration, preload=False):
+        super().__init__(model_adapter, configuration, preload)
 
         self.output_names = list(self.outputs)
-        if len(self.output_names) != 1:
-            raise RuntimeError("The BertNamedEntityRecognition model wrapper supports only 1 output")
+        self._check_io_number(-1, 1)
 
     def form_request(self, inputs):
         c_tokens_id = inputs
@@ -99,12 +112,13 @@ def postprocess(self, outputs, meta):
 
 
 class BertEmbedding(Bert):
-    def __init__(self, model_adapter, vocab, input_names):
-        super().__init__(model_adapter, vocab, input_names)
+    __model__ = 'bert-embedding'
+
+    def __init__(self, model_adapter, configuration, preload=False):
+        super().__init__(model_adapter, configuration, preload)
 
         self.output_names = list(self.outputs)
-        if len(self.output_names) != 1:
-            raise RuntimeError("The BertEmbedding model wrapper supports only 1 output")
+        self._check_io_number(-1, 1)
 
     def form_request(self, inputs):
         tokens_id, self.max_length = inputs
@@ -119,17 +133,26 @@ def postprocess(self, outputs, meta):
 
 
 class BertQuestionAnswering(Bert):
-    def __init__(self, model_adapter, vocab, input_names, output_names,
-                 max_answer_token_num, squad_ver):
-        super().__init__(model_adapter, vocab, input_names)
+    __model__ = 'bert-question-answering'
 
-        self.max_answer_token_num = max_answer_token_num
-        self.squad_ver = squad_ver
-        self.output_names = [o.strip() for o in output_names.split(',')]
+    def __init__(self, model_adapter, configuration, preload=False):
+        super().__init__(model_adapter, configuration, preload)
+
+        self.output_names = [o.strip() for o in self.output_names.split(',')]
         if self.outputs.keys() != set(self.output_names):
-            raise RuntimeError('The BertQuestionAnswering model output names: {}, actual network output names: {}'.format(
+            raise WrapperError(self.__model__, 'The Wrapper output names: {}, actual network output names: {}'.format(
                 self.output_names, list(self.outputs.keys())))
 
+    @classmethod
+    def parameters(cls):
+        parameters = super().parameters()
+        parameters.update({
+            'output_names': StringValue(description='Comma-separated names of output layers'),
+            'max_answer_token_num': NumericalValue(value_type=int),
+            'squad_ver': StringValue(),
+        })
+        return parameters
+
     def form_request(self, inputs):
         c_data, q_tokens_id = inputs
         input_ids = self.token_cls + q_tokens_id + self.token_sep + c_data.c_tokens_id + self.token_sep

demos/common/python/openvino/model_zoo/model_api/models/centernet.py

@@ -23,15 +23,19 @@
 
 
 class CenterNet(DetectionModel):
-    def __init__(self, model_adapter, resize_type=None,
-                 labels=None, threshold=0.5, iou_threshold=0.5):
-        if not resize_type:
-            resize_type = 'standard'
-        super().__init__(model_adapter, resize_type=resize_type,
-                         labels=labels, threshold=threshold, iou_threshold=iou_threshold)
+    __model__ = 'centernet'
+
+    def __init__(self, model_adapter, configuration=None, preload=False):
+        super().__init__(model_adapter, configuration, preload)
         self._check_io_number(1, 3)
         self._output_layer_names = sorted(self.outputs)
 
+    @classmethod
+    def parameters(cls):
+        parameters = super().parameters()
+        parameters['resize_type'].update_default_value('standard')
+        return parameters
+
     def postprocess(self, outputs, meta):
         heat = outputs[self._output_layer_names[0]][0]
         reg = outputs[self._output_layer_names[1]][0]

demos/common/python/openvino/model_zoo/model_api/models/classification.py

@@ -15,20 +15,19 @@
 """
 
 import numpy as np
+
+from .types import NumericalValue, ListValue, StringValue
 from .utils import softmax
 
 from .image_model import ImageModel
 
 
 class Classification(ImageModel):
-    def __init__(self, model_adapter, topk = 1, labels = None, resize_type='crop'):
-        super().__init__(model_adapter, resize_type=resize_type)
+    def __init__(self, model_adapter, configuration=None, preload=False):
+        super().__init__(model_adapter, configuration, preload)
         self._check_io_number(1, 1)
-        self.topk = topk
-        if isinstance(labels, (list, tuple)):
-            self.labels = labels
-        else:
-            self.labels = self._load_labels(labels) if labels else None
+        if self.path_to_labels:
+            self.labels = self._load_labels(self.path_to_labels)
         self.out_layer_name = self._get_outputs()
 
     @staticmethod
@@ -61,6 +60,19 @@ def _get_outputs(self):
                                 'labels must match ({} != {})'.format(layer_shape[1], len(self.labels)))
         return layer_name
 
+    @classmethod
+    def parameters(cls):
+        parameters = super().parameters()
+        parameters['resize_type'].update_default_value('crop')
+        parameters.update({
+            'topk': NumericalValue(value_type=int, default_value=1, min=1),
+            'labels': ListValue(description="List of class labels"),
+            'path_to_labels': StringValue(
+                description="Path to file with labels. Overrides the labels, if they sets via 'labels' parameter"
+            ),
+        })
+        return parameters
+
     def postprocess(self, outputs, meta):
         outputs = outputs[self.out_layer_name].squeeze()
         indices = np.argpartition(outputs, -self.topk)[-self.topk:]

demos/common/python/openvino/model_zoo/model_api/models/ctpn.py

@@ -17,14 +17,17 @@
 import cv2
 import numpy as np
 
+from .model import WrapperError
 from .detection_model import DetectionModel
+from .types import ListValue, NumericalValue
 from .utils import Detection, nms, clip_detections
 
 
 class CTPN(DetectionModel):
-    def __init__(self, model_adapter, input_size, threshold=0.9, iou_threshold=0.5):
-        super().__init__(model_adapter, labels=['Text'],
-                         threshold=threshold, iou_threshold=iou_threshold)
+    __model__ = 'CTPN'
+
+    def __init__(self, model_adapter, configuration=None, preload=False):
+        super().__init__(model_adapter, configuration, False)
         self._check_io_number(1, 2)
         self.bboxes_blob_name, self.scores_blob_name = self._get_outputs()
 
@@ -48,24 +51,37 @@ def __init__(self, model_adapter, input_size, threshold=0.9, iou_threshold=0.5):
             [0, -134, 15, 149]
         ])
 
-        self.h1, self.w1 = self.ctpn_keep_aspect_ratio(1200, 600, input_size[1], input_size[0])
+        self.h1, self.w1 = self.ctpn_keep_aspect_ratio(1200, 600, self.input_size[1], self.input_size[0])
         self.h2, self.w2 = self.ctpn_keep_aspect_ratio(600, 600, self.w1, self.h1)
         default_input_shape = self.inputs[self.image_blob_name].shape
         input_shape = {self.image_blob_name: (default_input_shape[:-2] + [self.h2, self.w2])}
         self.logger.debug('\tReshape model from {} to {}'.format(default_input_shape, input_shape[self.image_blob_name]))
         self.reshape(input_shape)
+        if preload:
+            self.load()
 
     def _get_outputs(self):
         (boxes_name, boxes_data_repr), (scores_name, scores_data_repr) = self.outputs.items()
 
         if len(boxes_data_repr.shape) != 4 or len(scores_data_repr.shape) != 4:
-            raise RuntimeError("Unexpected output blob shape. Only 4D output blobs are supported")
+            raise WrapperError(self.__model__, "Unexpected output blob shape. Only 4D output blobs are supported")
 
         if scores_data_repr.shape[1] == boxes_data_repr.shape[1] * 2:
             return scores_name, boxes_name
         if boxes_data_repr.shape[1] == scores_data_repr.shape[1] * 2:
             return boxes_name, scores_name
-        raise RuntimeError("One of outputs must be two times larger than another for the CTPN topology")
+        raise WrapperError(self.__model__, "One of outputs must be two times larger than another")
+
+    @classmethod
+    def parameters(cls):
+        parameters = super().parameters()
+        parameters.update({
+            'iou_threshold': NumericalValue(default_value=0.5, description="Threshold for NMS filtering"),
+            'input_size': ListValue()
+        })
+        parameters['threshold'].update_default_value(0.9)
+        parameters['labels'].update_default_value(['Text'])
+        return parameters
 
     def preprocess(self, inputs):
         meta = {'original_shape': inputs.shape}