tsadmetrics 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

tsadmetrics/_tsadeval/eTaPR_pkg/tapr.py

@@ -0,0 +1,362 @@
+import argparse
+from typing import Callable
+import math
+import copy
+from .DataManage import File_IO, Range as rng#, Time_Plot
+
+
+class TaPR:
+    def __init__(self, theta: float, delta: int, past_range: bool = False):
+        self._past_range = past_range
+        self._predictions = []  # list of Ranges
+        self._anomalies = []    # list of Ranges
+        self._ambiguous_inst = [] # list of Ranges
+
+        self._set_predictions = False
+        self._set_anomalies = False
+
+        #self._rho = theta
+        #self._pi = theta
+        self._theta = theta
+        self._delta = delta
+
+        pass
+
+    def set_anomalies(self, anomaly_list: list) -> None:
+        self._anomalies = copy.deepcopy(anomaly_list)
+        self._gen_ambiguous()
+        self._set_anomalies = True
+
+    def set_predictions(self, prediction_list: list) -> None:
+        self._predictions = copy.deepcopy(prediction_list)
+        self._set_predictions = True
+
+    def _gen_ambiguous(self):
+        for i in range(len(self._anomalies)):
+            start_id = self._anomalies[i].get_time()[1] + 1
+            end_id = end_id = start_id + self._delta
+
+            if self._past_range:
+                end_id = start_id + int(self._delta * (self._anomalies[i].get_time()[1] - self._anomalies[i].get_time()[0]))
+            
+            #if the next anomaly occurs during the theta, update the end_id
+            if i+1 < len(self._anomalies) and end_id > self._anomalies[i+1].get_time()[0]:
+                end_id = self._anomalies[i+1].get_time()[0] - 1
+
+            if start_id > end_id:
+                start_id = -2
+                end_id = -1
+
+            self._ambiguous_inst.append(rng.Range(start_id, end_id, str(i)))
+
+    def get_n_predictions(self):
+        return len(self._predictions)
+
+    def get_n_anomalies(self):
+        return len(self._anomalies)
+
+    def _ids_2_objects(self, id_list, range_list):
+        result = []
+        for id in id_list:
+            result.append(range_list[id])
+        return result
+
+    def TaR_d(self) -> float and list:
+        score, detected_id_list = self._TaR_d(self._anomalies, self._ambiguous_inst, self._predictions, self._theta)
+        return score, self._ids_2_objects(detected_id_list, self._anomalies)
+
+    def _TaR_d(self, anomalies: list, ambiguous_inst: list, predictions: list, threshold: float) -> float and list:
+        total_score = 0.0
+        detected_anomalies = []
+        total_score_p = 0.0
+        for anomaly_id in range(len(anomalies)):
+            anomaly = anomalies[anomaly_id]
+            ambiguous = ambiguous_inst[anomaly_id]
+
+            max_score = self._sum_of_func(anomaly.get_time()[0], anomaly.get_time()[1],
+                                          anomaly.get_time()[0], anomaly.get_time()[1], self._uniform_func)
+
+            score = 0.0
+            for prediction in predictions:
+                score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
+            
+            total_score_p += min(1.0, score/max_score)
+            if min(1.0, score / max_score) >= threshold:
+                total_score += 1.0
+                detected_anomalies.append(anomaly_id)
+
+        if len(anomalies) == 0:
+            self.TaR_p_value = 0
+            return 0.0, []
+        else:
+            self.TaR_p_value = total_score_p / len(anomalies)
+            return total_score / len(anomalies), detected_anomalies
+    
+    def TaR_p(self) -> float:
+        total_score = 0.0
+        for anomaly_id in range(len(self._anomalies)):
+            anomaly = self._anomalies[anomaly_id]
+            ambiguous = self._ambiguous_inst[anomaly_id]
+
+            max_score = self._sum_of_func(anomaly.get_time()[0], anomaly.get_time()[1],
+                                          anomaly.get_time()[0], anomaly.get_time()[1], self._uniform_func)
+
+            score = 0.0
+            for prediction in self._predictions:
+                score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
+
+            total_score += min(1.0, score/max_score)
+
+        if len(self._anomalies) == 0:
+            return 0.0
+        else:
+            return total_score / len(self._anomalies)
+
+
+    def TaP_d(self) -> float and list:
+        score, correct_id_list = self._TaP_d(self._anomalies, self._ambiguous_inst, self._predictions, self._theta)
+        return score, self._ids_2_objects(correct_id_list, self._predictions)
+
+    def _TaP_d(self, anomalies, ambiguous_inst, predictions, threshold):
+        #Compute TaP_d and TaP_p in one function to optimize the performance
+        correct_predictions = []
+        total_score = 0.0
+        total_score_p = 0.0
+        for prediction_id in range(len(predictions)):
+            max_score = predictions[prediction_id].get_time()[1] - predictions[prediction_id].get_time()[0] + 1
+
+            score = 0.0
+            for anomaly_id in range(len(anomalies)):
+                anomaly = anomalies[anomaly_id]
+                ambiguous = ambiguous_inst[anomaly_id]
+
+                score += self._overlap_and_subsequent_score(anomaly, ambiguous, predictions[prediction_id])
+            total_score_p += score / max_score
+            if (score/max_score) >= threshold:
+                total_score += 1.0
+                correct_predictions.append(prediction_id)
+
+        if len(predictions) == 0:
+            self.TaP_p_value = 0
+            return 0.0, []
+            
+        else:
+            self.TaP_p_value = total_score_p / len(predictions)
+            return total_score / len(predictions), correct_predictions
+        
+    
+        
+    def _detect(self, src_range: rng.Range, ranges: list, theta: int) -> bool:
+        rest_len = src_range.get_time()[1] - src_range.get_time()[0] + 1
+        for dst_range in ranges:
+            len = self._overlapped_len(src_range, dst_range)
+            if len != -1:
+                rest_len -= len
+        return (float)(rest_len) / (src_range.get_time()[1] - src_range.get_time()[0] + 1) <= (1.0 - theta)
+
+    def _overlapped_len(self, range1: rng.Range, range2: rng.Range) -> int:
+        detected_start = max(range1.get_time()[0], range2.get_time()[0])
+        detected_end = min(range1.get_time()[1], range2.get_time()[1])
+
+        if detected_end < detected_start:
+            return 0
+        else:
+            return detected_end - detected_start + 1
+
+    def _min_max_norm(self, value: int, org_min: int, org_max: int, new_min: int, new_max: int) -> float:
+        if org_min == org_max:
+            return new_min
+        else:
+            return (float)(new_min) + (float)(value - org_min) * (new_max - new_min) / (org_max - org_min)
+
+    def _decaying_func(self, val: float) -> float:
+        assert (-6 <= val <= 6)
+        return 1 / (1 + math.exp(val))
+
+    def _ascending_func(self, val: float) -> float:
+        assert (-6 <= val <= 6)
+        return 1 / (1 + math.exp(val * -1))
+
+    def _uniform_func(self, val: float) -> float:
+        return 1.0
+
+    def _sum_of_func(self, start_time: int, end_time: int, org_start: int, org_end: int,
+                     func: Callable[[float], float]) -> float:
+        val = 0.0
+        for timestamp in range(start_time, end_time + 1):
+            val += func(self._min_max_norm(timestamp, org_start, org_end, -6, 6))
+        return val
+
+    def _overlap_and_subsequent_score(self, anomaly: rng.Range, ambiguous: rng.Range, prediction: rng.Range) -> float:
+        score = 0.0
+
+        detected_start = max(anomaly.get_time()[0], prediction.get_time()[0])
+        detected_end = min(anomaly.get_time()[1], prediction.get_time()[1])
+
+        score += self._sum_of_func(detected_start, detected_end,
+                                   anomaly.get_time()[0], anomaly.get_time()[1], self._uniform_func)
+
+        if ambiguous.get_time()[0] < ambiguous.get_time()[1]:
+            detected_start = max(ambiguous.get_time()[0], prediction.get_time()[0])
+            detected_end = min(ambiguous.get_time()[1], prediction.get_time()[1])
+
+            score += self._sum_of_func(detected_start, detected_end,
+                                       ambiguous.get_time()[0], ambiguous.get_time()[1], self._decaying_func)
+
+        return score
+
+    def TaR_p(self) -> float:
+        total_score = 0.0
+        for anomaly_id in range(len(self._anomalies)):
+            anomaly = self._anomalies[anomaly_id]
+            ambiguous = self._ambiguous_inst[anomaly_id]
+
+            max_score = self._sum_of_func(anomaly.get_time()[0], anomaly.get_time()[1],
+                                          anomaly.get_time()[0], anomaly.get_time()[1], self._uniform_func)
+
+            score = 0.0
+            for prediction in self._predictions:
+                score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
+
+            total_score += min(1.0, score/max_score)
+
+        if len(self._anomalies) == 0:
+            return 0.0
+        else:
+            return total_score / len(self._anomalies)
+
+    def TaP_p(self) -> float:
+        total_score = 0.0
+        for prediction in self._predictions:
+            max_score = prediction.get_time()[1] - prediction.get_time()[0] + 1
+
+            score = 0.0
+            for anomaly_id in range(len(self._anomalies)):
+                anomaly = self._anomalies[anomaly_id]
+                ambiguous = self._ambiguous_inst[anomaly_id]
+
+                score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
+
+            total_score += score/max_score
+
+        if len(self._predictions) == 0:
+            return 0.0
+        else:
+            return total_score / len(self._predictions)
+
+
+def compute(anomalies: list, predictions: list, alpha: float, theta: float, delta: int) -> dict:
+    ev = TaPR(theta, delta)
+
+    ev.set_anomalies(anomalies)
+    ev.set_predictions(predictions)
+
+    tard_value, detected_list = ev.TaR_d()
+    tarp_value = ev.TaR_p()
+
+    tapd_value, correct_list = ev.TaP_d()
+    tapp_value = ev.TaP_p()
+
+    result = {}
+    tar_value = alpha * tard_value + (1 - alpha) * tarp_value
+    result['TaR'] = tar_value
+    result['TaRd'] = tard_value
+    result['TaRp'] = tarp_value
+
+    tap_value = alpha * tapd_value + (1 - alpha) * tapp_value
+    result['TaP'] = tap_value
+    result['TaPd'] = tapd_value
+    result['TaPp'] = tapp_value
+
+    detected_anomalies = []
+    for value in detected_list:
+        detected_anomalies.append(value.get_name())
+
+    result['Detected_Anomalies'] = detected_anomalies
+    result['Detected_Anomalies_Ranges'] = detected_list
+    result['Correct_Predictions_Ranges'] = correct_list
+
+    if tar_value + tap_value == 0:
+        result['f1'] = 0.0
+    else:
+        result['f1'] = (2 * tar_value * tap_value) / (tar_value + tap_value)
+
+    return result
+
+
+def compute_with_load(anomaly_file: str, prediction_file: str, file_type: str, alpha: float, theta: float, delta: int) -> dict:
+    anomalies = File_IO.load_file(anomaly_file, file_type)
+    predictions = File_IO.load_file(prediction_file, file_type)
+    return compute(anomalies, predictions, alpha, theta, delta)
+
+
+def print_result(anomalies: list, predictions: list, alpha: float, theta: float, delta: int, verbose: bool, graph: str) -> None:
+    org_predictions = copy.deepcopy(predictions)
+    result = compute(anomalies, predictions, alpha, theta, delta)
+
+    print("The parameters (alpha, theta, delta) are set as %g, %g, and %d." % (alpha, theta, delta))
+
+    print('\n[TaR]:', "%0.5f" % result['TaR'])
+    print("\t* Detection score:", "%0.5f" % result['TaRd'])
+    print("\t* Portion score:", "%0.5f" % result['TaRp'])
+    if verbose:
+        buf = '\t\tdetected anomalies: '
+        if len(result['Detected_Anomalies_Ranges']) == 0:
+            buf += "None  "
+        else:
+            for value in result['Detected_Anomalies_Ranges']:
+                buf += value.get_name() + '(' + str(value.get_time()[0]) + ':' + str(value.get_time()[1]) + '), '
+        print(buf[:-2])
+
+
+    print('\n[TaP]:', "%0.5f" % result['TaP'])
+    print("\t* Detection score:", "%0.5f" % result['TaPd'])
+    print("\t* Portion score:", "%0.5f" % result['TaPp'])
+    if verbose:
+        buf = '\t\tcorrect predictions: '
+        if len(result['Correct_Predictions_Ranges']) == 0:
+            buf += "None  "
+        else:
+            for value in result['Correct_Predictions_Ranges']:
+                buf += value.get_name() + '(' + str(value.get_time()[0]) + ':' + str(value.get_time()[1]) + '), '
+        print(buf[:-2])
+
+
+    assert(graph == 'screen' or graph == 'file' or graph == 'none' or graph == 'all')
+    if graph == 'screen' or graph == 'file' or graph == 'all':
+        Time_Plot.draw_graphs(anomalies, org_predictions, graph)
+
+
+if __name__ == '__main__':
+    argument_parser = argparse.ArgumentParser()
+    argument_parser.add_argument("--anomalies", help="anomaly file name (ground truth)", required=True)
+    argument_parser.add_argument("--predictions", help="prediction file name", required=True)
+    argument_parser.add_argument("--filetype", help="choose the file type between range and stream", required=True)
+    argument_parser.add_argument("--graph", help="show graph of results")
+
+    argument_parser.add_argument("--verbose", help="show detail results", action='store_true')
+    argument_parser.add_argument("--theta", help="set parameter theta")
+    argument_parser.add_argument("--alpha", help="set parameter alpha")
+    argument_parser.add_argument("--delta", help="set parameter delta")
+    arguments = argument_parser.parse_args()
+
+    arguments = argument_parser.parse_args()
+    theta, alpha, delta, graph = 0.5, 0.8, 600, 'none'  #default values
+    if arguments.theta is not None:
+        theta = float(arguments.theta)
+    if arguments.alpha is not None:
+        alpha = float(arguments.alpha)
+    if arguments.delta is not None:
+        delta = int(arguments.delta)
+    if arguments.graph is not None:
+        graph = arguments.graph
+
+    assert(0.0 <= theta <= 1.0)
+    assert(0.0 <= alpha <= 1.0)
+    assert(isinstance(delta, int))
+    assert(graph == 'screen' or graph == 'file' or graph == 'none' or graph == 'all')
+
+    anomalies = File_IO.load_file(arguments.anomalies, arguments.filetype)
+    predictions = File_IO.load_file(arguments.predictions, arguments.filetype)
+
+    print_result(anomalies, predictions, alpha, theta, delta, arguments.verbose, graph)

tsadmetrics/_tsadeval/prts/base/time_series_metrics.py

@@ -0,0 +1,165 @@
+from typing import Any
+
+import numpy as np
+
+
+class BaseTimeSeriesMetrics:
+    """Base class for time series metrics """
+
+    def score(self, real: np.ndarray, pred: np.ndarray) -> Any:
+        """
+
+        Args:
+            real:
+            pred:
+
+        Returns:
+
+        """
+        ...
+
+    def _udf_gamma(self):
+        """The function of the user-defined gamma.
+
+        Returns:
+            float: the value of the user-defined gamma
+        """
+
+        return 1.0
+
+    def _gamma_select(self, gamma: str, overlap: int) -> float:
+        """The function of selecting the gamma value according to the parameters.
+
+        Args:
+            gamma: str
+                - 'one': the value 1
+                - 'reciprocal';: a reciprocal of the overlap
+                - 'udf_gamma': user defined gamma
+            overlap: int
+                overlap between real and pred
+
+        Returns:
+            float: the selected gamma value
+        """
+        assert type(overlap) == int, TypeError("")
+
+        if gamma == "one":
+            return 1.0
+        elif gamma == "reciprocal":
+            if overlap > 1:
+                return 1.0 / overlap
+            else:
+                return 1.0
+        elif gamma == "udf_gamma":
+            if overlap > 1:
+                return 1.0 / self._udf_gamma()
+            else:
+                return 1.0
+        else:
+            raise ValueError(f"Expected one of one, reciprocal, udf_gamma. gamma type string: {gamma}")
+
+    def _gamma_function(self, overlap_count):
+        overlap = overlap_count[0]
+        return self._gamma_select(self.cardinality, overlap)
+
+    def _compute_omega_reward(self, r1, r2, overlap_count):
+        if r1[1] < r2[0] or r1[0] > r2[1]:
+            return 0
+        else:
+            overlap_count[0] += 1
+            overlap = np.zeros(r1.shape)
+            overlap[0] = max(r1[0], r2[0])
+            overlap[1] = min(r1[1], r2[1])
+            return self._omega_function(r1, overlap)
+
+    def _omega_function(self, rrange, overlap):
+        anomaly_length = rrange[1] - rrange[0] + 1
+        my_positional_bias = 0
+        max_positional_bias = 0
+        temp_bias = 0
+        for i in range(1, anomaly_length + 1):
+            temp_bias = self._delta_function(i, anomaly_length)
+            max_positional_bias += temp_bias
+            j = rrange[0] + i - 1
+            if j >= overlap[0] and j <= overlap[1]:
+                my_positional_bias += temp_bias
+        if max_positional_bias > 0:
+            res = my_positional_bias / max_positional_bias
+            return res
+        else:
+            return 0
+
+    def _delta_function(self, t, anomaly_length):
+        return self._delta_select(self.bias, t, anomaly_length)
+
+    def _delta_select(self, delta, t, anomaly_length):
+        if delta == "flat":
+            return 1.0
+        elif delta == "front":
+            return float(anomaly_length - t + 1.0)
+        elif delta == "middle":
+            if t <= anomaly_length / 2.0:
+                return float(t)
+            else:
+                return float(anomaly_length - t + 1.0)
+        elif delta == "back":
+            return float(t)
+        elif delta == "udf_delta":
+            return self._udf_delta(t, anomaly_length)
+        else:
+            raise Exception("Invalid positional bias value")
+
+    def _udf_delta(self):
+        """
+        user defined delta function
+        """
+
+        return 1.0
+
+    def _shift(self, arr, num, fill_value=np.nan):
+        arr = np.roll(arr, num)
+        if num < 0:
+            arr[num:] = fill_value
+        elif num > 0:
+            arr[:num] = fill_value
+        return arr
+
+    def _prepare_data(self, values_real, values_pred):
+
+        assert len(values_real) == len(values_pred)
+        assert np.allclose(np.unique(values_real), np.array([0, 1])) or np.allclose(
+            np.unique(values_real), np.array([1])
+        )
+        assert np.allclose(np.unique(values_pred), np.array([0, 1])) or np.allclose(
+            np.unique(values_pred), np.array([1])
+        )
+
+        predicted_anomalies_ = np.argwhere(values_pred == 1).ravel()
+        predicted_anomalies_shift_forward = self._shift(predicted_anomalies_, 1, fill_value=predicted_anomalies_[0])
+        predicted_anomalies_shift_backward = self._shift(predicted_anomalies_, -1, fill_value=predicted_anomalies_[-1])
+        predicted_anomalies_start = np.argwhere(
+            (predicted_anomalies_shift_forward - predicted_anomalies_) != -1
+        ).ravel()
+        predicted_anomalies_finish = np.argwhere(
+            (predicted_anomalies_ - predicted_anomalies_shift_backward) != -1
+        ).ravel()
+        predicted_anomalies = np.hstack(
+            [
+                predicted_anomalies_[predicted_anomalies_start].reshape(-1, 1),
+                predicted_anomalies_[predicted_anomalies_finish].reshape(-1, 1),
+            ]
+        )
+
+        real_anomalies_ = np.argwhere(values_real == 1).ravel()
+        real_anomalies_shift_forward = self._shift(real_anomalies_, 1, fill_value=real_anomalies_[0])
+        real_anomalies_shift_backward = self._shift(real_anomalies_, -1, fill_value=real_anomalies_[-1])
+        real_anomalies_start = np.argwhere((real_anomalies_shift_forward - real_anomalies_) != -1).ravel()
+        real_anomalies_finish = np.argwhere((real_anomalies_ - real_anomalies_shift_backward) != -1).ravel()
+        real_anomalies = np.hstack(
+            [
+                real_anomalies_[real_anomalies_start].reshape(-1, 1),
+                real_anomalies_[real_anomalies_finish].reshape(-1, 1),
+            ]
+        )
+
+        return real_anomalies, predicted_anomalies

tsadmetrics/_tsadeval/prts/basic_metrics_ts.py

@@ -0,0 +1,121 @@
+from .time_series_metrics.fscore import TimeSeriesFScore
+from .time_series_metrics.precision import TimeSeriesPrecision
+from .time_series_metrics.recall import TimeSeriesRecall
+
+
+def ts_precision(real, pred, alpha=0.0, cardinality="one", bias="flat"):
+    """Compute the range based precision.
+
+    The range based precision is the average of "Precision_Ti", where "Precision_Ti" is
+    the precision score of each predicted anomaly range.
+    "Precision_Ti" for a single predicted anomaly range is calculated by the following formula.
+        Precision_Ti = α x ExistenceReward + (1 - α) x OverlapReward , where 0 ≤ α ≤ 1
+    α represents the relative importance of rewarding existence, whereas
+    (1 − α) represents the relative importance of rewarding size, position, and cardinality.
+
+    "ExistenceReward" is 1 if a real anomaly range has overlap with even a single point of
+    the predicted anomaly range, 0 otherwise.
+    Note: For prediction, there is no need for an existence reward, since precision by definition
+          emphasizes prediction quality, and existence by itself is too low a bar for judging
+          the quality of a prediction (i.e., α = 0).
+
+    "OverlapReward" is calculated by the following formula.
+        OverlapReward = CardinalityFactor x Sum of ω
+    "CardinalityFactor" is 1 if the predicted anomaly range overlaps with only one real anomaly range.
+    Otherwise it receives 0 ≤ γ() ≤ 1 defined by the application.
+    "CardinalityFactor" serves as a scaling factor for the rewards "ω"s, which is earned from overlap
+    size and position.
+    In determing "ω", we consider the size of the correctly predicted portion of an predicted anomaly
+    range and the relative position of the correctly predicted portion of an predicted anomaly range.
+
+    Args:
+        real: np.ndarray
+            One-dimensional array of correct answers with values of 1 or 0.
+        pred: np.ndarray
+            One-dimensional array of predicted answers with values of 1 or 0.
+        alpha: float, default=0.0
+            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
+        cardinality: string, default="one"
+            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
+        bias: string, default="flat"
+            Positional bias. This should be "flat", "front", "middle", or "back"
+
+    Returns:
+        float: precision.score
+    """
+    precision = TimeSeriesPrecision(alpha, cardinality, bias)
+    return precision.score(real, pred)
+
+
+def ts_recall(real, pred, alpha=0.0, cardinality="one", bias="flat"):
+    """Compute the range based recall.
+
+    The range based recall is the average of "Recall_Ti", where "Recall_Ti" is
+    the recall score of each real anomaly range.
+    "Recall_Ti" for a single real anomaly range is calculated by the following formula.
+        Recall_Ti = α x ExistenceReward + (1 - α) x OverlapReward , where 0 ≤ α ≤ 1
+    α represents the relative importance of rewarding existence, whereas
+    (1 − α) represents the relative importance of rewarding size, position, and cardinality.
+
+    "ExistenceReward" is 1 if a prediction captures even a single point of the real anomaly range, 0 otherwise.
+
+    "OverlapReward" is calculated by the following formula.
+        OverlapReward = CardinalityFactor x Sum of ω
+    "CardinalityFactor" is 1 if the real anomaly range overlaps with only one predicted anomaly range.
+    Otherwise it receives 0 ≤ γ() ≤ 1 defined by the application.
+    "CardinalityFactor" serves as a scaling factor for the rewards "ω"s, which is earned from overlap
+    size and position.
+    In determing "ω", we consider the size of the correctly predicted portion of the real anomaly range
+    and the relative
+    position of the correctly predicted portion of the real anomaly range.
+
+    Args:
+        real: np.ndarray
+            One-dimensional array of correct answers with values of 1 or 0.
+        pred: np.ndarray
+            One-dimensional array of predicted answers with values of 1 or 0.
+        alpha: float, default=0.0
+            Relative importance of existence reward. 0 ≤ alpha ≤ 1.
+        cardinality: string, default="one"
+            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
+        bias: string, default="flat"
+            Positional bias. This should be "flat", "front", "middle", or "back"
+
+    Returns:
+        float: recall.score
+    """
+    recall = TimeSeriesRecall(alpha, cardinality, bias)
+    return recall.score(real, pred)
+
+
+def ts_fscore(real, pred, beta=1.0, p_alpha=0.0, r_alpha=0.0, cardinality="one", p_bias="flat", r_bias="flat"):
+    """Compute the range based f-score
+
+    The F-beta score is the weighted harmonic mean of precision and recall,
+    reaching its optimal value at 1 and its worst value at 0.
+    The beta parameter determines the weight of recall in the combined score.
+    beta < 1 lends more weight to precision, while beta > 1 favors recall
+    (beta -> 0 considers only precision, beta -> +inf only recall).
+
+    Args:
+        real: np.ndarray
+            One-dimensional array of correct answers with values of 1 or 0.
+        pred: np.ndarray
+            One-dimensional array of predicted answers with values of 1 or 0.
+        p_alpha: float, default=0.0
+            Relative importance of existence reward for precision. 0 ≤ alpha ≤ 1.
+        r_alpha: float, default=0.0
+            Relative importance of existence reward for recall. 0 ≤ alpha ≤ 1.
+        cardinality: string, default="one"
+            Cardinality type. This should be "one", "reciprocal" or "udf_gamma".
+        p_bias: string, default="flat"
+            Positional bias for precision. This should be "flat", "front", "middle", or "back"
+        r_bias: string, default="flat"
+            Positional bias for recall. This should be "flat", "front", "middle", or "back"
+
+    Returns:
+        float: f.score
+    """
+
+    fscore = TimeSeriesFScore(beta, p_alpha, r_alpha, cardinality, p_bias, r_bias)
+    return fscore.score(real, pred)