update & fix code

Author: HydrogenSulfate

applications/BasketballAction/predict/action_detect/reader/tsminf_reader.py

@@ -33,21 +33,22 @@ class TSMINFReader(DataReader):
     """
     Data reader for video dataset of jpg folder.
     """
-
     def __init__(self, name, mode, cfg, material=None):
         super(TSMINFReader, self).__init__(name, mode, cfg)
         name = name.upper()
-        self.seg_num        = cfg[name]['seg_num']
-        self.seglen         = cfg[name]['seglen']
-        self.short_size     = cfg[name]['short_size']
-        self.target_size    = cfg[name]['target_size']
-        self.batch_size     = cfg[name]['batch_size']
+        self.num_seg = cfg[name]['num_seg']
+        self.seglen = cfg[name]['seglen']
+        self.short_size = cfg[name]['short_size']
+        self.target_size = cfg[name]['target_size']
+        self.batch_size = cfg[name]['batch_size']
         self.reader_threads = cfg[name]['reader_threads']
-        self.buf_size       = cfg[name]['buf_size']
-        self.video_path     = cfg[name]['frame_list']
+        self.buf_size = cfg[name]['buf_size']
+        self.video_path = cfg[name]['frame_list']
 
-        self.img_mean       = np.array(cfg[name]['image_mean']).reshape([3, 1, 1]).astype(np.float32)
-        self.img_std        = np.array(cfg[name]['image_std']).reshape([3, 1, 1]).astype(np.float32)
+        self.img_mean = np.array(cfg[name]['image_mean']).reshape(
+            [3, 1, 1]).astype(np.float32)
+        self.img_std = np.array(cfg[name]['image_std']).reshape(
+            [3, 1, 1]).astype(np.float32)
 
         self.material = material
 
@@ -56,16 +57,16 @@ def create_reader(self):
         batch loader for TSN
         """
         _reader = self._inference_reader_creator_longvideo(
-                self.video_path,
-                self.mode,
-                seg_num=self.seg_num,
-                seglen=self.seglen,
-                short_size=self.short_size,
-                target_size=self.target_size,
-                img_mean=self.img_mean,
-                img_std=self.img_std,
-                num_threads = self.reader_threads,
-                buf_size = self.buf_size)
+            self.video_path,
+            self.mode,
+            num_seg=self.num_seg,
+            seglen=self.seglen,
+            short_size=self.short_size,
+            target_size=self.target_size,
+            img_mean=self.img_mean,
+            img_std=self.img_std,
+            num_threads=self.reader_threads,
+            buf_size=self.buf_size)
 
         def _batch_reader():
             batch_out = []
@@ -81,9 +82,10 @@ def _batch_reader():
 
         return _batch_reader
 
-
-    def _inference_reader_creator_longvideo(self, video_path, mode, seg_num, seglen,
-                                  short_size, target_size, img_mean, img_std, num_threads, buf_size):
+    def _inference_reader_creator_longvideo(self, video_path, mode, num_seg,
+                                            seglen, short_size, target_size,
+                                            img_mean, img_std, num_threads,
+                                            buf_size):
         """
         inference reader for video
         """
@@ -94,7 +96,7 @@ def reader():
             def image_buf(image_id_path_buf):
                 """
                 image_buf reader
-                """  
+                """
                 try:
                     img_path = image_id_path_buf[1]
                     img = Image.open(img_path).convert("RGB")
@@ -103,61 +105,68 @@ def image_buf(image_id_path_buf):
                     image_id_path_buf[2] = None
 
             frame_len = len(video_path)
-            read_thread_num = seg_num
+            read_thread_num = num_seg
             for i in range(0, frame_len, read_thread_num):
-                image_list_part = video_path[i: i + read_thread_num]
+                image_list_part = video_path[i:i + read_thread_num]
                 image_id_path_buf_list = []
                 for k in range(len(image_list_part)):
                     image_id_path_buf_list.append([k, image_list_part[k], None])
 
-                
-                with concurrent.futures.ThreadPoolExecutor(max_workers=read_thread_num) as executor:
-                    executor.map(lambda image_id_path_buf: image_buf(image_id_path_buf), image_id_path_buf_list)
+                with concurrent.futures.ThreadPoolExecutor(
+                        max_workers=read_thread_num) as executor:
+                    executor.map(
+                        lambda image_id_path_buf: image_buf(image_id_path_buf),
+                        image_id_path_buf_list)
                 imgs_seg_list = [x[2] for x in image_id_path_buf_list]
-                    
+
                 # add the fault-tolerant for bad image
                 for k in range(len(image_id_path_buf_list)):
                     img_buf = image_id_path_buf_list[k][2]
                     pad_id = 1
-                    while pad_id < seg_num and img_buf is None:
-                        img_buf = imgs_seg_list[(k + pad_id)%seg_num][2]
+                    while pad_id < num_seg and img_buf is None:
+                        img_buf = imgs_seg_list[(k + pad_id) % num_seg][2]
                     if img_buf is None:
-                        logger.info("read img erro from {} to {}".format(i, i + read_thread_num))
+                        print("read img erro from {} to {}".format(
+                            i, i + read_thread_num))
                         exit(0)
                     else:
                         imgs_seg_list[k] = img_buf
-                for pad_id in range(len(imgs_seg_list), seg_num):
+                for pad_id in range(len(imgs_seg_list), num_seg):
                     imgs_seg_list.append(imgs_seg_list[-1])
-                yield imgs_seg_list      
+                yield imgs_seg_list
 
 
-        def inference_imgs_transform(imgs_list, mode, seg_num, seglen, short_size,\
+        def inference_imgs_transform(imgs_list, mode, num_seg, seglen, short_size,\
                                     target_size, img_mean, img_std):
             """
             inference_imgs_transform
-            """ 
-            imgs_ret = imgs_transform(imgs_list, mode, seg_num, seglen, short_size,
-                        target_size, img_mean, img_std)
+            """
+            imgs_ret = imgs_transform(imgs_list, mode, num_seg, seglen,
+                                      short_size, target_size, img_mean,
+                                      img_std)
             label_ret = 0
 
             return imgs_ret, label_ret
 
-        mapper = functools.partial(
-            inference_imgs_transform,
-            mode=mode,
-            seg_num=seg_num,
-            seglen=seglen,
-            short_size=short_size,
-            target_size=target_size,
-            img_mean=img_mean,
-            img_std=img_std)
+        mapper = functools.partial(inference_imgs_transform,
+                                   mode=mode,
+                                   num_seg=num_seg,
+                                   seglen=seglen,
+                                   short_size=short_size,
+                                   target_size=target_size,
+                                   img_mean=img_mean,
+                                   img_std=img_std)
 
-        return paddle.reader.xmap_readers(mapper, reader, num_threads, buf_size, order=True)
+        return paddle.reader.xmap_readers(mapper,
+                                          reader,
+                                          num_threads,
+                                          buf_size,
+                                          order=True)
 
 
 def imgs_transform(imgs,
                    mode,
-                   seg_num,
+                   num_seg,
                    seglen,
                    short_size,
                    target_size,
@@ -186,7 +195,7 @@ def imgs_transform(imgs,
     imgs = np_imgs
     imgs -= img_mean
     imgs /= img_std
-    imgs = np.reshape(imgs, (seg_num, seglen * 3, target_size, target_size))
+    imgs = np.reshape(imgs, (num_seg, seglen * 3, target_size, target_size))
 
     return imgs
 
@@ -260,10 +269,10 @@ def _sample_crop_size(im_size):
                 'crop_h': crop_pair[1],
                 'offset_w': w_offset,
                 'offset_h': h_offset
-                }
-             
+            }
+
         return crop_info
-    
+
     crop_info = _sample_crop_size(im_size)
     crop_w = crop_info['crop_w']
     crop_h = crop_info['crop_h']
@@ -355,4 +364,3 @@ def group_scale(imgs, target_size):
             resized_imgs.append(img.resize((ow, oh), Image.BILINEAR))
 
     return resized_imgs
-

applications/BasketballAction/predict/configs_basketball/configs_basketball.yaml

@@ -1,7 +1,7 @@
 COMMON:
     fps: 5
     use_gpu: True
-    label_dic: 'configs_basketball/index_label_basketball_6.json' 
+    label_dic: 'configs_basketball/index_label_basketball_6.json'
     # debug
     PCM_ONLY: False
     DEBUG: False
@@ -14,7 +14,7 @@ PPTSM:
     params_file: "checkpoints_basketball/ppTSM/ppTSM.pdiparams"
     gpu_mem: 8000
     device_id: 0
-    seg_num: 8
+    num_seg: 8
     seglen: 1
     short_size: 256
     target_size: 224
@@ -57,6 +57,6 @@ ACTION:
     nms_thread: 0.01
     nms_offset: 10
 
-    classify_score_thread: 0.1    
-    iou_score_thread: 0.3      
+    classify_score_thread: 0.1
+    iou_score_thread: 0.3
 

applications/MultimodalVideoTag/scenario_lib/datareader/feature_reader.py

@@ -58,7 +58,7 @@ def __init__(self, name, mode, cfg):
         self.batch_size = cfg[mode.upper()]['batch_size']
         self.filelist = cfg[mode.upper()]['filelist']
         self.eigen_file = cfg.MODEL.get('eigen_file', None)
-        self.seg_num = cfg.MODEL.get('seg_num', None)
+        self.num_seg = cfg.MODEL.get('num_seg', None)
         self.loss_type = cfg.TRAIN['loss_type']
         vocab_file = os.path.join(cfg.TRAIN.ernie_pretrain_dict_path,
                                   'vocab.txt')
@@ -120,10 +120,13 @@ def reader():
                         yield batch_out
                         batch_out = []
                 except Exception as e:
-                    print("warning: load data {} failed, {}".format(filepath, str(e)))
+                    print("warning: load data {} failed, {}".format(
+                        filepath, str(e)))
                     traceback.print_exc()
                     continue
-	    # if self.mode == 'infer' and len(batch_out) > 0:
+
+
+# if self.mode == 'infer' and len(batch_out) > 0:
             if len(batch_out) > 0:
                 yield batch_out
 
@@ -224,13 +227,13 @@ def make_one_hot(label, dim=15):
     return one_hot_soft_label
 
 
-def generate_random_idx(feature_len, seg_num):
+def generate_random_idx(feature_len, num_seg):
     """
     generate_random_idx
     """
     idxs = []
-    stride = float(feature_len) / seg_num
-    for i in range(seg_num):
+    stride = float(feature_len) / num_seg
+    for i in range(num_seg):
         pos = (i + np.random.random()) * stride
         idxs.append(min(feature_len - 1, int(pos)))
     return idxs

applications/VideoQualityAssessment/paddlevideo/modeling/heads/tsm_rec_head.py

@@ -67,7 +67,7 @@ def init_weights(self):
         self.fc.bias.learning_rate = 2.0
         self.fc.bias.regularizer = paddle.regularizer.L2Decay(0.)
 
-    def forward(self, x, seg_num):
+    def forward(self, x, num_seg):
         """Define how the head is going to run.
 
         Args:
@@ -81,9 +81,9 @@ def forward(self, x, seg_num):
         # [N * num_segs, in_channels, 1, 1]
         if self.dropout is not None:
             x = self.dropout(x)
-        # [N * seg_num, in_channels, 1, 1]
-        x = paddle.reshape(x, [-1, seg_num, x.shape[1]])
-        # [N, seg_num, in_channels]
+        # [N * num_seg, in_channels, 1, 1]
+        x = paddle.reshape(x, [-1, num_seg, x.shape[1]])
+        # [N, num_seg, in_channels]
         x = paddle.mean(x, axis=1)
         # [N, 1, in_channels]
         x = paddle.reshape(x, shape=[-1, self.in_channels])
@@ -112,7 +112,7 @@ def loss(self, scores, labels, valid_mode=False, **kwargs):
             labels = labels[0]
             losses = dict()
             loss = self.loss_func(scores, labels, **kwargs)
-            
+
             score_list = paddle.tolist(scores)
             label_list = paddle.tolist(labels)
             score_list_len = len(score_list)
@@ -137,7 +137,7 @@ def loss(self, scores, labels, valid_mode=False, **kwargs):
                 loss_a = self.loss_func(scores, labels_a, **kwargs)
                 loss_b = self.loss_func(scores, labels_a, **kwargs)
             loss = lam * loss_a + (1 - lam) * loss_b
-            
+
             losses['loss'] = loss
             losses['output'] = output
             losses['label'] = label
@@ -151,4 +151,3 @@ def label_smooth_loss(self, scores, labels, **kwargs):
         labels = paddle.squeeze(labels, axis=1)
         loss = self.loss_func(scores, labels, **kwargs)
         return loss
-

applications/VideoQualityAssessment/paddlevideo/modeling/heads/tsn_head.py

@@ -20,6 +20,7 @@
 from ..weight_init import weight_init_
 import paddle.nn.functional as F
 
+
 @HEADS.register()
 class TSNHead(BaseHead):
     """TSN Head.
@@ -66,7 +67,7 @@ def init_weights(self):
                      mean=0.,
                      std=self.std)
 
-    def forward(self, x, seg_num):
+    def forward(self, x, num_seg):
         """Define how the head is going to run.
 
         Args:
@@ -83,9 +84,9 @@ def forward(self, x, seg_num):
         # [N * num_segs, in_channels, 1, 1]
         if self.dropout is not None:
             x = self.dropout(x)
-        # [N * seg_num, in_channels, 1, 1]
-        x = paddle.reshape(x, [-1, seg_num, x.shape[1]])
-        # [N, seg_num, in_channels]
+        # [N * num_seg, in_channels, 1, 1]
+        x = paddle.reshape(x, [-1, num_seg, x.shape[1]])
+        # [N, num_seg, in_channels]
         x = paddle.mean(x, axis=1)
         # [N, 1, in_channels]
         x = paddle.reshape(x, shape=[-1, self.in_channels])

benchmark/TimeSformer/timesformer_ucf101_videos_benchmark_bs1.yaml

@@ -12,7 +12,7 @@ MODEL: #MODEL field
         mlp_ratio: 4
         qkv_bias: True
         epsilon: 1e-6
-        seg_num: 8
+        num_seg: 8
         attention_type: 'divided_space_time'
     head:
         name: "TimeSformerHead" #Mandatory, indicate the type of head, associate to the 'paddlevideo/modeling/heads'

benchmark/TimeSformer/timesformer_ucf101_videos_benchmark_bs14.yaml

@@ -12,7 +12,7 @@ MODEL: #MODEL field
         mlp_ratio: 4
         qkv_bias: True
         epsilon: 1e-6
-        seg_num: 8
+        num_seg: 8
         attention_type: 'divided_space_time'
     head:
         name: "TimeSformerHead" #Mandatory, indicate the type of head, associate to the 'paddlevideo/modeling/heads'

benchmark/TimeSformer/timesformer_ucf101_videos_benchmark_bs14_mp.yaml

@@ -12,7 +12,7 @@ MODEL: #MODEL field
         mlp_ratio: 4
         qkv_bias: True
         epsilon: 1e-6
-        seg_num: 8
+        num_seg: 8
         attention_type: 'divided_space_time'
     head:
         name: "TimeSformerHead" #Mandatory, indicate the type of head, associate to the 'paddlevideo/modeling/heads'

benchmark/TimeSformer/timesformer_ucf101_videos_benchmark_bs1_mp.yaml

@@ -12,7 +12,7 @@ MODEL: #MODEL field
         mlp_ratio: 4
         qkv_bias: True
         epsilon: 1e-6
-        seg_num: 8
+        num_seg: 8
         attention_type: 'divided_space_time'
     head:
         name: "TimeSformerHead" #Mandatory, indicate the type of head, associate to the 'paddlevideo/modeling/heads'