use model_path name everywhere

Author: anzhella-pankratova

demos/face_recognition_demo/python/ie_module.py

@@ -19,12 +19,12 @@
 
 
 class Module:
-    def __init__(self, core, model, model_type):
+    def __init__(self, core, model_path, model_type):
         self.core = core
         self.model_type = model_type
-        log.info('Reading {} model {}'.format(model_type, model))
-        self.model = core.read_model(model)
-        self.model_path = model
+        log.info('Reading {} model {}'.format(model_type, model_path))
+        self.model = core.read_model(model_path)
+        self.model_path = model_path
         self.active_requests = 0
         self.clear()
 

demos/formula_recognition_demo/python/utils.py

@@ -120,9 +120,9 @@ def prerocess_crop(crop, tgt_shape, preprocess_type='crop'):
     return preprocess_image(PREPROCESSING[preprocess_type], bin_crop, tgt_shape)
 
 
-def read_net(model_xml, ie, model_type):
-    log.info('Reading {} model {}'.format(model_type, model_xml))
-    return ie.read_model(model_xml)
+def read_net(model_path, ie, model_type):
+    log.info('Reading {} model {}'.format(model_type, model_path))
+    return ie.read_model(model_path)
 
 
 def change_layout(model_input):

demos/gpt2_text_prediction_demo/python/gpt2_text_prediction_demo.py

@@ -79,9 +79,8 @@ def main():
     ie = Core()
 
     # read IR
-    model_path = args.model
     log.info('Reading model {}'.format(args.model))
-    model = ie.read_model(model_path)
+    model = ie.read_model(args.model)
 
     # check number inputs and outputs
     if len(model.inputs) != 1:

demos/image_translation_demo/python/image_translation_demo/models.py

@@ -12,8 +12,8 @@
 """
 
 class CocosnetModel:
-    def __init__(self, core, model_xml, device='CPU'):
-        model = core.read_model(model_xml)
+    def __init__(self, core, model_path, device='CPU'):
+        model = core.read_model(model_path)
         if len(model.inputs) != 3:
             raise RuntimeError("The CocosnetModel expects 3 input layers")
         if len(model.outputs) != 1:
@@ -38,8 +38,8 @@ def infer(self, input_semantics, reference_image, reference_semantics):
 
 
 class SegmentationModel:
-    def __init__(self, core, model_xml, device='CPU'):
-        model = core.read_model(model_xml)
+    def __init__(self, core, model_path, device='CPU'):
+        model = core.read_model(model_path)
         if len(model.inputs) != 1:
             raise RuntimeError("The SegmentationModel expects 1 input layer")
         if len(model.outputs) != 1:

demos/machine_translation_demo/python/machine_translation_demo.py

@@ -30,13 +30,12 @@ class Translator:
     """ Language translation.
 
     Arguments:
-        model_xml (str): path to model's .xml file.
-        model_bin (str): path to model's .bin file.
+        model_path (str): path to model's .xml file.
         tokenizer_src (str): path to src tokenizer.
         tokenizer_tgt (str): path to tgt tokenizer.
     """
-    def __init__(self, model_xml, device, tokenizer_src, tokenizer_tgt, output_name):
-        self.engine = TranslationEngine(model_xml, device, output_name)
+    def __init__(self, model_path, device, tokenizer_src, tokenizer_tgt, output_name):
+        self.engine = TranslationEngine(model_path, device, output_name)
         self.max_tokens = self.engine.get_max_tokens()
         self.tokenizer_src = Tokenizer(tokenizer_src, self.max_tokens)
         log.debug('Loaded src tokenizer, max tokens: {}'.format(self.max_tokens))
@@ -65,19 +64,19 @@ class TranslationEngine:
     """ OpenVINO engine for machine translation.
 
     Arguments:
-        model_xml (str): path to model's .xml file.
+        model_path (str): path to model's .xml file.
         output_name (str): name of output blob of model.
     """
-    def __init__(self, model_xml, device, output_name):
+    def __init__(self, model_path, device, output_name):
         log.info('OpenVINO Inference Engine')
         log.info('\tbuild: {}'.format(get_version()))
         core = Core()
 
-        log.info('Reading model {}'.format(model_xml))
-        self.model = core.read_model(model_xml)
+        log.info('Reading model {}'.format(model_path))
+        self.model = core.read_model(model_path)
         compiled_model = core.compile_model(self.model, args.device)
         self.infer_request = compiled_model.create_infer_request()
-        log.info('The model {} is loaded to {}'.format(model_xml, device))
+        log.info('The model {} is loaded to {}'.format(model_path, device))
         self.input_tensor_name = "tokens"
         self.output_tensor_name = output_name
         self.model.output(self.output_tensor_name) # ensure a tensor with the name exists
@@ -216,7 +215,7 @@ def parse_input(input):
 
 def main(args):
     model = Translator(
-        model_xml=args.model,
+        model_path=args.model,
         device=args.device,
         tokenizer_src=args.tokenizer_src,
         tokenizer_tgt=args.tokenizer_tgt,

demos/multi_camera_multi_target_tracking_demo/python/utils/ie_tools.py

@@ -57,14 +57,14 @@ def get_input_shape(self):
         """Returns an input shape of the wrapped IE model"""
         return self.model.inputs[0].shape
 
-    def load_model(self, core, model_xml, device, model_type, num_reqs=1, cpu_extension=''):
+    def load_model(self, core, model_path, device, model_type, num_reqs=1, cpu_extension=''):
         """Loads a model in the Inference Engine format"""
         # Plugin initialization for specified device and load extensions library if specified
         if cpu_extension and 'CPU' in device:
             core.add_extension(cpu_extension, 'CPU')
         # Read IR
-        log.info('Reading {} model {}'.format(model_type, model_xml))
-        self.model = core.read_model(model_xml)
+        log.info('Reading {} model {}'.format(model_type, model_path))
+        self.model = core.read_model(model_path)
 
         if len(self.model.inputs) not in self.get_allowed_inputs_len():
             raise RuntimeError("Supports topologies with only {} inputs, but got {}"
@@ -79,4 +79,4 @@ def load_model(self, core, model_xml, device, model_type, num_reqs=1, cpu_extens
         compiled_model = core.compile_model(self.model, device)
         self.infer_queue = AsyncInferQueue(compiled_model, num_reqs)
         self.infer_queue.set_callback(self.completion_callback)
-        log.info('The {} model {} is loaded to {}'.format(model_type, model_xml, device))
+        log.info('The {} model {} is loaded to {}'.format(model_type, model_path, device))

demos/single_human_pose_estimation_demo/python/detector.py

@@ -2,11 +2,11 @@
 
 
 class Detector:
-    def __init__(self, core, path_to_model_xml, label_class, thr=0.3, device='CPU'):
+    def __init__(self, core, model_path, label_class, thr=0.3, device='CPU'):
         self.thr = thr
         self.label_class = label_class
 
-        self.model = core.read_model(path_to_model_xml)
+        self.model = core.read_model(model_path)
         if len(self.model.inputs) != 1:
             raise RuntimeError("Detector supports only models with 1 input layer")
         if len(self.model.outputs) != 1:

demos/single_human_pose_estimation_demo/python/estimator.py

@@ -82,8 +82,8 @@ def get_trasformation_matrix(center, scale, output_size):
 
 
 class HumanPoseEstimator:
-    def __init__(self, core, path_to_model_xml, device='CPU'):
-        self.model = core.read_model(path_to_model_xml)
+    def __init__(self, core, model_path, device='CPU'):
+        self.model = core.read_model(model_path)
         if len(self.model.inputs) != 1:
             raise RuntimeError("HumanPoseEstimator supports only models with 1 input layer")
         if len(self.model.outputs) != 1:

demos/time_series_forecasting_demo/python/time_series_forecasting_demo.py

@@ -30,20 +30,20 @@ class ForecastingEngine:
     """ OpenVINO engine for Time Series Forecasting.
 
     Arguments:
-        model_xml (str): path to model's .xml file.
+        model_path (str): path to model's .xml file.
         input_name (str): name of input blob of model.
         output_name (str): name of output blob of model.
     """
-    def __init__(self, model_xml, input_name, output_name, quantiles):
+    def __init__(self, model_path, input_name, output_name, quantiles):
         device = "CPU"
         log.info('OpenVINO Inference Engine')
         log.info('\tbuild: {}'.format(get_version()))
         core = Core()
-        log.info('Reading model {}'.format(model_xml))
-        model = core.read_model(model_xml)
+        log.info('Reading model {}'.format(model_path))
+        model = core.read_model(model_path)
         compiled_model = core.compile_model(model, device)
         self.infer_request = compiled_model.create_infer_request()
-        log.info('The model {} is loaded to {}'.format(model_xml, device))
+        log.info('The model {} is loaded to {}'.format(model_path, device))
         self.input_tensor_name = input_name
         self.output_tensor_name = output_name
         self.quantiles = quantiles
@@ -159,7 +159,7 @@ def build_argparser():
 def main(args):
     quantiles = args.quantiles.split(",")
     model = ForecastingEngine(
-        model_xml=args.model,
+        model_path=args.model,
         input_name=args.input_name,
         output_name=args.output_name,
         quantiles=quantiles

demos/whiteboard_inpainting_demo/python/utils/ie_tools.py

@@ -53,13 +53,13 @@ def get_allowed_inputs_len(self):
     def get_allowed_outputs_len(self):
         return (1, )
 
-    def load_model(self, core, model_xml, device, cpu_extension=''):
+    def load_model(self, core, model_path, device, cpu_extension=''):
         """Loads a model in the Inference Engine format"""
         # Plugin initialization for specified device and load extensions library if specified
         if cpu_extension and 'CPU' in device:
             core.add_extension(cpu_extension, 'CPU')
         # Read IR
-        self.model = core.read_model(model_xml)
+        self.model = core.read_model(model_path)
 
         if len(self.model.inputs) not in self.get_allowed_inputs_len():
             raise RuntimeError("Supports topologies with only {} inputs, but got {}"