Upload 14 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/Poppins[[:space:]]Black[[:space:]]Italic[[:space:]]900.ttf filter=lfs diff=lfs merge=lfs -text
+data/Poppins[[:space:]]ExtraBold[[:space:]]Italic[[:space:]]800.ttf filter=lfs diff=lfs merge=lfs -text

Evaluation/eval_detection_gentime.py

@@ -0,0 +1,566 @@
+import json
+#import urllib.request, urllib.error, urllib.parse
+
+import numpy as np
+import pandas as pd
+
+from utils import get_blocked_videos
+from utils import interpolated_prec_rec
+from utils import segment_iou
+
+class ANETdetection(object):
+
+    GROUND_TRUTH_FIELDS = ['database']#, 'taxonomy', 'version']
+    PREDICTION_FIELDS = ['results', 'version', 'external_data']
+
+    def __init__(self, opt, ground_truth_filename=None, prediction_filename=None,
+                 ground_truth_fields=GROUND_TRUTH_FIELDS,
+                 prediction_fields=PREDICTION_FIELDS,
+                 tiou_thresholds=np.linspace(0.5, 0.95, 10), 
+                 subset='validation', verbose=False, 
+                 check_status=True):
+        if not ground_truth_filename:
+            raise IOError('Please input a valid ground truth file.')
+        if not prediction_filename:
+            raise IOError('Please input a valid prediction file.')
+        self.subset = subset
+        self.tiou_thresholds = tiou_thresholds
+        self.verbose = verbose
+        self.gt_fields = ground_truth_fields
+        self.pred_fields = prediction_fields
+        self.ap = None
+        self.tdiff = None
+        self.check_status = check_status
+        self.num_class = opt["num_of_class"]
+        # Retrieve blocked videos from server.
+        if self.check_status:
+            self.blocked_videos = get_blocked_videos()
+        else:
+            self.blocked_videos = list()
+        # Import ground truth and predictions.
+        self.ground_truth, self.activity_index, cidx = self._import_ground_truth(
+            ground_truth_filename)
+        self.prediction = self._import_prediction(prediction_filename, cidx)
+
+        if self.verbose:
+            print('[INIT] Loaded annotations from {} subset.'.format(subset))
+            nr_gt = len(self.ground_truth)
+            print('\tNumber of ground truth instances: {}'.format(nr_gt))
+            nr_pred = len(self.prediction)
+            print('\tNumber of predictions: {}'.format(nr_pred))
+            print('\tFixed threshold for tiou score: {}'.format(self.tiou_thresholds))
+
+    def _import_ground_truth(self, ground_truth_filename):
+        """Reads ground truth file, checks if it is well formatted, and returns
+           the ground truth instances and the activity classes.
+
+        Parameters
+        ----------
+        ground_truth_filename : str
+            Full path to the ground truth json file.
+
+        Outputs
+        -------
+        ground_truth : df
+            Data frame containing the ground truth instances.
+        activity_index : dict
+            Dictionary containing class index.
+        """
+        with open(ground_truth_filename, 'r') as fobj:
+            data = json.load(fobj)
+        # Checking format
+        if not all([field in list(data.keys()) for field in self.gt_fields]):
+            raise IOError('Please input a valid ground truth file.')
+
+        # Read ground truth data.
+        activity_index, cidx = {}, 0
+
+        video_lst, t_start_lst, t_end_lst, label_lst = [], [], [], []
+        for videoid, v in data['database'].items():
+            if self.subset not in v['subset']:
+                continue
+ 
+            for ann in v['annotations']:
+                if ann['label'] not in activity_index:
+                    activity_index[ann['label']] = cidx
+                    cidx += 1
+                video_lst.append(videoid)
+                t_start_lst.append(ann['segment'][0])
+                t_end_lst.append(ann['segment'][1])
+                label_lst.append(activity_index[ann['label']])
+        
+        ground_truth = pd.DataFrame({'video-id': video_lst,
+                                     't-start': t_start_lst,
+                                     't-end': t_end_lst,
+                                     'label': label_lst})
+
+        return ground_truth, activity_index, cidx
+
+    def _import_prediction(self, prediction_filename, cidx):
+        """Reads prediction file, checks if it is well formatted, and returns
+           the prediction instances.
+
+        Parameters
+        ----------
+        prediction_filename : str
+            Full path to the prediction json file.
+
+        Outputs
+        -------
+        prediction : df
+            Data frame containing the prediction instances.
+        """
+        with open(prediction_filename, 'r') as fobj:
+            data = json.load(fobj)
+        # Checking format...
+        if not all([field in list(data.keys()) for field in self.pred_fields]):
+            raise IOError('Please input a valid prediction file.')
+
+        # Read predicitons.
+        video_lst, t_start_lst, t_end_lst = [], [], []
+        label_lst, score_lst = [], []
+        gentime_lst = []
+        for videoid, v in data['results'].items():
+            if videoid in self.blocked_videos:
+                continue
+            for result in v:
+                if result['label'] not in self.activity_index.keys():
+                    continue
+
+                label = self.activity_index[result['label']]
+                video_lst.append(videoid)
+                t_start_lst.append(result['segment'][0])
+                t_end_lst.append(result['segment'][1])
+                label_lst.append(label)
+                score_lst.append(result['score'])
+                gentime_lst.append(result['gentime'])
+
+        prediction = pd.DataFrame({'video-id': video_lst,
+                                   't-start': t_start_lst,
+                                   't-end': t_end_lst,
+                                   'label': label_lst,
+                                   'score': score_lst,
+                                   'gentime': gentime_lst})
+        return prediction
+
+    def wrapper_compute_average_precision(self):
+        """Computes average precision for each class in the subset.
+        """
+        ap = np.zeros((len(self.tiou_thresholds), len(list(self.activity_index.items()))))
+        tdiff = np.zeros((len(self.tiou_thresholds), len(list(self.activity_index.items()))))
+        cnt_tp = np.zeros((len(self.tiou_thresholds), len(list(self.activity_index.items()))))
+        for activity, cidx in self.activity_index.items():
+            gt_idx = self.ground_truth['label'] == cidx
+            pred_idx = self.prediction['label'] == cidx
+            ap[:,cidx], tdiff[:,cidx], cnt_tp[:,cidx] = compute_average_precision_detection(
+                self.ground_truth.loc[gt_idx].reset_index(drop=True),
+                self.prediction.loc[pred_idx].reset_index(drop=True),
+                tiou_thresholds=self.tiou_thresholds)
+                
+        sum_tdiff = np.sum(tdiff, axis=1)
+        total_tp = np.sum(cnt_tp, axis=1)
+        final_tdiff = sum_tdiff/total_tp
+        
+        return ap, final_tdiff
+
+    def evaluate(self):
+        """Evaluates a prediction file. For the detection task we measure the
+        interpolated mean average precision to measure the performance of a
+        method.
+        """
+        self.ap, self.tdiff = self.wrapper_compute_average_precision()
+        self.mAP = self.ap.mean(axis=1)
+        if self.verbose:
+            print('[RESULTS] Performance on ActivityNet detection task.')
+            print('\tAverage-mAP: {}'.format(self.mAP.mean()))
+            print('\tAverage-time diff: {}'.format(self.tdiff.mean()))
+
+def compute_average_precision_detection(ground_truth, prediction, tiou_thresholds=np.linspace(0.5, 0.95, 10)):
+    """Compute average precision (detection task) between ground truth and
+    predictions data frames. If multiple predictions occurs for the same
+    predicted segment, only the one with highest score is matches as
+    true positive. This code is greatly inspired by Pascal VOC devkit.
+
+    Parameters
+    ----------
+    ground_truth : df
+        Data frame containing the ground truth instances.
+        Required fields: ['video-id', 't-start', 't-end']
+    prediction : df
+        Data frame containing the prediction instances.
+        Required fields: ['video-id, 't-start', 't-end', 'score']
+    tiou_thresholds : 1darray, optional
+        Temporal intersection over union threshold.
+
+    Outputs
+    -------
+    ap : float
+        Average precision score.
+    """
+    npos = float(len(ground_truth))
+    lock_gt = np.ones((len(tiou_thresholds),len(ground_truth))) * -1
+
+    # Sort predictions by decreasing score order.
+    sort_idx = prediction['score'].values.argsort()[::-1]
+    prediction = prediction.loc[sort_idx].reset_index(drop=True)
+
+    # Initialize true positive and false positive vectors.
+    tp = np.zeros((len(tiou_thresholds), len(prediction)))
+    fp = np.zeros((len(tiou_thresholds), len(prediction)))
+    timediff = np.zeros((len(tiou_thresholds), len(prediction)))
+
+    # Adaptation to query faster
+    ground_truth_gbvn = ground_truth.groupby('video-id')
+
+    # Assigning true positive to truly grount truth instances.
+    for idx, this_pred in prediction.iterrows():
+
+        try:
+            # Check if there is at least one ground truth in the video associated.
+            ground_truth_videoid = ground_truth_gbvn.get_group(this_pred['video-id'])
+        except Exception as e:
+            fp[:, idx] = 1
+            continue
+
+        this_gt = ground_truth_videoid.reset_index()
+        tiou_arr = segment_iou(this_pred[['t-start', 't-end']].values,
+                               this_gt[['t-start', 't-end']].values)
+        gentime_pred_arr= this_pred['gentime']
+        gentime_gt_arr = this_gt['t-end'].values
+        tiou_sorted_idx = tiou_arr.argsort()[::-1]
+        for tidx, tiou_thr in enumerate(tiou_thresholds):
+            for jdx in tiou_sorted_idx:
+                if tiou_arr[jdx] < tiou_thr:
+                    fp[tidx, idx] = 1
+                    break
+                if lock_gt[tidx, this_gt.loc[jdx]['index']] >= 0:
+                    continue
+                # Assign as true positive after the filters above.
+                tp[tidx, idx] = 1
+                timediff[tidx, idx]=(gentime_pred_arr-gentime_gt_arr[jdx])#/len_gt_arr[jdx]
+                lock_gt[tidx, this_gt.loc[jdx]['index']] = idx
+                break
+
+            if fp[tidx, idx] == 0 and tp[tidx, idx] == 0:
+                fp[tidx, idx] = 1
+
+    ap = np.zeros(len(tiou_thresholds))
+    tdiff = np.zeros(len(tiou_thresholds))
+    cnt_tp = np.zeros(len(tiou_thresholds))
+
+    for tidx in range(len(tiou_thresholds)):
+        # Computing prec-rec
+        this_tp = np.cumsum(tp[tidx,:]).astype(float)
+        this_fp = np.cumsum(fp[tidx,:]).astype(float)
+
+        # print(this_tp, npos)
+        rec = this_tp / npos
+        prec = this_tp / (this_tp + this_fp)
+        # print('###', rec, prec)
+        ap[tidx] = interpolated_prec_rec(prec, rec)
+        this_tdiff=np.cumsum(timediff[tidx,:]).astype(float)
+        if len(this_tdiff)==0:
+            continue
+        tdiff[tidx]=this_tdiff[-1]#  / max(1,this_tp[-1])
+        cnt_tp[tidx]=this_tp[-1]
+    
+    return ap,tdiff, cnt_tp
+
+
+
+
+
+# import json
+# #import urllib.request, urllib.error, urllib.parse
+
+# import numpy as np
+# import pandas as pd
+
+# from utils import get_blocked_videos
+# from utils import interpolated_prec_rec
+# from utils import segment_iou
+
+# class ANETdetection(object):
+
+#     GROUND_TRUTH_FIELDS = ['database']#, 'taxonomy', 'version']
+#     PREDICTION_FIELDS = ['results', 'version', 'external_data']
+
+#     def __init__(self, opt, ground_truth_filename=None, prediction_filename=None,
+#                  ground_truth_fields=GROUND_TRUTH_FIELDS,
+#                  prediction_fields=PREDICTION_FIELDS,
+#                  tiou_thresholds=np.linspace(0.5, 0.95, 10), 
+#                  subset='validation', verbose=False, 
+#                  check_status=True):
+#         if not ground_truth_filename:
+#             raise IOError('Please input a valid ground truth file.')
+#         if not prediction_filename:
+#             raise IOError('Please input a valid prediction file.')
+#         self.subset = subset
+#         self.tiou_thresholds = tiou_thresholds
+#         self.verbose = verbose
+#         self.gt_fields = ground_truth_fields
+#         self.pred_fields = prediction_fields
+#         self.ap = None
+#         self.tdiff = None
+#         self.check_status = check_status
+#         self.num_class = opt["num_of_class"]
+#         # Retrieve blocked videos from server.
+#         if self.check_status:
+#             self.blocked_videos = get_blocked_videos()
+#         else:
+#             self.blocked_videos = list()
+#         # Import ground truth and predictions.
+#         self.ground_truth, self.activity_index, cidx = self._import_ground_truth(
+#             ground_truth_filename)
+#         self.prediction = self._import_prediction(prediction_filename, cidx)
+
+#         if self.verbose:
+#             print('[INIT] Loaded annotations from {} subset.'.format(subset))
+#             nr_gt = len(self.ground_truth)
+#             print('\tNumber of ground truth instances: {}'.format(nr_gt))
+#             nr_pred = len(self.prediction)
+#             print('\tNumber of predictions: {}'.format(nr_pred))
+#             print('\tFixed threshold for tiou score: {}'.format(self.tiou_thresholds))
+
+#     def _import_ground_truth(self, ground_truth_filename):
+#         """Reads ground truth file, checks if it is well formatted, and returns
+#            the ground truth instances and the activity classes.
+
+#         Parameters
+#         ----------
+#         ground_truth_filename : str
+#             Full path to the ground truth json file.
+
+#         Outputs
+#         -------
+#         ground_truth : df
+#             Data frame containing the ground truth instances.
+#         activity_index : dict
+#             Dictionary containing class index.
+#         """
+#         with open(ground_truth_filename, 'r') as fobj:
+#             data = json.load(fobj)
+#         # Checking format
+#         if not all([field in list(data.keys()) for field in self.gt_fields]):
+#             raise IOError('Please input a valid ground truth file.')
+
+#         # Read ground truth data.
+#         activity_index, cidx = {}, 0
+
+#         video_lst, t_start_lst, t_end_lst, label_lst = [], [], [], []
+#         for videoid, v in data['database'].items():
+#             if self.subset not in v['subset']:
+#                 continue
+ 
+#             for ann in v['annotations']:
+#                 if ann['label'] not in activity_index:
+#                     activity_index[ann['label']] = cidx
+#                     cidx += 1
+#                 video_lst.append(videoid)
+#                 t_start_lst.append(ann['segment'][0])
+#                 t_end_lst.append(ann['segment'][1])
+#                 label_lst.append(activity_index[ann['label']])
+        
+#         ground_truth = pd.DataFrame({'video-id': video_lst,
+#                                      't-start': t_start_lst,
+#                                      't-end': t_end_lst,
+#                                      'label': label_lst})
+
+#         return ground_truth, activity_index, cidx
+
+#     def _import_prediction(self, prediction_filename, cidx):
+#         """Reads prediction file, checks if it is well formatted, and returns
+#            the prediction instances.
+
+#         Parameters
+#         ----------
+#         prediction_filename : str
+#             Full path to the prediction json file.
+
+#         Outputs
+#         -------
+#         prediction : df
+#             Data frame containing the prediction instances.
+#         """
+#         with open(prediction_filename, 'r') as fobj:
+#             data = json.load(fobj)
+#         # Checking format...
+#         if not all([field in list(data.keys()) for field in self.pred_fields]):
+#             raise IOError('Please input a valid prediction file.')
+
+#         # Read predicitons.
+#         video_lst, t_start_lst, t_end_lst = [], [], []
+#         label_lst, score_lst = [], []
+#         gentime_lst = []
+#         for videoid, v in data['results'].items():
+#             if videoid in self.blocked_videos:
+#                 continue
+#             for result in v:
+#                 if result['label'] not in self.activity_index.keys():
+#                     continue
+
+#                 label = self.activity_index[result['label']]
+#                 video_lst.append(videoid)
+#                 t_start_lst.append(result['segment'][0])
+#                 t_end_lst.append(result['segment'][1])
+#                 label_lst.append(label)
+#                 score_lst.append(result['score'])
+#                 gentime_lst.append(result['gentime'])
+
+#         prediction = pd.DataFrame({'video-id': video_lst,
+#                                    't-start': t_start_lst,
+#                                    't-end': t_end_lst,
+#                                    'label': label_lst,
+#                                    'score': score_lst,
+#                                    'gentime': gentime_lst})
+#         return prediction
+
+#     def wrapper_compute_average_precision(self):
+#         """Computes average precision for each class in the subset.
+#         """
+#         ap = np.zeros((len(self.tiou_thresholds), len(list(self.activity_index.items()))))
+#         tdiff = np.zeros((len(self.tiou_thresholds), len(list(self.activity_index.items()))))
+#         cnt_tp = np.zeros((len(self.tiou_thresholds), len(list(self.activity_index.items()))))
+        
+#         for activity, cidx in self.activity_index.items():
+#             gt_idx = self.ground_truth['label'] == cidx
+#             pred_idx = self.prediction['label'] == cidx
+#             ap[:,cidx], tdiff[:,cidx], cnt_tp[:,cidx] = compute_average_precision_detection(
+#                 self.ground_truth.loc[gt_idx].reset_index(drop=True),
+#                 self.prediction.loc[pred_idx].reset_index(drop=True),
+#                 tiou_thresholds=self.tiou_thresholds)
+                
+#         sum_tdiff = np.sum(tdiff, axis=1)
+#         total_tp = np.sum(cnt_tp, axis=1)
+        
+#         # FIX: Handle division by zero
+#         final_tdiff = np.zeros_like(total_tp)
+#         valid_mask = total_tp > 0
+#         final_tdiff[valid_mask] = sum_tdiff[valid_mask] / total_tp[valid_mask]
+#         # For cases where total_tp is 0, keep final_tdiff as 0
+        
+#         return ap, final_tdiff
+
+#     def evaluate(self):
+#         """Evaluates a prediction file. For the detection task we measure the
+#         interpolated mean average precision to measure the performance of a
+#         method.
+#         """
+#         self.ap, self.tdiff = self.wrapper_compute_average_precision()
+#         self.mAP = self.ap.mean(axis=1)
+#         if self.verbose:
+#             print('[RESULTS] Performance on ActivityNet detection task.')
+#             print('\tAverage-mAP: {}'.format(self.mAP.mean()))
+#             print('\tAverage-time diff: {}'.format(self.tdiff.mean()))
+
+# def compute_average_precision_detection(ground_truth, prediction, tiou_thresholds=np.linspace(0.5, 0.95, 10)):
+#     """Compute average precision (detection task) between ground truth and
+#     predictions data frames. If multiple predictions occurs for the same
+#     predicted segment, only the one with highest score is matches as
+#     true positive. This code is greatly inspired by Pascal VOC devkit.
+
+#     Parameters
+#     ----------
+#     ground_truth : df
+#         Data frame containing the ground truth instances.
+#         Required fields: ['video-id', 't-start', 't-end']
+#     prediction : df
+#         Data frame containing the prediction instances.
+#         Required fields: ['video-id, 't-start', 't-end', 'score']
+#     tiou_thresholds : 1darray, optional
+#         Temporal intersection over union threshold.
+
+#     Outputs
+#     -------
+#     ap : float
+#         Average precision score.
+#     """
+#     npos = float(len(ground_truth))
+#     lock_gt = np.ones((len(tiou_thresholds),len(ground_truth))) * -1
+
+#     # Sort predictions by decreasing score order.
+#     sort_idx = prediction['score'].values.argsort()[::-1]
+#     prediction = prediction.loc[sort_idx].reset_index(drop=True)
+
+#     # Initialize true positive and false positive vectors.
+#     tp = np.zeros((len(tiou_thresholds), len(prediction)))
+#     fp = np.zeros((len(tiou_thresholds), len(prediction)))
+#     timediff = np.zeros((len(tiou_thresholds), len(prediction)))
+
+#     # Adaptation to query faster
+#     ground_truth_gbvn = ground_truth.groupby('video-id')
+
+#     # Assigning true positive to truly grount truth instances.
+#     for idx, this_pred in prediction.iterrows():
+
+#         try:
+#             # Check if there is at least one ground truth in the video associated.
+#             ground_truth_videoid = ground_truth_gbvn.get_group(this_pred['video-id'])
+#         except Exception as e:
+#             fp[:, idx] = 1
+#             continue
+
+#         this_gt = ground_truth_videoid.reset_index()
+#         tiou_arr = segment_iou(this_pred[['t-start', 't-end']].values,
+#                                this_gt[['t-start', 't-end']].values)
+#         gentime_pred_arr= this_pred['gentime']
+#         gentime_gt_arr = this_gt['t-end'].values
+#         tiou_sorted_idx = tiou_arr.argsort()[::-1]
+#         for tidx, tiou_thr in enumerate(tiou_thresholds):
+#             for jdx in tiou_sorted_idx:
+#                 if tiou_arr[jdx] < tiou_thr:
+#                     fp[tidx, idx] = 1
+#                     break
+#                 if lock_gt[tidx, this_gt.loc[jdx]['index']] >= 0:
+#                     continue
+#                 # Assign as true positive after the filters above.
+#                 tp[tidx, idx] = 1
+                
+#                 # FIX: Add safety check for NaN/Inf values
+#                 time_diff = gentime_pred_arr - gentime_gt_arr[jdx]
+#                 if np.isfinite(time_diff):
+#                     timediff[tidx, idx] = time_diff
+#                 else:
+#                     timediff[tidx, idx] = 0.0  # Default value for invalid time differences
+                    
+#                 lock_gt[tidx, this_gt.loc[jdx]['index']] = idx
+#                 break
+
+#             if fp[tidx, idx] == 0 and tp[tidx, idx] == 0:
+#                 fp[tidx, idx] = 1
+
+#     ap = np.zeros(len(tiou_thresholds))
+#     tdiff = np.zeros(len(tiou_thresholds))
+#     cnt_tp = np.zeros(len(tiou_thresholds))
+
+#     for tidx in range(len(tiou_thresholds)):
+#         # Computing prec-rec
+#         this_tp = np.cumsum(tp[tidx,:]).astype(float)
+#         this_fp = np.cumsum(fp[tidx,:]).astype(float)
+
+#         # Handle edge cases
+#         if npos == 0:
+#             ap[tidx] = 0.0
+#             tdiff[tidx] = 0.0
+#             cnt_tp[tidx] = 0.0
+#             continue
+        
+#         rec = this_tp / npos
+        
+#         # FIX: Handle division by zero in precision calculation
+#         denominator = this_tp + this_fp
+#         prec = np.zeros_like(this_tp)
+#         valid_mask = denominator > 0
+#         prec[valid_mask] = this_tp[valid_mask] / denominator[valid_mask]
+        
+#         ap[tidx] = interpolated_prec_rec(prec, rec)
+        
+#         # FIX: Handle time difference calculation more safely
+#         this_tdiff = np.cumsum(timediff[tidx,:]).astype(float)
+#         if len(this_tdiff) == 0 or this_tp[-1] == 0:
+#             tdiff[tidx] = 0.0
+#         else:
+#             tdiff[tidx] = this_tdiff[-1]
+#         cnt_tp[tidx] = this_tp[-1] if len(this_tp) > 0 else 0.0
+    
+#     return ap, tdiff, cnt_tp

Evaluation/utils.py

@@ -0,0 +1,76 @@
+import json
+#import urllib.request, urllib.error, urllib.parse
+
+import numpy as np
+
+API = 'http://ec2-52-11-11-89.us-west-2.compute.amazonaws.com/challenge17/api.py'
+
+def get_blocked_videos(api=API):
+#    api_url = '{}?action=get_blocked'.format(api)
+#    req = urllib.request.Request(api_url)
+#    response = urllib.request.urlopen(req)
+#    return json.loads(response.read())
+    return list()
+
+def interpolated_prec_rec(prec, rec):
+    """Interpolated AP - VOCdevkit from VOC 2011.
+    """
+    mprec = np.hstack([[0], prec, [0]])
+    mrec = np.hstack([[0], rec, [1]])
+    for i in range(len(mprec) - 1)[::-1]:
+        mprec[i] = max(mprec[i], mprec[i + 1])
+    idx = np.where(mrec[1::] != mrec[0:-1])[0] + 1
+    ap = np.sum((mrec[idx] - mrec[idx - 1]) * mprec[idx])
+    return ap
+
+def segment_iou(target_segment, candidate_segments):
+    """Compute the temporal intersection over union between a
+    target segment and all the test segments.
+
+    Parameters
+    ----------
+    target_segment : 1d array
+        Temporal target segment containing [starting, ending] times.
+    candidate_segments : 2d array
+        Temporal candidate segments containing N x [starting, ending] times.
+
+    Outputs
+    -------
+    tiou : 1d array
+        Temporal intersection over union score of the N's candidate segments.
+    """
+    tt1 = np.maximum(target_segment[0], candidate_segments[:, 0])
+    tt2 = np.minimum(target_segment[1], candidate_segments[:, 1])
+    # Intersection including Non-negative overlap score.
+    segments_intersection = (tt2 - tt1).clip(0)
+    # Segment union.
+    segments_union = (candidate_segments[:, 1] - candidate_segments[:, 0]) \
+      + (target_segment[1] - target_segment[0]) - segments_intersection
+    # Compute overlap as the ratio of the intersection
+    # over union of two segments.
+    tIoU = segments_intersection.astype(float) / segments_union
+    return tIoU
+
+def wrapper_segment_iou(target_segments, candidate_segments):
+    """Compute intersection over union btw segments
+    Parameters
+    ----------
+    target_segments : ndarray
+        2-dim array in format [m x 2:=[init, end]]
+    candidate_segments : ndarray
+        2-dim array in format [n x 2:=[init, end]]
+    Outputs
+    -------
+    tiou : ndarray
+        2-dim array [n x m] with IOU ratio.
+    Note: It assumes that candidate-segments are more scarce that target-segments
+    """
+    if candidate_segments.ndim != 2 or target_segments.ndim != 2:
+        raise ValueError('Dimension of arguments is incorrect')
+
+    n, m = candidate_segments.shape[0], target_segments.shape[0]
+    tiou = np.empty((n, m))
+    for i in range(m):
+        tiou[:, i] = segment_iou(target_segments[i,:], candidate_segments)
+
+    return tiou

checkpoint/README.md

@@ -0,0 +1 @@
+Please put the model files in this folder.

data/Poppins Black Italic 900.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d56d2b8ff884cfae1b637e73a71f3caf1d16cdb5b4acc123d9cd0b5864ca2567
+size 156916

data/Poppins ExtraBold Italic 800.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db8f803d5aaf8e646fd868d0a897ed9997985b88c931bfae3e08c7c8dc2556be
+size 158896