Merge pull request #3397 from anzhella-pankratova/action_recognition_demo_fix

action_recognition_demo.py: use AsyncInferQueue

Author: Wovchena

demos/action_recognition_demo/python/action_recognition_demo/models.py

@@ -22,6 +22,8 @@
 import cv2
 import numpy as np
 
+from openvino.runtime import AsyncInferQueue
+
 
 def center_crop(frame, crop_size):
     img_h, img_w, _ = frame.shape
@@ -93,22 +95,27 @@ def __init__(self, model_path, core, target_device, num_requests, model_type):
             log.error("Demo supports only models with 1 output")
             sys.exit(1)
 
+        self.outputs = {}
         compiled_model = core.compile_model(self.model, target_device)
         self.output_tensor = compiled_model.outputs[0]
         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 = [compiled_model.create_infer_request() for _ in range(self.num_requests)]
+        self.infer_queue = AsyncInferQueue(compiled_model, num_requests)
+        self.infer_queue.set_callback(self.completion_callback)
         log.info('The {} model {} is loaded to {}'.format(model_type, model_path, target_device))
 
+    def completion_callback(self, infer_request, id):
+        self.outputs[id] = infer_request.results[self.output_tensor]
+
     def async_infer(self, frame, req_id):
         input_data = {self.input_name: frame}
-        self.infer_requests[req_id].start_async(inputs=input_data)
+        self.infer_queue.start_async(input_data, req_id)
 
     def wait_request(self, req_id):
-        self.infer_requests[req_id].wait()
-        return self.infer_requests[req_id].results[self.output_tensor]
+        self.infer_queue[req_id].wait()
+        return self.outputs.pop(req_id, None)
 
 
 class DummyDecoder:

demos/action_recognition_demo/python/action_recognition_demo/steps.py

@@ -101,6 +101,10 @@ def __init__(self, encoder):
         self.encoder = encoder
         self.async_model = AsyncWrapper(self.encoder, self.encoder.num_requests)
 
+    def __del__(self):
+        for ireq in self.encoder.infer_queue:
+            ireq.cancel()
+
     def process(self, frame):
         preprocessed = preprocess_frame(frame)
         preprocessed = preprocessed[np.newaxis, ...]  # add batch dimension
@@ -121,6 +125,10 @@ def __init__(self, decoder, sequence_size=16):
         self.async_model = AsyncWrapper(self.decoder, self.decoder.num_requests)
         self._embeddings = deque(maxlen=self.sequence_size)
 
+    def __del__(self):
+        for ireq in self.decoder.infer_queue:
+            ireq.cancel()
+
     def process(self, item):
         if item is None:
             return None

demos/gesture_recognition_demo/python/gesture_recognition_demo/common.py

@@ -68,8 +68,9 @@ def completion_callback(self, infer_request, id):
     def infer(self, data):
         """Runs model on the specified input"""
 
-        self.async_infer(data, 0)
-        return self.wait_request(0)
+        input_data = {self.input_tensor_name: data}
+        self.infer_queue[0].infer(input_data)
+        return self.infer_queue[0].get_tensor(self.output_tensor_name).data[:]
 
     def async_infer(self, data, req_id):
         """Requests model inference for the specified input"""
@@ -79,8 +80,5 @@ def async_infer(self, data, req_id):
 
     def wait_request(self, req_id):
         """Waits for the model output by the specified request ID"""
-        self.infer_queue.wait_all()
-        try:
-            return self.outputs.pop(req_id)
-        except KeyError:
-            return None
+        self.infer_queue[req_id].wait()
+        return self.outputs.pop(req_id, None)