Fix some errors (#3661)

Author: Wovchena

data/dataset_definitions.yml

@@ -1472,16 +1472,16 @@ datasets:
       input_suffix: in
       reference_suffix: out
 
-  -   name: online_mstcn_plus_encoder_dataset
-      data_source: annotation
-      reader: numpy_reader
-      annotation_conversion:
-          converter: feature_regression
-          reference_dir: image
-          input_dir: image
-          input_suffix: in
-          reference_suffix: out
-          use_bin_data: True
+  - name: online_mstcn_plus_encoder_dataset
+    data_source: annotation
+    reader: numpy_reader
+    annotation_conversion:
+      converter: feature_regression
+      reference_dir: image
+      input_dir: image
+      input_suffix: in
+      reference_suffix: out
+      use_bin_data: True
 
   - name: smartlab_detection_10cl_top
     data_source: object_detection/streams_1/top/images

demos/3d_segmentation_demo/python/3d_segmentation_demo.py

@@ -173,7 +173,7 @@ def normalize(image, mask, full_intensities_range):
 
 
 def resample_np(data, output_shape, order):
-    assert(len(data.shape) == len(output_shape))
+    assert len(data.shape) == len(output_shape)
     factor = [float(o) / i for i, o in zip(data.shape, output_shape)]
     return interpolation.zoom(data, zoom=factor, order=order)
 

demos/mri_reconstruction_demo/python/mri_reconstruction_demo.py

@@ -14,7 +14,7 @@
 logger = logging.getLogger('mri_reconstruction_demo')
 
 def kspace_to_image(kspace):
-    assert(len(kspace.shape) == 3 and kspace.shape[-1] == 2)
+    assert len(kspace.shape) == 3 and kspace.shape[-1] == 2
     fft = cv.idft(kspace, flags=cv.DFT_SCALE)
     img = cv.magnitude(fft[:, :, 0], fft[:, :, 1])
     return cv.normalize(img, dst=None, alpha=255, beta=0, norm_type=cv.NORM_MINMAX, dtype=cv.CV_8U)

demos/smartlab_demo/python/display.py

@@ -90,7 +90,7 @@ def draw_text_without_background(self, img, text,
         cv2.putText(img, text, (x, y + text_h + font_scale - 1), font, font_scale, text_color, font_thickness)
         return text_size
 
-    def display_result(self, frame_top, frame_side, side_seg_results, top_seg_results, \
+    def display_result(self, frame_top, frame_side, side_seg_results, top_seg_results,
                        top_det_results, side_det_results, scoring, state, keyframe, frame_counter, fps):
 
         if state == 'Initial':
@@ -167,16 +167,6 @@ def display_result(self, frame_top, frame_side, side_seg_results, top_seg_result
         m_weights_tweezers = scoring['measuring_score_weights_tweezers']
         e_tidy = scoring['end_score_tidy']
 
-        # display keyframe
-        i_rider_k = keyframe['initial_score_rider']
-        i_balance_k = keyframe['initial_score_balance']
-        m_rider_tweezers_k = keyframe['measuring_score_rider_tweezers']
-        m_balance_k = keyframe['measuring_score_balance']
-        m_object_left_k = keyframe['measuring_score_object_left']
-        m_weights_right_k = keyframe['measuring_score_weights_right']
-        m_weights_tweezers_k = keyframe['measuring_score_weights_tweezers']
-        e_tidy_k = keyframe['end_score_tidy']
-
         w, h = self.draw_text_without_background(self.score_board, f"SCORE - {display_status}",
                                                  pos=(self.w1, 60), text_color_bg=initial_text_color_bg)
         w, h = self.draw_text(self.score_board, f"INITIALISE RIDER[{i_rider}]",

demos/smartlab_demo/python/evaluator.py

@@ -567,7 +567,7 @@ def evaluate_rider_tweezers(self):
                     # if rider move, check tweezers and rider distance
                     # if tweezers and rider are apart more than use_tweezers_threshold pixels (based on euclidean distance), consider not using tweezers
                     if np.linalg.norm(
-                        rider_min_coordinate - tweezers_min_coordinate) <= self.use_tweezers_threshold and self.rider_tweezers_lock_mark == False:
+                        rider_min_coordinate - tweezers_min_coordinate) <= self.use_tweezers_threshold and not self.rider_tweezers_lock_mark:
                         self.scoring['measuring_score_rider_tweezers'] = 1
                         self.keyframe['measuring_score_rider_tweezers'] = self.frame_counter
 
@@ -655,7 +655,7 @@ def evaluate_object_left_from_view(self, view):
                 else:  # if object put happens on the right, then give zero score mark
                     self.object_direction = 'right'
                     self.object_is_in_tray_now = True
-                    if self.is_object_put == False or self.is_change_object_direction:
+                    if not self.is_object_put or self.is_change_object_direction:
                         self.is_object_put = True
                         self.is_change_object_direction = False
                         object_left_score = 0
@@ -688,7 +688,7 @@ def evaluate_object_left_from_view(self, view):
                     self.object_is_in_tray_now = True
                     # give mark when object is put first time,
                     # change mark only if student change direction afterward
-                    if self.is_object_put == False or self.is_change_object_direction:
+                    if not self.is_object_put or self.is_change_object_direction:
                         self.is_change_object_direction = False
                         object_left_score = 1
                         object_left_keyframe = self.frame_counter
@@ -698,7 +698,7 @@ def evaluate_object_left_from_view(self, view):
                 else:
                     self.object_direction = 'right'
                     self.object_is_in_tray_now = True
-                    if self.is_object_put == False or self.is_change_object_direction:
+                    if not self.is_object_put or self.is_change_object_direction:
                         self.is_object_put = True
                         self.is_change_object_direction = False
                         object_left_score = 0
@@ -831,7 +831,7 @@ def evaluate_end_tidy(self):
                         self.keyframe["end_score_tidy"] = self.frame_counter
                     else:
                         self.evaluate_rider()
-                        if self.rider_zero == True:
+                        if self.rider_zero:
                             self.scoring["end_score_tidy"] = 1
                             self.keyframe["end_score_tidy"] = self.frame_counter
                         else:
@@ -853,7 +853,7 @@ def evaluate_end_tidy(self):
                         self.keyframe["end_score_tidy"] = self.frame_counter
                     else:
                         self.evaluate_rider()
-                        if self.rider_zero == True:
+                        if self.rider_zero:
                             self.scoring["end_score_tidy"] = 1
                             self.keyframe["end_score_tidy"] = self.frame_counter
                         else:
@@ -889,7 +889,7 @@ def lose_balance_mark(self):
             self.keyframe['initial_score_balance'] = self.frame_counter
         elif self.state == "Measuring":
             self.balance_persist_duration = 0
-            if self.measuring_state_balance_lock_mark == False:
+            if not self.measuring_state_balance_lock_mark:
                 self.scoring['measuring_score_balance'] = 0
                 self.keyframe['measuring_score_balance'] = self.frame_counter
 
@@ -932,11 +932,11 @@ def evaluate_scale_balance(self):
                 right_roundscrew2_coor = roundscrew2_coor[0]
 
             # find center coordinate of roundscrew2 and pointerhead
-            left_roundscrew2_center_coor = [(left_roundscrew2_coor[0] + left_roundscrew2_coor[2]) / 2, \
+            left_roundscrew2_center_coor = [(left_roundscrew2_coor[0] + left_roundscrew2_coor[2]) / 2,
                                             (left_roundscrew2_coor[1] + left_roundscrew2_coor[3]) / 2]
-            right_roundscrew2_center_coor = [(right_roundscrew2_coor[0] + right_roundscrew2_coor[2]) / 2, \
+            right_roundscrew2_center_coor = [(right_roundscrew2_coor[0] + right_roundscrew2_coor[2]) / 2,
                                              (right_roundscrew2_coor[1] + right_roundscrew2_coor[3]) / 2]
-            pointerhead_center_coor = [(pointerhead_coor[0][0] + pointerhead_coor[0][2]) / 2, \
+            pointerhead_center_coor = [(pointerhead_coor[0][0] + pointerhead_coor[0][2]) / 2,
                                        (pointerhead_coor[0][1] + pointerhead_coor[0][3]) / 2]
 
             # rotate to make two roundscrew1 in a horizontal line
@@ -955,7 +955,7 @@ def evaluate_scale_balance(self):
                 self.lose_balance_mark()
 
         elif len(scale_coor) == 1 and len(pointerhead_coor) == 1:
-            pointerhead_center_coor = [(pointerhead_coor[0][0] + pointerhead_coor[0][2]) / 2, \
+            pointerhead_center_coor = [(pointerhead_coor[0][0] + pointerhead_coor[0][2]) / 2,
                                        (pointerhead_coor[0][1] + pointerhead_coor[0][3]) / 2]
             lower_limit = (scale_coor[0][0] + scale_coor[0][2]) / 2 - self.balance_threshold
             upper_limit = (scale_coor[0][0] + scale_coor[0][2]) / 2 + self.balance_threshold

demos/smartlab_demo/python/object_detection/detector.py

@@ -105,7 +105,7 @@ def __init__(self,
         self.all_classes += list(self.top_loc_exp.mw_classes)
         self.all_classes += list(self.side_glb_exp.mw_classes)
         self.all_classes += list(self.side_loc_exp.mw_classes)
-        self.all_classes = sorted(list(set(self.all_classes)))
+        self.all_classes = sorted(set(self.all_classes))
 
         #  max-number constraints:
         self.max_nums = {

demos/smartlab_demo/python/segmentor.py

@@ -118,14 +118,12 @@ def inference_async(self, frame_top, frame_side, frame_index):
         frame_side = frame_side[np.newaxis, :, :, :].transpose((0, 3, 1, 2)).astype(np.float32)
         frame_top = frame_top[np.newaxis, :, :, :].transpose((0, 3, 1, 2)).astype(np.float32)
 
-        self.infer_encoder_side_request.start_async(inputs={ \
+        self.infer_encoder_side_request.start_async(inputs={
             self.encoder_side_input_keys['input_image']: frame_side,
             self.encoder_side_input_keys['shifted_input']: self.shifted_tesor_side})
 
-        self.infer_encoder_top_request.start_async(inputs= \
-                                                       {self.encoder_top_input_keys['input_image']: frame_top,
-                                                        self.encoder_top_input_keys[
-                                                            'shifted_input']: self.shifted_tesor_top})
+        self.infer_encoder_top_request.start_async(inputs={self.encoder_top_input_keys['input_image']: frame_top,
+                                                           self.encoder_top_input_keys['shifted_input']: self.shifted_tesor_top})
 
         while True:
             if self.infer_encoder_side_request.wait_for(0) and self.infer_encoder_top_request.wait_for(0):

demos/smartlab_demo/python/smartlab_demo.py

@@ -74,8 +74,9 @@ def video_loop(args, cap_top, cap_side, detector, segmentor, evaluator, display)
     # multithread setup
     executor = concurrent.futures.ThreadPoolExecutor()
     future_detector = None
-    future_segmentor = None
     buffer_display = None
+    scoring = None
+    keyframe = None
 
     while cap_top.isOpened() and cap_side.isOpened():
         ret_top, frame_top = cap_top.read()

models/intel/smartlab-action-recognition-0001/README.md

@@ -2,7 +2,7 @@
 
 ## Use Case and High-Level Description
 
-There are 3 models for smartlab action recogntion including two encoder models and one decoder model. 
+There are 3 models for smartlab action recogntion including two encoder models and one decoder model.
 
 These models are fine-tuned with smartlab dataset to predict actions and can classfy 3 types of action including "noise_action", "put_take" and "adjust_rider".
 
@@ -20,7 +20,7 @@ Output `put_take` action
 
 ## Encoder models specification
 
-The smartlab-action-recognition-0001-encoder-* have Mobilenet-V2 like backbone with convolutional encoder part of the action recognition. 
+The smartlab-action-recognition-0001-encoder-* have Mobilenet-V2 like backbone with convolutional encoder part of the action recognition.
 
 There are two models called: `smartlab-action-recognition-0001-encoder-side` and `smartlab-action-recognition-0001-encoder-top`, which have the same strcuture but different weights.
 

models/public/erfnet/accuracy-check.yml

@@ -10,7 +10,7 @@ models:
         preprocessing:
           - type: resize
             dst_width: 976
-            dst_height: 208 
+            dst_height: 208
         postprocessing:
           - type: resize_segmentation_mask
             dst_width: 1640
@@ -44,4 +44,4 @@ models:
           - type: mean_iou
             use_argmax: false
             presenter:  print_scalar
-            reference: 0.7647
+            reference: 0.7647