Add files using upload-large-folder tool

TransRAC/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

TransRAC/.idea/SVIP_Counting.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

TransRAC/.idea/deployment.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="PublishConfigData" remoteFilesAllowedToDisappearOnAutoupload="false">
+    <serverData>
+      <paths name="root@10.15.89.41:23035 password">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+    </serverData>
+  </component>
+</project>

TransRAC/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8" project-jdk-type="Python SDK" />
+</project>

TransRAC/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/SVIP_Counting.iml" filepath="$PROJECT_DIR$/.idea/SVIP_Counting.iml" />
+    </modules>
+  </component>
+</project>

TransRAC/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

TransRAC/dataset/RepCountA_Loader.py

@@ -0,0 +1,104 @@
+''' 
+Repcount data loader from fixed frames file(.npz) which will be uploaded soon.
+if you don't pre-process the data file,for example,your raw file is .mp4,
+you can use the *RepCountA_raw_Loader.py*(slowly).
+or
+you can use 'tools.video2npz.py' to transform .mp4 tp .npz
+'''
+import csv
+import os
+import os.path as osp
+import numpy as np
+import math
+
+from torch.utils.data import Dataset, DataLoader
+import torch
+from .label_norm import normalize_label
+
+
+class MyData(Dataset):
+
+    def __init__(self, root_path, video_path, label_path, num_frame):
+        """
+        :param root_path: root path
+        :param video_path: video child path (folder)
+        :param label_path: label child path(.csv)
+        """
+        self.root_path = root_path
+        self.video_path = os.path.join(self.root_path, video_path)  # train or valid
+        self.label_path = os.path.join(self.root_path, label_path)
+        self.video_dir = os.listdir(self.video_path)
+        self.label_dict = get_labels_dict(self.label_path)  # get all labels
+        self.num_frame = num_frame
+
+    def __getitem__(self, inx):
+        """ get data item
+        :param  video_tensor, label
+        """
+        video_file_name = self.video_dir[inx]
+        file_path = os.path.join(self.video_path, video_file_name)
+        video_tensor, video_frame_length = get_frames(file_path)  # [64, 3, 224, 224]
+        video_tensor = video_tensor.transpose(0, 1)  # [64, 3, 224, 224] -> [ 3, 64, 224, 224]
+        if video_file_name in self.label_dict.keys():
+            time_points = self.label_dict[video_file_name]
+            label = preprocess(video_frame_length, time_points, num_frames=self.num_frame)
+            label = torch.tensor(label)
+            return [video_tensor, label]
+        else:
+            print(video_file_name, 'not exist')
+            return
+
+    def __len__(self):
+        """:return the number of video """
+        return len(self.video_dir)
+
+
+def get_frames(npz_path):
+    # get frames from .npz files
+    with np.load(npz_path, allow_pickle=True) as data:
+        frames = data['imgs']  # numpy.narray [64, 3, 224, 224]
+        frames_length = data['fps'].item()  # the raw video(.mp4) total frames number
+        frames = torch.FloatTensor(frames)
+        frames -= 127.5
+        frames /= 127.5
+    return frames, frames_length
+
+
+def get_labels_dict(path):
+    # read label.csv to RAM
+    labels_dict = {}
+    check_file_exist(path)
+    with open(path, encoding='utf-8') as f:
+        f_csv = csv.DictReader(f)
+        for row in f_csv:
+            cycle = [int(float(row[key])) for key in row.keys() if 'L' in key and row[key] != '']
+            if not row['count']:
+                print(row['name'] + 'error')
+            else:
+                labels_dict[row['name'].split('.')[0] + str('.npz')] = cycle
+
+    return labels_dict
+
+
+def preprocess(video_frame_length, time_points, num_frames):
+    """
+    process label(.csv) to density map label
+    Args:
+        video_frame_length: video total frame number, i.e 1024frames
+        time_points: label point example [1, 23, 23, 40,45,70,.....] or [0]
+        num_frames: 64
+    Returns: for example [0.1,0.8,0.1, .....]
+    """
+    new_crop = []
+    for i in range(len(time_points)):  # frame_length -> 64
+        item = min(math.ceil((float((time_points[i])) / float(video_frame_length)) * num_frames), num_frames - 1)
+        new_crop.append(item)
+    new_crop = np.sort(new_crop)
+    label = normalize_label(new_crop, num_frames)
+
+    return label
+
+
+def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
+    if not osp.isfile(filename):
+        raise FileNotFoundError(msg_tmpl.format(filename))

TransRAC/dataset/RepCountA_raw_Loader.py

@@ -0,0 +1,142 @@
+"""
+If you don't want to pre-process the RepCount dataset, 
+you can use this script to load data from raw video(.mp4).
+The trainning speed is slower and the memory cost more.
+"""
+
+import os
+import os.path as osp
+import numpy as np
+import math
+import cv2
+from torch.utils.data import Dataset
+import torch
+import csv
+import kornia
+from .label_norm import normalize_label
+import torchvision.transforms as transforms
+
+class MyData(Dataset):
+
+    def __init__(self, root_path, video_path, label_path, num_frame):
+        self.root_path = root_path
+        self.video_path = video_path
+        self.label_dir = os.path.join(root_path, label_path)
+        self.video_dir = os.listdir(os.path.join(self.root_path, self.video_path))
+        self.label_dict = get_labels_dict(self.label_dir)  # get all labels
+        self.num_frame = num_frame
+
+    def __getitem__(self, inx):
+        video_file_name= self.video_dir[inx]
+        file_path = os.path.join(self.root_path, self.video_path, video_file_name)
+        video_rd = VideoRead(file_path, num_frames=self.num_frame)
+        video_tensor = video_rd.crop_frame()
+        video_frame_length = video_rd.frame_length
+        video_tensor = video_tensor.transpose(0, 1)  # [64, 3, 224, 224] -> [ 3, 64, 224, 224]
+        if video_file_name in self.label_dict.keys():
+            time_points = self.label_dict[video_file_name]
+            label = preprocess(video_frame_length, time_points, num_frames=self.num_frame)
+            label = torch.tensor(label)
+            return [video_tensor, label]
+        else:
+            print(video_file_name, 'not exist')
+            return
+        
+    def __len__(self):
+        """返回数据集的大小"""
+        return len(self.video_dir)
+
+
+class VideoRead:
+    def __init__(self, video_path, num_frames):
+        self.video_path = video_path
+        self.frame_length = 0
+        self.num_frames = num_frames
+
+    def get_frame(self):
+        cap = cv2.VideoCapture(self.video_path)
+        assert cap.isOpened()
+        frames = []
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frames.append(frame)
+        cap.release()
+        self.frame_length = len(frames)
+        return frames
+
+    def crop_frame(self):
+        """to crop frames to tensor
+        return: tensor [64, 3, 224, 224]
+        """
+        frames = self.get_frame()  # frames: the all frames of video
+        frames_tensor = []
+        if self.num_frames <= len(frames):
+            for i in range(self.num_frames):
+                #  select 64 frames from total original frames, proportionally
+                frame = frames[i * len(frames) // self.num_frames]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [3, 224, 224]
+                frame = transforms.ToTensor()(frame)
+                frames_tensor.append(frame)
+
+        else:  # if raw frames number lower than 64, padding it. 
+            for i in range(self.frame_length):
+                frame = frames[i]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [ 3, 224, 224]
+                frame = transforms.ToTensor()(frame)
+                frames_tensor.append(frame)
+            for i in range(self.num_frames - self.frame_length):
+                frame = frames[self.frame_length - 1]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [ 3, 224, 224]
+                frame = transforms.ToTensor()(frame)
+                frames_tensor.append(frame)
+        Frame_Tensor=torch.as_tensor(np.stack(frames_tensor))   
+
+        return Frame_Tensor
+
+
+def get_labels_dict(path):
+    labels_dict = {}
+    check_file_exist(path)
+    with open(path, encoding='utf-8') as f:
+        f_csv = csv.DictReader(f)
+        for row in f_csv:
+            cycle = [int(row[key]) for key in row.keys() if 'L' in key and row[key] != '']
+            labels_dict[row['name']] = cycle
+
+    return labels_dict
+
+def preprocess(video_frame_length, time_points, num_frames):
+    """
+    process label(.csv) to density map label
+    Args:
+        video_frame_length: video total frame number, i.e 1024frames
+        time_points: label point example [1, 23, 23, 40,45,70,.....] or [0]
+        num_frames: 64
+    Returns: for example list [0.1,0.8,0.1, .....]
+    """
+    new_crop = []
+    for i in range(len(time_points)):  # frame_length -> 64
+        item = min(math.ceil((float((time_points[i])) / float(video_frame_length)) * num_frames), num_frames - 1)
+        new_crop.append(item)
+    new_crop = np.sort(new_crop)
+    label = normalize_label(new_crop, num_frames)
+
+    return label
+
+def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
+    if not osp.isfile(filename):
+        raise FileNotFoundError(msg_tmpl.format(filename))
+
+# # example
+# root_dir = r'/p300/data/dataset/'
+# video_dir = 'train'
+# label_dir = 'train.csv'
+# train_dataset = MyData(root_dir, video_dir, label_dir,64)
+# trainloader = DataLoader(train_dataset, batch_size=1, shuffle=True)
+

TransRAC/dataset/RepCountB_Loader.py

@@ -0,0 +1,111 @@
+import os
+
+import numpy as np
+import csv
+import cv2
+from torch.utils.data import Dataset, DataLoader
+import kornia
+import torch
+import torchvision.transforms as transforms
+
+
+class TestData(Dataset):
+    def __init__(self, root_path, video_path, label_path, num_frame):
+        self.root_path = root_path
+        self.video_path = video_path
+        self.label_dir = os.path.join(root_path, label_path)
+        self.video_dir = os.listdir(os.path.join(self.root_path, self.video_path))
+        self.label_dict = get_labels_dict(self.label_dir)  # get all labels
+        self.num_frame = num_frame
+
+    def __getitem__(self, inx):
+        video_name= self.video_dir[inx]
+        file_path = os.path.join(self.root_path, self.video_path, video_name)
+        video_rd = VideoRead(file_path, num_frames=self.num_frame)
+        video_tensor = video_rd.crop_frame()
+        video_frame_length = video_rd.frame_length
+        video_tensor = video_tensor.transpose(0, 1)  # [64, 3, 224, 224] -> [ 3, 64, 224, 224]
+        count = self.label_dict[video_name]
+        count = torch.tensor(count)
+
+        return video_tensor, count
+    def __len__(self):
+        """返回数据集的大小"""
+        return len(self.video_dir)
+
+
+class VideoRead:
+    def __init__(self, video_path, num_frames=64):
+        self.video_path = video_path
+        self.frame_length = 0
+        self.num_frames = num_frames
+
+    def get_frame(self):
+        cap = cv2.VideoCapture(self.video_path)
+        assert cap.isOpened()
+        frames = []
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frames.append(frame)
+        cap.release()
+        self.frame_length = len(frames)
+        return frames
+
+    def crop_frame(self):
+        """to crop frames to tensor [64, 3, 224, 224]"""
+        frames = self.get_frame()  # frames: the all frames of video
+        frames_tensor = []
+        if self.num_frames <= len(frames):
+            for i in range(self.num_frames):
+                #  select 64 frames from total original frames, proportionally
+                frame = frames[i * len(frames) // self.num_frames]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [64, 3, 224, 224]
+                frame = transforms.ToTensor()(frame)
+                frames_tensor.append(frame)
+
+        else:   # if raw frames number lower than 64, padding it. 
+            for i in range(self.frame_length):
+                frame = frames[i]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [64, 3, 224, 224]
+                frame = transforms.ToTensor()(frame)
+                frames_tensor.append(frame)
+            for i in range(self.num_frames - self.frame_length):
+                frame = frames[self.frame_length - 1]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [64, 3, 224, 224]
+                frame = transforms.ToTensor()(frame)
+                frames_tensor.append(frame)
+        # frames_tensor = np.asarray_chkfinite(frames_tensor, dtype=np.uint8)
+        # frames_tensor = kornia.image_to_tensor(frames_tensor, keepdim=False).div(255.0)
+        Frame_Tensor=torch.as_tensor(np.stack(frames_tensor))   
+
+        return Frame_Tensor
+
+
+def get_labels_dict(path):
+    labels_dict = {}
+    check_file_exist(path)
+    with open(path, encoding='utf-8') as f:
+        f_csv = csv.DictReader(f)
+        for row in f_csv:
+            cycle = [int(row[key]) for key in row.keys() if 'L' in key and row[key] != '']
+            if not row['count']:
+                print(row['name']+'error')
+            else:
+                labels_dict[row['name']] = int(row['count'])
+
+    return labels_dict
+
+
+def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
+    if not os.path.isfile(filename):
+        raise FileNotFoundError(msg_tmpl.format(filename))
+
+
+
+

TransRAC/dataset/UCFRep_loader.py

@@ -0,0 +1,113 @@
+import os
+
+import numpy as np
+import csv
+import cv2
+from torch.utils.data import Dataset, DataLoader
+import kornia
+import torch
+
+class TestData(Dataset):
+    def __init__(self, root_path, video_path, label_path, num_frame):
+        """
+        Args:
+            root_path:
+            video_path:
+            label_path:
+            num_frame:
+        """
+        self.root_path = root_path
+        self.video_path = video_path
+        self.label_dir = os.path.join(root_path, label_path)
+        self.video_dir = os.listdir(os.path.join(self.root_path, self.video_path))
+        self.label_dict = get_labels_dict(self.label_dir)  # get all labels
+        self.num_frame = num_frame
+
+    def __getitem__(self, inx):
+        """获取数据集中的item  """
+
+        video_name= self.video_dir[inx]
+        file_path = os.path.join(self.root_path, self.video_path, video_name)
+        video_rd = VideoRead(file_path, num_frames=self.num_frame)
+        video_tensor = video_rd.crop_frame()
+        video_frame_length = video_rd.frame_length
+        video_tensor = video_tensor.transpose(0, 1)  # [64, 3, 224, 224] -> [ 3, 64, 224, 224]
+        count = self.label_dict[video_name]
+        count = torch.tensor(count)
+
+        return video_tensor, count
+    def __len__(self):
+        """返回数据集的大小"""
+        return len(self.video_dir)
+
+
+class VideoRead:
+    def __init__(self, video_path, num_frames):
+        self.video_path = video_path
+        self.frame_length = 0
+        self.num_frames = num_frames
+
+    def get_frame(self):
+        cap = cv2.VideoCapture(self.video_path)
+        assert cap.isOpened()
+        frames = []
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frames.append(frame)
+        cap.release()
+        self.frame_length = len(frames)
+        return frames
+
+    def crop_frame(self):
+        """to crop frames to 64 frames"""
+        frames = self.get_frame()
+        frames_tensor = []
+        if self.num_frames <= self.frame_length:
+            for i in range(1, self.num_frames + 1):
+                frame = frames[i * len(frames) // self.num_frames - 1]  # Proportional extraction (64 frames) 
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [64, 3, 224, 224]
+                # frame = transform(frame).unsqueeze(0)
+                frames_tensor.append(frame)
+
+        else:  # if raw frames number lower than 64, padding it. 
+            for i in range(self.frame_length):
+                frame = frames[i]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [64, 3, 224, 224]
+                frames_tensor.append(frame)
+            for i in range(self.num_frames - self.frame_length):
+                frame = frames[self.frame_length - 1]
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (224, 224))  # [64, 3, 224, 224]
+                frames_tensor.append(frame)
+        frames_tensor = np.asarray_chkfinite(frames_tensor, dtype=np.uint8)
+        frames_tensor = kornia.image_to_tensor(frames_tensor, keepdim=False).div(255.0)
+
+        return frames_tensor
+
+
+def get_labels_dict(path):
+    labels_dict = {}
+    check_file_exist(path)
+    with open(path, encoding='utf-8') as f:
+        f_csv = csv.DictReader(f)
+        for row in f_csv:
+            if not row['count']:
+                print(row['name']+'error')
+            else:
+                labels_dict[row['name']] = int(row['count'])
+
+    return labels_dict
+
+
+def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
+    if not os.path.isfile(filename):
+        raise FileNotFoundError(msg_tmpl.format(filename))
+
+
+
+

TransRAC/dataset/label_norm.py

@@ -0,0 +1,35 @@
+""" transform label to groundtruth(density map)"""
+from scipy import integrate
+import math
+import numpy as np
+
+
+def PDF(x, u, sig):
+    # f(x)
+    return np.exp(-(x - u) ** 2 / (2 * sig ** 2)) / (math.sqrt(2 * math.pi) * sig)
+
+# integral f(x)
+def get_integrate(x_1, x_2, avg, sig):
+    y, err = integrate.quad(PDF, x_1, x_2, args=(avg, sig))
+    return y
+
+
+def normalize_label(y_frame, y_length):
+    # y_length: total frames
+    # return: normalize_label  size:nparray(y_length,)
+    y_label = [0 for i in range(y_length)]  # 坐标轴长度，即帧数
+    for i in range(0, len(y_frame), 2):
+        x_a = y_frame[i]
+        x_b = y_frame[i + 1]
+        avg = (x_b + x_a) / 2
+        sig = (x_b - x_a) / 6
+        num = x_b - x_a + 1  # 帧数量 update 1104
+        if num != 1:
+            for j in range(num):
+                x_1 = x_a - 0.5 + j
+                x_2 = x_a + 0.5 + j
+                y_ing = get_integrate(x_1, x_2, avg, sig)
+                y_label[x_a + j] = y_ing
+        else:
+            y_label[x_a] = 1
+    return y_label

TransRAC/figures/readme.md

@@ -0,0 +1 @@
+

TransRAC/log/__init__.py

@@ -0,0 +1 @@
+## store log

TransRAC/mmaction/__init__.py

@@ -0,0 +1,15 @@
+import mmcv
+from mmcv import digit_version
+
+from .version import __version__
+
+mmcv_minimum_version = '1.3.1'
+mmcv_maximum_version = '1.4.0'
+mmcv_version = digit_version(mmcv.__version__)
+
+assert (digit_version(mmcv_minimum_version) <= mmcv_version
+        <= digit_version(mmcv_maximum_version)), \
+    f'MMCV=={mmcv.__version__} is used but incompatible. ' \
+    f'Please install mmcv>={mmcv_minimum_version}, <={mmcv_maximum_version}.'
+
+__all__ = ['__version__']

TransRAC/mmaction/apis/__init__.py

@@ -0,0 +1,8 @@
+from .inference import inference_recognizer, init_recognizer
+from .test import multi_gpu_test, single_gpu_test
+from .train import train_model
+
+__all__ = [
+    'train_model', 'init_recognizer', 'inference_recognizer', 'multi_gpu_test',
+    'single_gpu_test'
+]

TransRAC/mmaction/apis/inference.py

@@ -0,0 +1,156 @@
+import os
+import os.path as osp
+import re
+from operator import itemgetter
+
+import mmcv
+import torch
+from mmcv.parallel import collate, scatter
+from mmcv.runner import load_checkpoint
+
+from mmaction.core import OutputHook
+from mmaction.datasets.pipelines import Compose
+from mmaction.models import build_recognizer
+
+
+def init_recognizer(config,
+                    checkpoint=None,
+                    device='cuda:0',
+                    use_frames=False):
+    """Initialize a recognizer from config file.
+
+    Args:
+        config (str | :obj:`mmcv.Config`): Config file path or the config
+            object.
+        checkpoint (str | None, optional): Checkpoint path/url. If set to None,
+            the model will not load any weights. Default: None.
+        device (str | :obj:`torch.device`): The desired device of returned
+            tensor. Default: 'cuda:0'.
+        use_frames (bool): Whether to use rawframes as input. Default:False.
+
+    Returns:
+        nn.Module: The constructed recognizer.
+    """
+    if isinstance(config, str):
+        config = mmcv.Config.fromfile(config)
+    elif not isinstance(config, mmcv.Config):
+        raise TypeError('config must be a filename or Config object, '
+                        f'but got {type(config)}')
+    if ((use_frames and config.dataset_type != 'RawframeDataset')
+            or (not use_frames and config.dataset_type != 'VideoDataset')):
+        input_type = 'rawframes' if use_frames else 'video'
+        raise RuntimeError('input data type should be consist with the '
+                           f'dataset type in config, but got input type '
+                           f"'{input_type}' and dataset type "
+                           f"'{config.dataset_type}'")
+
+    # pretrained model is unnecessary since we directly load checkpoint later
+    config.model.backbone.pretrained = None
+    model = build_recognizer(config.model, test_cfg=config.get('test_cfg'))
+
+    if checkpoint is not None:
+        load_checkpoint(model, checkpoint, map_location=device)
+    model.cfg = config
+    model.to(device)
+    model.eval()
+    return model
+
+
+def inference_recognizer(model,
+                         video_path,
+                         label_path,
+                         use_frames=False,
+                         outputs=None,
+                         as_tensor=True):
+    """Inference a video with the detector.
+
+    Args:
+        model (nn.Module): The loaded recognizer.
+        video_path (str): The video file path/url or the rawframes directory
+            path. If ``use_frames`` is set to True, it should be rawframes
+            directory path. Otherwise, it should be video file path.
+        label_path (str): The label file path.
+        use_frames (bool): Whether to use rawframes as input. Default:False.
+        outputs (list(str) | tuple(str) | str | None) : Names of layers whose
+            outputs need to be returned, default: None.
+        as_tensor (bool): Same as that in ``OutputHook``. Default: True.
+
+    Returns:
+        dict[tuple(str, float)]: Top-5 recognition result dict.
+        dict[torch.tensor | np.ndarray]:
+            Output feature maps from layers specified in `outputs`.
+    """
+    if not (osp.exists(video_path) or video_path.startswith('http')):
+        raise RuntimeError(f"'{video_path}' is missing")
+
+    if osp.isfile(video_path) and use_frames:
+        raise RuntimeError(
+            f"'{video_path}' is a video file, not a rawframe directory")
+    if osp.isdir(video_path) and not use_frames:
+        raise RuntimeError(
+            f"'{video_path}' is a rawframe directory, not a video file")
+
+    if isinstance(outputs, str):
+        outputs = (outputs, )
+    assert outputs is None or isinstance(outputs, (tuple, list))
+
+    cfg = model.cfg
+    device = next(model.parameters()).device  # model device
+    # construct label map
+    with open(label_path, 'r') as f:
+        label = [line.strip() for line in f]
+    # build the data pipeline
+    test_pipeline = cfg.data.test.pipeline
+    test_pipeline = Compose(test_pipeline)
+    # prepare data
+    if use_frames:
+        filename_tmpl = cfg.data.test.get('filename_tmpl', 'img_{:05}.jpg')
+        modality = cfg.data.test.get('modality', 'RGB')
+        start_index = cfg.data.test.get('start_index', 1)
+
+        # count the number of frames that match the format of `filename_tmpl`
+        # RGB pattern example: img_{:05}.jpg -> ^img_\d+.jpg$
+        # Flow patteren example: {}_{:05d}.jpg -> ^x_\d+.jpg$
+        pattern = f'^{filename_tmpl}$'
+        if modality == 'Flow':
+            pattern = pattern.replace('{}', 'x')
+        pattern = pattern.replace(
+            pattern[pattern.find('{'):pattern.find('}') + 1], '\\d+')
+        total_frames = len(
+            list(
+                filter(lambda x: re.match(pattern, x) is not None,
+                       os.listdir(video_path))))
+
+        data = dict(
+            frame_dir=video_path,
+            total_frames=total_frames,
+            label=-1,
+            start_index=start_index,
+            filename_tmpl=filename_tmpl,
+            modality=modality)
+    else:
+        start_index = cfg.data.test.get('start_index', 0)
+        data = dict(
+            filename=video_path,
+            label=-1,
+            start_index=start_index,
+            modality='RGB')
+    data = test_pipeline(data)
+    data = collate([data], samples_per_gpu=1)
+    if next(model.parameters()).is_cuda:
+        # scatter to specified GPU
+        data = scatter(data, [device])[0]
+
+    # forward the model
+    with OutputHook(model, outputs=outputs, as_tensor=as_tensor) as h:
+        with torch.no_grad():
+            scores = model(return_loss=False, **data)[0]
+        returned_features = h.layer_outputs if outputs else None
+
+    score_tuples = tuple(zip(label, scores))
+    score_sorted = sorted(score_tuples, key=itemgetter(1), reverse=True)
+
+    top5_label = score_sorted[:5]
+    if outputs:
+        return top5_label, returned_features
+    return top5_label

TransRAC/mmaction/apis/test.py

@@ -0,0 +1,204 @@
+import os.path as osp
+import pickle
+import shutil
+import tempfile
+# TODO import test functions from mmcv and delete them from mmaction2
+import warnings
+
+import mmcv
+import torch
+import torch.distributed as dist
+from mmcv.runner import get_dist_info
+
+try:
+    from mmcv.engine import (single_gpu_test, multi_gpu_test,
+                             collect_results_gpu, collect_results_cpu)
+    from_mmcv = True
+except (ImportError, ModuleNotFoundError):
+    warnings.warn(
+        'DeprecationWarning: single_gpu_test, multi_gpu_test, '
+        'collect_results_cpu, collect_results_gpu from mmaction2 will be '
+        'deprecated. Please install mmcv through master branch.')
+    from_mmcv = False
+
+if not from_mmcv:
+
+    def single_gpu_test(model, data_loader):  # noqa: F811
+        """Test model with a single gpu.
+
+        This method tests model with a single gpu and
+        displays test progress bar.
+
+        Args:
+            model (nn.Module): Model to be tested.
+            data_loader (nn.Dataloader): Pytorch data loader.
+
+        Returns:
+            list: The prediction results.
+        """
+        model.eval()
+        results = []
+        dataset = data_loader.dataset
+        prog_bar = mmcv.ProgressBar(len(dataset))
+        for data in data_loader:
+            with torch.no_grad():
+                result = model(return_loss=False, **data)
+            results.extend(result)
+
+            # use the first key as main key to calculate the batch size
+            batch_size = len(next(iter(data.values())))
+            for _ in range(batch_size):
+                prog_bar.update()
+        return results
+
+    def multi_gpu_test(  # noqa: F811
+            model, data_loader, tmpdir=None, gpu_collect=True):
+        """Test model with multiple gpus.
+
+        This method tests model with multiple gpus and collects the results
+        under two different modes: gpu and cpu modes. By setting
+        'gpu_collect=True' it encodes results to gpu tensors and use gpu
+        communication for results collection. On cpu mode it saves the results
+        on different gpus to 'tmpdir' and collects them by the rank 0 worker.
+
+        Args:
+            model (nn.Module): Model to be tested.
+            data_loader (nn.Dataloader): Pytorch data loader.
+            tmpdir (str): Path of directory to save the temporary results from
+                different gpus under cpu mode. Default: None
+            gpu_collect (bool): Option to use either gpu or cpu to collect
+                results. Default: True
+
+        Returns:
+            list: The prediction results.
+        """
+        model.eval()
+        results = []
+        dataset = data_loader.dataset
+        rank, world_size = get_dist_info()
+        if rank == 0:
+            prog_bar = mmcv.ProgressBar(len(dataset))
+        for data in data_loader:
+            with torch.no_grad():
+                result = model(return_loss=False, **data)
+            results.extend(result)
+
+            if rank == 0:
+                # use the first key as main key to calculate the batch size
+                batch_size = len(next(iter(data.values())))
+                for _ in range(batch_size * world_size):
+                    prog_bar.update()
+
+        # collect results from all ranks
+        if gpu_collect:
+            results = collect_results_gpu(results, len(dataset))
+        else:
+            results = collect_results_cpu(results, len(dataset), tmpdir)
+        return results
+
+    def collect_results_cpu(result_part, size, tmpdir=None):  # noqa: F811
+        """Collect results in cpu mode.
+
+        It saves the results on different gpus to 'tmpdir' and collects
+        them by the rank 0 worker.
+
+        Args:
+            result_part (list): Results to be collected
+            size (int): Result size.
+            tmpdir (str): Path of directory to save the temporary results from
+                different gpus under cpu mode. Default: None
+
+        Returns:
+            list: Ordered results.
+        """
+        rank, world_size = get_dist_info()
+        # create a tmp dir if it is not specified
+        if tmpdir is None:
+            MAX_LEN = 512
+            # 32 is whitespace
+            dir_tensor = torch.full((MAX_LEN, ),
+                                    32,
+                                    dtype=torch.uint8,
+                                    device='cuda')
+            if rank == 0:
+                mmcv.mkdir_or_exist('.dist_test')
+                tmpdir = tempfile.mkdtemp(dir='.dist_test')
+                tmpdir = torch.tensor(
+                    bytearray(tmpdir.encode()),
+                    dtype=torch.uint8,
+                    device='cuda')
+                dir_tensor[:len(tmpdir)] = tmpdir
+            dist.broadcast(dir_tensor, 0)
+            tmpdir = dir_tensor.cpu().numpy().tobytes().decode().rstrip()
+        else:
+            mmcv.mkdir_or_exist(tmpdir)
+        # synchronizes all processes to make sure tmpdir exist
+        dist.barrier()
+        # dump the part result to the dir
+        mmcv.dump(result_part, osp.join(tmpdir, f'part_{rank}.pkl'))
+        # synchronizes all processes for loding pickle file
+        dist.barrier()
+        # collect all parts
+        if rank != 0:
+            return None
+        # load results of all parts from tmp dir
+        part_list = []
+        for i in range(world_size):
+            part_file = osp.join(tmpdir, f'part_{i}.pkl')
+            part_list.append(mmcv.load(part_file))
+        # sort the results
+        ordered_results = []
+        for res in zip(*part_list):
+            ordered_results.extend(list(res))
+        # the dataloader may pad some samples
+        ordered_results = ordered_results[:size]
+        # remove tmp dir
+        shutil.rmtree(tmpdir)
+        return ordered_results
+
+    def collect_results_gpu(result_part, size):  # noqa: F811
+        """Collect results in gpu mode.
+
+        It encodes results to gpu tensors and use gpu communication for results
+        collection.
+
+        Args:
+            result_part (list): Results to be collected
+            size (int): Result size.
+
+        Returns:
+            list: Ordered results.
+        """
+        rank, world_size = get_dist_info()
+        # dump result part to tensor with pickle
+        part_tensor = torch.tensor(
+            bytearray(pickle.dumps(result_part)),
+            dtype=torch.uint8,
+            device='cuda')
+        # gather all result part tensor shape
+        shape_tensor = torch.tensor(part_tensor.shape, device='cuda')
+        shape_list = [shape_tensor.clone() for _ in range(world_size)]
+        dist.all_gather(shape_list, shape_tensor)
+        # padding result part tensor to max length
+        shape_max = torch.tensor(shape_list).max()
+        part_send = torch.zeros(shape_max, dtype=torch.uint8, device='cuda')
+        part_send[:shape_tensor[0]] = part_tensor
+        part_recv_list = [
+            part_tensor.new_zeros(shape_max) for _ in range(world_size)
+        ]
+        # gather all result part
+        dist.all_gather(part_recv_list, part_send)
+
+        if rank == 0:
+            part_list = []
+            for recv, shape in zip(part_recv_list, shape_list):
+                part_list.append(
+                    pickle.loads(recv[:shape[0]].cpu().numpy().tobytes()))
+            # sort the results
+            ordered_results = []
+            for res in zip(*part_list):
+                ordered_results.extend(list(res))
+            # the dataloader may pad some samples
+            ordered_results = ordered_results[:size]
+            return ordered_results
+        return None

TransRAC/mmaction/apis/train.py

@@ -0,0 +1,261 @@
+import copy as cp
+import os.path as osp
+
+import torch
+from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
+from mmcv.runner import (DistSamplerSeedHook, EpochBasedRunner, OptimizerHook,
+                         build_optimizer, get_dist_info)
+from mmcv.runner.hooks import Fp16OptimizerHook
+
+from ..core import (DistEvalHook, EvalHook, OmniSourceDistSamplerSeedHook,
+                    OmniSourceRunner)
+from ..datasets import build_dataloader, build_dataset
+from ..utils import PreciseBNHook, get_root_logger
+from .test import multi_gpu_test
+from mmcv_custom.runner import EpochBasedRunnerAmp
+import apex
+import os.path as osp
+
+
+def train_model(model,
+                dataset,
+                cfg,
+                distributed=False,
+                validate=False,
+                test=dict(test_best=False, test_last=False),
+                timestamp=None,
+                meta=None):
+    """Train model entry function.
+
+    Args:
+        model (nn.Module): The model to be trained.
+        dataset (:obj:`Dataset`): Train dataset.
+        cfg (dict): The config dict for training.
+        distributed (bool): Whether to use distributed training.
+            Default: False.
+        validate (bool): Whether to do evaluation. Default: False.
+        test (dict): The testing option, with two keys: test_last & test_best.
+            The value is True or False, indicating whether to test the
+            corresponding checkpoint.
+            Default: dict(test_best=False, test_last=False).
+        timestamp (str | None): Local time for runner. Default: None.
+        meta (dict | None): Meta dict to record some important information.
+            Default: None
+    """
+    logger = get_root_logger(log_level=cfg.log_level)
+
+    # prepare data loaders
+    dataset = dataset if isinstance(dataset, (list, tuple)) else [dataset]
+
+    if 'optimizer_config' not in cfg:
+        cfg.optimizer_config={}
+    dataloader_setting = dict(
+        videos_per_gpu=cfg.data.get('videos_per_gpu', 1) // cfg.optimizer_config.get('update_interval', 1),
+        workers_per_gpu=cfg.data.get('workers_per_gpu', 1),
+        num_gpus=len(cfg.gpu_ids),
+        dist=distributed,
+        seed=cfg.seed)
+    dataloader_setting = dict(dataloader_setting,
+                              **cfg.data.get('train_dataloader', {}))
+
+    if cfg.omnisource:
+        # The option can override videos_per_gpu
+        train_ratio = cfg.data.get('train_ratio', [1] * len(dataset))
+        omni_videos_per_gpu = cfg.data.get('omni_videos_per_gpu', None)
+        if omni_videos_per_gpu is None:
+            dataloader_settings = [dataloader_setting] * len(dataset)
+        else:
+            dataloader_settings = []
+            for videos_per_gpu in omni_videos_per_gpu:
+                this_setting = cp.deepcopy(dataloader_setting)
+                this_setting['videos_per_gpu'] = videos_per_gpu
+                dataloader_settings.append(this_setting)
+        data_loaders = [
+            build_dataloader(ds, **setting)
+            for ds, setting in zip(dataset, dataloader_settings)
+        ]
+
+    else:
+        data_loaders = [
+            build_dataloader(ds, **dataloader_setting) for ds in dataset
+        ]
+
+    # build runner
+    optimizer = build_optimizer(model, cfg.optimizer)
+    # use apex fp16 optimizer
+    # Noticed that this is just a temporary patch. We shoud not encourage this kind of code style
+    use_amp = False
+    if (
+        cfg.optimizer_config.get("type", None)
+        and cfg.optimizer_config["type"] == "DistOptimizerHook"
+    ):
+        if cfg.optimizer_config.get("use_fp16", False):
+            model, optimizer = apex.amp.initialize(
+                model.cuda(), optimizer, opt_level="O1"
+            )
+            for m in model.modules():
+                if hasattr(m, "fp16_enabled"):
+                    m.fp16_enabled = True
+            use_amp = True
+
+    # put model on gpus
+    if distributed:
+        find_unused_parameters = cfg.get('find_unused_parameters', False)
+        # Sets the `find_unused_parameters` parameter in
+        # torch.nn.parallel.DistributedDataParallel
+        model = MMDistributedDataParallel(
+            model.cuda(),
+            device_ids=[torch.cuda.current_device()],
+            broadcast_buffers=False,
+            find_unused_parameters=find_unused_parameters)
+    else:
+        model = MMDataParallel(
+            model.cuda(cfg.gpu_ids[0]), device_ids=cfg.gpu_ids)
+
+    if use_amp:
+        Runner = EpochBasedRunnerAmp
+        runner = Runner(
+            model,
+            optimizer=optimizer,
+            work_dir=cfg.work_dir,
+            logger=logger,
+            meta=meta,
+            amp=use_amp)
+    else:
+        Runner = OmniSourceRunner if cfg.omnisource else EpochBasedRunner
+        runner = Runner(
+            model,
+            optimizer=optimizer,
+            work_dir=cfg.work_dir,
+            logger=logger,
+            meta=meta)
+    # an ugly workaround to make .log and .log.json filenames the same
+    runner.timestamp = timestamp
+
+    # fp16 setting
+    fp16_cfg = cfg.get('fp16', None)
+    if fp16_cfg is not None:
+        optimizer_config = Fp16OptimizerHook(
+            **cfg.optimizer_config, **fp16_cfg, distributed=distributed)
+    elif distributed and 'type' not in cfg.optimizer_config:
+        optimizer_config = OptimizerHook(**cfg.optimizer_config)
+    else:
+        optimizer_config = cfg.optimizer_config
+
+    # register hooks
+    runner.register_training_hooks(cfg.lr_config, optimizer_config,
+                                   cfg.checkpoint_config, cfg.log_config,
+                                   cfg.get('momentum_config', None))
+    if distributed:
+        if cfg.omnisource:
+            runner.register_hook(OmniSourceDistSamplerSeedHook())
+        else:
+            runner.register_hook(DistSamplerSeedHook())
+
+    # precise bn setting
+    if cfg.get('precise_bn', False):
+        precise_bn_dataset = build_dataset(cfg.data.train)
+        dataloader_setting = dict(
+            videos_per_gpu=cfg.data.get('videos_per_gpu', 1),
+            workers_per_gpu=0,  # save memory and time
+            num_gpus=len(cfg.gpu_ids),
+            dist=distributed,
+            seed=cfg.seed)
+        data_loader_precise_bn = build_dataloader(precise_bn_dataset,
+                                                  **dataloader_setting)
+        precise_bn_hook = PreciseBNHook(data_loader_precise_bn,
+                                        **cfg.get('precise_bn'))
+        runner.register_hook(precise_bn_hook)
+
+    if validate:
+        eval_cfg = cfg.get('evaluation', {})
+        val_dataset = build_dataset(cfg.data.val, dict(test_mode=True))
+        dataloader_setting = dict(
+            videos_per_gpu=cfg.data.get('videos_per_gpu', 1),
+            workers_per_gpu=cfg.data.get('workers_per_gpu', 1),
+            # cfg.gpus will be ignored if distributed
+            num_gpus=len(cfg.gpu_ids),
+            dist=distributed,
+            shuffle=False)
+        dataloader_setting = dict(dataloader_setting,
+                                  **cfg.data.get('val_dataloader', {}))
+        val_dataloader = build_dataloader(val_dataset, **dataloader_setting)
+        eval_hook = DistEvalHook if distributed else EvalHook
+        runner.register_hook(eval_hook(val_dataloader, **eval_cfg))
+
+    if cfg.resume_from:
+        runner.resume(cfg.resume_from, resume_amp=use_amp)
+    elif cfg.get("auto_resume", False) and osp.exists(osp.join(runner.work_dir, 'latest.pth')):
+        runner.auto_resume()
+    elif cfg.load_from:
+        runner.load_checkpoint(cfg.load_from)
+    runner_kwargs = dict()
+    if cfg.omnisource:
+        runner_kwargs = dict(train_ratio=train_ratio)
+    runner.run(data_loaders, cfg.workflow, cfg.total_epochs, **runner_kwargs)
+
+    if test['test_last'] or test['test_best']:
+        best_ckpt_path = None
+        if test['test_best']:
+            if hasattr(eval_hook, 'best_ckpt_path'):
+                best_ckpt_path = eval_hook.best_ckpt_path
+
+            if best_ckpt_path is None or not osp.exists(best_ckpt_path):
+                test['test_best'] = False
+                if best_ckpt_path is None:
+                    runner.logger.info('Warning: test_best set as True, but '
+                                       'is not applicable '
+                                       '(eval_hook.best_ckpt_path is None)')
+                else:
+                    runner.logger.info('Warning: test_best set as True, but '
+                                       'is not applicable (best_ckpt '
+                                       f'{best_ckpt_path} not found)')
+                if not test['test_last']:
+                    return
+
+        test_dataset = build_dataset(cfg.data.test, dict(test_mode=True))
+        gpu_collect = cfg.get('evaluation', {}).get('gpu_collect', False)
+        tmpdir = cfg.get('evaluation', {}).get('tmpdir',
+                                               osp.join(cfg.work_dir, 'tmp'))
+        dataloader_setting = dict(
+            videos_per_gpu=cfg.data.get('videos_per_gpu', 1),
+            workers_per_gpu=cfg.data.get('workers_per_gpu', 1),
+            num_gpus=len(cfg.gpu_ids),
+            dist=distributed,
+            shuffle=False)
+        dataloader_setting = dict(dataloader_setting,
+                                  **cfg.data.get('test_dataloader', {}))
+
+        test_dataloader = build_dataloader(test_dataset, **dataloader_setting)
+
+        names, ckpts = [], []
+
+        if test['test_last']:
+            names.append('last')
+            ckpts.append(None)
+        if test['test_best']:
+            names.append('best')
+            ckpts.append(best_ckpt_path)
+
+        for name, ckpt in zip(names, ckpts):
+            if ckpt is not None:
+                runner.load_checkpoint(ckpt)
+
+            outputs = multi_gpu_test(runner.model, test_dataloader, tmpdir,
+                                     gpu_collect)
+            rank, _ = get_dist_info()
+            if rank == 0:
+                out = osp.join(cfg.work_dir, f'{name}_pred.pkl')
+                test_dataset.dump_results(outputs, out)
+
+                eval_cfg = cfg.get('evaluation', {})
+                for key in [
+                        'interval', 'tmpdir', 'start', 'gpu_collect',
+                        'save_best', 'rule', 'by_epoch', 'broadcast_bn_buffers'
+                ]:
+                    eval_cfg.pop(key, None)
+
+                eval_res = test_dataset.evaluate(outputs, **eval_cfg)
+                runner.logger.info(f'Testing results of the {name} checkpoint')
+                for metric_name, val in eval_res.items():
+                    runner.logger.info(f'{metric_name}: {val:.04f}')

TransRAC/mmaction/core/__init__.py

@@ -0,0 +1,6 @@
+from .bbox import *  # noqa: F401, F403
+from .evaluation import *  # noqa: F401, F403
+from .hooks import *  # noqa: F401, F403
+from .optimizer import *  # noqa: F401, F403
+from .runner import *  # noqa: F401, F403
+from .scheduler import *  # noqa: F401, F403

TransRAC/mmaction/datasets/__init__.py

@@ -0,0 +1,27 @@
+from .activitynet_dataset import ActivityNetDataset
+from .audio_dataset import AudioDataset
+from .audio_feature_dataset import AudioFeatureDataset
+from .audio_visual_dataset import AudioVisualDataset
+from .ava_dataset import AVADataset
+from .base import BaseDataset
+from .blending_utils import (BaseMiniBatchBlending, CutmixBlending,
+                             MixupBlending, LabelSmoothing)
+from .builder import (BLENDINGS, DATASETS, PIPELINES, build_dataloader,
+                      build_dataset)
+from .dataset_wrappers import RepeatDataset
+from .hvu_dataset import HVUDataset
+from .image_dataset import ImageDataset
+from .pose_dataset import PoseDataset
+from .rawframe_dataset import RawframeDataset
+from .rawvideo_dataset import RawVideoDataset
+from .ssn_dataset import SSNDataset
+from .video_dataset import VideoDataset
+
+__all__ = [
+    'VideoDataset', 'build_dataloader', 'build_dataset', 'RepeatDataset',
+    'RawframeDataset', 'BaseDataset', 'ActivityNetDataset', 'SSNDataset',
+    'HVUDataset', 'AudioDataset', 'AudioFeatureDataset', 'ImageDataset',
+    'RawVideoDataset', 'AVADataset', 'AudioVisualDataset',
+    'BaseMiniBatchBlending', 'CutmixBlending', 'MixupBlending', 'LabelSmoothing', 'DATASETS',
+    'PIPELINES', 'BLENDINGS', 'PoseDataset'
+]

TransRAC/mmaction/datasets/activitynet_dataset.py

@@ -0,0 +1,269 @@
+import copy
+import os
+import os.path as osp
+import warnings
+from collections import OrderedDict
+
+import mmcv
+import numpy as np
+
+from ..core import average_recall_at_avg_proposals
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class ActivityNetDataset(BaseDataset):
+    """ActivityNet dataset for temporal action localization.
+
+    The dataset loads raw features and apply specified transforms to return a
+    dict containing the frame tensors and other information.
+
+    The ann_file is a json file with multiple objects, and each object has a
+    key of the name of a video, and value of total frames of the video, total
+    seconds of the video, annotations of a video, feature frames (frames
+    covered by features) of the video, fps and rfps. Example of a
+    annotation file:
+
+    .. code-block:: JSON
+
+        {
+            "v_--1DO2V4K74":  {
+                "duration_second": 211.53,
+                "duration_frame": 6337,
+                "annotations": [
+                    {
+                        "segment": [
+                            30.025882995319815,
+                            205.2318595943838
+                        ],
+                        "label": "Rock climbing"
+                    }
+                ],
+                "feature_frame": 6336,
+                "fps": 30.0,
+                "rfps": 29.9579255898
+            },
+            "v_--6bJUbfpnQ": {
+                "duration_second": 26.75,
+                "duration_frame": 647,
+                "annotations": [
+                    {
+                        "segment": [
+                            2.578755070202808,
+                            24.914101404056165
+                        ],
+                        "label": "Drinking beer"
+                    }
+                ],
+                "feature_frame": 624,
+                "fps": 24.0,
+                "rfps": 24.1869158879
+            },
+            ...
+        }
+
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        data_prefix (str | None): Path to a directory where videos are held.
+            Default: None.
+        test_mode (bool): Store True when building test or validation dataset.
+            Default: False.
+    """
+
+    def __init__(self, ann_file, pipeline, data_prefix=None, test_mode=False):
+        super().__init__(ann_file, pipeline, data_prefix, test_mode)
+
+    def load_annotations(self):
+        """Load the annotation according to ann_file into video_infos."""
+        video_infos = []
+        anno_database = mmcv.load(self.ann_file)
+        for video_name in anno_database:
+            video_info = anno_database[video_name]
+            video_info['video_name'] = video_name
+            video_infos.append(video_info)
+        return video_infos
+
+    def prepare_test_frames(self, idx):
+        """Prepare the frames for testing given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['data_prefix'] = self.data_prefix
+        return self.pipeline(results)
+
+    def prepare_train_frames(self, idx):
+        """Prepare the frames for training given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['data_prefix'] = self.data_prefix
+        return self.pipeline(results)
+
+    def __len__(self):
+        """Get the size of the dataset."""
+        return len(self.video_infos)
+
+    def _import_ground_truth(self):
+        """Read ground truth data from video_infos."""
+        ground_truth = {}
+        for video_info in self.video_infos:
+            video_id = video_info['video_name'][2:]
+            this_video_ground_truths = []
+            for ann in video_info['annotations']:
+                t_start, t_end = ann['segment']
+                label = ann['label']
+                this_video_ground_truths.append([t_start, t_end, label])
+            ground_truth[video_id] = np.array(this_video_ground_truths)
+        return ground_truth
+
+    @staticmethod
+    def proposals2json(results, show_progress=False):
+        """Convert all proposals to a final dict(json) format.
+
+        Args:
+            results (list[dict]): All proposals.
+            show_progress (bool): Whether to show the progress bar.
+                Defaults: False.
+
+        Returns:
+            dict: The final result dict. E.g.
+
+            .. code-block:: Python
+
+                dict(video-1=[dict(segment=[1.1,2.0]. score=0.9),
+                              dict(segment=[50.1, 129.3], score=0.6)])
+        """
+        result_dict = {}
+        print('Convert proposals to json format')
+        if show_progress:
+            prog_bar = mmcv.ProgressBar(len(results))
+        for result in results:
+            video_name = result['video_name']
+            result_dict[video_name[2:]] = result['proposal_list']
+            if show_progress:
+                prog_bar.update()
+        return result_dict
+
+    @staticmethod
+    def _import_proposals(results):
+        """Read predictions from results."""
+        proposals = {}
+        num_proposals = 0
+        for result in results:
+            video_id = result['video_name'][2:]
+            this_video_proposals = []
+            for proposal in result['proposal_list']:
+                t_start, t_end = proposal['segment']
+                score = proposal['score']
+                this_video_proposals.append([t_start, t_end, score])
+                num_proposals += 1
+            proposals[video_id] = np.array(this_video_proposals)
+        return proposals, num_proposals
+
+    def dump_results(self, results, out, output_format, version='VERSION 1.3'):
+        """Dump data to json/csv files."""
+        if output_format == 'json':
+            result_dict = self.proposals2json(results)
+            output_dict = {
+                'version': version,
+                'results': result_dict,
+                'external_data': {}
+            }
+            mmcv.dump(output_dict, out)
+        elif output_format == 'csv':
+            # TODO: add csv handler to mmcv and use mmcv.dump
+            os.makedirs(out, exist_ok=True)
+            header = 'action,start,end,tmin,tmax'
+            for result in results:
+                video_name, outputs = result
+                output_path = osp.join(out, video_name + '.csv')
+                np.savetxt(
+                    output_path,
+                    outputs,
+                    header=header,
+                    delimiter=',',
+                    comments='')
+        else:
+            raise ValueError(
+                f'The output format {output_format} is not supported.')
+
+    def evaluate(
+            self,
+            results,
+            metrics='AR@AN',
+            metric_options={
+                'AR@AN':
+                dict(
+                    max_avg_proposals=100,
+                    temporal_iou_thresholds=np.linspace(0.5, 0.95, 10))
+            },
+            logger=None,
+            **deprecated_kwargs):
+        """Evaluation in feature dataset.
+
+        Args:
+            results (list[dict]): Output results.
+            metrics (str | sequence[str]): Metrics to be performed.
+                Defaults: 'AR@AN'.
+            metric_options (dict): Dict for metric options. Options are
+                ``max_avg_proposals``, ``temporal_iou_thresholds`` for
+                ``AR@AN``.
+                default: ``{'AR@AN': dict(max_avg_proposals=100,
+                temporal_iou_thresholds=np.linspace(0.5, 0.95, 10))}``.
+            logger (logging.Logger | None): Training logger. Defaults: None.
+            deprecated_kwargs (dict): Used for containing deprecated arguments.
+                See 'https://github.com/open-mmlab/mmaction2/pull/286'.
+
+        Returns:
+            dict: Evaluation results for evaluation metrics.
+        """
+        # Protect ``metric_options`` since it uses mutable value as default
+        metric_options = copy.deepcopy(metric_options)
+
+        if deprecated_kwargs != {}:
+            warnings.warn(
+                'Option arguments for metrics has been changed to '
+                "`metric_options`, See 'https://github.com/open-mmlab/mmaction2/pull/286' "  # noqa: E501
+                'for more details')
+            metric_options['AR@AN'] = dict(metric_options['AR@AN'],
+                                           **deprecated_kwargs)
+
+        if not isinstance(results, list):
+            raise TypeError(f'results must be a list, but got {type(results)}')
+        assert len(results) == len(self), (
+            f'The length of results is not equal to the dataset len: '
+            f'{len(results)} != {len(self)}')
+
+        metrics = metrics if isinstance(metrics, (list, tuple)) else [metrics]
+        allowed_metrics = ['AR@AN']
+        for metric in metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(f'metric {metric} is not supported')
+
+        eval_results = OrderedDict()
+        ground_truth = self._import_ground_truth()
+        proposal, num_proposals = self._import_proposals(results)
+
+        for metric in metrics:
+            if metric == 'AR@AN':
+                temporal_iou_thresholds = metric_options.setdefault(
+                    'AR@AN', {}).setdefault('temporal_iou_thresholds',
+                                            np.linspace(0.5, 0.95, 10))
+                max_avg_proposals = metric_options.setdefault(
+                    'AR@AN', {}).setdefault('max_avg_proposals', 100)
+                if isinstance(temporal_iou_thresholds, list):
+                    temporal_iou_thresholds = np.array(temporal_iou_thresholds)
+
+                recall, _, _, auc = (
+                    average_recall_at_avg_proposals(
+                        ground_truth,
+                        proposal,
+                        num_proposals,
+                        max_avg_proposals=max_avg_proposals,
+                        temporal_iou_thresholds=temporal_iou_thresholds))
+                eval_results['auc'] = auc
+                eval_results['AR@1'] = np.mean(recall[:, 0])
+                eval_results['AR@5'] = np.mean(recall[:, 4])
+                eval_results['AR@10'] = np.mean(recall[:, 9])
+                eval_results['AR@100'] = np.mean(recall[:, 99])
+
+        return eval_results

TransRAC/mmaction/datasets/audio_dataset.py

@@ -0,0 +1,69 @@
+import os.path as osp
+
+import torch
+
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class AudioDataset(BaseDataset):
+    """Audio dataset for video recognition. Extracts the audio feature on-the-
+    fly. Annotation file can be that of the rawframe dataset, or:
+
+    .. code-block:: txt
+
+        some/directory-1.wav 163 1
+        some/directory-2.wav 122 1
+        some/directory-3.wav 258 2
+        some/directory-4.wav 234 2
+        some/directory-5.wav 295 3
+        some/directory-6.wav 121 3
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        suffix (str): The suffix of the audio file. Default: '.wav'.
+        kwargs (dict): Other keyword args for `BaseDataset`.
+    """
+
+    def __init__(self, ann_file, pipeline, suffix='.wav', **kwargs):
+        self.suffix = suffix
+        super().__init__(ann_file, pipeline, modality='Audio', **kwargs)
+
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        if self.ann_file.endswith('.json'):
+            return self.load_json_annotations()
+        video_infos = []
+        with open(self.ann_file, 'r') as fin:
+            for line in fin:
+                line_split = line.strip().split()
+                video_info = {}
+                idx = 0
+                filename = line_split[idx]
+                if self.data_prefix is not None:
+                    if not filename.endswith(self.suffix):
+                        filename = osp.join(self.data_prefix,
+                                            filename + self.suffix)
+                    else:
+                        filename = osp.join(self.data_prefix, filename)
+                video_info['audio_path'] = filename
+                idx += 1
+                # idx for total_frames
+                video_info['total_frames'] = int(line_split[idx])
+                idx += 1
+                # idx for label[s]
+                label = [int(x) for x in line_split[idx:]]
+                assert label, f'missing label in line: {line}'
+                if self.multi_class:
+                    assert self.num_classes is not None
+                    onehot = torch.zeros(self.num_classes)
+                    onehot[label] = 1.0
+                    video_info['label'] = onehot
+                else:
+                    assert len(label) == 1
+                    video_info['label'] = label[0]
+                video_infos.append(video_info)
+
+        return video_infos

TransRAC/mmaction/datasets/audio_feature_dataset.py

@@ -0,0 +1,70 @@
+import os.path as osp
+
+import torch
+
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class AudioFeatureDataset(BaseDataset):
+    """Audio feature dataset for video recognition. Reads the features
+    extracted off-line. Annotation file can be that of the rawframe dataset,
+    or:
+
+    .. code-block:: txt
+
+        some/directory-1.npy 163 1
+        some/directory-2.npy 122 1
+        some/directory-3.npy 258 2
+        some/directory-4.npy 234 2
+        some/directory-5.npy 295 3
+        some/directory-6.npy 121 3
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        suffix (str): The suffix of the audio feature file. Default: '.npy'.
+        kwargs (dict): Other keyword args for `BaseDataset`.
+    """
+
+    def __init__(self, ann_file, pipeline, suffix='.npy', **kwargs):
+        self.suffix = suffix
+        super().__init__(ann_file, pipeline, modality='Audio', **kwargs)
+
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        if self.ann_file.endswith('.json'):
+            return self.load_json_annotations()
+        video_infos = []
+        with open(self.ann_file, 'r') as fin:
+            for line in fin:
+                line_split = line.strip().split()
+                video_info = {}
+                idx = 0
+                filename = line_split[idx]
+                if self.data_prefix is not None:
+                    if not filename.endswith(self.suffix):
+                        filename = osp.join(self.data_prefix,
+                                            filename) + self.suffix
+                    else:
+                        filename = osp.join(self.data_prefix, filename)
+                video_info['audio_path'] = filename
+                idx += 1
+                # idx for total_frames
+                video_info['total_frames'] = int(line_split[idx])
+                idx += 1
+                # idx for label[s]
+                label = [int(x) for x in line_split[idx:]]
+                assert label, f'missing label in line: {line}'
+                if self.multi_class:
+                    assert self.num_classes is not None
+                    onehot = torch.zeros(self.num_classes)
+                    onehot[label] = 1.0
+                    video_info['label'] = onehot
+                else:
+                    assert len(label) == 1
+                    video_info['label'] = label[0]
+                video_infos.append(video_info)
+
+        return video_infos

TransRAC/mmaction/datasets/audio_visual_dataset.py

@@ -0,0 +1,76 @@
+import os.path as osp
+
+from .builder import DATASETS
+from .rawframe_dataset import RawframeDataset
+
+
+@DATASETS.register_module()
+class AudioVisualDataset(RawframeDataset):
+    """Dataset that reads both audio and visual data, supporting both rawframes
+    and videos. The annotation file is same as that of the rawframe dataset,
+    such as:
+
+    .. code-block:: txt
+
+        some/directory-1 163 1
+        some/directory-2 122 1
+        some/directory-3 258 2
+        some/directory-4 234 2
+        some/directory-5 295 3
+        some/directory-6 121 3
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        audio_prefix (str): Directory of the audio files.
+        kwargs (dict): Other keyword args for `RawframeDataset`. `video_prefix`
+            is also allowed if pipeline is designed for videos.
+    """
+
+    def __init__(self, ann_file, pipeline, audio_prefix, **kwargs):
+        self.audio_prefix = audio_prefix
+        self.video_prefix = kwargs.pop('video_prefix', None)
+        self.data_prefix = kwargs.get('data_prefix', None)
+        super().__init__(ann_file, pipeline, **kwargs)
+
+    def load_annotations(self):
+        video_infos = []
+        with open(self.ann_file, 'r') as fin:
+            for line in fin:
+                line_split = line.strip().split()
+                video_info = {}
+                idx = 0
+                # idx for frame_dir
+                frame_dir = line_split[idx]
+                if self.audio_prefix is not None:
+                    audio_path = osp.join(self.audio_prefix,
+                                          frame_dir + '.npy')
+                    video_info['audio_path'] = audio_path
+                if self.video_prefix:
+                    video_path = osp.join(self.video_prefix,
+                                          frame_dir + '.mp4')
+                    video_info['filename'] = video_path
+                if self.data_prefix is not None:
+                    frame_dir = osp.join(self.data_prefix, frame_dir)
+                    video_info['frame_dir'] = frame_dir
+                idx += 1
+                if self.with_offset:
+                    # idx for offset and total_frames
+                    video_info['offset'] = int(line_split[idx])
+                    video_info['total_frames'] = int(line_split[idx + 1])
+                    idx += 2
+                else:
+                    # idx for total_frames
+                    video_info['total_frames'] = int(line_split[idx])
+                    idx += 1
+                # idx for label[s]
+                label = [int(x) for x in line_split[idx:]]
+                assert len(label) != 0, f'missing label in line: {line}'
+                if self.multi_class:
+                    assert self.num_classes is not None
+                    video_info['label'] = label
+                else:
+                    assert len(label) == 1
+                    video_info['label'] = label[0]
+                video_infos.append(video_info)
+        return video_infos

TransRAC/mmaction/datasets/ava_dataset.py

@@ -0,0 +1,382 @@
+import copy
+import os
+import os.path as osp
+from collections import defaultdict
+from datetime import datetime
+
+import mmcv
+import numpy as np
+from mmcv.utils import print_log
+
+from ..core.evaluation.ava_utils import ava_eval, read_labelmap, results2csv
+from ..utils import get_root_logger
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class AVADataset(BaseDataset):
+    """AVA dataset for spatial temporal detection.
+
+    Based on official AVA annotation files, the dataset loads raw frames,
+    bounding boxes, proposals and applies specified transformations to return
+    a dict containing the frame tensors and other information.
+
+    This datasets can load information from the following files:
+
+    .. code-block:: txt
+
+        ann_file -> ava_{train, val}_{v2.1, v2.2}.csv
+        exclude_file -> ava_{train, val}_excluded_timestamps_{v2.1, v2.2}.csv
+        label_file -> ava_action_list_{v2.1, v2.2}.pbtxt /
+                      ava_action_list_{v2.1, v2.2}_for_activitynet_2019.pbtxt
+        proposal_file -> ava_dense_proposals_{train, val}.FAIR.recall_93.9.pkl
+
+    Particularly, the proposal_file is a pickle file which contains
+    ``img_key`` (in format of ``{video_id},{timestamp}``). Example of a pickle
+    file:
+
+    .. code-block:: JSON
+
+        {
+            ...
+            '0f39OWEqJ24,0902':
+                array([[0.011   , 0.157   , 0.655   , 0.983   , 0.998163]]),
+            '0f39OWEqJ24,0912':
+                array([[0.054   , 0.088   , 0.91    , 0.998   , 0.068273],
+                       [0.016   , 0.161   , 0.519   , 0.974   , 0.984025],
+                       [0.493   , 0.283   , 0.981   , 0.984   , 0.983621]]),
+            ...
+        }
+
+    Args:
+        ann_file (str): Path to the annotation file like
+            ``ava_{train, val}_{v2.1, v2.2}.csv``.
+        exclude_file (str): Path to the excluded timestamp file like
+            ``ava_{train, val}_excluded_timestamps_{v2.1, v2.2}.csv``.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        label_file (str): Path to the label file like
+            ``ava_action_list_{v2.1, v2.2}.pbtxt`` or
+            ``ava_action_list_{v2.1, v2.2}_for_activitynet_2019.pbtxt``.
+            Default: None.
+        filename_tmpl (str): Template for each filename.
+            Default: 'img_{:05}.jpg'.
+        proposal_file (str): Path to the proposal file like
+            ``ava_dense_proposals_{train, val}.FAIR.recall_93.9.pkl``.
+            Default: None.
+        person_det_score_thr (float): The threshold of person detection scores,
+            bboxes with scores above the threshold will be used. Default: 0.9.
+            Note that 0 <= person_det_score_thr <= 1. If no proposal has
+            detection score larger than the threshold, the one with the largest
+            detection score will be used.
+        num_classes (int): The number of classes of the dataset. Default: 81.
+            (AVA has 80 action classes, another 1-dim is added for potential
+            usage)
+        custom_classes (list[int]): A subset of class ids from origin dataset.
+            Please note that 0 should NOT be selected, and ``num_classes``
+            should be equal to ``len(custom_classes) + 1``
+        data_prefix (str): Path to a directory where videos are held.
+            Default: None.
+        test_mode (bool): Store True when building test or validation dataset.
+            Default: False.
+        modality (str): Modality of data. Support 'RGB', 'Flow'.
+                        Default: 'RGB'.
+        num_max_proposals (int): Max proposals number to store. Default: 1000.
+        timestamp_start (int): The start point of included timestamps. The
+            default value is referred from the official website. Default: 902.
+        timestamp_end (int): The end point of included timestamps. The
+            default value is referred from the official website. Default: 1798.
+    """
+
+    _FPS = 30
+
+    def __init__(self,
+                 ann_file,
+                 exclude_file,
+                 pipeline,
+                 label_file=None,
+                 filename_tmpl='img_{:05}.jpg',
+                 proposal_file=None,
+                 person_det_score_thr=0.9,
+                 num_classes=81,
+                 custom_classes=None,
+                 data_prefix=None,
+                 test_mode=False,
+                 modality='RGB',
+                 num_max_proposals=1000,
+                 timestamp_start=900,
+                 timestamp_end=1800):
+        # since it inherits from `BaseDataset`, some arguments
+        # should be assigned before performing `load_annotations()`
+        self.custom_classes = custom_classes
+        if custom_classes is not None:
+            assert num_classes == len(custom_classes) + 1
+            assert 0 not in custom_classes
+            _, class_whitelist = read_labelmap(open(label_file))
+            assert set(custom_classes).issubset(class_whitelist)
+
+            self.custom_classes = tuple([0] + custom_classes)
+        self.exclude_file = exclude_file
+        self.label_file = label_file
+        self.proposal_file = proposal_file
+        assert 0 <= person_det_score_thr <= 1, (
+            'The value of '
+            'person_det_score_thr should in [0, 1]. ')
+        self.person_det_score_thr = person_det_score_thr
+        self.num_classes = num_classes
+        self.filename_tmpl = filename_tmpl
+        self.num_max_proposals = num_max_proposals
+        self.timestamp_start = timestamp_start
+        self.timestamp_end = timestamp_end
+        self.logger = get_root_logger()
+        super().__init__(
+            ann_file,
+            pipeline,
+            data_prefix,
+            test_mode,
+            modality=modality,
+            num_classes=num_classes)
+
+        if self.proposal_file is not None:
+            self.proposals = mmcv.load(self.proposal_file)
+        else:
+            self.proposals = None
+
+        if not test_mode:
+            valid_indexes = self.filter_exclude_file()
+            self.logger.info(
+                f'{len(valid_indexes)} out of {len(self.video_infos)} '
+                f'frames are valid.')
+            self.video_infos = [self.video_infos[i] for i in valid_indexes]
+
+    def parse_img_record(self, img_records):
+        """Merge image records of the same entity at the same time.
+
+        Args:
+            img_records (list[dict]): List of img_records (lines in AVA
+                annotations).
+
+        Returns:
+            tuple(list): A tuple consists of lists of bboxes, action labels and
+                entity_ids
+        """
+        bboxes, labels, entity_ids = [], [], []
+        while len(img_records) > 0:
+            img_record = img_records[0]
+            num_img_records = len(img_records)
+            selected_records = list(
+                filter(
+                    lambda x: np.array_equal(x['entity_box'], img_record[
+                        'entity_box']), img_records))
+            num_selected_records = len(selected_records)
+            img_records = list(
+                filter(
+                    lambda x: not np.array_equal(x['entity_box'], img_record[
+                        'entity_box']), img_records))
+            assert len(img_records) + num_selected_records == num_img_records
+
+            bboxes.append(img_record['entity_box'])
+            valid_labels = np.array([
+                selected_record['label']
+                for selected_record in selected_records
+            ])
+
+            # The format can be directly used by BCELossWithLogits
+            label = np.zeros(self.num_classes, dtype=np.float32)
+            label[valid_labels] = 1.
+
+            labels.append(label)
+            entity_ids.append(img_record['entity_id'])
+
+        bboxes = np.stack(bboxes)
+        labels = np.stack(labels)
+        entity_ids = np.stack(entity_ids)
+        return bboxes, labels, entity_ids
+
+    def filter_exclude_file(self):
+        """Filter out records in the exclude_file."""
+        valid_indexes = []
+        if self.exclude_file is None:
+            valid_indexes = list(range(len(self.video_infos)))
+        else:
+            exclude_video_infos = [
+                x.strip().split(',') for x in open(self.exclude_file)
+            ]
+            for i, video_info in enumerate(self.video_infos):
+                valid_indexes.append(i)
+                for video_id, timestamp in exclude_video_infos:
+                    if (video_info['video_id'] == video_id
+                            and video_info['timestamp'] == int(timestamp)):
+                        valid_indexes.pop()
+                        break
+        return valid_indexes
+
+    def load_annotations(self):
+        """Load AVA annotations."""
+        video_infos = []
+        records_dict_by_img = defaultdict(list)
+        with open(self.ann_file, 'r') as fin:
+            for line in fin:
+                line_split = line.strip().split(',')
+
+                label = int(line_split[6])
+                if self.custom_classes is not None:
+                    if label not in self.custom_classes:
+                        continue
+                    label = self.custom_classes.index(label)
+
+                video_id = line_split[0]
+                timestamp = int(line_split[1])
+                img_key = f'{video_id},{timestamp:04d}'
+
+                entity_box = np.array(list(map(float, line_split[2:6])))
+                entity_id = int(line_split[7])
+                shot_info = (0, (self.timestamp_end - self.timestamp_start) *
+                             self._FPS)
+
+                video_info = dict(
+                    video_id=video_id,
+                    timestamp=timestamp,
+                    entity_box=entity_box,
+                    label=label,
+                    entity_id=entity_id,
+                    shot_info=shot_info)
+                records_dict_by_img[img_key].append(video_info)
+
+        for img_key in records_dict_by_img:
+            video_id, timestamp = img_key.split(',')
+            bboxes, labels, entity_ids = self.parse_img_record(
+                records_dict_by_img[img_key])
+            ann = dict(
+                gt_bboxes=bboxes, gt_labels=labels, entity_ids=entity_ids)
+            frame_dir = video_id
+            if self.data_prefix is not None:
+                frame_dir = osp.join(self.data_prefix, frame_dir)
+            video_info = dict(
+                frame_dir=frame_dir,
+                video_id=video_id,
+                timestamp=int(timestamp),
+                img_key=img_key,
+                shot_info=shot_info,
+                fps=self._FPS,
+                ann=ann)
+            video_infos.append(video_info)
+
+        return video_infos
+
+    def prepare_train_frames(self, idx):
+        """Prepare the frames for training given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        img_key = results['img_key']
+
+        results['filename_tmpl'] = self.filename_tmpl
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+        results['timestamp_start'] = self.timestamp_start
+        results['timestamp_end'] = self.timestamp_end
+
+        if self.proposals is not None:
+            if img_key not in self.proposals:
+                results['proposals'] = np.array([[0, 0, 1, 1]])
+                results['scores'] = np.array([1])
+            else:
+                proposals = self.proposals[img_key]
+                assert proposals.shape[-1] in [4, 5]
+                if proposals.shape[-1] == 5:
+                    thr = min(self.person_det_score_thr, max(proposals[:, 4]))
+                    positive_inds = (proposals[:, 4] >= thr)
+                    proposals = proposals[positive_inds]
+                    proposals = proposals[:self.num_max_proposals]
+                    results['proposals'] = proposals[:, :4]
+                    results['scores'] = proposals[:, 4]
+                else:
+                    proposals = proposals[:self.num_max_proposals]
+                    results['proposals'] = proposals
+
+        ann = results.pop('ann')
+        results['gt_bboxes'] = ann['gt_bboxes']
+        results['gt_labels'] = ann['gt_labels']
+        results['entity_ids'] = ann['entity_ids']
+
+        return self.pipeline(results)
+
+    def prepare_test_frames(self, idx):
+        """Prepare the frames for testing given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        img_key = results['img_key']
+
+        results['filename_tmpl'] = self.filename_tmpl
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+        results['timestamp_start'] = self.timestamp_start
+        results['timestamp_end'] = self.timestamp_end
+
+        if self.proposals is not None:
+            if img_key not in self.proposals:
+                results['proposals'] = np.array([[0, 0, 1, 1]])
+                results['scores'] = np.array([1])
+            else:
+                proposals = self.proposals[img_key]
+                assert proposals.shape[-1] in [4, 5]
+                if proposals.shape[-1] == 5:
+                    thr = min(self.person_det_score_thr, max(proposals[:, 4]))
+                    positive_inds = (proposals[:, 4] >= thr)
+                    proposals = proposals[positive_inds]
+                    proposals = proposals[:self.num_max_proposals]
+                    results['proposals'] = proposals[:, :4]
+                    results['scores'] = proposals[:, 4]
+                else:
+                    proposals = proposals[:self.num_max_proposals]
+                    results['proposals'] = proposals
+
+        ann = results.pop('ann')
+        # Follow the mmdet variable naming style.
+        results['gt_bboxes'] = ann['gt_bboxes']
+        results['gt_labels'] = ann['gt_labels']
+        results['entity_ids'] = ann['entity_ids']
+
+        return self.pipeline(results)
+
+    def dump_results(self, results, out):
+        """Dump predictions into a csv file."""
+        assert out.endswith('csv')
+        results2csv(self, results, out, self.custom_classes)
+
+    def evaluate(self,
+                 results,
+                 metrics=('mAP', ),
+                 metric_options=None,
+                 logger=None):
+        """Evaluate the prediction results and report mAP."""
+        assert len(metrics) == 1 and metrics[0] == 'mAP', (
+            'For evaluation on AVADataset, you need to use metrics "mAP" '
+            'See https://github.com/open-mmlab/mmaction2/pull/567 '
+            'for more info.')
+        time_now = datetime.now().strftime('%Y%m%d_%H%M%S')
+        temp_file = f'AVA_{time_now}_result.csv'
+        results2csv(self, results, temp_file, self.custom_classes)
+
+        ret = {}
+        for metric in metrics:
+            msg = f'Evaluating {metric} ...'
+            if logger is None:
+                msg = '\n' + msg
+            print_log(msg, logger=logger)
+
+            eval_result = ava_eval(
+                temp_file,
+                metric,
+                self.label_file,
+                self.ann_file,
+                self.exclude_file,
+                custom_classes=self.custom_classes)
+            log_msg = []
+            for k, v in eval_result.items():
+                log_msg.append(f'\n{k}\t{v: .4f}')
+            log_msg = ''.join(log_msg)
+            print_log(log_msg, logger=logger)
+            ret.update(eval_result)
+
+        os.remove(temp_file)
+
+        return ret

TransRAC/mmaction/datasets/base.py

@@ -0,0 +1,287 @@
+import copy
+import os.path as osp
+import warnings
+from abc import ABCMeta, abstractmethod
+from collections import OrderedDict, defaultdict
+
+import mmcv
+import numpy as np
+import torch
+from mmcv.utils import print_log
+from torch.utils.data import Dataset
+
+from ..core import (mean_average_precision, mean_class_accuracy,
+                    mmit_mean_average_precision, top_k_accuracy)
+from .pipelines import Compose
+
+
+class BaseDataset(Dataset, metaclass=ABCMeta):
+    """Base class for datasets.
+
+    All datasets to process video should subclass it.
+    All subclasses should overwrite:
+
+    - Methods:`load_annotations`, supporting to load information from an
+    annotation file.
+    - Methods:`prepare_train_frames`, providing train data.
+    - Methods:`prepare_test_frames`, providing test data.
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        data_prefix (str | None): Path to a directory where videos are held.
+            Default: None.
+        test_mode (bool): Store True when building test or validation dataset.
+            Default: False.
+        multi_class (bool): Determines whether the dataset is a multi-class
+            dataset. Default: False.
+        num_classes (int | None): Number of classes of the dataset, used in
+            multi-class datasets. Default: None.
+        start_index (int): Specify a start index for frames in consideration of
+            different filename format. However, when taking videos as input,
+            it should be set to 0, since frames loaded from videos count
+            from 0. Default: 1.
+        modality (str): Modality of data. Support 'RGB', 'Flow', 'Audio'.
+            Default: 'RGB'.
+        sample_by_class (bool): Sampling by class, should be set `True` when
+            performing inter-class data balancing. Only compatible with
+            `multi_class == False`. Only applies for training. Default: False.
+        power (float): We support sampling data with the probability
+            proportional to the power of its label frequency (freq ^ power)
+            when sampling data. `power == 1` indicates uniformly sampling all
+            data; `power == 0` indicates uniformly sampling all classes.
+            Default: 0.
+        dynamic_length (bool): If the dataset length is dynamic (used by
+            ClassSpecificDistributedSampler). Default: False.
+    """
+
+    def __init__(self,
+                 ann_file,
+                 pipeline,
+                 data_prefix=None,
+                 test_mode=False,
+                 multi_class=False,
+                 num_classes=None,
+                 start_index=1,
+                 modality='RGB',
+                 sample_by_class=False,
+                 power=0,
+                 dynamic_length=False):
+        super().__init__()
+
+        self.ann_file = ann_file
+        self.data_prefix = osp.realpath(
+            data_prefix) if data_prefix is not None and osp.isdir(
+                data_prefix) else data_prefix
+        self.test_mode = test_mode
+        self.multi_class = multi_class
+        self.num_classes = num_classes
+        self.start_index = start_index
+        self.modality = modality
+        self.sample_by_class = sample_by_class
+        self.power = power
+        self.dynamic_length = dynamic_length
+
+        assert not (self.multi_class and self.sample_by_class)
+
+        self.pipeline = Compose(pipeline)
+        self.video_infos = self.load_annotations()
+        if self.sample_by_class:
+            self.video_infos_by_class = self.parse_by_class()
+
+            class_prob = []
+            for _, samples in self.video_infos_by_class.items():
+                class_prob.append(len(samples) / len(self.video_infos))
+            class_prob = [x**self.power for x in class_prob]
+
+            summ = sum(class_prob)
+            class_prob = [x / summ for x in class_prob]
+
+            self.class_prob = dict(zip(self.video_infos_by_class, class_prob))
+
+    @abstractmethod
+    def load_annotations(self):
+        """Load the annotation according to ann_file into video_infos."""
+
+    # json annotations already looks like video_infos, so for each dataset,
+    # this func should be the same
+    def load_json_annotations(self):
+        """Load json annotation file to get video information."""
+        video_infos = mmcv.load(self.ann_file)
+        num_videos = len(video_infos)
+        path_key = 'frame_dir' if 'frame_dir' in video_infos[0] else 'filename'
+        for i in range(num_videos):
+            path_value = video_infos[i][path_key]
+            if self.data_prefix is not None:
+                path_value = osp.join(self.data_prefix, path_value)
+            video_infos[i][path_key] = path_value
+            if self.multi_class:
+                assert self.num_classes is not None
+            else:
+                assert len(video_infos[i]['label']) == 1
+                video_infos[i]['label'] = video_infos[i]['label'][0]
+        return video_infos
+
+    def parse_by_class(self):
+        video_infos_by_class = defaultdict(list)
+        for item in self.video_infos:
+            label = item['label']
+            video_infos_by_class[label].append(item)
+        return video_infos_by_class
+
+    @staticmethod
+    def label2array(num, label):
+        arr = np.zeros(num, dtype=np.float32)
+        arr[label] = 1.
+        return arr
+
+    def evaluate(self,
+                 results,
+                 metrics='top_k_accuracy',
+                 metric_options=dict(top_k_accuracy=dict(topk=(1, 5))),
+                 logger=None,
+                 **deprecated_kwargs):
+        """Perform evaluation for common datasets.
+
+        Args:
+            results (list): Output results.
+            metrics (str | sequence[str]): Metrics to be performed.
+                Defaults: 'top_k_accuracy'.
+            metric_options (dict): Dict for metric options. Options are
+                ``topk`` for ``top_k_accuracy``.
+                Default: ``dict(top_k_accuracy=dict(topk=(1, 5)))``.
+            logger (logging.Logger | None): Logger for recording.
+                Default: None.
+            deprecated_kwargs (dict): Used for containing deprecated arguments.
+                See 'https://github.com/open-mmlab/mmaction2/pull/286'.
+
+        Returns:
+            dict: Evaluation results dict.
+        """
+        # Protect ``metric_options`` since it uses mutable value as default
+        metric_options = copy.deepcopy(metric_options)
+
+        if deprecated_kwargs != {}:
+            warnings.warn(
+                'Option arguments for metrics has been changed to '
+                "`metric_options`, See 'https://github.com/open-mmlab/mmaction2/pull/286' "  # noqa: E501
+                'for more details')
+            metric_options['top_k_accuracy'] = dict(
+                metric_options['top_k_accuracy'], **deprecated_kwargs)
+
+        if not isinstance(results, list):
+            raise TypeError(f'results must be a list, but got {type(results)}')
+        assert len(results) == len(self), (
+            f'The length of results is not equal to the dataset len: '
+            f'{len(results)} != {len(self)}')
+
+        metrics = metrics if isinstance(metrics, (list, tuple)) else [metrics]
+        allowed_metrics = [
+            'top_k_accuracy', 'mean_class_accuracy', 'mean_average_precision',
+            'mmit_mean_average_precision'
+        ]
+
+        for metric in metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(f'metric {metric} is not supported')
+
+        eval_results = OrderedDict()
+        gt_labels = [ann['label'] for ann in self.video_infos]
+
+        for metric in metrics:
+            msg = f'Evaluating {metric} ...'
+            if logger is None:
+                msg = '\n' + msg
+            print_log(msg, logger=logger)
+
+            if metric == 'top_k_accuracy':
+                topk = metric_options.setdefault('top_k_accuracy',
+                                                 {}).setdefault(
+                                                     'topk', (1, 5))
+                if not isinstance(topk, (int, tuple)):
+                    raise TypeError('topk must be int or tuple of int, '
+                                    f'but got {type(topk)}')
+                if isinstance(topk, int):
+                    topk = (topk, )
+
+                top_k_acc = top_k_accuracy(results, gt_labels, topk)
+                log_msg = []
+                for k, acc in zip(topk, top_k_acc):
+                    eval_results[f'top{k}_acc'] = acc
+                    log_msg.append(f'\ntop{k}_acc\t{acc:.4f}')
+                log_msg = ''.join(log_msg)
+                print_log(log_msg, logger=logger)
+                continue
+
+            if metric == 'mean_class_accuracy':
+                mean_acc = mean_class_accuracy(results, gt_labels)
+                eval_results['mean_class_accuracy'] = mean_acc
+                log_msg = f'\nmean_acc\t{mean_acc:.4f}'
+                print_log(log_msg, logger=logger)
+                continue
+
+            if metric in [
+                    'mean_average_precision', 'mmit_mean_average_precision'
+            ]:
+                gt_labels = [
+                    self.label2array(self.num_classes, label)
+                    for label in gt_labels
+                ]
+                if metric == 'mean_average_precision':
+                    mAP = mean_average_precision(results, gt_labels)
+                    eval_results['mean_average_precision'] = mAP
+                    log_msg = f'\nmean_average_precision\t{mAP:.4f}'
+                elif metric == 'mmit_mean_average_precision':
+                    mAP = mmit_mean_average_precision(results, gt_labels)
+                    eval_results['mmit_mean_average_precision'] = mAP
+                    log_msg = f'\nmmit_mean_average_precision\t{mAP:.4f}'
+                print_log(log_msg, logger=logger)
+                continue
+
+        return eval_results
+
+    @staticmethod
+    def dump_results(results, out):
+        """Dump data to json/yaml/pickle strings or files."""
+        return mmcv.dump(results, out)
+
+    def prepare_train_frames(self, idx):
+        """Prepare the frames for training given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+
+        # prepare tensor in getitem
+        # If HVU, type(results['label']) is dict
+        if self.multi_class and isinstance(results['label'], list):
+            onehot = torch.zeros(self.num_classes)
+            onehot[results['label']] = 1.
+            results['label'] = onehot
+
+        return self.pipeline(results)
+
+    def prepare_test_frames(self, idx):
+        """Prepare the frames for testing given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+
+        # prepare tensor in getitem
+        # If HVU, type(results['label']) is dict
+        if self.multi_class and isinstance(results['label'], list):
+            onehot = torch.zeros(self.num_classes)
+            onehot[results['label']] = 1.
+            results['label'] = onehot
+
+        return self.pipeline(results)
+
+    def __len__(self):
+        """Get the size of the dataset."""
+        return len(self.video_infos)
+
+    def __getitem__(self, idx):
+        """Get the sample for either training or testing given index."""
+        if self.test_mode:
+            return self.prepare_test_frames(idx)
+
+        return self.prepare_train_frames(idx)

TransRAC/mmaction/datasets/builder.py

@@ -0,0 +1,132 @@
+import platform
+import random
+from functools import partial
+
+import numpy as np
+from mmcv.parallel import collate
+from mmcv.runner import get_dist_info
+from mmcv.utils import Registry, build_from_cfg
+from torch.utils.data import DataLoader
+
+from .samplers import ClassSpecificDistributedSampler, DistributedSampler
+
+if platform.system() != 'Windows':
+    # https://github.com/pytorch/pytorch/issues/973
+    import resource
+    rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
+    hard_limit = rlimit[1]
+    soft_limit = min(4096, hard_limit)
+    resource.setrlimit(resource.RLIMIT_NOFILE, (soft_limit, hard_limit))
+
+DATASETS = Registry('dataset')
+PIPELINES = Registry('pipeline')
+BLENDINGS = Registry('blending')
+
+
+def build_dataset(cfg, default_args=None):
+    """Build a dataset from config dict.
+
+    Args:
+        cfg (dict): Config dict. It should at least contain the key "type".
+        default_args (dict | None, optional): Default initialization arguments.
+            Default: None.
+
+    Returns:
+        Dataset: The constructed dataset.
+    """
+    if cfg['type'] == 'RepeatDataset':
+        from .dataset_wrappers import RepeatDataset
+        dataset = RepeatDataset(
+            build_dataset(cfg['dataset'], default_args), cfg['times'])
+    else:
+        dataset = build_from_cfg(cfg, DATASETS, default_args)
+    return dataset
+
+
+def build_dataloader(dataset,
+                     videos_per_gpu,
+                     workers_per_gpu,
+                     num_gpus=1,
+                     dist=True,
+                     shuffle=True,
+                     seed=None,
+                     drop_last=False,
+                     pin_memory=True,
+                     **kwargs):
+    """Build PyTorch DataLoader.
+
+    In distributed training, each GPU/process has a dataloader.
+    In non-distributed training, there is only one dataloader for all GPUs.
+
+    Args:
+        dataset (:obj:`Dataset`): A PyTorch dataset.
+        videos_per_gpu (int): Number of videos on each GPU, i.e.,
+            batch size of each GPU.
+        workers_per_gpu (int): How many subprocesses to use for data
+            loading for each GPU.
+        num_gpus (int): Number of GPUs. Only used in non-distributed
+            training. Default: 1.
+        dist (bool): Distributed training/test or not. Default: True.
+        shuffle (bool): Whether to shuffle the data at every epoch.
+            Default: True.
+        seed (int | None): Seed to be used. Default: None.
+        drop_last (bool): Whether to drop the last incomplete batch in epoch.
+            Default: False
+        pin_memory (bool): Whether to use pin_memory in DataLoader.
+            Default: True
+        kwargs (dict, optional): Any keyword argument to be used to initialize
+            DataLoader.
+
+    Returns:
+        DataLoader: A PyTorch dataloader.
+    """
+    rank, world_size = get_dist_info()
+    sample_by_class = getattr(dataset, 'sample_by_class', False)
+
+    if dist:
+        if sample_by_class:
+            dynamic_length = getattr(dataset, 'dynamic_length', True)
+            sampler = ClassSpecificDistributedSampler(
+                dataset,
+                world_size,
+                rank,
+                dynamic_length=dynamic_length,
+                shuffle=shuffle,
+                seed=seed)
+        else:
+            sampler = DistributedSampler(
+                dataset, world_size, rank, shuffle=shuffle, seed=seed)
+        shuffle = False
+        batch_size = videos_per_gpu
+        num_workers = workers_per_gpu
+    else:
+        sampler = None
+        batch_size = num_gpus * videos_per_gpu
+        num_workers = num_gpus * workers_per_gpu
+
+    init_fn = partial(
+        worker_init_fn, num_workers=num_workers, rank=rank,
+        seed=seed) if seed is not None else None
+
+    data_loader = DataLoader(
+        dataset,
+        batch_size=batch_size,
+        sampler=sampler,
+        num_workers=num_workers,
+        collate_fn=partial(collate, samples_per_gpu=videos_per_gpu),
+        pin_memory=pin_memory,
+        shuffle=shuffle,
+        worker_init_fn=init_fn,
+        drop_last=drop_last,
+        **kwargs)
+
+    return data_loader
+
+
+def worker_init_fn(worker_id, num_workers, rank, seed):
+    """Init the random seed for various workers."""
+    # The seed of each worker equals to
+    # num_worker * rank + worker_id + user_seed
+    worker_seed = num_workers * rank + worker_id + seed
+    np.random.seed(worker_seed)
+    random.seed(worker_seed)

TransRAC/mmaction/datasets/dataset_wrappers.py

@@ -0,0 +1,30 @@
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class RepeatDataset:
+    """A wrapper of repeated dataset.
+
+    The length of repeated dataset will be ``times`` larger than the original
+    dataset. This is useful when the data loading time is long but the dataset
+    is small. Using RepeatDataset can reduce the data loading time between
+    epochs.
+
+    Args:
+        dataset (:obj:`Dataset`): The dataset to be repeated.
+        times (int): Repeat times.
+    """
+
+    def __init__(self, dataset, times):
+        self.dataset = dataset
+        self.times = times
+
+        self._ori_len = len(self.dataset)
+
+    def __getitem__(self, idx):
+        """Get data."""
+        return self.dataset[idx % self._ori_len]
+
+    def __len__(self):
+        """Length after repetition."""
+        return self.times * self._ori_len

TransRAC/mmaction/datasets/hvu_dataset.py

@@ -0,0 +1,191 @@
+import copy
+import os.path as osp
+from collections import OrderedDict
+
+import mmcv
+import numpy as np
+from mmcv.utils import print_log
+
+from ..core import mean_average_precision
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class HVUDataset(BaseDataset):
+    """HVU dataset, which supports the recognition tags of multiple categories.
+    Accept both video annotation files or rawframe annotation files.
+
+    The dataset loads videos or raw frames and applies specified transforms to
+    return a dict containing the frame tensors and other information.
+
+    The ann_file is a json file with multiple dictionaries, and each dictionary
+    indicates a sample video with the filename and tags, the tags are organized
+    as different categories. Example of a video dictionary:
+
+    .. code-block:: txt
+
+        {
+            'filename': 'gD_G1b0wV5I_001015_001035.mp4',
+            'label': {
+                'concept': [250, 131, 42, 51, 57, 155, 122],
+                'object': [1570, 508],
+                'event': [16],
+                'action': [180],
+                'scene': [206]
+            }
+        }
+
+    Example of a rawframe dictionary:
+
+    .. code-block:: txt
+
+        {
+            'frame_dir': 'gD_G1b0wV5I_001015_001035',
+            'total_frames': 61
+            'label': {
+                'concept': [250, 131, 42, 51, 57, 155, 122],
+                'object': [1570, 508],
+                'event': [16],
+                'action': [180],
+                'scene': [206]
+            }
+        }
+
+
+    Args:
+        ann_file (str): Path to the annotation file, should be a json file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        tag_categories (list[str]): List of category names of tags.
+        tag_category_nums (list[int]): List of number of tags in each category.
+        filename_tmpl (str | None): Template for each filename. If set to None,
+            video dataset is used. Default: None.
+        **kwargs: Keyword arguments for ``BaseDataset``.
+    """
+
+    def __init__(self,
+                 ann_file,
+                 pipeline,
+                 tag_categories,
+                 tag_category_nums,
+                 filename_tmpl=None,
+                 **kwargs):
+        assert len(tag_categories) == len(tag_category_nums)
+        self.tag_categories = tag_categories
+        self.tag_category_nums = tag_category_nums
+        self.filename_tmpl = filename_tmpl
+        self.num_categories = len(self.tag_categories)
+        self.num_tags = sum(self.tag_category_nums)
+        self.category2num = dict(zip(tag_categories, tag_category_nums))
+        self.start_idx = [0]
+        for i in range(self.num_categories - 1):
+            self.start_idx.append(self.start_idx[-1] +
+                                  self.tag_category_nums[i])
+        self.category2startidx = dict(zip(tag_categories, self.start_idx))
+        self.start_index = kwargs.pop('start_index', 0)
+        self.dataset_type = None
+        super().__init__(
+            ann_file, pipeline, start_index=self.start_index, **kwargs)
+
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        assert self.ann_file.endswith('.json')
+        return self.load_json_annotations()
+
+    def load_json_annotations(self):
+        video_infos = mmcv.load(self.ann_file)
+        num_videos = len(video_infos)
+
+        video_info0 = video_infos[0]
+        assert ('filename' in video_info0) != ('frame_dir' in video_info0)
+        path_key = 'filename' if 'filename' in video_info0 else 'frame_dir'
+        self.dataset_type = 'video' if path_key == 'filename' else 'rawframe'
+        if self.dataset_type == 'rawframe':
+            assert self.filename_tmpl is not None
+
+        for i in range(num_videos):
+            path_value = video_infos[i][path_key]
+            if self.data_prefix is not None:
+                path_value = osp.join(self.data_prefix, path_value)
+            video_infos[i][path_key] = path_value
+
+            # We will convert label to torch tensors in the pipeline
+            video_infos[i]['categories'] = self.tag_categories
+            video_infos[i]['category_nums'] = self.tag_category_nums
+            if self.dataset_type == 'rawframe':
+                video_infos[i]['filename_tmpl'] = self.filename_tmpl
+                video_infos[i]['start_index'] = self.start_index
+                video_infos[i]['modality'] = self.modality
+
+        return video_infos
+
+    @staticmethod
+    def label2array(num, label):
+        arr = np.zeros(num, dtype=np.float32)
+        arr[label] = 1.
+        return arr
+
+    def evaluate(self,
+                 results,
+                 metrics='mean_average_precision',
+                 metric_options=None,
+                 logger=None):
+        """Evaluation in HVU Video Dataset. We only support evaluating mAP for
+        each tag categories. Since some tag categories are missing for some
+        videos, we can not evaluate mAP for all tags.
+
+        Args:
+            results (list): Output results.
+            metrics (str | sequence[str]): Metrics to be performed.
+                Defaults: 'mean_average_precision'.
+            metric_options (dict | None): Dict for metric options.
+                Default: None.
+            logger (logging.Logger | None): Logger for recording.
+                Default: None.
+
+        Returns:
+            dict: Evaluation results dict.
+        """
+        # Protect ``metric_options`` since it uses mutable value as default
+        metric_options = copy.deepcopy(metric_options)
+
+        if not isinstance(results, list):
+            raise TypeError(f'results must be a list, but got {type(results)}')
+        assert len(results) == len(self), (
+            f'The length of results is not equal to the dataset len: '
+            f'{len(results)} != {len(self)}')
+
+        metrics = metrics if isinstance(metrics, (list, tuple)) else [metrics]
+
+        # There should be only one metric in the metrics list:
+        # 'mean_average_precision'
+        assert len(metrics) == 1
+        metric = metrics[0]
+        assert metric == 'mean_average_precision'
+
+        gt_labels = [ann['label'] for ann in self.video_infos]
+
+        eval_results = OrderedDict()
+
+        for category in self.tag_categories:
+
+            start_idx = self.category2startidx[category]
+            num = self.category2num[category]
+            preds = [
+                result[start_idx:start_idx + num]
+                for video_idx, result in enumerate(results)
+                if category in gt_labels[video_idx]
+            ]
+            gts = [
+                gt_label[category] for gt_label in gt_labels
+                if category in gt_label
+            ]
+
+            gts = [self.label2array(num, item) for item in gts]
+
+            mAP = mean_average_precision(preds, gts)
+            eval_results[f'{category}_mAP'] = mAP
+            log_msg = f'\n{category}_mAP\t{mAP:.4f}'
+            print_log(log_msg, logger=logger)
+
+        return eval_results

TransRAC/mmaction/datasets/image_dataset.py

@@ -0,0 +1,45 @@
+from .builder import DATASETS
+from .video_dataset import VideoDataset
+
+
+@DATASETS.register_module()
+class ImageDataset(VideoDataset):
+    """Image dataset for action recognition, used in the Project OmniSource.
+
+    The dataset loads image list and apply specified transforms to return a
+    dict containing the image tensors and other information. For the
+    ImageDataset
+
+    The ann_file is a text file with multiple lines, and each line indicates
+    the image path and the image label, which are split with a whitespace.
+    Example of a annotation file:
+
+    .. code-block:: txt
+
+        path/to/image1.jpg 1
+        path/to/image2.jpg 1
+        path/to/image3.jpg 2
+        path/to/image4.jpg 2
+        path/to/image5.jpg 3
+        path/to/image6.jpg 3
+
+    Example of a multi-class annotation file:
+
+    .. code-block:: txt
+
+        path/to/image1.jpg 1 3 5
+        path/to/image2.jpg 1 2
+        path/to/image3.jpg 2
+        path/to/image4.jpg 2 4 6 8
+        path/to/image5.jpg 3
+        path/to/image6.jpg 3
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        **kwargs: Keyword arguments for ``BaseDataset``.
+    """
+
+    def __init__(self, ann_file, pipeline, **kwargs):
+        super().__init__(ann_file, pipeline, start_index=None, **kwargs)
+        # use `start_index=None` to indicate it is for `ImageDataset`

TransRAC/mmaction/datasets/pose_dataset.py

@@ -0,0 +1,98 @@
+import os.path as osp
+
+import mmcv
+import numpy as np
+
+from ..utils import get_root_logger
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class PoseDataset(BaseDataset):
+    """Pose dataset for action recognition.
+
+    The dataset loads pose and apply specified transforms to return a
+    dict containing pose information.
+
+    The ann_file is a pickle file, the json file contains a list of
+    annotations, the fields of an annotation include frame_dir(video_id),
+    total_frames, label, kp, kpscore.
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        valid_ratio (float | None): The valid_ratio for videos in KineticsPose.
+            For a video with n frames, it is a valid training sample only if
+            n * valid_ratio frames have human pose. None means not applicable
+            (only applicable to Kinetics Pose). Default: None.
+        box_thr (str | None): The threshold for human proposals. Only boxes
+            with confidence score larger than `box_thr` is kept. None means
+            not applicable (only applicable to Kinetics Pose [ours]). Allowed
+            choices are '0.5', '0.6', '0.7', '0.8', '0.9'. Default: None.
+        class_prob (dict | None): The per class sampling probability. If not
+            None, it will override the class_prob calculated in
+            BaseDataset.__init__(). Default: None.
+        **kwargs: Keyword arguments for ``BaseDataset``.
+    """
+
+    def __init__(self,
+                 ann_file,
+                 pipeline,
+                 valid_ratio=None,
+                 box_thr=None,
+                 class_prob=None,
+                 **kwargs):
+        modality = 'Pose'
+
+        super().__init__(
+            ann_file, pipeline, start_index=0, modality=modality, **kwargs)
+
+        # box_thr, which should be a string
+        self.box_thr = box_thr
+        if self.box_thr is not None:
+            assert box_thr in ['0.5', '0.6', '0.7', '0.8', '0.9']
+
+        # Thresholding Training Examples
+        self.valid_ratio = valid_ratio
+        if self.valid_ratio is not None:
+            assert isinstance(self.valid_ratio, float)
+            if self.box_thr is None:
+                self.video_infos = self.video_infos = [
+                    x for x in self.video_infos
+                    if x['valid_frames'] / x['total_frames'] >= valid_ratio
+                ]
+            else:
+                key = f'valid@{self.box_thr}'
+                self.video_infos = [
+                    x for x in self.video_infos
+                    if x[key] / x['total_frames'] >= valid_ratio
+                ]
+                if self.box_thr != '0.5':
+                    box_thr = float(self.box_thr)
+                    for item in self.video_infos:
+                        inds = [
+                            i for i, score in enumerate(item['box_score'])
+                            if score >= box_thr
+                        ]
+                        item['anno_inds'] = np.array(inds)
+
+        if class_prob is not None:
+            self.class_prob = class_prob
+
+        logger = get_root_logger()
+        logger.info(f'{len(self)} videos remain after valid thresholding')
+
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        assert self.ann_file.endswith('.pkl')
+        return self.load_pkl_annotations()
+
+    def load_pkl_annotations(self):
+        data = mmcv.load(self.ann_file)
+
+        for item in data:
+            # Sometimes we may need to load anno from the file
+            if 'filename' in item:
+                item['filename'] = osp.join(self.data_prefix, item['filename'])
+        return data

TransRAC/mmaction/datasets/rawframe_dataset.py

@@ -0,0 +1,183 @@
+import copy
+import os.path as osp
+
+import torch
+
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class RawframeDataset(BaseDataset):
+    """Rawframe dataset for action recognition.
+
+    The dataset loads raw frames and apply specified transforms to return a
+    dict containing the frame tensors and other information.
+
+    The ann_file is a text file with multiple lines, and each line indicates
+    the directory to frames of a video, total frames of the video and
+    the label of a video, which are split with a whitespace.
+    Example of a annotation file:
+
+    .. code-block:: txt
+
+        some/directory-1 163 1
+        some/directory-2 122 1
+        some/directory-3 258 2
+        some/directory-4 234 2
+        some/directory-5 295 3
+        some/directory-6 121 3
+
+    Example of a multi-class annotation file:
+
+
+    .. code-block:: txt
+
+        some/directory-1 163 1 3 5
+        some/directory-2 122 1 2
+        some/directory-3 258 2
+        some/directory-4 234 2 4 6 8
+        some/directory-5 295 3
+        some/directory-6 121 3
+
+    Example of a with_offset annotation file (clips from long videos), each
+    line indicates the directory to frames of a video, the index of the start
+    frame, total frames of the video clip and the label of a video clip, which
+    are split with a whitespace.
+
+
+    .. code-block:: txt
+
+        some/directory-1 12 163 3
+        some/directory-2 213 122 4
+        some/directory-3 100 258 5
+        some/directory-4 98 234 2
+        some/directory-5 0 295 3
+        some/directory-6 50 121 3
+
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        data_prefix (str | None): Path to a directory where videos are held.
+            Default: None.
+        test_mode (bool): Store True when building test or validation dataset.
+            Default: False.
+        filename_tmpl (str): Template for each filename.
+            Default: 'img_{:05}.jpg'.
+        with_offset (bool): Determines whether the offset information is in
+            ann_file. Default: False.
+        multi_class (bool): Determines whether it is a multi-class
+            recognition dataset. Default: False.
+        num_classes (int | None): Number of classes in the dataset.
+            Default: None.
+        modality (str): Modality of data. Support 'RGB', 'Flow'.
+            Default: 'RGB'.
+        sample_by_class (bool): Sampling by class, should be set `True` when
+            performing inter-class data balancing. Only compatible with
+            `multi_class == False`. Only applies for training. Default: False.
+        power (float): We support sampling data with the probability
+            proportional to the power of its label frequency (freq ^ power)
+            when sampling data. `power == 1` indicates uniformly sampling all
+            data; `power == 0` indicates uniformly sampling all classes.
+            Default: 0.
+        dynamic_length (bool): If the dataset length is dynamic (used by
+            ClassSpecificDistributedSampler). Default: False.
+    """
+
+    def __init__(self,
+                 ann_file,
+                 pipeline,
+                 data_prefix=None,
+                 test_mode=False,
+                 filename_tmpl='img_{:05}.jpg',
+                 with_offset=False,
+                 multi_class=False,
+                 num_classes=None,
+                 start_index=1,
+                 modality='RGB',
+                 sample_by_class=False,
+                 power=0.,
+                 dynamic_length=False):
+        self.filename_tmpl = filename_tmpl
+        self.with_offset = with_offset
+        super().__init__(
+            ann_file,
+            pipeline,
+            data_prefix,
+            test_mode,
+            multi_class,
+            num_classes,
+            start_index,
+            modality,
+            sample_by_class=sample_by_class,
+            power=power,
+            dynamic_length=dynamic_length)
+
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        if self.ann_file.endswith('.json'):
+            return self.load_json_annotations()
+        video_infos = []
+        with open(self.ann_file, 'r') as fin:
+            for line in fin:
+                line_split = line.strip().split()
+                video_info = {}
+                idx = 0
+                # idx for frame_dir
+                frame_dir = line_split[idx]
+                if self.data_prefix is not None:
+                    frame_dir = osp.join(self.data_prefix, frame_dir)
+                video_info['frame_dir'] = frame_dir
+                idx += 1
+                if self.with_offset:
+                    # idx for offset and total_frames
+                    video_info['offset'] = int(line_split[idx])
+                    video_info['total_frames'] = int(line_split[idx + 1])
+                    idx += 2
+                else:
+                    # idx for total_frames
+                    video_info['total_frames'] = int(line_split[idx])
+                    idx += 1
+                # idx for label[s]
+                label = [int(x) for x in line_split[idx:]]
+                assert label, f'missing label in line: {line}'
+                if self.multi_class:
+                    assert self.num_classes is not None
+                    video_info['label'] = label
+                else:
+                    assert len(label) == 1
+                    video_info['label'] = label[0]
+                video_infos.append(video_info)
+
+        return video_infos
+
+    def prepare_train_frames(self, idx):
+        """Prepare the frames for training given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['filename_tmpl'] = self.filename_tmpl
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+
+        # prepare tensor in getitem
+        if self.multi_class:
+            onehot = torch.zeros(self.num_classes)
+            onehot[results['label']] = 1.
+            results['label'] = onehot
+
+        return self.pipeline(results)
+
+    def prepare_test_frames(self, idx):
+        """Prepare the frames for testing given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['filename_tmpl'] = self.filename_tmpl
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+
+        # prepare tensor in getitem
+        if self.multi_class:
+            onehot = torch.zeros(self.num_classes)
+            onehot[results['label']] = 1.
+            results['label'] = onehot
+
+        return self.pipeline(results)

TransRAC/mmaction/datasets/rawvideo_dataset.py

@@ -0,0 +1,146 @@
+import copy
+import os.path as osp
+import random
+
+import mmcv
+
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class RawVideoDataset(BaseDataset):
+    """RawVideo dataset for action recognition, used in the Project OmniSource.
+
+    The dataset loads clips of raw videos and apply specified transforms to
+    return a dict containing the frame tensors and other information. Not that
+    for this dataset, `multi_class` should be False.
+
+    The ann_file is a text file with multiple lines, and each line indicates
+    a sample video with the filepath (without suffix), label, number of clips
+    and index of positive clips (starting from 0), which are split with a
+    whitespace. Raw videos should be first trimmed into 10 second clips,
+    organized in the following format:
+
+    .. code-block:: txt
+
+        some/path/D32_1gwq35E/part_0.mp4
+        some/path/D32_1gwq35E/part_1.mp4
+        ......
+        some/path/D32_1gwq35E/part_n.mp4
+
+    Example of a annotation file:
+
+    .. code-block:: txt
+
+        some/path/D32_1gwq35E 66 10 0 1 2
+        some/path/-G-5CJ0JkKY 254 5 3 4
+        some/path/T4h1bvOd9DA 33 1 0
+        some/path/4uZ27ivBl00 341 2 0 1
+        some/path/0LfESFkfBSw 186 234 7 9 11
+        some/path/-YIsNpBEx6c 169 100 9 10 11
+
+    The first line indicates that the raw video `some/path/D32_1gwq35E` has
+    action label `66`, consists of 10 clips (from `part_0.mp4` to
+    `part_9.mp4`). The 1st, 2nd and 3rd clips are positive clips.
+
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        sampling_strategy (str): The strategy to sample clips from raw videos.
+            Choices are 'random' or 'positive'. Default: 'positive'.
+        clipname_tmpl (str): The template of clip name in the raw video.
+            Default: 'part_{}.mp4'.
+        **kwargs: Keyword arguments for ``BaseDataset``.
+    """
+
+    def __init__(self,
+                 ann_file,
+                 pipeline,
+                 clipname_tmpl='part_{}.mp4',
+                 sampling_strategy='positive',
+                 **kwargs):
+        super().__init__(ann_file, pipeline, start_index=0, **kwargs)
+        assert self.multi_class is False
+        self.sampling_strategy = sampling_strategy
+        self.clipname_tmpl = clipname_tmpl
+        # If positive, we should only keep those raw videos with positive
+        # clips
+        if self.sampling_strategy == 'positive':
+            self.video_infos = [
+                x for x in self.video_infos if len(x['positive_clip_inds'])
+            ]
+
+    # do not support multi_class
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        if self.ann_file.endswith('.json'):
+            return self.load_json_annotations()
+
+        video_infos = []
+        with open(self.ann_file, 'r') as fin:
+            for line in fin:
+                line_split = line.strip().split()
+                video_dir = line_split[0]
+                label = int(line_split[1])
+                num_clips = int(line_split[2])
+                positive_clip_inds = [int(ind) for ind in line_split[3:]]
+
+                if self.data_prefix is not None:
+                    video_dir = osp.join(self.data_prefix, video_dir)
+                video_infos.append(
+                    dict(
+                        video_dir=video_dir,
+                        label=label,
+                        num_clips=num_clips,
+                        positive_clip_inds=positive_clip_inds))
+        return video_infos
+
+    # do not support multi_class
+    def load_json_annotations(self):
+        """Load json annotation file to get video information."""
+        video_infos = mmcv.load(self.ann_file)
+        num_videos = len(video_infos)
+        path_key = 'video_dir'
+        for i in range(num_videos):
+            if self.data_prefix is not None:
+                path_value = video_infos[i][path_key]
+                path_value = osp.join(self.data_prefix, path_value)
+                video_infos[i][path_key] = path_value
+        return video_infos
+
+    def sample_clip(self, results):
+        """Sample a clip from the raw video given the sampling strategy."""
+        assert self.sampling_strategy in ['positive', 'random']
+        if self.sampling_strategy == 'positive':
+            assert results['positive_clip_inds']
+            ind = random.choice(results['positive_clip_inds'])
+        else:
+            ind = random.randint(0, results['num_clips'] - 1)
+        clipname = self.clipname_tmpl.format(ind)
+
+        # if the first char of self.clipname_tmpl is a letter, use osp.join;
+        # otherwise, directly concat them
+        if self.clipname_tmpl[0].isalpha():
+            filename = osp.join(results['video_dir'], clipname)
+        else:
+            filename = results['video_dir'] + clipname
+        results['filename'] = filename
+        return results
+
+    def prepare_train_frames(self, idx):
+        """Prepare the frames for training given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results = self.sample_clip(results)
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+        return self.pipeline(results)
+
+    def prepare_test_frames(self, idx):
+        """Prepare the frames for testing given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results = self.sample_clip(results)
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+        return self.pipeline(results)

TransRAC/mmaction/datasets/ssn_dataset.py

@@ -0,0 +1,881 @@
+import copy
+import os.path as osp
+import warnings
+from collections import OrderedDict
+
+import mmcv
+import numpy as np
+from torch.nn.modules.utils import _pair
+
+from ..core import softmax
+from ..localization import (eval_ap, load_localize_proposal_file,
+                            perform_regression, temporal_iou, temporal_nms)
+from ..utils import get_root_logger
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+class SSNInstance:
+    """Proposal instance of SSN.
+
+    Args:
+        start_frame (int): Index of the proposal's start frame.
+        end_frame (int): Index of the proposal's end frame.
+        num_video_frames (int): Total frames of the video.
+        label (int | None): The category label of the proposal. Default: None.
+        best_iou (float): The highest IOU with the groundtruth instance.
+            Default: 0.
+        overlap_self (float): Percent of the proposal's own span contained
+            in a groundtruth instance. Default: 0.
+    """
+
+    def __init__(self,
+                 start_frame,
+                 end_frame,
+                 num_video_frames,
+                 label=None,
+                 best_iou=0,
+                 overlap_self=0):
+        self.start_frame = start_frame
+        self.end_frame = min(end_frame, num_video_frames)
+        self.num_video_frames = num_video_frames
+        self.label = label if label is not None else -1
+        self.coverage = (end_frame - start_frame) / num_video_frames
+        self.best_iou = best_iou
+        self.overlap_self = overlap_self
+        self.loc_reg = None
+        self.size_reg = None
+        self.regression_targets = [0., 0.]
+
+    def compute_regression_targets(self, gt_list):
+        """Compute regression targets of positive proposals.
+
+        Args:
+            gt_list (list): The list of groundtruth instances.
+        """
+        # Find the groundtruth instance with the highest IOU.
+        ious = [
+            temporal_iou(self.start_frame, self.end_frame, gt.start_frame,
+                         gt.end_frame) for gt in gt_list
+        ]
+        best_gt = gt_list[np.argmax(ious)]
+
+        # interval: [start_frame, end_frame)
+        proposal_center = (self.start_frame + self.end_frame - 1) / 2
+        gt_center = (best_gt.start_frame + best_gt.end_frame - 1) / 2
+        proposal_size = self.end_frame - self.start_frame
+        gt_size = best_gt.end_frame - best_gt.start_frame
+
+        # Get regression targets:
+        # (1). Localization regression target:
+        #     center shift proportional to the proposal duration
+        # (2). Duration/Size regression target:
+        #     logarithm of the groundtruth duration over proposal duration
+
+        self.loc_reg = (gt_center - proposal_center) / proposal_size
+        self.size_reg = np.log(gt_size / proposal_size)
+        self.regression_targets = ([self.loc_reg, self.size_reg]
+                                   if self.loc_reg is not None else [0., 0.])
+
+
+@DATASETS.register_module()
+class SSNDataset(BaseDataset):
+    """Proposal frame dataset for Structured Segment Networks.
+
+    Based on proposal information, the dataset loads raw frames and applies
+    specified transforms to return a dict containing the frame tensors and
+    other information.
+
+    The ann_file is a text file with multiple lines and each
+    video's information takes up several lines. This file can be a normalized
+    file with percent or standard file with specific frame indexes. If the file
+    is a normalized file, it will be converted into a standard file first.
+
+    Template information of a video in a standard file:
+    .. code-block:: txt
+        # index
+        video_id
+        num_frames
+        fps
+        num_gts
+        label, start_frame, end_frame
+        label, start_frame, end_frame
+        ...
+        num_proposals
+        label, best_iou, overlap_self, start_frame, end_frame
+        label, best_iou, overlap_self, start_frame, end_frame
+        ...
+
+    Example of a standard annotation file:
+    .. code-block:: txt
+        # 0
+        video_validation_0000202
+        5666
+        1
+        3
+        8 130 185
+        8 832 1136
+        8 1303 1381
+        5
+        8 0.0620 0.0620 790 5671
+        8 0.1656 0.1656 790 2619
+        8 0.0833 0.0833 3945 5671
+        8 0.0960 0.0960 4173 5671
+        8 0.0614 0.0614 3327 5671
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        train_cfg (dict): Config for training.
+        test_cfg (dict): Config for testing.
+        data_prefix (str): Path to a directory where videos are held.
+        test_mode (bool): Store True when building test or validation dataset.
+            Default: False.
+        filename_tmpl (str): Template for each filename.
+            Default: 'img_{:05}.jpg'.
+        start_index (int): Specify a start index for frames in consideration of
+            different filename format. Default: 1.
+        modality (str): Modality of data. Support 'RGB', 'Flow'.
+            Default: 'RGB'.
+        video_centric (bool): Whether to sample proposals just from
+            this video or sample proposals randomly from the entire dataset.
+            Default: True.
+        reg_normalize_constants (list): Regression target normalized constants,
+            including mean and standard deviation of location and duration.
+        body_segments (int): Number of segments in course period.
+            Default: 5.
+        aug_segments (list[int]): Number of segments in starting and
+            ending period. Default: (2, 2).
+        aug_ratio (int | float | tuple[int | float]): The ratio of the length
+            of augmentation to that of the proposal. Defualt: (0.5, 0.5).
+        clip_len (int): Frames of each sampled output clip.
+            Default: 1.
+        frame_interval (int): Temporal interval of adjacent sampled frames.
+            Default: 1.
+        filter_gt (bool): Whether to filter videos with no annotation
+            during training. Default: True.
+        use_regression (bool): Whether to perform regression. Default: True.
+        verbose (bool): Whether to print full information or not.
+            Default: False.
+    """
+
+    def __init__(self,
+                 ann_file,
+                 pipeline,
+                 train_cfg,
+                 test_cfg,
+                 data_prefix,
+                 test_mode=False,
+                 filename_tmpl='img_{:05d}.jpg',
+                 start_index=1,
+                 modality='RGB',
+                 video_centric=True,
+                 reg_normalize_constants=None,
+                 body_segments=5,
+                 aug_segments=(2, 2),
+                 aug_ratio=(0.5, 0.5),
+                 clip_len=1,
+                 frame_interval=1,
+                 filter_gt=True,
+                 use_regression=True,
+                 verbose=False):
+        self.logger = get_root_logger()
+        super().__init__(
+            ann_file,
+            pipeline,
+            data_prefix=data_prefix,
+            test_mode=test_mode,
+            start_index=start_index,
+            modality=modality)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self.assigner = train_cfg.ssn.assigner
+        self.sampler = train_cfg.ssn.sampler
+        self.evaluater = test_cfg.ssn.evaluater
+        self.verbose = verbose
+        self.filename_tmpl = filename_tmpl
+
+        if filter_gt or not test_mode:
+            valid_inds = [
+                i for i, video_info in enumerate(self.video_infos)
+                if len(video_info['gts']) > 0
+            ]
+        self.logger.info(f'{len(valid_inds)} out of {len(self.video_infos)} '
+                         f'videos are valid.')
+        self.video_infos = [self.video_infos[i] for i in valid_inds]
+
+        # construct three pools:
+        # 1. Positive(Foreground)
+        # 2. Background
+        # 3. Incomplete
+        self.positive_pool = []
+        self.background_pool = []
+        self.incomplete_pool = []
+        self.construct_proposal_pools()
+
+        if reg_normalize_constants is None:
+            self.reg_norm_consts = self._compute_reg_normalize_constants()
+        else:
+            self.reg_norm_consts = reg_normalize_constants
+        self.video_centric = video_centric
+        self.body_segments = body_segments
+        self.aug_segments = aug_segments
+        self.aug_ratio = _pair(aug_ratio)
+        if not mmcv.is_tuple_of(self.aug_ratio, (int, float)):
+            raise TypeError(f'aug_ratio should be int, float'
+                            f'or tuple of int and float, '
+                            f'but got {type(aug_ratio)}')
+        assert len(self.aug_ratio) == 2
+
+        total_ratio = (
+            self.sampler.positive_ratio + self.sampler.background_ratio +
+            self.sampler.incomplete_ratio)
+        self.positive_per_video = int(
+            self.sampler.num_per_video *
+            (self.sampler.positive_ratio / total_ratio))
+        self.background_per_video = int(
+            self.sampler.num_per_video *
+            (self.sampler.background_ratio / total_ratio))
+        self.incomplete_per_video = (
+            self.sampler.num_per_video - self.positive_per_video -
+            self.background_per_video)
+
+        self.test_interval = self.test_cfg.ssn.sampler.test_interval
+        # number of consecutive frames
+        self.clip_len = clip_len
+        # number of steps (sparse sampling for efficiency of io)
+        self.frame_interval = frame_interval
+
+        # test mode or not
+        self.filter_gt = filter_gt
+        self.use_regression = use_regression
+        self.test_mode = test_mode
+
+        # yapf: disable
+        if self.verbose:
+            self.logger.info(f"""
+            SSNDataset: proposal file {self.proposal_file} parsed.
+
+            There are {len(self.positive_pool) + len(self.background_pool) +
+                len(self.incomplete_pool)} usable proposals from {len(self.video_infos)} videos.
+            {len(self.positive_pool)} positive proposals
+            {len(self.incomplete_pool)} incomplete proposals
+            {len(self.background_pool)} background proposals
+
+            Sample config:
+            FG/BG/INCOMP: {self.positive_per_video}/{self.background_per_video}/{self.incomplete_per_video}  # noqa:E501
+            Video Centric: {self.video_centric}
+
+            Regression Normalization Constants:
+            Location: mean {self.reg_norm_consts[0][0]:.05f} std {self.reg_norm_consts[1][0]:.05f} # noqa: E501
+            Duration: mean {self.reg_norm_consts[0][1]:.05f} std {self.reg_norm_consts[1][1]:.05f} # noqa: E501
+            """)
+        # yapf: enable
+        else:
+            self.logger.info(
+                f'SSNDataset: proposal file {self.proposal_file} parsed.')
+
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        video_infos = []
+        if 'normalized_' in self.ann_file:
+            self.proposal_file = self.ann_file.replace('normalized_', '')
+            if not osp.exists(self.proposal_file):
+                raise Exception(f'Please refer to `$MMACTION2/tools/data` to'
+                                f'denormalize {self.ann_file}.')
+        else:
+            self.proposal_file = self.ann_file
+        proposal_infos = load_localize_proposal_file(self.proposal_file)
+        # proposal_info:[video_id, num_frames, gt_list, proposal_list]
+        # gt_list member: [label, start_frame, end_frame]
+        # proposal_list member: [label, best_iou, overlap_self,
+        #                        start_frame, end_frame]
+        for proposal_info in proposal_infos:
+            if self.data_prefix is not None:
+                frame_dir = osp.join(self.data_prefix, proposal_info[0])
+            num_frames = int(proposal_info[1])
+            # gts:start, end, num_frames, class_label, tIoU=1
+            gts = []
+            for x in proposal_info[2]:
+                if int(x[2]) > int(x[1]) and int(x[1]) < num_frames:
+                    ssn_instance = SSNInstance(
+                        int(x[1]),
+                        int(x[2]),
+                        num_frames,
+                        label=int(x[0]),
+                        best_iou=1.0)
+                    gts.append(ssn_instance)
+            # proposals:start, end, num_frames, class_label
+            # tIoU=best_iou, overlap_self
+            proposals = []
+            for x in proposal_info[3]:
+                if int(x[4]) > int(x[3]) and int(x[3]) < num_frames:
+                    ssn_instance = SSNInstance(
+                        int(x[3]),
+                        int(x[4]),
+                        num_frames,
+                        label=int(x[0]),
+                        best_iou=float(x[1]),
+                        overlap_self=float(x[2]))
+                    proposals.append(ssn_instance)
+            video_infos.append(
+                dict(
+                    frame_dir=frame_dir,
+                    video_id=proposal_info[0],
+                    total_frames=num_frames,
+                    gts=gts,
+                    proposals=proposals))
+        return video_infos
+
+    def results_to_detections(self, results, top_k=2000, **kwargs):
+        """Convert prediction results into detections.
+
+        Args:
+            results (list): Prediction results.
+            top_k (int): Number of top results. Default: 2000.
+
+        Returns:
+            list: Detection results.
+        """
+        num_classes = results[0]['activity_scores'].shape[1] - 1
+        detections = [dict() for _ in range(num_classes)]
+
+        for idx in range(len(self)):
+            video_id = self.video_infos[idx]['video_id']
+            relative_proposals = results[idx]['relative_proposal_list']
+            if len(relative_proposals[0].shape) == 3:
+                relative_proposals = np.squeeze(relative_proposals, 0)
+
+            activity_scores = results[idx]['activity_scores']
+            completeness_scores = results[idx]['completeness_scores']
+            regression_scores = results[idx]['bbox_preds']
+            if regression_scores is None:
+                regression_scores = np.zeros(
+                    (len(relative_proposals), num_classes, 2),
+                    dtype=np.float32)
+            regression_scores = regression_scores.reshape((-1, num_classes, 2))
+
+            if top_k <= 0:
+                combined_scores = (
+                    softmax(activity_scores[:, 1:], dim=1) *
+                    np.exp(completeness_scores))
+                for i in range(num_classes):
+                    center_scores = regression_scores[:, i, 0][:, None]
+                    duration_scores = regression_scores[:, i, 1][:, None]
+                    detections[i][video_id] = np.concatenate(
+                        (relative_proposals, combined_scores[:, i][:, None],
+                         center_scores, duration_scores),
+                        axis=1)
+            else:
+                combined_scores = (
+                    softmax(activity_scores[:, 1:], dim=1) *
+                    np.exp(completeness_scores))
+                keep_idx = np.argsort(combined_scores.ravel())[-top_k:]
+                for k in keep_idx:
+                    class_idx = k % num_classes
+                    proposal_idx = k // num_classes
+                    new_item = [
+                        relative_proposals[proposal_idx, 0],
+                        relative_proposals[proposal_idx,
+                                           1], combined_scores[proposal_idx,
+                                                               class_idx],
+                        regression_scores[proposal_idx, class_idx,
+                                          0], regression_scores[proposal_idx,
+                                                                class_idx, 1]
+                    ]
+                    if video_id not in detections[class_idx]:
+                        detections[class_idx][video_id] = np.array([new_item])
+                    else:
+                        detections[class_idx][video_id] = np.vstack(
+                            [detections[class_idx][video_id], new_item])
+
+        return detections
+
+    def evaluate(self,
+                 results,
+                 metrics='mAP',
+                 metric_options=dict(mAP=dict(eval_dataset='thumos14')),
+                 logger=None,
+                 **deprecated_kwargs):
+        """Evaluation in SSN proposal dataset.
+
+        Args:
+            results (list[dict]): Output results.
+            metrics (str | sequence[str]): Metrics to be performed.
+                Defaults: 'mAP'.
+            metric_options (dict): Dict for metric options. Options are
+                ``eval_dataset`` for ``mAP``.
+                Default: ``dict(mAP=dict(eval_dataset='thumos14'))``.
+            logger (logging.Logger | None): Logger for recording.
+                Default: None.
+            deprecated_kwargs (dict): Used for containing deprecated arguments.
+                See 'https://github.com/open-mmlab/mmaction2/pull/286'.
+
+        Returns:
+            dict: Evaluation results for evaluation metrics.
+        """
+        # Protect ``metric_options`` since it uses mutable value as default
+        metric_options = copy.deepcopy(metric_options)
+
+        if deprecated_kwargs != {}:
+            warnings.warn(
+                'Option arguments for metrics has been changed to '
+                "`metric_options`, See 'https://github.com/open-mmlab/mmaction2/pull/286' "  # noqa: E501
+                'for more details')
+            metric_options['mAP'] = dict(metric_options['mAP'],
+                                         **deprecated_kwargs)
+
+        if not isinstance(results, list):
+            raise TypeError(f'results must be a list, but got {type(results)}')
+        assert len(results) == len(self), (
+            f'The length of results is not equal to the dataset len: '
+            f'{len(results)} != {len(self)}')
+
+        metrics = metrics if isinstance(metrics, (list, tuple)) else [metrics]
+        allowed_metrics = ['mAP']
+        for metric in metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(f'metric {metric} is not supported')
+
+        detections = self.results_to_detections(results, **self.evaluater)
+
+        if self.use_regression:
+            self.logger.info('Performing location regression')
+            for class_idx, _ in enumerate(detections):
+                detections[class_idx] = {
+                    k: perform_regression(v)
+                    for k, v in detections[class_idx].items()
+                }
+            self.logger.info('Regression finished')
+
+        self.logger.info('Performing NMS')
+        for class_idx, _ in enumerate(detections):
+            detections[class_idx] = {
+                k: temporal_nms(v, self.evaluater.nms)
+                for k, v in detections[class_idx].items()
+            }
+        self.logger.info('NMS finished')
+
+        # get gts
+        all_gts = self.get_all_gts()
+        for class_idx, _ in enumerate(detections):
+            if class_idx not in all_gts:
+                all_gts[class_idx] = dict()
+
+        # get predictions
+        plain_detections = {}
+        for class_idx, _ in enumerate(detections):
+            detection_list = []
+            for video, dets in detections[class_idx].items():
+                detection_list.extend([[video, class_idx] + x[:3]
+                                       for x in dets.tolist()])
+            plain_detections[class_idx] = detection_list
+
+        eval_results = OrderedDict()
+        for metric in metrics:
+            if metric == 'mAP':
+                eval_dataset = metric_options.setdefault('mAP', {}).setdefault(
+                    'eval_dataset', 'thumos14')
+                if eval_dataset == 'thumos14':
+                    iou_range = np.arange(0.1, 1.0, .1)
+                    ap_values = eval_ap(plain_detections, all_gts, iou_range)
+                    map_ious = ap_values.mean(axis=0)
+                    self.logger.info('Evaluation finished')
+
+                    for iou, map_iou in zip(iou_range, map_ious):
+                        eval_results[f'mAP@{iou:.02f}'] = map_iou
+
+        return eval_results
+
+    def construct_proposal_pools(self):
+        """Construct positve proposal pool, incomplete proposal pool and
+        background proposal pool of the entire dataset."""
+        for video_info in self.video_infos:
+            positives = self.get_positives(
+                video_info['gts'], video_info['proposals'],
+                self.assigner.positive_iou_threshold,
+                self.sampler.add_gt_as_proposals)
+            self.positive_pool.extend([(video_info['video_id'], proposal)
+                                       for proposal in positives])
+
+            incompletes, backgrounds = self.get_negatives(
+                video_info['proposals'],
+                self.assigner.incomplete_iou_threshold,
+                self.assigner.background_iou_threshold,
+                self.assigner.background_coverage_threshold,
+                self.assigner.incomplete_overlap_threshold)
+            self.incomplete_pool.extend([(video_info['video_id'], proposal)
+                                         for proposal in incompletes])
+            self.background_pool.extend([video_info['video_id'], proposal]
+                                        for proposal in backgrounds)
+
+    def get_all_gts(self):
+        """Fetch groundtruth instances of the entire dataset."""
+        gts = {}
+        for video_info in self.video_infos:
+            video = video_info['video_id']
+            for gt in video_info['gts']:
+                class_idx = gt.label - 1
+                # gt_info: [relative_start, relative_end]
+                gt_info = [
+                    gt.start_frame / video_info['total_frames'],
+                    gt.end_frame / video_info['total_frames']
+                ]
+                gts.setdefault(class_idx, {}).setdefault(video,
+                                                         []).append(gt_info)
+
+        return gts
+
+    @staticmethod
+    def get_positives(gts, proposals, positive_threshold, with_gt=True):
+        """Get positive/foreground proposals.
+
+        Args:
+            gts (list): List of groundtruth instances(:obj:`SSNInstance`).
+            proposals (list): List of proposal instances(:obj:`SSNInstance`).
+            positive_threshold (float): Minimum threshold of overlap of
+                positive/foreground proposals and groundtruths.
+            with_gt (bool): Whether to include groundtruth instances in
+                positive proposals. Default: True.
+
+        Returns:
+            list[:obj:`SSNInstance`]: (positives), positives is a list
+                comprised of positive proposal instances.
+        """
+        positives = [
+            proposal for proposal in proposals
+            if proposal.best_iou > positive_threshold
+        ]
+
+        if with_gt:
+            positives.extend(gts)
+
+        for proposal in positives:
+            proposal.compute_regression_targets(gts)
+
+        return positives
+
+    @staticmethod
+    def get_negatives(proposals,
+                      incomplete_iou_threshold,
+                      background_iou_threshold,
+                      background_coverage_threshold=0.01,
+                      incomplete_overlap_threshold=0.7):
+        """Get negative proposals, including incomplete proposals and
+        background proposals.
+
+        Args:
+            proposals (list): List of proposal instances(:obj:`SSNInstance`).
+            incomplete_iou_threshold (float): Maximum threshold of overlap
+                of incomplete proposals and groundtruths.
+            background_iou_threshold (float): Maximum threshold of overlap
+                of background proposals and groundtruths.
+            background_coverage_threshold (float): Minimum coverage
+                of background proposals in video duration. Default: 0.01.
+            incomplete_overlap_threshold (float): Minimum percent of incomplete
+                proposals' own span contained in a groundtruth instance.
+                Default: 0.7.
+
+        Returns:
+            list[:obj:`SSNInstance`]: (incompletes, backgrounds), incompletes
+                and backgrounds are lists comprised of incomplete
+                proposal instances and background proposal instances.
+        """
+        incompletes = []
+        backgrounds = []
+
+        for proposal in proposals:
+            if (proposal.best_iou < incomplete_iou_threshold
+                    and proposal.overlap_self > incomplete_overlap_threshold):
+                incompletes.append(proposal)
+            elif (proposal.best_iou < background_iou_threshold
+                  and proposal.coverage > background_coverage_threshold):
+                backgrounds.append(proposal)
+
+        return incompletes, backgrounds
+
+    def _video_centric_sampling(self, record):
+        """Sample proposals from the this video instance.
+
+        Args:
+            record (dict): Information of the video instance(video_info[idx]).
+                key: frame_dir, video_id, total_frames,
+                gts: List of groundtruth instances(:obj:`SSNInstance`).
+                proposals: List of proposal instances(:obj:`SSNInstance`).
+        """
+        positives = self.get_positives(record['gts'], record['proposals'],
+                                       self.assigner.positive_iou_threshold,
+                                       self.sampler.add_gt_as_proposals)
+        incompletes, backgrounds = self.get_negatives(
+            record['proposals'], self.assigner.incomplete_iou_threshold,
+            self.assigner.background_iou_threshold,
+            self.assigner.background_coverage_threshold,
+            self.assigner.incomplete_overlap_threshold)
+
+        def sample_video_proposals(proposal_type, video_id, video_pool,
+                                   num_requested_proposals, dataset_pool):
+            """This method will sample proposals from the this video pool. If
+            the video pool is empty, it will fetch from the dataset pool
+            (collect proposal of the entire dataset).
+
+            Args:
+                proposal_type (int): Type id of proposal.
+                    Positive/Foreground: 0
+                    Negative:
+                        Incomplete: 1
+                        Background: 2
+                video_id (str): Name of the video.
+                video_pool (list): Pool comprised of proposals in this video.
+                num_requested_proposals (int): Number of proposals
+                    to be sampled.
+                dataset_pool (list): Proposals of the entire dataset.
+
+            Returns:
+                list[(str, :obj:`SSNInstance`), int]:
+                    video_id (str): Name of the video.
+                    :obj:`SSNInstance`: Instance of class SSNInstance.
+                    proposal_type (int): Type of proposal.
+            """
+
+            if len(video_pool) == 0:
+                idx = np.random.choice(
+                    len(dataset_pool), num_requested_proposals, replace=False)
+                return [(dataset_pool[x], proposal_type) for x in idx]
+
+            replicate = len(video_pool) < num_requested_proposals
+            idx = np.random.choice(
+                len(video_pool), num_requested_proposals, replace=replicate)
+            return [((video_id, video_pool[x]), proposal_type) for x in idx]
+
+        out_proposals = []
+        out_proposals.extend(
+            sample_video_proposals(0, record['video_id'], positives,
+                                   self.positive_per_video,
+                                   self.positive_pool))
+        out_proposals.extend(
+            sample_video_proposals(1, record['video_id'], incompletes,
+                                   self.incomplete_per_video,
+                                   self.incomplete_pool))
+        out_proposals.extend(
+            sample_video_proposals(2, record['video_id'], backgrounds,
+                                   self.background_per_video,
+                                   self.background_pool))
+
+        return out_proposals
+
+    def _random_sampling(self):
+        """Randomly sample proposals from the entire dataset."""
+        out_proposals = []
+
+        positive_idx = np.random.choice(
+            len(self.positive_pool),
+            self.positive_per_video,
+            replace=len(self.positive_pool) < self.positive_per_video)
+        out_proposals.extend([(self.positive_pool[x], 0)
+                              for x in positive_idx])
+        incomplete_idx = np.random.choice(
+            len(self.incomplete_pool),
+            self.incomplete_per_video,
+            replace=len(self.incomplete_pool) < self.incomplete_per_video)
+        out_proposals.extend([(self.incomplete_pool[x], 1)
+                              for x in incomplete_idx])
+        background_idx = np.random.choice(
+            len(self.background_pool),
+            self.background_per_video,
+            replace=len(self.background_pool) < self.background_per_video)
+        out_proposals.extend([(self.background_pool[x], 2)
+                              for x in background_idx])
+
+        return out_proposals
+
+    def _get_stage(self, proposal, num_frames):
+        """Fetch the scale factor of starting and ending stage and get the
+        stage split.
+
+        Args:
+            proposal (:obj:`SSNInstance`): Proposal instance.
+            num_frames (int): Total frames of the video.
+
+        Returns:
+            tuple[float, float, list]: (starting_scale_factor,
+                ending_scale_factor, stage_split), starting_scale_factor is
+                the ratio of the effective sampling length to augment length
+                in starting stage, ending_scale_factor is the ratio of the
+                effective sampling length to augment length in ending stage,
+                stage_split is  ending segment id of starting, course and
+                ending stage.
+        """
+        # proposal interval: [start_frame, end_frame)
+        start_frame = proposal.start_frame
+        end_frame = proposal.end_frame
+        ori_clip_len = self.clip_len * self.frame_interval
+
+        duration = end_frame - start_frame
+        assert duration != 0
+
+        valid_starting = max(0,
+                             start_frame - int(duration * self.aug_ratio[0]))
+        valid_ending = min(num_frames - ori_clip_len + 1,
+                           end_frame - 1 + int(duration * self.aug_ratio[1]))
+
+        valid_starting_length = start_frame - valid_starting - ori_clip_len
+        valid_ending_length = (valid_ending - end_frame + 1) - ori_clip_len
+
+        starting_scale_factor = ((valid_starting_length + ori_clip_len + 1) /
+                                 (duration * self.aug_ratio[0]))
+        ending_scale_factor = (valid_ending_length + ori_clip_len + 1) / (
+            duration * self.aug_ratio[1])
+
+        aug_start, aug_end = self.aug_segments
+        stage_split = [
+            aug_start, aug_start + self.body_segments,
+            aug_start + self.body_segments + aug_end
+        ]
+
+        return starting_scale_factor, ending_scale_factor, stage_split
+
+    def _compute_reg_normalize_constants(self):
+        """Compute regression target normalized constants."""
+        if self.verbose:
+            self.logger.info('Compute regression target normalized constants')
+        targets = []
+        for video_info in self.video_infos:
+            positives = self.get_positives(
+                video_info['gts'], video_info['proposals'],
+                self.assigner.positive_iou_threshold, False)
+            for positive in positives:
+                targets.append(list(positive.regression_targets))
+
+        return np.array((np.mean(targets, axis=0), np.std(targets, axis=0)))
+
+    def prepare_train_frames(self, idx):
+        """Prepare the frames for training given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['filename_tmpl'] = self.filename_tmpl
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+
+        if self.video_centric:
+            # yapf: disable
+            results['out_proposals'] = self._video_centric_sampling(self.video_infos[idx])  # noqa: E501
+            # yapf: enable
+        else:
+            results['out_proposals'] = self._random_sampling()
+
+        out_proposal_scale_factor = []
+        out_proposal_type = []
+        out_proposal_labels = []
+        out_proposal_reg_targets = []
+
+        for _, proposal in enumerate(results['out_proposals']):
+            # proposal: [(video_id, SSNInstance), proposal_type]
+            num_frames = proposal[0][1].num_video_frames
+
+            (starting_scale_factor, ending_scale_factor,
+             _) = self._get_stage(proposal[0][1], num_frames)
+
+            # proposal[1]: Type id of proposal.
+            # Positive/Foreground: 0
+            # Negative:
+            #   Incomplete: 1
+            #   Background: 2
+
+            # Positivte/Foreground proposal
+            if proposal[1] == 0:
+                label = proposal[0][1].label
+            # Incomplete proposal
+            elif proposal[1] == 1:
+                label = proposal[0][1].label
+            # Background proposal
+            elif proposal[1] == 2:
+                label = 0
+            else:
+                raise ValueError(f'Proposal type should be 0, 1, or 2,'
+                                 f'but got {proposal[1]}')
+            out_proposal_scale_factor.append(
+                [starting_scale_factor, ending_scale_factor])
+            if not isinstance(label, int):
+                raise TypeError(f'proposal_label must be an int,'
+                                f'but got {type(label)}')
+            out_proposal_labels.append(label)
+            out_proposal_type.append(proposal[1])
+
+            reg_targets = proposal[0][1].regression_targets
+            if proposal[1] == 0:
+                # Normalize regression targets of positive proposals.
+                reg_targets = ((reg_targets[0] - self.reg_norm_consts[0][0]) /
+                               self.reg_norm_consts[1][0],
+                               (reg_targets[1] - self.reg_norm_consts[0][1]) /
+                               self.reg_norm_consts[1][1])
+            out_proposal_reg_targets.append(reg_targets)
+
+        results['reg_targets'] = np.array(
+            out_proposal_reg_targets, dtype=np.float32)
+        results['proposal_scale_factor'] = np.array(
+            out_proposal_scale_factor, dtype=np.float32)
+        results['proposal_labels'] = np.array(out_proposal_labels)
+        results['proposal_type'] = np.array(out_proposal_type)
+
+        return self.pipeline(results)
+
+    def prepare_test_frames(self, idx):
+        """Prepare the frames for testing given the index."""
+        results = copy.deepcopy(self.video_infos[idx])
+        results['filename_tmpl'] = self.filename_tmpl
+        results['modality'] = self.modality
+        results['start_index'] = self.start_index
+
+        proposals = results['proposals']
+        num_frames = results['total_frames']
+        ori_clip_len = self.clip_len * self.frame_interval
+        frame_ticks = np.arange(
+            0, num_frames - ori_clip_len, self.test_interval, dtype=int) + 1
+
+        num_sampled_frames = len(frame_ticks)
+
+        if len(proposals) == 0:
+            proposals.append(SSNInstance(0, num_frames - 1, num_frames))
+
+        relative_proposal_list = []
+        proposal_tick_list = []
+        scale_factor_list = []
+
+        for proposal in proposals:
+            relative_proposal = (proposal.start_frame / num_frames,
+                                 proposal.end_frame / num_frames)
+            relative_duration = relative_proposal[1] - relative_proposal[0]
+            relative_starting_duration = relative_duration * self.aug_ratio[0]
+            relative_ending_duration = relative_duration * self.aug_ratio[1]
+            relative_starting = (
+                relative_proposal[0] - relative_starting_duration)
+            relative_ending = relative_proposal[1] + relative_ending_duration
+
+            real_relative_starting = max(0.0, relative_starting)
+            real_relative_ending = min(1.0, relative_ending)
+
+            starting_scale_factor = (
+                (relative_proposal[0] - real_relative_starting) /
+                relative_starting_duration)
+            ending_scale_factor = (
+                (real_relative_ending - relative_proposal[1]) /
+                relative_ending_duration)
+
+            proposal_ranges = (real_relative_starting, *relative_proposal,
+                               real_relative_ending)
+            proposal_ticks = (np.array(proposal_ranges) *
+                              num_sampled_frames).astype(np.int32)
+
+            relative_proposal_list.append(relative_proposal)
+            proposal_tick_list.append(proposal_ticks)
+            scale_factor_list.append(
+                (starting_scale_factor, ending_scale_factor))
+
+        results['relative_proposal_list'] = np.array(
+            relative_proposal_list, dtype=np.float32)
+        results['scale_factor_list'] = np.array(
+            scale_factor_list, dtype=np.float32)
+        results['proposal_tick_list'] = np.array(
+            proposal_tick_list, dtype=np.int32)
+        results['reg_norm_consts'] = self.reg_norm_consts
+
+        return self.pipeline(results)

TransRAC/mmaction/datasets/video_dataset.py

@@ -0,0 +1,60 @@
+import os.path as osp
+
+from .base import BaseDataset
+from .builder import DATASETS
+
+
+@DATASETS.register_module()
+class VideoDataset(BaseDataset):
+    """Video dataset for action recognition.
+
+    The dataset loads raw videos and apply specified transforms to return a
+    dict containing the frame tensors and other information.
+
+    The ann_file is a text file with multiple lines, and each line indicates
+    a sample video with the filepath and label, which are split with a
+    whitespace. Example of a annotation file:
+
+    .. code-block:: txt
+
+        some/path/000.mp4 1
+        some/path/001.mp4 1
+        some/path/002.mp4 2
+        some/path/003.mp4 2
+        some/path/004.mp4 3
+        some/path/005.mp4 3
+
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        pipeline (list[dict | callable]): A sequence of data transforms.
+        start_index (int): Specify a start index for frames in consideration of
+            different filename format. However, when taking videos as input,
+            it should be set to 0, since frames loaded from videos count
+            from 0. Default: 0.
+        **kwargs: Keyword arguments for ``BaseDataset``.
+    """
+
+    def __init__(self, ann_file, pipeline, start_index=0, **kwargs):
+        super().__init__(ann_file, pipeline, start_index=start_index, **kwargs)
+
+    def load_annotations(self):
+        """Load annotation file to get video information."""
+        if self.ann_file.endswith('.json'):
+            return self.load_json_annotations()
+
+        video_infos = []
+        with open(self.ann_file, 'r') as fin:
+            for line in fin:
+                line_split = line.strip().split()
+                if self.multi_class:
+                    assert self.num_classes is not None
+                    filename, label = line_split[0], line_split[1:]
+                    label = list(map(int, label))
+                else:
+                    filename, label = line_split
+                    label = int(label)
+                if self.data_prefix is not None:
+                    filename = osp.join(self.data_prefix, filename)
+                video_infos.append(dict(filename=filename, label=label))
+        return video_infos

TransRAC/mmaction/localization/__init__.py

@@ -0,0 +1,10 @@
+from .bsn_utils import generate_bsp_feature, generate_candidate_proposals
+from .proposal_utils import soft_nms, temporal_iop, temporal_iou
+from .ssn_utils import (eval_ap, load_localize_proposal_file,
+                        perform_regression, temporal_nms)
+
+__all__ = [
+    'generate_candidate_proposals', 'generate_bsp_feature', 'temporal_iop',
+    'temporal_iou', 'soft_nms', 'load_localize_proposal_file',
+    'perform_regression', 'temporal_nms', 'eval_ap'
+]

TransRAC/mmaction/localization/bsn_utils.py

@@ -0,0 +1,267 @@
+import os.path as osp
+
+import numpy as np
+
+from .proposal_utils import temporal_iop, temporal_iou
+
+
+def generate_candidate_proposals(video_list,
+                                 video_infos,
+                                 tem_results_dir,
+                                 temporal_scale,
+                                 peak_threshold,
+                                 tem_results_ext='.csv',
+                                 result_dict=None):
+    """Generate Candidate Proposals with given temporal evalutation results.
+    Each proposal file will contain:
+    'tmin,tmax,tmin_score,tmax_score,score,match_iou,match_ioa'.
+
+    Args:
+        video_list (list[int]): List of video indexs to generate proposals.
+        video_infos (list[dict]): List of video_info dict that contains
+            'video_name', 'duration_frame', 'duration_second',
+            'feature_frame', and 'annotations'.
+        tem_results_dir (str): Directory to load temporal evaluation
+            results.
+        temporal_scale (int): The number (scale) on temporal axis.
+        peak_threshold (float): The threshold for proposal generation.
+        tem_results_ext (str): File extension for temporal evaluation
+            model output. Default: '.csv'.
+        result_dict (dict | None): The dict to save the results. Default: None.
+
+    Returns:
+        dict: A dict contains video_name as keys and proposal list as value.
+            If result_dict is not None, save the results to it.
+    """
+    if tem_results_ext != '.csv':
+        raise NotImplementedError('Only support csv format now.')
+
+    tscale = temporal_scale
+    tgap = 1. / tscale
+    proposal_dict = {}
+    for video_index in video_list:
+        video_name = video_infos[video_index]['video_name']
+        tem_path = osp.join(tem_results_dir, video_name + tem_results_ext)
+        tem_results = np.loadtxt(
+            tem_path, dtype=np.float32, delimiter=',', skiprows=1)
+        start_scores = tem_results[:, 1]
+        end_scores = tem_results[:, 2]
+
+        max_start = max(start_scores)
+        max_end = max(end_scores)
+
+        start_bins = np.zeros(len(start_scores))
+        start_bins[[0, -1]] = 1
+        end_bins = np.zeros(len(end_scores))
+        end_bins[[0, -1]] = 1
+        for idx in range(1, tscale - 1):
+            if start_scores[idx] > start_scores[
+                    idx + 1] and start_scores[idx] > start_scores[idx - 1]:
+                start_bins[idx] = 1
+            elif start_scores[idx] > (peak_threshold * max_start):
+                start_bins[idx] = 1
+            if end_scores[idx] > end_scores[
+                    idx + 1] and end_scores[idx] > end_scores[idx - 1]:
+                end_bins[idx] = 1
+            elif end_scores[idx] > (peak_threshold * max_end):
+                end_bins[idx] = 1
+
+        tmin_list = []
+        tmin_score_list = []
+        tmax_list = []
+        tmax_score_list = []
+        for idx in range(tscale):
+            if start_bins[idx] == 1:
+                tmin_list.append(tgap / 2 + tgap * idx)
+                tmin_score_list.append(start_scores[idx])
+            if end_bins[idx] == 1:
+                tmax_list.append(tgap / 2 + tgap * idx)
+                tmax_score_list.append(end_scores[idx])
+
+        new_props = []
+        for tmax, tmax_score in zip(tmax_list, tmax_score_list):
+            for tmin, tmin_score in zip(tmin_list, tmin_score_list):
+                if tmin >= tmax:
+                    break
+                new_props.append([tmin, tmax, tmin_score, tmax_score])
+
+        new_props = np.stack(new_props)
+
+        score = (new_props[:, 2] * new_props[:, 3]).reshape(-1, 1)
+        new_props = np.concatenate((new_props, score), axis=1)
+
+        new_props = new_props[new_props[:, -1].argsort()[::-1]]
+        video_info = video_infos[video_index]
+        video_frame = video_info['duration_frame']
+        video_second = video_info['duration_second']
+        feature_frame = video_info['feature_frame']
+        corrected_second = float(feature_frame) / video_frame * video_second
+
+        gt_tmins = []
+        gt_tmaxs = []
+        for annotations in video_info['annotations']:
+            gt_tmins.append(annotations['segment'][0] / corrected_second)
+            gt_tmaxs.append(annotations['segment'][1] / corrected_second)
+
+        new_iou_list = []
+        new_ioa_list = []
+        for new_prop in new_props:
+            new_iou = max(
+                temporal_iou(new_prop[0], new_prop[1], gt_tmins, gt_tmaxs))
+            new_ioa = max(
+                temporal_iop(new_prop[0], new_prop[1], gt_tmins, gt_tmaxs))
+            new_iou_list.append(new_iou)
+            new_ioa_list.append(new_ioa)
+
+        new_iou_list = np.array(new_iou_list).reshape(-1, 1)
+        new_ioa_list = np.array(new_ioa_list).reshape(-1, 1)
+        new_props = np.concatenate((new_props, new_iou_list), axis=1)
+        new_props = np.concatenate((new_props, new_ioa_list), axis=1)
+        proposal_dict[video_name] = new_props
+        if result_dict is not None:
+            result_dict[video_name] = new_props
+    return proposal_dict
+
+
+def generate_bsp_feature(video_list,
+                         video_infos,
+                         tem_results_dir,
+                         pgm_proposals_dir,
+                         top_k=1000,
+                         bsp_boundary_ratio=0.2,
+                         num_sample_start=8,
+                         num_sample_end=8,
+                         num_sample_action=16,
+                         num_sample_interp=3,
+                         tem_results_ext='.csv',
+                         pgm_proposal_ext='.csv',
+                         result_dict=None):
+    """Generate Boundary-Sensitive Proposal Feature with given proposals.
+
+    Args:
+        video_list (list[int]): List of video indexs to generate bsp_feature.
+        video_infos (list[dict]): List of video_info dict that contains
+            'video_name'.
+        tem_results_dir (str): Directory to load temporal evaluation
+            results.
+        pgm_proposals_dir (str): Directory to load proposals.
+        top_k (int): Number of proposals to be considered. Default: 1000
+        bsp_boundary_ratio (float): Ratio for proposal boundary
+            (start/end). Default: 0.2.
+        num_sample_start (int): Num of samples for actionness in
+            start region. Default: 8.
+        num_sample_end (int): Num of samples for actionness in end region.
+            Default: 8.
+        num_sample_action (int): Num of samples for actionness in center
+            region. Default: 16.
+        num_sample_interp (int): Num of samples for interpolation for
+            each sample point. Default: 3.
+        tem_results_ext (str): File extension for temporal evaluation
+            model output. Default: '.csv'.
+        pgm_proposal_ext (str): File extension for proposals. Default: '.csv'.
+        result_dict (dict | None): The dict to save the results. Default: None.
+
+    Returns:
+        bsp_feature_dict (dict): A dict contains video_name as keys and
+            bsp_feature as value. If result_dict is not None, save the
+            results to it.
+    """
+    if tem_results_ext != '.csv' or pgm_proposal_ext != '.csv':
+        raise NotImplementedError('Only support csv format now.')
+
+    bsp_feature_dict = {}
+    for video_index in video_list:
+        video_name = video_infos[video_index]['video_name']
+
+        # Load temporal evaluation results
+        tem_path = osp.join(tem_results_dir, video_name + tem_results_ext)
+        tem_results = np.loadtxt(
+            tem_path, dtype=np.float32, delimiter=',', skiprows=1)
+        score_action = tem_results[:, 0]
+        seg_tmins = tem_results[:, 3]
+        seg_tmaxs = tem_results[:, 4]
+        video_scale = len(tem_results)
+        video_gap = seg_tmaxs[0] - seg_tmins[0]
+        video_extend = int(video_scale / 4 + 10)
+
+        # Load proposals results
+        proposal_path = osp.join(pgm_proposals_dir,
+                                 video_name + pgm_proposal_ext)
+        pgm_proposals = np.loadtxt(
+            proposal_path, dtype=np.float32, delimiter=',', skiprows=1)
+        pgm_proposals = pgm_proposals[:top_k]
+
+        # Generate temporal sample points
+        boundary_zeros = np.zeros([video_extend])
+        score_action = np.concatenate(
+            (boundary_zeros, score_action, boundary_zeros))
+        begin_tp = []
+        middle_tp = []
+        end_tp = []
+        for i in range(video_extend):
+            begin_tp.append(-video_gap / 2 -
+                            (video_extend - 1 - i) * video_gap)
+            end_tp.append(video_gap / 2 + seg_tmaxs[-1] + i * video_gap)
+        for i in range(video_scale):
+            middle_tp.append(video_gap / 2 + i * video_gap)
+        t_points = begin_tp + middle_tp + end_tp
+
+        bsp_feature = []
+        for pgm_proposal in pgm_proposals:
+            tmin = pgm_proposal[0]
+            tmax = pgm_proposal[1]
+
+            tlen = tmax - tmin
+            # Temporal range for start
+            tmin_0 = tmin - tlen * bsp_boundary_ratio
+            tmin_1 = tmin + tlen * bsp_boundary_ratio
+            # Temporal range for end
+            tmax_0 = tmax - tlen * bsp_boundary_ratio
+            tmax_1 = tmax + tlen * bsp_boundary_ratio
+
+            # Generate features at start boundary
+            tlen_start = (tmin_1 - tmin_0) / (num_sample_start - 1)
+            tlen_start_sample = tlen_start / num_sample_interp
+            t_new = [
+                tmin_0 - tlen_start / 2 + tlen_start_sample * i
+                for i in range(num_sample_start * num_sample_interp + 1)
+            ]
+            y_new_start_action = np.interp(t_new, t_points, score_action)
+            y_new_start = [
+                np.mean(y_new_start_action[i * num_sample_interp:(i + 1) *
+                                           num_sample_interp + 1])
+                for i in range(num_sample_start)
+            ]
+            # Generate features at end boundary
+            tlen_end = (tmax_1 - tmax_0) / (num_sample_end - 1)
+            tlen_end_sample = tlen_end / num_sample_interp
+            t_new = [
+                tmax_0 - tlen_end / 2 + tlen_end_sample * i
+                for i in range(num_sample_end * num_sample_interp + 1)
+            ]
+            y_new_end_action = np.interp(t_new, t_points, score_action)
+            y_new_end = [
+                np.mean(y_new_end_action[i * num_sample_interp:(i + 1) *
+                                         num_sample_interp + 1])
+                for i in range(num_sample_end)
+            ]
+            # Generate features for action
+            tlen_action = (tmax - tmin) / (num_sample_action - 1)
+            tlen_action_sample = tlen_action / num_sample_interp
+            t_new = [
+                tmin - tlen_action / 2 + tlen_action_sample * i
+                for i in range(num_sample_action * num_sample_interp + 1)
+            ]
+            y_new_action = np.interp(t_new, t_points, score_action)
+            y_new_action = [
+                np.mean(y_new_action[i * num_sample_interp:(i + 1) *
+                                     num_sample_interp + 1])
+                for i in range(num_sample_action)
+            ]
+            feature = np.concatenate([y_new_action, y_new_start, y_new_end])
+            bsp_feature.append(feature)
+        bsp_feature = np.array(bsp_feature)
+        bsp_feature_dict[video_name] = bsp_feature
+        if result_dict is not None:
+            result_dict[video_name] = bsp_feature
+    return bsp_feature_dict

TransRAC/mmaction/localization/proposal_utils.py

@@ -0,0 +1,94 @@
+import numpy as np
+
+
+def temporal_iou(proposal_min, proposal_max, gt_min, gt_max):
+    """Compute IoU score between a groundtruth bbox and the proposals.
+
+    Args:
+        proposal_min (list[float]): List of temporal anchor min.
+        proposal_max (list[float]): List of temporal anchor max.
+        gt_min (float): Groundtruth temporal box min.
+        gt_max (float): Groundtruth temporal box max.
+
+    Returns:
+        list[float]: List of iou scores.
+    """
+    len_anchors = proposal_max - proposal_min
+    int_tmin = np.maximum(proposal_min, gt_min)
+    int_tmax = np.minimum(proposal_max, gt_max)
+    inter_len = np.maximum(int_tmax - int_tmin, 0.)
+    union_len = len_anchors - inter_len + gt_max - gt_min
+    jaccard = np.divide(inter_len, union_len)
+    return jaccard
+
+
+def temporal_iop(proposal_min, proposal_max, gt_min, gt_max):
+    """Compute IoP score between a groundtruth bbox and the proposals.
+
+    Compute the IoP which is defined as the overlap ratio with
+    groundtruth proportional to the duration of this proposal.
+
+    Args:
+        proposal_min (list[float]): List of temporal anchor min.
+        proposal_max (list[float]): List of temporal anchor max.
+        gt_min (float): Groundtruth temporal box min.
+        gt_max (float): Groundtruth temporal box max.
+
+    Returns:
+        list[float]: List of intersection over anchor scores.
+    """
+    len_anchors = np.array(proposal_max - proposal_min)
+    int_tmin = np.maximum(proposal_min, gt_min)
+    int_tmax = np.minimum(proposal_max, gt_max)
+    inter_len = np.maximum(int_tmax - int_tmin, 0.)
+    scores = np.divide(inter_len, len_anchors)
+    return scores
+
+
+def soft_nms(proposals, alpha, low_threshold, high_threshold, top_k):
+    """Soft NMS for temporal proposals.
+
+    Args:
+        proposals (np.ndarray): Proposals generated by network.
+        alpha (float): Alpha value of Gaussian decaying function.
+        low_threshold (float): Low threshold for soft nms.
+        high_threshold (float): High threshold for soft nms.
+        top_k (int): Top k values to be considered.
+
+    Returns:
+        np.ndarray: The updated proposals.
+    """
+    proposals = proposals[proposals[:, -1].argsort()[::-1]]
+    tstart = list(proposals[:, 0])
+    tend = list(proposals[:, 1])
+    tscore = list(proposals[:, -1])
+    rstart = []
+    rend = []
+    rscore = []
+
+    while len(tscore) > 0 and len(rscore) <= top_k:
+        max_index = np.argmax(tscore)
+        max_width = tend[max_index] - tstart[max_index]
+        iou_list = temporal_iou(tstart[max_index], tend[max_index],
+                                np.array(tstart), np.array(tend))
+        iou_exp_list = np.exp(-np.square(iou_list) / alpha)
+
+        for idx, _ in enumerate(tscore):
+            if idx != max_index:
+                current_iou = iou_list[idx]
+                if current_iou > low_threshold + (high_threshold -
+                                                  low_threshold) * max_width:
+                    tscore[idx] = tscore[idx] * iou_exp_list[idx]
+
+        rstart.append(tstart[max_index])
+        rend.append(tend[max_index])
+        rscore.append(tscore[max_index])
+        tstart.pop(max_index)
+        tend.pop(max_index)
+        tscore.pop(max_index)
+
+    rstart = np.array(rstart).reshape(-1, 1)
+    rend = np.array(rend).reshape(-1, 1)
+    rscore = np.array(rscore).reshape(-1, 1)
+    new_proposals = np.concatenate((rstart, rend, rscore), axis=1)
+    return new_proposals

TransRAC/mmaction/localization/ssn_utils.py

@@ -0,0 +1,168 @@
+from itertools import groupby
+
+import numpy as np
+
+from ..core import average_precision_at_temporal_iou
+from . import temporal_iou
+
+
+def load_localize_proposal_file(filename):
+    """Load the proposal file and split it into many parts which contain one
+    video's information separately.
+
+    Args:
+        filename(str): Path to the proposal file.
+
+    Returns:
+        list: List of all videos' information.
+    """
+    lines = list(open(filename))
+
+    # Split the proposal file into many parts which contain one video's
+    # information separately.
+    groups = groupby(lines, lambda x: x.startswith('#'))
+
+    video_infos = [[x.strip() for x in list(g)] for k, g in groups if not k]
+
+    def parse_group(video_info):
+        """Parse the video's information.
+
+        Template information of a video in a standard file:
+            # index
+            video_id
+            num_frames
+            fps
+            num_gts
+            label, start_frame, end_frame
+            label, start_frame, end_frame
+            ...
+            num_proposals
+            label, best_iou, overlap_self, start_frame, end_frame
+            label, best_iou, overlap_self, start_frame, end_frame
+            ...
+
+        Example of a standard annotation file:
+
+        .. code-block:: txt
+
+            # 0
+            video_validation_0000202
+            5666
+            1
+            3
+            8 130 185
+            8 832 1136
+            8 1303 1381
+            5
+            8 0.0620 0.0620 790 5671
+            8 0.1656 0.1656 790 2619
+            8 0.0833 0.0833 3945 5671
+            8 0.0960 0.0960 4173 5671
+            8 0.0614 0.0614 3327 5671
+
+        Args:
+            video_info (list): Information of the video.
+
+        Returns:
+            tuple[str, int, list, list]:
+                video_id (str): Name of the video.
+                num_frames (int): Number of frames in the video.
+                gt_boxes (list): List of the information of gt boxes.
+                proposal_boxes (list): List of the information of
+                    proposal boxes.
+        """
+        offset = 0
+        video_id = video_info[offset]
+        offset += 1
+
+        num_frames = int(float(video_info[1]) * float(video_info[2]))
+        num_gts = int(video_info[3])
+        offset = 4
+
+        gt_boxes = [x.split() for x in video_info[offset:offset + num_gts]]
+        offset += num_gts
+        num_proposals = int(video_info[offset])
+        offset += 1
+        proposal_boxes = [
+            x.split() for x in video_info[offset:offset + num_proposals]
+        ]
+
+        return video_id, num_frames, gt_boxes, proposal_boxes
+
+    return [parse_group(video_info) for video_info in video_infos]
+
+
+def perform_regression(detections):
+    """Perform regression on detection results.
+
+    Args:
+        detections (list): Detection results before regression.
+
+    Returns:
+        list: Detection results after regression.
+    """
+    starts = detections[:, 0]
+    ends = detections[:, 1]
+    centers = (starts + ends) / 2
+    durations = ends - starts
+
+    new_centers = centers + durations * detections[:, 3]
+    new_durations = durations * np.exp(detections[:, 4])
+
+    new_detections = np.concatenate(
+        (np.clip(new_centers - new_durations / 2, 0,
+                 1)[:, None], np.clip(new_centers + new_durations / 2, 0,
+                                      1)[:, None], detections[:, 2:]),
+        axis=1)
+    return new_detections
+
+
+def temporal_nms(detections, threshold):
+    """Parse the video's information.
+
+    Args:
+        detections (list): Detection results before NMS.
+        threshold (float): Threshold of NMS.
+
+    Returns:
+        list: Detection results after NMS.
+    """
+    starts = detections[:, 0]
+    ends = detections[:, 1]
+    scores = detections[:, 2]
+
+    order = scores.argsort()[::-1]
+
+    keep = []
+    while order.size > 0:
+        i = order[0]
+        keep.append(i)
+        ious = temporal_iou(starts[order[1:]], ends[order[1:]], starts[i],
+                            ends[i])
+        idxs = np.where(ious <= threshold)[0]
+        order = order[idxs + 1]
+
+    return detections[keep, :]
+
+
+def eval_ap(detections, gt_by_cls, iou_range):
+    """Evaluate average precisions.
+
+    Args:
+        detections (dict): Results of detections.
+        gt_by_cls (dict): Information of groudtruth.
+        iou_range (list): Ranges of iou.
+
+    Returns:
+        list: Average precision values of classes at ious.
+    """
+    ap_values = np.zeros((len(detections), len(iou_range)))
+
+    for iou_idx, min_overlap in enumerate(iou_range):
+        for class_idx, _ in enumerate(detections):
+            ap = average_precision_at_temporal_iou(gt_by_cls[class_idx],
+                                                   detections[class_idx],
+                                                   [min_overlap])
+            ap_values[class_idx, iou_idx] = ap
+
+    return ap_values

TransRAC/mmaction/utils/decorators.py

@@ -0,0 +1,32 @@
+from types import MethodType
+
+
+def import_module_error_func(module_name):
+    """When a function is imported incorrectly due to a missing module, raise
+    an import error when the function is called."""
+
+    def decorate(func):
+
+        def new_func(*args, **kwargs):
+            raise ImportError(
+                f'Please install {module_name} to use {func.__name__}.')
+
+        return new_func
+
+    return decorate
+
+
+def import_module_error_class(module_name):
+    """When a class is imported incorrectly due to a missing module, raise an
+    import error when the class is instantiated."""
+
+    def decorate(cls):
+
+        def import_error_init(*args, **kwargs):
+            raise ImportError(
+                f'Please install {module_name} to use {cls.__name__}.')
+
+        cls.__init__ = MethodType(import_error_init, cls)
+        return cls
+
+    return decorate

TransRAC/mmaction/utils/logger.py

@@ -0,0 +1,24 @@
+import logging
+
+from mmcv.utils import get_logger
+
+
+def get_root_logger(log_file=None, log_level=logging.INFO):
+    """Use ``get_logger`` method in mmcv to get the root logger.
+
+    The logger will be initialized if it has not been initialized. By default a
+    StreamHandler will be added. If ``log_file`` is specified, a FileHandler
+    will also be added. The name of the root logger is the top-level package
+    name, e.g., "mmaction".
+
+    Args:
+        log_file (str | None): The log filename. If specified, a FileHandler
+            will be added to the root logger.
+        log_level (int): The root logger level. Note that only the process of
+            rank 0 is affected, while other processes will set the level to
+            "Error" and be silent most of the time.
+
+    Returns:
+        :obj:`logging.Logger`: The root logger.
+    """
+    return get_logger(__name__.split('.')[0], log_file, log_level)

TransRAC/mmaction/utils/optimizer.py

@@ -0,0 +1,33 @@
+from mmcv.runner import OptimizerHook, HOOKS
+try:
+    import apex
+except:
+    print('apex is not installed')
+
+
+@HOOKS.register_module()
+class DistOptimizerHook(OptimizerHook):
+    """Optimizer hook for distributed training."""
+
+    def __init__(self, update_interval=1, grad_clip=None, coalesce=True, bucket_size_mb=-1, use_fp16=False):
+        self.grad_clip = grad_clip
+        self.coalesce = coalesce
+        self.bucket_size_mb = bucket_size_mb
+        self.update_interval = update_interval
+        self.use_fp16 = use_fp16
+
+    def before_run(self, runner):
+        runner.optimizer.zero_grad()
+
+    def after_train_iter(self, runner):
+        runner.outputs['loss'] /= self.update_interval
+        if self.use_fp16:
+            with apex.amp.scale_loss(runner.outputs['loss'], runner.optimizer) as scaled_loss:
+                scaled_loss.backward()
+        else:
+            runner.outputs['loss'].backward()
+        if self.every_n_iters(runner, self.update_interval):
+            if self.grad_clip is not None:
+                self.clip_grads(runner.model.parameters())
+            runner.optimizer.step()
+            runner.optimizer.zero_grad()

TransRAC/mmaction/version.py

@@ -0,0 +1,18 @@
+# Copyright (c) Open-MMLab. All rights reserved.
+
+__version__ = '0.15.0'
+
+
+def parse_version_info(version_str):
+    version_info = []
+    for x in version_str.split('.'):
+        if x.isdigit():
+            version_info.append(int(x))
+        elif x.find('rc') != -1:
+            patch_version = x.split('rc')
+            version_info.append(int(patch_version[0]))
+            version_info.append(f'rc{patch_version[1]}')
+    return tuple(version_info)
+
+
+version_info = parse_version_info(__version__)

TransRAC/mmcv_custom/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

TransRAC/models/TransRAC.py

@@ -0,0 +1,254 @@
+"""TransRAC network"""
+from mmcv import Config
+from mmaction.models import build_model
+from mmcv.runner import load_checkpoint
+import torch
+import torch.nn as nn
+import math
+from torch.cuda.amp import autocast
+import numpy as np
+import torch.nn.functional as F
+
+
+class attention(nn.Module):
+    """Scaled dot-product attention mechanism."""
+
+    def __init__(self, scale=64, att_dropout=None):
+        super().__init__()
+        # self.dropout = nn.Dropout(attention_dropout)
+        self.softmax = nn.Softmax(dim=-1)
+        self.dropout = nn.Dropout(att_dropout)
+        self.scale = scale
+
+    def forward(self, q, k, v, attn_mask=None):
+        # q: [B, head, F, model_dim]
+        scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.scale)  # [B,Head, F, F]
+        if attn_mask:
+            scores = scores.masked_fill_(attn_mask, -np.inf)
+        scores = self.softmax(scores)
+        scores = self.dropout(scores)  # [B,head, F, F]
+        # context = torch.matmul(scores, v)  # output
+        return scores  # [B,head,F, F]
+
+
+class Similarity_matrix(nn.Module):
+    ''' buliding similarity matrix by self-attention mechanism '''
+
+    def __init__(self, num_heads=4, model_dim=512):
+        super().__init__()
+
+        # self.dim_per_head = model_dim // num_heads
+        self.num_heads = num_heads
+        self.model_dim = model_dim
+        self.input_size = 512
+        self.linear_q = nn.Linear(self.input_size, model_dim)
+        self.linear_k = nn.Linear(self.input_size, model_dim)
+        self.linear_v = nn.Linear(self.input_size, model_dim)
+
+        self.attention = attention(att_dropout=0)
+        # self.out = nn.Linear(model_dim, model_dim)
+        # self.layer_norm = nn.LayerNorm(model_dim)
+
+    def forward(self, query, key, value, attn_mask=None):
+        batch_size = query.size(0)
+        # dim_per_head = self.dim_per_head
+        num_heads = self.num_heads
+        # linear projection
+        query = self.linear_q(query)  # [B,F,model_dim]
+        key = self.linear_k(key)
+        value = self.linear_v(value)
+        # split by heads
+        # [B,F,model_dim] ->  [B,F,num_heads,per_head]->[B,num_heads,F,per_head]
+        query = query.reshape(batch_size, -1, num_heads, self.model_dim // self.num_heads).transpose(1, 2)
+        key = key.reshape(batch_size, -1, num_heads, self.model_dim // self.num_heads).transpose(1, 2)
+        value = value.reshape(batch_size, -1, num_heads, self.model_dim // self.num_heads).transpose(1, 2)
+        # similar_matrix :[B,H,F,F ]
+        matrix = self.attention(query, key, value, attn_mask)
+
+        return matrix
+
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        x = x + self.pe[:x.size(0), :]
+        x = self.dropout(x)
+        return x
+
+
+class TransEncoder(nn.Module):
+    '''standard transformer encoder'''
+
+    def __init__(self, d_model, n_head, dim_ff, dropout=0.0, num_layers=1, num_frames=64):
+        super(TransEncoder, self).__init__()
+        self.pos_encoder = PositionalEncoding(d_model, 0.1, num_frames)
+
+        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model,
+                                                   nhead=n_head,
+                                                   dim_feedforward=dim_ff,
+                                                   dropout=dropout,
+                                                   activation='relu')
+        encoder_norm = nn.LayerNorm(d_model)
+        self.trans_encoder = nn.TransformerEncoder(encoder_layer, num_layers, encoder_norm)
+
+    def forward(self, src):
+        src = self.pos_encoder(src)
+        e_op = self.trans_encoder(src)
+        return e_op
+
+
+class Prediction(nn.Module):
+    ''' predict the density map with densenet '''
+
+    def __init__(self, input_dim, n_hidden_1, n_hidden_2, out_dim):
+        super(Prediction, self).__init__()
+        self.layers = nn.Sequential(
+            nn.Linear(input_dim, n_hidden_1),
+            nn.LayerNorm(n_hidden_1),
+            nn.Dropout(p=0.25, inplace=False),
+            nn.ReLU(True),
+            nn.Linear(n_hidden_1, n_hidden_2),
+            nn.ReLU(True),
+            nn.Dropout(p=0.25, inplace=False),
+            nn.Linear(n_hidden_2, out_dim)
+        )
+
+    def forward(self, x):
+        x = self.layers(x)
+        return x
+
+
+class TransferModel(nn.Module):
+    def __init__(self, config, checkpoint, num_frames, scales, OPEN=False):
+        super(TransferModel, self).__init__()
+        self.num_frames = num_frames
+        self.config = config
+        self.checkpoint = checkpoint
+        self.scales = scales
+        self.OPEN = OPEN
+
+        self.backbone = self.load_model()  # load pretrain model
+
+        self.Replication_padding1 = nn.ConstantPad3d((0, 0, 0, 0, 1, 1), 0)
+        self.Replication_padding2 = nn.ConstantPad3d((0, 0, 0, 0, 2, 2), 0)
+        self.Replication_padding4 = nn.ConstantPad3d((0, 0, 0, 0, 4, 4), 0)
+
+        self.conv3D = nn.Conv3d(in_channels=768,
+                                out_channels=512,
+                                kernel_size=3,
+                                padding=(3, 1, 1),
+                                dilation=(3, 1, 1))
+
+        self.bn1 = nn.BatchNorm3d(512)
+        self.SpatialPooling = nn.MaxPool3d(kernel_size=(1, 7, 7))
+
+        self.sims = Similarity_matrix()
+        self.conv3x3 = nn.Conv2d(in_channels=4 * len(self.scales),  # num_head*scale_num
+                                 out_channels=32,
+                                 kernel_size=3,
+                                 padding=1)
+
+        self.bn2 = nn.BatchNorm2d(32)
+
+        self.dropout1 = nn.Dropout(0.25)
+        self.input_projection = nn.Linear(self.num_frames * 32, 512)  # 线性投射层
+        self.ln1 = nn.LayerNorm(512)
+
+        self.transEncoder = TransEncoder(d_model=512, n_head=4, dropout=0.2, dim_ff=512, num_layers=1,
+                                         num_frames=self.num_frames)
+        self.FC = Prediction(512, 512, 256, 1)  #
+
+    def load_model(self):
+        # # # load  pretrained model of video swin transformer using mmaction and mmcv API
+        cfg = Config.fromfile(self.config)
+        model = build_model(cfg.model, train_cfg=cfg.get('train_cfg'), test_cfg=cfg.get('test_cfg'))
+
+        # # # load hyperparameters by mmcv api
+        load_checkpoint(model, self.checkpoint, map_location='cpu')
+        backbone = model.backbone
+
+        # # # load hyperparameters by pytorch
+        # loaded_ckpt = torch.load(self.checkpoint)
+        # backbone = model.backbone
+        # net_dict = backbone.state_dict()
+        # state_dict = {k: v for k, v in loaded_ckpt.items() if k in net_dict.keys()}
+        # net_dict.update(state_dict)
+        # backbone.load_state_dict(net_dict, strict=False)
+
+        print('--------- backbone loaded ------------')
+
+        return backbone
+
+    def forward(self, x):
+        # x: tensor([batch_size, channel, temporal_dim, height, width])
+        with autocast():
+            batch_size, c, num_frames, h, w = x.shape
+            # scales = [1,4,8]
+            ### We currently only support 1, 4, 8 flames. If you want to add more scale, you can change the part and don't forget padding.
+            multi_scales = []
+            for scale in self.scales:
+                if scale == 4:
+                    x = self.Replication_padding2(x)
+                    crops = [x[:, :, i:i + scale, :, :] for i in
+                             range(0, self.num_frames - scale + scale // 2 * 2, max(scale // 2, 1))]
+                elif scale == 8:
+                    x = self.Replication_padding4(x)
+                    crops = [x[:, :, i:i + scale, :, :] for i in
+                             range(0, self.num_frames - scale + scale // 2 * 2, max(scale // 2, 1))]
+                else:
+                    crops = [x[:, :, i:i + 1, :, :] for i in range(0, self.num_frames)]
+
+                slice = []
+                ## feature extract with video SwinTransformer
+                if not self.OPEN:
+                    with torch.no_grad():
+                        for crop in crops:
+                            crop = self.backbone(crop)  # ->[batch_size, 768, scale/2(up), 7, 7]
+                            slice.append(crop)
+                else:  # train  the feature extractor (video SwinTransformer backbone)
+                    for crop in crops:
+                        crop = self.backbone(crop)  # ->[batch_size, 768, scale/2(up), 7, 7]
+                        slice.append(crop)
+
+                x_scale = torch.cat(slice, dim=2)  # -> [b,768,f,size,size]
+                x_scale = F.relu(self.bn1(self.conv3D(x_scale)))  # ->[b,512,f,7,7]
+                # print(x_scale.shape)
+                x_scale = self.SpatialPooling(x_scale)  # ->[b,512,f,1,1]
+                x_scale = x_scale.squeeze(3).squeeze(3)  # -> [b,512,f]
+                x_scale = x_scale.transpose(1, 2)  # -> [b,f,512]
+
+                # -------- similarity matrix ---------
+                x_sims = F.relu(self.sims(x_scale, x_scale, x_scale))  # -> [b,4,f,f]
+                multi_scales.append(x_sims)
+
+            x = torch.cat(multi_scales, dim=1)  # [B,4*scale_num,f,f]
+            ## x are the similarity matrixs
+            x_matrix = x
+            x = F.relu(self.bn2(self.conv3x3(x)))  # [b,32,f,f]
+            x = self.dropout1(x)
+
+            x = x.permute(0, 2, 3, 1)  # [b,f,f,32]
+            # --------- transformer encoder ------
+            x = x.flatten(start_dim=2)  # ->[b,f,32*f]
+            x = F.relu(self.input_projection(x))  # ->[b,f, 512]
+            x = self.ln1(x)
+
+            x = x.transpose(0, 1)  # [f,b,512]
+            x = self.transEncoder(x)  #
+            x = x.transpose(0, 1)  # ->[b,f, 512]
+
+            x = self.FC(x)  # ->[b,f,1]
+            x = x.squeeze(2)
+
+            return x, x_matrix

TransRAC/open_set/new_valid.csv

@@ -0,0 +1,129 @@
+,Unnamed: 0,type,name,count,L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12,L13,L14,L15,L16,L17,L18,L19,L20,L21,L22,L23,L24,L25,L26,L27,L28,L29,L30,L31,L32,L33,L34,L35,L36,L37,L38,L39,L40,L41,L42,L43,L44,L45,L46,L47,L48,L49,L50,L51,L52,L53,L54,L55,L56,L57,L58,L59,L60,L61,L62,L63,L64,L65,L66,L67,L68,L69,L70,L71,L72,L73,L74,L75,L76,L77,L78,L79,L80,L81,L82,L83,L84,L85,L86,L87,L88,L89,L90,L91,L92,L93,L94,L95,L96,L97,L98,L99,L100,L101,L102,L103,L104,L105,L106,L107,L108,L109,L110,L111,L112,L113,L114,L115,L116,L117,L118,L119,L120,L121,L122,L123,L124,L125,L126,L127,L128,L129,L130,L131,L132,L133,L134,L135,L136,L137,L138,L139,L140,L141,L142,L143,L144,L145,L146,L147,L148,L149,L150,L151,L152,L153,L154,L155,L156,L157,L158,L159,L160,L161,L162,L163,L164,L165,L166,L167,L168,L169,L170,L171,L172,L173,L174,L175,L176,L177,L178,L179,L180,L181,L182,L183,L184,L185,L186,L187,L188,L189,L190,L191,L192,L193,L194,L195,L196,L197,L198,L199,L200,L201,L202,L203,L204,L205,L206,L207,L208,L209,L210,L211,L212,L213,L214,L215,L216,L217,L218,L219,L220,L221,L222,L223,L224,L225,L226,L227,L228,L229,L230,L231,L232,L233,L234,L235,L236,L237,L238,L239,L240,L241,L242,L243,L244,L245,L246,L247,L248,L249,L250,L251,L252,L253,L254,L255,L256,L257,L258,L259,L260,L261,L262,L263,L264,L265,L266,L267,L268,L269,L270,L271,L272,L273,L274,L275,L276,L277,L278,L279,L280,L281,L282,L283,L284,L285,L286,L287,L288,L289,L290,L291,L292,L293,L294,L295,L296,L297,L298,L299,L300,L301,L302
+0,0,frontraise,train951.mp4,4,6,72,72.0,132.0,132.0,204.0,204.0,271.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+1,1,frontraise,train952.mp4,10,13,62,62.0,103.0,103.0,126.0,126.0,146.0,146.0,171.0,171.0,194.0,194.0,215.0,215.0,239.0,239.0,260.0,260.0,281.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+4,4,front_raise,stu5_11.mp4,6,104,179,179.0,255.0,255.0,330.0,426.0,501.0,703.0,789.0,790.0,853.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+7,7,front_raise,stu4_14.mp4,5,6,87,87.0,177.0,177.0,276.0,276.0,377.0,377.0,490.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+28,28,frontraise,train940.mp4,5,45,94,94.0,148.0,148.0,201.0,201.0,255.0,255.0,299.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+33,33,front_raise,stu9_22.mp4,6,39,124,124.0,207.0,207.0,277.0,566.0,659.0,659.0,750.0,750.0,851.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+35,35,front_raise,stu1_14.mp4,3,15,227,227.0,403.0,403.0,540.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+39,39,frontraise,train987.mp4,7,0,36,36.0,78.0,78.0,118.0,118.0,160.0,160.0,204.0,204.0,244.0,244.0,279.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+42,43,front_raise,stu7_18.mp4,5,40,207,208.0,337.0,338.0,399.0,402.0,466.0,555.0,663.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+51,52,front_raise,stu6_8.mp4,6,19,110,111.0,191.0,198.0,346.0,382.0,553.0,579.0,702.0,702.0,822.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+54,55,front_raise,stu9_26.mp4,3,142,239,239.0,339.0,339.0,436.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+64,66,front_raise,stu2_20.mp4,13,79,145,145.0,198.0,198.0,251.0,251.0,304.0,304.0,360.0,360.0,412.0,412.0,466.0,466.0,518.0,518.0,572.0,572.0,629.0,630.0,679.0,679.0,736.0,736.0,789.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+65,67,front_raise,stu10_16.mp4,6,22,94,94.0,147.0,147.0,197.0,197.0,249.0,249.0,300.0,300.0,343.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+83,85,frontraise,test586.mp4,7,19,56,56.0,99.0,99.0,136.0,136.0,178.0,178.0,220.0,220.0,257.0,257.0,298.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+89,91,front_raise,stu1_20.mp4,3,36,105,105.0,186.0,186.0,265.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+93,95,front_raise,stu3_9.mp4,12,24,84,84.0,145.0,145.0,210.0,210.0,278.0,278.0,350.0,350.0,422.0,422.0,492.0,492.0,562.0,562.0,630.0,630.0,708.0,708.0,784.0,784.0,854.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+117,119,front_raise,stu6_6.mp4,9,5,309,309.0,455.0,455.0,562.0,563.0,663.0,663.0,770.0,772.0,867.0,867.0,977.0,977.0,1102.0,1107.0,1204.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+127,129,front_raise,stu7_21.mp4,7,39,129,129.0,213.0,215.0,314.0,316.0,406.0,407.0,504.0,551.0,606.0,608.0,672.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+130,132,front_raise,stu10_23.mp4,9,39,87,87.0,138.0,138.0,188.0,188.0,237.0,365.0,441.0,441.0,489.0,489.0,536.0,536.0,578.0,578.0,615.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+138,140,front_raise,stu2_16.mp4,2,336,513,513.0,709.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+140,142,front_raise,stu9_25.mp4,1,87,202,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+147,149,frontraise,train954.mp4,6,3,47,47.0,91.0,91.0,142.0,142.0,195.0,195.0,243.0,243.0,286.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+150,152,front_raise,stu8_17.mp4,23,69,121,121.0,170.0,170.0,219.0,219.0,269.0,269.0,319.0,319.0,369.0,369.0,417.0,417.0,456.0,457.0,505.0,505.0,554.0,554.0,603.0,603.0,646.0,646.0,694.0,694.0,762.0,762.0,803.0,803.0,856.0,856.0,908.0,908.0,951.0,951.0,1006.0,1006.0,1056.0,1056.0,1106.0,1106.0,1157.0,1157.0,1199.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+161,163,front_raise,stu10_18.mp4,4,63,457,457.0,724.0,725.0,833.0,833.0,934.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+162,164,front_raise,stu6_10.mp4,3,57,167,174.0,298.0,304.0,405.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+164,166,frontraise,train1005.mp4,4,1,60,60.0,131.0,131.0,193.0,193.0,273.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+167,169,front_raise,stu9_20.mp4,7,64,147,147.0,225.0,225.0,290.0,291.0,376.0,376.0,429.0,429.0,485.0,600.0,712.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+173,175,front_raise,stu4_13.mp4,6,4,65,65.0,135.0,135.0,209.0,211.0,286.0,286.0,365.0,366.0,437.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+174,176,front_raise,stu5_13.mp4,4,0,60,60.0,129.0,129.0,188.0,188.0,263.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+176,178,front_raise,stu10_15.mp4,17,14,73,73.0,127.0,135.0,180.0,180.0,226.0,226.0,268.0,268.0,313.0,313.0,356.0,356.0,404.0,404.0,448.0,448.0,526.0,526.0,569.0,570.0,620.0,620.0,661.0,661.0,710.0,710.0,752.0,752.0,797.0,798.0,844.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+195,197,front_raise,stu3_11.mp4,3,17,100,100.0,176.0,176.0,234.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+201,203,frontraise,test531.mp4,4,0,79,79.0,151.0,151.0,221.0,222.0,290.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+203,205,front_raise,stu2_17.mp4,5,48,147,147.0,298.0,298.0,428.0,428.0,559.0,561.0,695.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+204,206,front_raise,stu9_16.mp4,6,46,127,128.0,202.0,202.0,285.0,285.0,361.0,361.0,480.0,480.0,604.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+206,208,front_raise,stu1_15.mp4,1,59,215,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+207,209,front_raise,stu7_23.mp4,4,0,100,100.0,201.0,203.0,318.0,318.0,418.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+219,222,front_raise,stu9_27.mp4,17,6,60,61.0,111.0,198.0,241.0,241.0,279.0,280.0,316.0,316.0,359.0,359.0,399.0,399.0,436.0,437.0,478.0,478.0,516.0,516.0,558.0,559.0,599.0,599.0,636.0,636.0,676.0,676.0,720.0,720.0,759.0,759.0,808.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+229,232,frontraise,val359.mp4,1,3,225,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+238,241,front_raise,stu5_14.mp4,9,0,75,75.0,157.0,157.0,242.0,242.0,331.0,331.0,411.0,411.0,497.0,497.0,574.0,574.0,654.0,654.0,723.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+247,250,front_raise,stu7_15.mp4,4,1,107,108.0,209.0,209.0,318.0,319.0,431.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+256,260,frontraise,test558.mp4,2,0,127,128.0,255.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+262,266,front_raise,stu4_9.mp4,4,59,254,275.0,407.0,408.0,548.0,549.0,651.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+265,269,frontraise,train929.mp4,4,2,49,49.0,108.0,108.0,162.0,162.0,220.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+274,279,front_raise,stu8_22.mp4,10,4,50,51.0,94.0,94.0,133.0,133.0,172.0,172.0,211.0,211.0,245.0,329.0,390.0,390.0,436.0,436.0,499.0,499.0,550.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+276,281,front_raise,stu1_16.mp4,3,616,711,711.0,763.0,763.0,839.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+277,282,front_raise,stu3_17.mp4,5,7,83,83.0,157.0,157.0,222.0,241.0,313.0,313.0,377.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+287,292,front_raise,stu4_10.mp4,13,5,42,42.0,92.0,93.0,145.0,145.0,194.0,194.0,243.0,243.0,296.0,297.0,340.0,341.0,387.0,387.0,439.0,440.0,491.0,492.0,534.0,535.0,584.0,586.0,624.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+290,295,front_raise,stu2_19.mp4,5,29,148,148.0,272.0,272.0,387.0,387.0,489.0,490.0,595.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+293,298,front_raise,stu1_21.mp4,4,190,281,281.0,371.0,371.0,548.0,548.0,719.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+311,316,frontraise,test557.mp4,3,24,111,113.0,212.0,213.0,299.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+317,322,frontraise,test570.mp4,3,0,95,95.0,177.0,177.0,262.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+325,330,front_raise,stu8_18.mp4,9,45,126,127.0,199.0,199.0,275.0,275.0,358.0,358.0,435.0,435.0,504.0,504.0,578.0,578.0,653.0,653.0,719.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+338,343,front_raise,stu2_18.mp4,39,59,104,104.0,147.0,147.0,199.0,199.0,241.0,241.0,287.0,287.0,335.0,335.0,379.0,379.0,427.0,427.0,472.0,472.0,517.0,742.0,761.0,761.0,776.0,777.0,791.0,792.0,807.0,807.0,823.0,823.0,838.0,838.0,854.0,854.0,870.0,870.0,887.0,887.0,901.0,1018.0,1036.0,1036.0,1050.0,1050.0,1064.0,1064.0,1078.0,1078.0,1091.0,1092.0,1105.0,1105.0,1120.0,1120.0,1137.0,1137.0,1153.0,1153.0,1165.0,1304.0,1319.0,1319.0,1335.0,1335.0,1349.0,1349.0,1363.0,1363.0,1377.0,1377.0,1392.0,1392.0,1406.0,1406.0,1422.0,1422.0,1434.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+342,347,front_raise,stu8_21.mp4,3,45,146,146.0,239.0,239.0,327.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+348,353,frontraise,test577.mp4,3,6,80,80.0,160.0,160.0,264.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+351,356,front_raise,stu9_14.mp4,11,30,77,77.0,132.0,132.0,174.0,174.0,217.0,217.0,288.0,288.0,337.0,337.0,385.0,463.0,500.0,500.0,536.0,536.0,569.0,569.0,597.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+375,380,frontraise,test584.mp4,5,5,39,39.0,79.0,79.0,133.0,133.0,177.0,177.0,215.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+378,383,front_raise,stu10_21.mp4,2,66,146,146.0,242.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+395,400,front_raise,stu9_23.mp4,5,34,163,195.0,330.0,331.0,446.0,446.0,553.0,566.0,669.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+401,406,front_raise,stu10_20.mp4,8,28,212,212.0,327.0,327.0,458.0,458.0,558.0,558.0,647.0,647.0,737.0,737.0,828.0,828.0,913.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+403,408,front_raise,stu10_14.mp4,14,49,135,135.0,212.0,212.0,289.0,290.0,363.0,364.0,432.0,432.0,498.0,498.0,564.0,564.0,647.0,647.0,723.0,723.0,805.0,805.0,900.0,900.0,981.0,981.0,1071.0,1071.0,1154.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+427,432,frontraise,train1022.mp4,3,52,125,125.0,197.0,197.0,264.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+454,459,front_raise,stu6_11.mp4,22,107,127,127.0,146.0,146.0,162.0,162.0,180.0,180.0,198.0,198.0,219.0,219.0,238.0,238.0,264.0,264.0,288.0,288.0,313.0,331.0,410.0,520.0,568.0,568.0,656.0,656.0,733.0,734.0,828.0,828.0,922.0,922.0,964.0,965.0,1002.0,1002.0,1033.0,1033.0,1070.0,1070.0,1114.0,1114.0,1174.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+455,460,front_raise,stu6_14.mp4,4,47,112,112.0,190.0,392.0,478.0,478.0,563.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+459,465,front_raise,stu3_14.mp4,3,3,136,136.0,199.0,199.0,256.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+460,466,frontraise,train941.mp4,4,39,108,108.0,171.0,171.0,229.0,229.0,289.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+462,468,frontraise,test541.mp4,3,0,112,112.0,204.0,204.0,299.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+469,475,frontraise,train970.mp4,5,40,88,88.0,138.0,138.0,188.0,188.0,236.0,236.0,285.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+485,491,front_raise,stu3_8.mp4,6,66,127,127.0,190.0,190.0,257.0,257.0,322.0,322.0,390.0,390.0,448.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+489,495,front_raise,stu10_22.mp4,4,96,226,226.0,345.0,345.0,456.0,456.0,554.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+492,498,front_raise,stu1_18.mp4,9,40,123,123.0,195.0,195.0,263.0,263.0,336.0,336.0,427.0,427.0,515.0,515.0,611.0,611.0,681.0,681.0,753.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+494,500,front_raise,stu2_22.mp4,7,26,56,56.0,95.0,95.0,135.0,135.0,175.0,176.0,215.0,216.0,255.0,255.0,292.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+498,504,front_raise,stu2_24.mp4,5,0,124,124.0,290.0,290.0,464.0,465.0,672.0,673.0,869.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+500,506,frontraise,train960.mp4,2,1,106,106.0,199.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+508,514,front_raise,stu9_24.mp4,2,71,168,168.0,269.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+515,521,front_raise,stu6_12.mp4,4,21,97,97.0,177.0,177.0,267.0,267.0,348.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+522,528,frontraise,test528.mp4,2,0,168,168.0,281.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+525,532,front_raise,stu7_20.mp4,6,27,218,223.0,356.0,357.0,457.0,459.0,530.0,533.0,640.0,640.0,727.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+534,541,front_raise,stu6_9.mp4,18,5,100,106.0,210.0,222.0,317.0,334.0,428.0,430.0,512.0,515.0,612.0,615.0,713.0,713.0,798.0,800.0,912.0,912.0,995.0,995.0,1085.0,1085.0,1167.0,1167.0,1267.0,1268.0,1353.0,1353.0,1451.0,1452.0,1555.0,1557.0,1651.0,1654.0,1747.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+546,553,front_raise,stu8_20.mp4,8,5,128,128.0,222.0,222.0,331.0,331.0,426.0,426.0,523.0,523.0,633.0,633.0,743.0,743.0,839.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+556,563,front_raise,stu7_22.mp4,2,179,278,288.0,473.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+559,566,front_raise,stu9_21.mp4,16,349,422,443.0,521.0,522.0,597.0,597.0,667.0,667.0,730.0,730.0,807.0,807.0,876.0,876.0,936.0,937.0,1013.0,1013.0,1098.0,1098.0,1186.0,1187.0,1258.0,1258.0,1337.0,1338.0,1436.0,1617.0,1681.0,1727.0,1792.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+565,572,front_raise,stu9_12.mp4,7,0,45,45.0,91.0,91.0,131.0,131.0,176.0,199.0,240.0,240.0,286.0,286.0,334.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+569,576,frontraise,test545.mp4,1,0,204,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+580,590,frontraise,train1000.mp4,3,49,141,141.0,238.0,238.0,293.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+595,605,front_raise,stu5_15.mp4,18,56,109,109.0,177.0,177.0,234.0,234.0,322.0,384.0,463.0,463.0,533.0,533.0,622.0,622.0,707.0,728.0,791.0,791.0,856.0,856.0,927.0,976.0,1040.0,1040.0,1096.0,1096.0,1151.0,1151.0,1192.0,1192.0,1262.0,1262.0,1339.0,1340.0,1420.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+610,621,front_raise,stu8_19.mp4,9,45,86,86.0,120.0,120.0,154.0,154.0,187.0,187.0,224.0,224.0,256.0,256.0,291.0,291.0,322.0,322.0,351.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+628,639,front_raise,stu9_15.mp4,3,0,184,184.0,362.0,363.0,529.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+629,640,frontraise,test587.mp4,3,7,115,115.0,217.0,217.0,299.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+635,646,front_raise,stu3_12.mp4,2,155,389,389.0,548.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+636,647,front_raise,stu4_8.mp4,3,40,134,137.0,271.0,304.0,424.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+12,13,front_raise,stu10_17.mp4,11,6,105,105.0,177.0,177.0,242.0,242.0,317.0,317.0,392.0,392.0,461.0,461.0,541.0,541.0,616.0,616.0,690.0,691.0,769.0,769.0,852.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+20,21,front_raise,stu10_24.mp4,14,60,97,97.0,131.0,131.0,162.0,162.0,194.0,243.0,292.0,292.0,326.0,326.0,361.0,361.0,398.0,755.0,791.0,791.0,828.0,828.0,858.0,858.0,892.0,892.0,923.0,923.0,961.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+43,44,frontraise,test538.mp4,5,8,64,64.0,122.0,122.0,172.0,172.0,223.0,224.0,268.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+49,50,frontraise,test536.mp4,6,21,69,69.0,112.0,112.0,158.0,158.0,203.0,203.0,245.0,245.0,288.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+55,56,front_raise,stu5_12.mp4,5,34,152,152.0,255.0,255.0,352.0,352.0,468.0,468.0,582.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+56,57,front_raise,stu9_17.mp4,15,45,111,111.0,168.0,192.0,251.0,251.0,320.0,320.0,386.0,386.0,441.0,447.0,511.0,511.0,566.0,566.0,635.0,859.0,932.0,932.0,991.0,991.0,1044.0,1045.0,1098.0,1098.0,1159.0,1159.0,1215.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+64,65,front_raise,stu3_10.mp4,5,33,95,95.0,149.0,149.0,199.0,199.0,255.0,255.0,310.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+80,81,front_raise,stu4_12.mp4,4,33,158,159.0,261.0,262.0,376.0,376.0,465.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+82,83,front_raise,stu7_17.mp4,5,14,100,100.0,195.0,195.0,297.0,299.0,388.0,390.0,467.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+99,100,front_raise,stu10_19.mp4,8,24,88,88.0,153.0,153.0,221.0,221.0,287.0,287.0,354.0,354.0,425.0,425.0,495.0,495.0,570.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+107,108,frontraise,test534.mp4,3,1,37,37.0,81.0,81.0,130.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+109,110,front_raise,stu6_13.mp4,9,28,104,104.0,182.0,182.0,265.0,265.0,329.0,329.0,390.0,390.0,447.0,447.0,509.0,509.0,579.0,579.0,624.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+111,112,front_raise,stu8_23.mp4,3,55,133,133.0,194.0,194.0,265.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+119,120,frontraise,test539.mp4,2,4,125,125.0,240.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+120,121,front_raise,stu2_14.mp4,7,0,40,40.0,89.0,132.0,246.0,246.0,349.0,349.0,441.0,441.0,539.0,539.0,633.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+127,128,front_raise,stu3_15.mp4,4,336,486,486.0,555.0,556.0,642.0,642.0,715.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+128,129,front_raise,stu3_18.mp4,16,1,40,40.0,77.0,77.0,117.0,117.0,151.0,151.0,187.0,187.0,222.0,380.0,418.0,418.0,453.0,453.0,490.0,490.0,529.0,538.0,590.0,823.0,863.0,863.0,900.0,900.0,936.0,936.0,975.0,975.0,1017.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+129,130,front_raise,stu5_16.mp4,10,80,136,136.0,215.0,215.0,284.0,284.0,354.0,354.0,430.0,430.0,499.0,499.0,561.0,561.0,633.0,633.0,713.0,713.0,778.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+1,2,front_raise,stu2_15.mp4,8,80,147,147.0,203.0,203.0,264.0,264.0,321.0,321.0,382.0,382.0,443.0,443.0,512.0,512.0,578.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+13,14,front_raise,stu2_23.mp4,6,6,113,113.0,221.0,221.0,316.0,316.0,398.0,398.0,495.0,495.0,586.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+15,16,front_raise,stu6_7.mp4,5,6,50,50.0,94.0,94.0,130.0,130.0,167.0,167.0,204.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+16,17,front_raise,stu9_18.mp4,23,28,72,121.0,166.0,166.0,204.0,339.0,384.0,384.0,423.0,423.0,462.0,463.0,508.0,508.0,554.0,554.0,602.0,649.0,690.0,690.0,730.0,730.0,769.0,769.0,813.0,841.0,889.0,889.0,935.0,1031.0,1073.0,1073.0,1122.0,1122.0,1169.0,1169.0,1213.0,1246.0,1336.0,1336.0,1423.0,1423.0,1517.0,1517.0,1606.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+18,19,front_raise,stu7_19.mp4,4,15,314,318.0,512.0,515.0,688.0,690.0,853.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+19,20,front_raise,stu7_16.mp4,4,0,62,63.0,114.0,114.0,163.0,163.0,211.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+23,24,front_raise,stu5_17.mp4,4,0,51,51.0,136.0,136.0,215.0,215.0,289.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+26,27,front_raise,stu2_21.mp4,4,8,112,112.0,237.0,237.0,376.0,376.0,511.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+40,41,front_raise,stu1_17.mp4,6,5,39,39.0,85.0,85.0,129.0,129.0,174.0,222.0,264.0,264.0,318.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+43,44,frontraise,train1025.mp4,3,0,102,102.0,214.0,214.0,299.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+57,58,frontraise,test571.mp4,3,0,94,94.0,190.0,191.0,283.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+68,69,front_raise,stu3_16.mp4,5,32,157,270.0,464.0,464.0,583.0,583.0,691.0,692.0,830.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+70,71,front_raise,stu1_19.mp4,3,89,176,202.0,280.0,280.0,348.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+77,78,front_raise,stu4_11.mp4,4,25,141,143.0,241.0,243.0,343.0,345.0,447.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+82,83,front_raise,stu9_13.mp4,2,60,138,363.0,445.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+93,96,front_raise,stu10_13.mp4,3,11,314,314.0,509.0,509.0,719.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+94,98,front_raise,stu9_19.mp4,7,34,119,119.0,191.0,191.0,273.0,273.0,364.0,364.0,436.0,436.0,542.0,542.0,632.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+101,105,frontraise,train990.mp4,4,87,133,134.0,175.0,176.0,224.0,226.0,271.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+103,107,frontraise,train1010.mp4,6,25,68,68.0,115.0,115.0,158.0,158.0,200.0,200.0,241.0,241.0,281.0,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,