tsadmetrics 0.1.16__py3-none-any.whl → 1.0.0__py3-none-any.whl

tsadmetrics/metrics/tem/tmem/EnhancedTimeseriesAwareFScore.py

@@ -0,0 +1,252 @@
+from ....base.Metric import Metric
+import numpy as np
+import math
+from ....utils.functions_conversion import full_series_to_segmentwise, full_series_to_pointwise
+class EnhancedTimeseriesAwareFScore(Metric):
+    """
+    Calculate enhanced time series aware F-score for anomaly detection in time series.
+    
+    This metric is similar to the range-based F-score in that it accounts for both detection existence 
+    and overlap proportion. Additionally, it requires that a significant fraction :math:`{\\theta_r}` of each true anomaly 
+    segment be detected, and that a significant fraction :math:`{\\theta_p}` of each predicted segment overlaps with the 
+    ground truth. Finally, F-score contributions from each event are weighted by the square root of the 
+    true segment’s length, providing a compromise between point-wise and segment-wise approaches.
+
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://doi.org/10.1145/3477314.3507024
+
+    Parameters:
+        theta_p (float):
+            Minimum fraction (:math:`{0 \\leq \\theta_p \\leq 1}`) of a predicted segment that must be overlapped 
+            by ground truth to count as detected.
+        theta_r (float):
+            Minimum fraction (:math:`{0 \\leq \\theta_r \\leq 1}`) of a true segment that must be overlapped 
+            by predictions to count as detected.
+    """
+    name = "etaf"
+    binary_prediction = True
+    param_schema = {
+        "theta_p": {
+            "default": 0.5,
+            "type": float
+        },
+        "theta_r": {
+            "default": 0.5,
+            "type": float
+        }
+    }
+
+    def __init__(self, **kwargs):
+        super().__init__(name="etaf", **kwargs)
+
+    def _min_max_norm(self, value, org_min, org_max, new_min, new_max) -> 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 _uniform_func(self, val: float) -> float:
+        return 1.0
+    
+    def _sum_of_func(self, start_time, end_time, org_start, org_end,
+                     func) -> 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, ambiguous, prediction) -> float:
+        score = 0.0
+
+        detected_start = max(anomaly[0], prediction[0])
+        detected_end = min(anomaly[1], prediction[1])
+
+        score += self._sum_of_func(detected_start, detected_end,
+                                   anomaly[0], anomaly[1], self._uniform_func)
+
+        if ambiguous[0] < ambiguous[1]:
+            detected_start = max(ambiguous[0], prediction[0])
+            detected_end = min(ambiguous[1], prediction[1])
+
+            score += self._sum_of_func(detected_start, detected_end,
+                                       ambiguous[0], ambiguous[1], self._decaying_func)
+        return score
+    
+    def _gen_ambiguous(self,y_true_sw, y_pred_sw):
+        ambiguous_inst = []
+        for i in range(len(y_true_sw)):
+            start_id = y_true_sw[i][1] + 1
+            end_id = start_id 
+
+            if i + 1 < len(y_true_sw) and end_id > y_true_sw[i + 1][0]:
+                end_id = y_true_sw[i + 1][0] - 1
+
+            if start_id > end_id:
+                start_id = -2
+                end_id = -1
+
+            ambiguous_inst.append([start_id, end_id])
+        return ambiguous_inst
+    
+    def _compute_overlap_scores_and_weights(self, y_true_sw, y_pred_sw):
+
+        predictions_weight = []
+        predictions_total_weight = 0.0
+        #computing weights
+        for a_prediction in y_pred_sw:
+            first, last = a_prediction
+            temp_weight = math.sqrt(last-first+1)
+            predictions_weight.append(temp_weight)
+            predictions_total_weight += temp_weight
+
+        #computing the score matrix
+        ambiguous_inst = self._gen_ambiguous(y_true_sw, y_pred_sw)
+        overlap_score_mat_org = np.zeros((len(y_true_sw), len(y_pred_sw)))
+        for anomaly_id in range(len(y_true_sw)):
+            for prediction_id in range(len(y_pred_sw)):
+                overlap_score_mat_org[anomaly_id, prediction_id] = \
+                    float(self._overlap_and_subsequent_score(y_true_sw[anomaly_id], ambiguous_inst[anomaly_id], y_pred_sw[prediction_id]))
+
+        #computing the maximum scores for each anomaly or prediction
+        max_anomaly_score = []
+        max_prediction_score = []
+        for an_anomaly in y_true_sw:
+            start, end = an_anomaly
+            max_anomaly_score.append(float(self._sum_of_func(start, end, start, end, self._uniform_func)))
+        for a_prediction in y_pred_sw:
+            max_prediction_score.append(a_prediction[1]-a_prediction[0] + 1)
+
+
+        return predictions_weight, predictions_total_weight, overlap_score_mat_org, max_anomaly_score, max_prediction_score
+
+    def _pruning(self, y_true_sw, y_pred_sw, overlap_score_mat_elm, max_anomaly_score, max_prediction_score):
+
+
+        while True:
+            tars = overlap_score_mat_elm.sum(axis=1)/max_anomaly_score
+            elem_anomaly_ids = set(np.where(tars<self.params['theta_r'])[0]) - set(np.where(tars==0.0)[0])
+            for id in elem_anomaly_ids:
+                overlap_score_mat_elm[id] = np.zeros(len(y_pred_sw))
+            taps = overlap_score_mat_elm.sum(axis=0)/max_prediction_score
+            elem_prediction_ids = set(np.where(taps<self.params['theta_p'])[0]) - set(np.where(taps==0.0)[0])
+            for id in elem_prediction_ids:
+                overlap_score_mat_elm[:, id] = np.zeros(len(y_true_sw))
+
+            if len(elem_anomaly_ids) == 0 and len(elem_prediction_ids) == 0:
+                break
+        return overlap_score_mat_elm
+
+    def _etar_p(self, y_true_sw, y_pred_sw, overlap_score_mat_elm, predictions_weight, predictions_total_weight, max_prediction_score):
+        """
+        Calculate precision for the enhanced time series aware F-score.
+
+        Parameters:
+            y_true_sw (np.array):
+                The ground truth binary labels for the time series data, in segment-wise format.
+            y_pred_sw (np.array):
+                The predicted binary labels for the time series data, in segment-wise format.
+            overlap_score_mat_org (np.array):
+                The original overlap score matrix.
+            max_anomaly_score (list):
+                The maximum scores for each anomaly segment.
+            max_prediction_score (list):
+                The maximum scores for each prediction segment.
+        Returns:
+            float: The precision value.
+        """
+        etap_d = 0
+        etap_p = 0
+        if len(y_true_sw) == 0.0 or len(y_pred_sw) == 0.0:
+            etap_d,etap_p = 0.0, 0.0
+        
+        etap_d = overlap_score_mat_elm.sum(axis=0) / max_prediction_score
+        etap_p = etap_d
+
+        etap_d = np.where(etap_d >= self.params['theta_p'], 1.0, etap_d)
+        etap_d = np.where(etap_d <  self.params['theta_p'], 0.0, etap_d)
+        corrected_id_list = np.where(etap_d >= self.params['theta_p'])[0]
+
+        detection_scores = etap_d
+        portion_scores = etap_p
+
+
+        scores = (detection_scores + detection_scores * portion_scores)/2
+        final_score = 0.0
+        for i in range(max(len(scores),len(etap_d),len(corrected_id_list))):
+            if i < len(scores):
+                final_score += float(predictions_weight[i]) * scores[i]
+            
+        
+        final_score /= float(predictions_total_weight)
+        return final_score
+
+    
+    def _etar_d(self, y_true_sw, y_pred_sw, overlap_score_mat_elm, max_anomaly_score, max_prediction_score):
+        """
+        Calculate recall for the enhanced time series aware F-score.
+
+        Parameters:
+            y_true_sw (np.array):
+                The ground truth binary labels for the time series data, in segment-wise format.
+            y_pred_sw (np.array):
+                The predicted binary labels for the time series data, in segment-wise format.
+            overlap_score_mat_org (np.array):
+                The original overlap score matrix.
+            max_anomaly_score (list):
+                The maximum scores for each anomaly segment.
+            max_prediction_score (list):
+                The maximum scores for each prediction segment.
+        Returns:
+            float: The recall value.
+        """
+        if len(y_true_sw) == 0.0 or len(y_pred_sw) == 0.0:
+            return np.zeros(len(y_true_sw)), []
+        theta = self.params['theta_r']
+        scores = overlap_score_mat_elm.sum(axis=1) / max_anomaly_score
+        scores = np.where(scores >= theta, 1.0, scores)
+        scores = np.where(scores <  theta, 0.0, scores)
+        detected_id_list = np.where(scores >= theta)[0]
+
+        return scores, detected_id_list
+    def _compute(self, y_true, y_pred):
+        """
+        Calculate the enhanced time series aware F-score.
+
+        Parameters:
+            y_true (np.array):
+                The ground truth binary labels for the time series data.
+            y_pred (np.array):
+                The predicted binary labels for the time series data.
+
+        Returns:
+            float: The time series aware F-score, which is the harmonic mean of precision and recall, adjusted by the beta value.
+        """
+
+        if np.sum(y_pred) == 0:
+            return 0
+        y_true_sw = np.array(full_series_to_segmentwise(y_true))
+        y_pred_sw = np.array(full_series_to_segmentwise(y_pred))
+
+        predictions_weight, predictions_total_weight, overlap_score_mat_org, max_anomaly_score, max_prediction_score = self._compute_overlap_scores_and_weights(y_true_sw,y_pred_sw)
+        overlap_score_mat_elm = self._pruning(y_true_sw, y_pred_sw, overlap_score_mat_org, max_anomaly_score, max_prediction_score)
+        detection_scores, detected_id_list = self._etar_d(y_true_sw, y_pred_sw, overlap_score_mat_elm, max_anomaly_score, max_prediction_score)
+        precision = self._etar_p(y_true_sw, y_pred_sw, overlap_score_mat_elm, predictions_weight, predictions_total_weight, max_prediction_score)
+
+        if len(y_true_sw) == 0 or len(y_pred_sw) == 0:
+            portion_scores = 0.0
+        else:
+            portion_scores = overlap_score_mat_elm.sum(axis=1) / max_anomaly_score
+            portion_scores = np.where(portion_scores > 1.0, 1.0, portion_scores)
+        recall = ((detection_scores + detection_scores * portion_scores)/2).mean()
+
+        if precision + recall == 0:
+            return 0.0
+        else:
+            return (2 * recall * precision) / (recall + precision)
+        

tsadmetrics/metrics/tem/tmem/TemporalDistance.py

@@ -0,0 +1,68 @@
+from ....base.Metric import Metric
+import numpy as np
+from ....utils.functions_conversion import full_series_to_pointwise
+
+class TemporalDistance(Metric):
+    """
+    Calculate temporal distance for anomaly detection in time series.
+
+    This metric computes the sum of the distances from each labelled anomaly point to
+    the closest predicted anomaly point, and from each predicted anomaly point to the
+    closest labelled anomaly point. 
+
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    For more information, see the original paper:
+    https://sciendo.com/article/10.2478/ausi-2019-0008
+
+    Parameters:
+        distance (int):
+            The distance type parameter for the temporal distance calculation.
+            - 0: Euclidean distance
+            - 1: Squared Euclidean distance
+    """
+    name = "td"
+    binary_prediction = True
+    param_schema = {
+        "distance": {
+            "default": 0,
+            "type": int
+        }
+    }
+
+    def __init__(self, **kwargs):
+        super().__init__(name="td", **kwargs)
+
+    def _compute(self, y_true, y_pred):
+        """
+        Calculate the temporal distance.
+
+        Parameters:
+            y_true (np.array):
+                The ground truth binary labels for the time series data.
+            y_pred (np.array):
+                The predicted binary labels for the time series data.
+
+        Returns:
+            float: The temporal distance.
+        """
+
+        def _dist(a, b):
+            dist = 0
+            for pt in a:
+                if len(b) > 0:
+                    dist += min(abs(b - pt))
+                else:
+                    dist += len(y_true)
+            return dist
+
+        y_true_pw = np.array(full_series_to_pointwise(y_true))
+        y_pred_pw = np.array(full_series_to_pointwise(y_pred))
+
+        distance = self.params['distance']
+        if distance == 0:
+            return _dist(y_true_pw, y_pred_pw) + _dist(y_pred_pw, y_true_pw)
+        elif distance == 1:
+            return _dist(y_true_pw, y_pred_pw)**2 + _dist(y_pred_pw, y_true_pw)**2
+        else:
+            raise ValueError(f"Distance {distance} not supported")

tsadmetrics/metrics/tem/tmem/__init__.py

@@ -0,0 +1,9 @@
+from .AbsoluteDetectionDistance import AbsoluteDetectionDistance
+from .TemporalDistance import TemporalDistance
+from .EnhancedTimeseriesAwareFScore import EnhancedTimeseriesAwareFScore
+
+__all__ = [
+    "AbsoluteDetectionDistance",
+    "TemporalDistance",
+    "EnhancedTimeseriesAwareFScore"
+]

tsadmetrics/metrics/tem/tpdm/CompositeFScore.py

@@ -0,0 +1,104 @@
+from ....base.Metric import Metric
+import numpy as np
+from ....utils.functions_conversion import full_series_to_segmentwise
+
+class CompositeFScore(Metric):
+    """
+    Composite F-score for anomaly detection in time series.
+
+    This metric combines aspects of the point-wise F-score and the segment-wise
+    F-score. It is defined as the harmonic mean of point-wise precision and
+    segment-wise recall. Using point-wise precision ensures that false positives
+    are properly penalized, a limitation often found in purely segment-wise
+    metrics.
+
+    Reference:
+        Implementation based on:
+        https://ieeexplore.ieee.org/document/9525836
+
+        For more details, see:
+        https://doi.org/10.1109/TNNLS.2021.3105827
+
+    Attributes:
+        name (str):
+            Fixed name identifier for this metric: `"cf"`.
+        binary_prediction (bool):
+            Indicates that this metric requires binary predictions.
+        param_schema (dict):
+            Defines supported parameters. Includes:
+                - beta (float): Weighting factor for recall in the F-score
+                  calculation. Default = 1.0.
+
+    Raises:
+        ValueError:
+            If inputs are invalid or improperly shaped (checked by the base class).
+        TypeError:
+            If inputs are not array-like.
+    """
+
+    name = "cf"
+    binary_prediction = True
+    param_schema = {
+        "beta": {
+            "default": 1.0,
+            "type": float
+        }
+    }
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the CompositeFScore metric.
+
+        Parameters:
+            **kwargs:
+                Optional keyword arguments passed to the base `Metric` class.
+                Supported parameter:
+                    - beta (float): Weight factor for recall in the F-score.
+        """
+        super().__init__(name="cf", **kwargs)
+
+    def _compute(self, y_true, y_pred):
+        """
+        Compute the composite F-score.
+
+        The score is computed as:
+            F_beta = (1 + beta^2) * (precision * recall) / (beta^2 * precision + recall)
+
+        where:
+            - precision is computed point-wise.
+            - recall is computed segment-wise, meaning a segment is counted as
+              correctly detected if any point within it is predicted as anomalous.
+
+        Parameters:
+            y_true (np.ndarray):
+                Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
+            y_pred (np.ndarray):
+                Predicted binary labels for the time series.
+
+        Returns:
+            float:
+                The composite F-score. Returns 0 if either precision or recall is 0.
+        """
+        tp = np.sum(y_pred * y_true)
+        fp = np.sum(y_pred * (1 - y_true))
+
+        tp_sw = 0
+        fn_sw = 0
+        for gt_anomaly in full_series_to_segmentwise(y_true):
+            found = False
+            for i_index in range(gt_anomaly[0], gt_anomaly[1] + 1):
+                if y_pred[i_index] == 1:
+                    tp_sw += 1
+                    found = True
+                    break
+            if not found:
+                fn_sw += 1
+
+        precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+        recall = tp_sw / (tp_sw + fn_sw) if (tp_sw + fn_sw) > 0 else 0
+
+        if precision == 0 or recall == 0:
+            return 0
+
+        beta = self.params['beta']
+        return ((1 + beta**2) * precision * recall) / (beta**2 * precision + recall)

tsadmetrics/metrics/tem/tpdm/PointadjustedAucPr.py

@@ -0,0 +1,123 @@
+from ....base.Metric import Metric
+import numpy as np
+from ....utils.functions_conversion import full_series_to_segmentwise
+from ....utils.functions_auc import auc
+
+class PointadjustedAucPr(Metric):
+    """
+    Point-adjusted Area Under the Precision-Recall Curve (AUC-PR) for anomaly detection.
+
+    Unlike the standard point-wise AUC-PR, this variant uses a point-adjusted evaluation:
+    
+    - Each anomalous segment in `y_true` is considered correctly detected if **at least
+      one point** within that segment is predicted as anomalous.
+    - Once a segment is detected, all its points are marked as detected in the adjusted
+      prediction.
+    
+    This adjustment accounts for the fact that detecting any part of an anomalous
+    segment is often sufficient in practice.
+
+    Reference:
+        Implementation of:
+        https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    Attributes:
+        name (str):
+            Fixed name identifier for this metric: `"pa_auc_pr"`.
+        binary_prediction (bool):
+            Indicates whether this metric requires binary predictions.
+            Always `False`, as it expects continuous anomaly scores.
+        param_schema (dict):
+            Empty schema since this metric has no tunable parameters.
+
+    Raises:
+        ValueError:
+            If `y_true` and `y_anomaly_scores` have mismatched lengths.
+        TypeError:
+            If inputs are not array-like.
+    """
+
+    name = "pa_auc_pr"
+    binary_prediction = False
+    param_schema = {}
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the PointadjustedAucPr metric.
+
+        Parameters:
+            **kwargs:
+                Optional keyword arguments passed to the base `Metric` class.
+        """
+        super().__init__(name="pa_auc_pr", **kwargs)
+
+    def compute_point_adjusted(self, y_true, y_pred):
+        """
+        Apply point-adjustment to predictions and compute precision/recall.
+
+        For each ground-truth anomalous segment, if any point is predicted as
+        anomalous, the entire segment is marked as detected.
+
+        Parameters:
+            y_true (np.ndarray):
+                Ground-truth binary labels (0 = normal, 1 = anomaly).
+            y_pred (np.ndarray):
+                Binary predictions (0 = normal, 1 = anomaly).
+
+        Returns:
+            tuple[float, float]:
+                - precision (float): Adjusted precision score.
+                - recall (float): Adjusted recall score.
+        """
+        adjusted_prediction = y_pred.copy()
+
+        for start, end in full_series_to_segmentwise(y_true):
+            if np.any(adjusted_prediction[start:end + 1]):
+                adjusted_prediction[start:end + 1] = 1
+            else:
+                adjusted_prediction[start:end + 1] = 0
+
+        tp = np.sum(adjusted_prediction * y_true)
+        fp = np.sum(adjusted_prediction * (1 - y_true))
+        fn = np.sum((1 - adjusted_prediction) * y_true)
+
+        precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+        recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+
+        return precision, recall
+
+    def _compute(self, y_true, y_anomaly_scores):
+        """
+        Compute the point-adjusted AUC-PR score.
+
+        Parameters:
+            y_true (np.ndarray):
+                Ground-truth binary labels for the time series.
+            y_anomaly_scores (np.ndarray):
+                Continuous anomaly scores assigned to each point.
+
+        Returns:
+            float:
+                The point-adjusted AUC-PR score.
+        """
+        unique_thresholds = np.unique(y_anomaly_scores)
+        unique_thresholds = np.sort(unique_thresholds)[::-1]  # descending
+
+        precisions, recalls = [], []
+
+        for threshold in unique_thresholds:
+            y_pred_binary = (y_anomaly_scores >= threshold).astype(int)
+            precision, recall = self.compute_point_adjusted(y_true, y_pred_binary)
+            precisions.append(precision)
+            recalls.append(recall)
+
+        # Add endpoints for PR curve
+        recalls = [0.0] + recalls + [1.0]
+        precisions = [1.0] + precisions + [0.0]
+
+        # Sort by recall (increasing order)
+        sorted_indices = np.argsort(recalls)
+        recalls_sorted = np.array(recalls)[sorted_indices]
+        precisions_sorted = np.array(precisions)[sorted_indices]
+
+        return auc(recalls_sorted, precisions_sorted)

tsadmetrics/metrics/tem/tpdm/PointadjustedAucRoc.py

@@ -0,0 +1,119 @@
+from ....base.Metric import Metric
+import numpy as np
+from ....utils.functions_conversion import full_series_to_segmentwise
+from ....utils.functions_auc import auc
+
+class PointadjustedAucRoc(Metric):
+    """
+    Point-adjusted Area Under the ROC Curve (AUC-ROC) for anomaly detection in time series.
+
+    Unlike standard point-wise AUC-ROC, this metric applies **point-adjusted evaluation**:
+    
+    - Each anomalous segment in `y_true` is considered correctly detected if **at least one
+      point** within that segment is predicted as anomalous.
+    - Once a segment is detected, all its points are marked as detected in the adjusted
+      predictions.
+    - Adjusted predictions are then used to compute true positive rate (TPR) and false
+      positive rate (FPR) at multiple thresholds to construct the ROC curve.
+
+    Reference:
+        Implementation based on:
+        https://link.springer.com/article/10.1007/s10618-023-00988-8
+
+    Attributes:
+        name (str):
+            Fixed name identifier for this metric: `"pa_auc_roc"`.
+        binary_prediction (bool):
+            Indicates that this metric expects continuous anomaly scores.
+        param_schema (dict):
+            Empty schema since this metric has no tunable parameters.
+
+    Raises:
+        ValueError:
+            If `y_true` and `y_anomaly_scores` have mismatched lengths.
+        TypeError:
+            If inputs are not array-like.
+    """
+
+    name = "pa_auc_roc"
+    binary_prediction = False
+    param_schema = {}
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the PointadjustedAucRoc metric.
+
+        Parameters:
+            **kwargs:
+                Optional keyword arguments passed to the base `Metric` class.
+        """
+        super().__init__(name="pa_auc_roc", **kwargs)
+
+    def compute_point_adjusted(self, y_true, y_pred):
+        """
+        Apply point-adjustment and compute TPR and FPR.
+
+        For each ground-truth anomalous segment, if any point is predicted as
+        anomalous, the entire segment is marked as detected.
+
+        Parameters:
+            y_true (np.ndarray):
+                Ground-truth binary labels (0 = normal, 1 = anomaly).
+            y_pred (np.ndarray):
+                Binary predictions (0 = normal, 1 = anomaly).
+
+        Returns:
+            tuple[float, float]:
+                - tpr (float): True positive rate.
+                - fpr (float): False positive rate.
+        """
+        adjusted_prediction = y_pred.copy()
+
+        for start, end in full_series_to_segmentwise(y_true):
+            if np.any(adjusted_prediction[start:end + 1]):
+                adjusted_prediction[start:end + 1] = 1
+            else:
+                adjusted_prediction[start:end + 1] = 0
+
+        tp = np.sum(adjusted_prediction * y_true)
+        fp = np.sum(adjusted_prediction * (1 - y_true))
+        fn = np.sum((1 - adjusted_prediction) * y_true)
+        tpr = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        fpr = fp / (fp + (len(y_true) - np.sum(y_true) - fp)) if (fp + (len(y_true) - np.sum(y_true) - fp)) > 0 else 0.0
+        return tpr, fpr
+
+    def _compute(self, y_true, y_anomaly_scores):
+        """
+        Compute the point-adjusted AUC-ROC score.
+
+        Parameters:
+            y_true (np.ndarray):
+                Ground-truth binary labels for the time series.
+            y_anomaly_scores (np.ndarray):
+                Continuous anomaly scores assigned to each point.
+
+        Returns:
+            float:
+                The point-adjusted AUC-ROC score.
+        """
+        unique_thresholds = np.unique(y_anomaly_scores)
+        unique_thresholds = np.sort(unique_thresholds)[::-1]  # descending
+
+        tprs, fprs = [], []
+
+        for threshold in unique_thresholds:
+            y_pred_binary = (y_anomaly_scores >= threshold).astype(int)
+            tpr, fpr = self.compute_point_adjusted(y_true, y_pred_binary)
+            tprs.append(tpr)
+            fprs.append(fpr)
+
+        # Add endpoints for ROC curve
+        tprs = [0.0] + tprs + [1.0]
+        fprs = [0.0] + fprs + [1.0]
+
+        # Sort by FPR to ensure monotonic increasing for AUC calculation
+        sorted_indices = np.argsort(fprs)
+        fprs_sorted = np.array(fprs)[sorted_indices]
+        tprs_sorted = np.array(tprs)[sorted_indices]
+
+        return auc(fprs_sorted, tprs_sorted)