tsadmetrics 0.1.17__py3-none-any.whl → 1.0.1__py3-none-any.whl

tsadmetrics/metric_utils.py

@@ -1,98 +0,0 @@
-import numpy as np
-from ._tsadeval.metrics import pointwise_to_full_series, segmentwise_to_full_series
-
-def is_full_series(length: int, anomalies: np.array):
-    # [1 0 1 1 0]
-    return len(anomalies.shape) == 1 and len(anomalies) == length
-
-def is_pointwise(length: int, anomalies: np.array):
-    # [0 2 3]
-    return len(anomalies.shape) == 1 and len(anomalies) < length
-
-def is_segmentwise(length: int, anomalies: np.array):
-    # [[0 0] [2 3]]
-    return len(anomalies.shape) == 2
-
-
-def transform_to_full_series(length: int, anomalies: np.array):
-    if is_full_series(length, anomalies):
-        return anomalies
-    elif is_pointwise(anomalies):
-        return pointwise_to_full_series(anomalies, length)
-    elif is_segmentwise(length, anomalies):
-        return segmentwise_to_full_series(anomalies, length)
-    else:
-        raise ValueError(f"Illegal shape of anomalies:\n{anomalies}")
-
-def counting_method(y_true: np.array, y_pred: np.array, k: int):
-    em,da,ma,fa = 0,0,0,0
-    for i_gt in range(len(y_true)):
-        i_pa = i_gt
-        gt = y_true[i_gt]
-        pa = y_pred[i_pa]
-        if gt==1 and pa==1:
-            em+=1
-        elif gt==0 and pa==1:
-            fa+=1
-        elif gt==1 and pa==0:
-            anom_range = y_pred[i_gt-k:i_pa+k+1]
-            detected = False
-            for r in anom_range:
-                if r==1:
-                    em+=1
-                    detected=True
-                    break
-            if not detected:
-                ma+=1
-        elif gt==0 and pa==0:
-            pass
-    # b = DelayThresholdedPointAdjust(len(y_true),y_true,y_pred,k=k)
-    # da = b.tp-em
-    # ma = b.fn
-
-    return em,da,ma,fa
-
-
-#Range Based utils
-
-def cardinality(n_intersections,mode):
-    if mode == 'one':
-        return 1
-    elif mode == 'reciprocal':
-        if n_intersections==0:
-            return 1
-        else:
-            return float(1/n_intersections)
-    else:
-        raise Exception("Error, wrong cardinality mode.")
-    
-    
-def size(anomaly_range, overlap_set, position, bias):
-    if overlap_set == None:
-        return 0
-    
-    my_value = 0
-    max_value = 0
-    anomaly_length = anomaly_range[1] - anomaly_range[0] + 1
-    for i in range(1,anomaly_length+1):
-        bias_value = position(i, anomaly_length,bias)
-        max_value += bias_value
-        if  anomaly_range[0]+i-1 >= overlap_set[0] and anomaly_range[0]+i-1 <= overlap_set[1]:
-            my_value += bias_value
-    return my_value / max_value
-
-def position(i, anomaly_length,bias):
-    if bias == 'flat':
-        return 1
-    elif bias == 'front-end':
-        return anomaly_length - i + 1
-    elif bias == 'back-end':
-        return i
-    elif bias == 'middle':
-        if i <= anomaly_length / 2:
-            return i
-        else:
-            return anomaly_length - i + 1
-    else:
-        raise Exception("Error, wrong bias value.")
-    

tsadmetrics/non_binary_metrics.py

@@ -1,372 +0,0 @@
-import numpy as np
-from ._tsadeval.metrics import *
-from .validation import validate_non_binary_inputs
-from sklearn.metrics import auc
-from pate.PATE_metric import PATE 
-def precision_at_k(y_true : np.array, y_anomaly_scores:  np.array):
-    """
-    Calculate the precision at k score for anomaly detection in time series.
-
-    This metric evaluates how many of the top-k points (with highest anomaly scores)
-    actually correspond to true anomalies. It is particularly useful when we are 
-    interested in identifying the most anomalous points, without needing to set a 
-    fixed threshold.
-
-    The value of k is automatically set to the number of true anomalies present in 
-    y_true. That is, k = sum(y_true).
-
-    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
-
-    Parameters:
-        y_true (np.array):
-            The ground truth binary labels for the time series data.
-        y_anomaly_scores (np.array):
-            The predicted anomaly scores for the time series data.
-
-    Returns:
-        float: The precision at k score.
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-
-    m = PatK_pw(y_true,y_anomaly_scores)
-
-    return m.get_score()
-
-def auc_roc_pw(y_true : np.array, y_anomaly_scores:  np.array):
-    """
-    Calculate the AUC-ROC score for anomaly detection in time series.
-
-    This is the standard Area Under the Receiver Operating Characteristic Curve (AUC-ROC),
-    computed in a point-wise manner. That is, each point in the time series is treated
-    independently when calculating true positives, false positives, and false negatives.
-
-    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
-
-    Parameters:
-        y_true (np.array):
-            Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
-        y_anomaly_scores (np.array):
-            Continuous anomaly scores assigned to each point in the series.
-
-    Returns:
-        float: AUC-ROC score.
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-    
-    m = AUC_ROC(y_true,y_anomaly_scores)
-
-    return m.get_score()
-
-
-def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
-    """
-    Calculate the AUC-PR score for anomaly detection in time series.
-
-    This is the standard Area Under the Precision-Recall Curve (AUC-PR),
-    computed in a point-wise manner. That is, each point in the time series is treated
-    independently when calculating precision and recall.
-
-    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
-
-    Parameters:
-        y_true (np.array):
-            Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
-        y_anomaly_scores (np.array):
-            Continuous anomaly scores assigned to each point in the series.
-
-    Returns:
-        float: AUC-PR score.
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-
-    m = AUC_PR_pw(y_true,y_anomaly_scores)
-
-    return m.get_score()
-
-
-def auc_roc_pa(y_true: np.array, y_anomaly_scores: np.array):
-    """
-    Calculate the AUC-ROC score using point-adjusted evaluation for anomaly detection in time series.
-
-    This is the standard Area Under the Receiver Operating Characteristic Curve (AUC-ROC), but instead 
-    of computing true positive rate (TPR) and false positive rate (FPR) point-wise, it uses a point-adjusted 
-    approach. Specifically, for each ground-truth anomalous segment, if at least one point within that 
-    segment is predicted as anomalous, the entire segment is considered correctly detected. The adjusted 
-    predictions are then compared to the ground-truth labels to compute true positives, false positives, 
-    and false negatives, which are used to construct the ROC curve.
-
-    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
-
-    Parameters:
-        y_true (np.array):
-            Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
-        y_anomaly_scores (np.array):
-            Continuous anomaly scores assigned to each point in the series.
-
-    Returns:
-        float: AUC-ROC score (with point-adjusted evaluation).
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-    
-    tprs = [0]
-    fprs = [0]
-    tps, fps, fns = [], [], []
-
-    p_adj = PointAdjust(len(y_true), y_true, (np.array(y_anomaly_scores) >= 0.5).astype(int))
-    segments = p_adj.get_gt_anomalies_segmentwise()
-    idx = np.argsort(y_anomaly_scores)[::-1].astype(int)
-    y_true_sorted = np.array(y_true)[idx]
-    y_anomaly_scores_sorted = np.array(y_anomaly_scores)[idx]
-    
-    segment_mins = []
-    for start, end in segments:
-        anoms_scores = y_anomaly_scores[start:end+1]
-        segment_mins.append([np.max(anoms_scores), end-start+1])
-
-    for i_t in range(len(y_anomaly_scores_sorted)):
-        fp, tp, fn = 0, 0, 0
-        if i_t > 0 and y_anomaly_scores_sorted[i_t] == y_anomaly_scores_sorted[i_t-1]:
-            tp = tps[-1]
-            fp = fps[-1]
-            fn = fns[-1]
-        else:
-            if y_true_sorted[i_t] == 0:
-                # FP
-                if len(fps) == 0:
-                    aux_y_pred = (y_anomaly_scores >= y_anomaly_scores_sorted[i_t]).astype(int)
-                    for i in range(len(aux_y_pred)):
-                        if aux_y_pred[i] == 1 and y_true[i] == 0:
-                            fp += 1
-                else:
-                    fp = fps[i_t-1] + 1
-            else:
-                if len(fps) == 0:
-                    aux_y_pred = (y_anomaly_scores >= y_anomaly_scores_sorted[i_t]).astype(int)
-                    for i in range(len(aux_y_pred)):
-                        if aux_y_pred[i] == 1 and y_true[i] == 0:
-                            fp += 1
-                else:
-                    fp = fps[i_t-1]
-            for score, length in segment_mins:
-                if score >= y_anomaly_scores_sorted[i_t]:
-                    # TP
-                    tp += length
-                else:
-                    # FN
-                    fn += length
-        tps.append(tp)
-        fns.append(fn)
-        fps.append(fp)
-    for tp, fp, fn in zip(tps, fps, fns):
-        if tp + fn > 0:
-            tprs.append(tp / (tp + fn))
-        else:
-            tprs.append(0)
-        if fp + (len(y_true) - np.sum(y_true)) > 0:
-            fprs.append(fp / (fp + (len(y_true) - np.sum(y_true))))
-        else:
-            fprs.append(0)
-    
-    auc_value = auc(fprs, tprs)
-    return auc_value
-
-def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
-    """
-    Calculate the AUC-PR score using point-adjusted evaluation for anomaly detection in time series.
-
-    This is the standard Area Under the Precision-Recall Curve (AUC-PR), but instead of computing 
-    precision and recall point-wise, it uses a point-adjusted approach. Specifically, for each 
-    ground-truth anomalous segment, if at least one point within that segment is predicted as anomalous, 
-    the entire segment is considered correctly detected. The adjusted predictions are then compared 
-    to the ground-truth labels to compute true positives, false positives, and false negatives,
-    which are used to construct the PR curve.
-
-    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
-
-    Parameters:
-        y_true (np.array):
-            Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
-        y_anomaly_scores (np.array):
-            Continuous anomaly scores assigned to each point in the series.
-
-    Returns:
-        float: AUC-PR score (with point-adjusted evaluation).
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-    
-    precisions = [1]
-    recalls = [0]
-    tps,fps,fns = [],[],[]
-
-    p_adj = PointAdjust(len(y_true),y_true,(np.array(y_anomaly_scores) >= 0.5).astype(int))
-    segments= p_adj.get_gt_anomalies_segmentwise()
-    idx = np.argsort(y_anomaly_scores)[::-1].astype(int)
-    y_true_sorted = np.array(y_true)[idx]
-    y_anomaly_scores_sorted = np.array(y_anomaly_scores)[idx]
-    
-    segment_mins = []
-    for start,end in segments:
-        anoms_scores = y_anomaly_scores[start:end+1]
-        segment_mins.append([np.max(anoms_scores),end-start+1])
-
-    for i_t in range(len(y_anomaly_scores_sorted)):
-        fp,tp,fn = 0,0,0
-        if i_t > 0 and y_anomaly_scores_sorted[i_t] == y_anomaly_scores_sorted[i_t-1] :
-            tp = tps[-1]
-            fp = fps[-1]
-            fn = fns[-1]
-        else:
-            if y_true_sorted[i_t] == 0:
-                #FP
-                if len(fps)==0:
-                    aux_y_pred = (y_anomaly_scores >= y_anomaly_scores_sorted[i_t]).astype(int)
-                    for i in range(len(aux_y_pred)):
-                        if aux_y_pred[i] == 1 and y_true[i] == 0:
-                            fp+=1
-
-
-                else:
-                    fp=fps[i_t-1]+1
-            else:
-                if len(fps)==0:
-                    aux_y_pred = (y_anomaly_scores >= y_anomaly_scores_sorted[i_t]).astype(int)
-                    for i in range(len(aux_y_pred)):
-                        if aux_y_pred[i] == 1 and y_true[i] == 0:
-                            fp+=1
-                else:
-                    fp=fps[i_t-1]
-            for score, length in segment_mins:
-                if score >= y_anomaly_scores_sorted[i_t]:
-                    #TP
-                    tp+= length
-                else:
-                    #FN
-                    fn+= length
-        tps.append(tp)
-        fns.append(fn)
-        fps.append(fp)
-    for tp,fp,fn in zip(tps,fps,fns):
-        if tp>0:
-            precisions.append(tp/(tp+fp))
-            recalls.append(tp/(tp+fn))
-        else:
-            precisions.append(0)
-            recalls.append(0)    
-      
-    
-    recalls.append(1)
-    precisions.append(0)
-
-    auc_value = auc(recalls, precisions)
-    return auc_value
-
-
-
-
-
-
-def vus_roc(y_true : np.array ,y_anomaly_scores:  np.array, window=4):
-    """
-    Calculate the VUS-ROC (Volume Under the ROC Surface) score for anomaly detection in time series.
-
-    This metric extends the classical AUC-ROC by introducing a temporal tolerance parameter `l`, which
-    smooths the binary ground-truth labels. The idea is to allow a flexible evaluation that tolerates
-    small misalignments in the detection of anomalies. The final score is computed by integrating 
-    the ROC-AUC over different values of the tolerance parameter, from 0 to `window`, thus producing
-    a volume under the ROC surface.
-
-    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
-
-    For more information, see the original paper:
-    https://dl.acm.org/doi/10.14778/3551793.3551830
-
-    Parameters:
-        y_true (np.array):
-            Ground-truth binary labels (0 = normal, 1 = anomaly).
-        y_anomaly_scores (np.array):
-            Anomaly scores for each time point.
-        window (int):
-            Maximum temporal tolerance `l` used to smooth the evaluation.
-
-    Returns:
-        float: VUS-ROC score.
-
-    
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-
-    m = VUS_ROC(y_true,y_anomaly_scores,max_window=window)
-
-    return m.get_score()
-
-
-def vus_pr(y_true : np.array ,y_anomaly_scores:  np.array,  window=4):
-    """
-    Calculate the VUS-PR (Volume Under the PR Surface) score for anomaly detection in time series.
-
-    This metric is an extension of the classical AUC-PR, incorporating a temporal tolerance parameter `l`
-    that smooths the binary ground-truth labels. It allows for some flexibility in the detection of 
-    anomalies that are temporally close to the true events. The final metric integrates the PR-AUC
-    over several levels of temporal tolerance (from 0 to `window`), yielding a volume under the PR surface.
-
-    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
-    
-    For more information, see the original paper:
-    https://dl.acm.org/doi/10.14778/3551793.3551830
-
-    Parameters:
-        y_true (np.array):
-            Ground-truth binary labels (0 = normal, 1 = anomaly).
-        y_anomaly_scores (np.array):
-            Anomaly scores for each time point.
-        window (int):
-            Maximum temporal tolerance `l` used to smooth the evaluation.
-
-    Returns:
-        float: VUS-PR score.
-
-    
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-
-    m = VUS_PR(y_true,y_anomaly_scores,max_window=window)
-
-    return m.get_score()
-
-
-def real_pate(y_true: np.array, y_anomaly_scores: np.array, early: int, delay: int):
-    """
-    Calculate PATE score for anomaly detection in time series using real-valued anomaly scores.
-
-    This version of PATE evaluates real-valued anomaly scores by assigning weights to predictions 
-    based on their temporal proximity to the true anomaly intervals. It defines an early buffer of 
-    length `early` before each anomaly and a delay buffer of length `delay` after it. Detections with 
-    high scores within the anomaly interval receive full weight, while those in the buffer zones are 
-    assigned linearly decaying weights depending on their distance from the interval. Scores outside 
-    these zones contribute to false positives, and intervals with insufficient detection are penalized 
-    as false negatives.
-
-    The final PATE score aggregates these weighted contributions across all time steps, yielding 
-    a smooth performance measure that is sensitive to both the timing and confidence of the predictions.
-
-    Implementation of https://arxiv.org/abs/2405.12096
-    
-    For more information, see the original paper:
-    https://arxiv.org/abs/2405.12096
-
-    Parameters:
-        y_true (np.array):
-            Ground truth binary labels (0 = normal, 1 = anomaly).
-        y_anomaly_scores (np.array):
-            Real-valued anomaly scores for each time point.
-        early (int):
-            Length of the early buffer zone before each anomaly interval.
-        delay (int):
-            Length of the delay buffer zone after each anomaly interval.
-
-    Returns:
-        float: The real-valued PATE score.
-    """
-    validate_non_binary_inputs(y_true, y_anomaly_scores)
-
-    return PATE(y_true, y_anomaly_scores, early, delay, binary_scores=False)

tsadmetrics/scripts/compute_metrics.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-from tsadmetrics.utils import compute_metrics_from_file
-
-
-def main():
-    
-    parser = argparse.ArgumentParser(
-        description='Compute metrics from anomaly detection results and configuration files.'
-    )
-    
-    
-    parser.add_argument(
-        '--res_file', 
-        type=str, 
-        required=True,
-        help='Path to the results CSV file (e.g., results.csv)'
-    )
-    parser.add_argument(
-        '--conf_file', 
-        type=str, 
-        required=True,
-        help='Path to the configuration JSON file (e.g., conf.json)'
-    )
-    parser.add_argument(
-        '--output_dir', 
-        type=str, 
-        required=True,
-        help='Directory where output files will be saved (e.g., ./output_dir)'
-    )
-    
-    args = parser.parse_args()
-    
-    
-    compute_metrics_from_file(
-        results_file=args.res_file,
-        conf_file=args.conf_file,
-        output_dir=args.output_dir
-    )
-
-if __name__ == '__main__':
-    main()

tsadmetrics/utils.py

@@ -1,124 +0,0 @@
-import numpy as np
-import pandas as pd
-import time
-import sys
-import tsadmetrics
-def compute_metrics(y_true: np.array,y_pred: np.array, metrics: list, metrics_params: dict, is_anomaly_score = False, verbose = False):
-    """
-    Computes the specified metrics for the given true and predicted values.
-
-    Parameters:
-        y_true (np.array):
-            True labels.
-        y_pred (np.array):
-            Predicted labels or scores.
-        metrics (list):
-            List of metric names to compute.
-        metrics_params (dict):
-            Dictionary of parameters for each metric.
-        is_anomaly_score (bool):
-            Flag indicating if y_true and y_pred are anomaly scores. Otherwise, they are treated as binary labels.
-        verbose (bool):
-            Flag to print additional information.
-    Returns:
-        results (DataFrame): DataFrame containing the computed metrics and their values.
-    """
-    if not (np.array_equal(np.unique(y_true), [0, 1]) or np.array_equal(np.unique(y_true), [0]) or np.array_equal(np.unique(y_true), [1])):
-        raise ValueError("y_true must be binary labels (0 or 1).")  
-    if not is_anomaly_score:
-        #Chech if y_true and y_pred are binary labels
-        if not ( np.array_equal(np.unique(y_pred), [0, 1])):
-            raise ValueError("y_true and y_pred must be binary labels (0 or 1) when is_anomaly_score is False. Which is the default.")
-    else:
-        # Check if y_true and y_pred are anomaly scores
-        if not (np.all((y_pred >= 0) & (y_pred <= 1))):
-            raise ValueError("y_true must be binary labels (0 or 1), and y_pred must be anomaly scores in the range [0, 1] when is_anomaly_score is True.")
-    results = {}
-    
-    for metric in metrics:
-        metric_name = metric[0]
-        metric_func = metric[1]
-        if verbose:
-            print(f"Calculating metric: {metric_name}")
-            t0 = time.time()
-        metric_value = metric_func(y_true, y_pred, **metrics_params.get(metric_name, {}))
-        if verbose:
-            t1 = time.time()
-            print(f"Metric {metric_name} calculated in {t1 - t0:.4f} seconds")
-            print(f"Metric {metric_name} value: {metric_value}")
-        # Store the result in the DataFrame
-        results[metric_name] = metric_value
-
-    metrics_df = pd.DataFrame(columns=['metric_name', 'metric_value'])
-    metrics_df['metric_name'] = results.keys()
-    metrics_df['metric_value'] = results.values()
-    
-    return metrics_df
-
-
-def compute_metrics_from_file(results_file: str, conf_file: str, output_dir: str = '.'):
-    """
-    Computes metrics based on prediction results from a CSV file and configuration from a JSON file.
-
-    Parameters:
-        results_file (str):
-            Path to CSV file containing y_true and y_pred columns.
-        conf_file (str):
-            Path to JSON configuration file with metrics and parameters.
-
-    Returns:
-        pd.DataFrame: DataFrame with computed metrics.
-    """
-    # Read results data
-    res = pd.read_csv(results_file)
-    y_true = res['y_true'].values
-    y_pred = res['y_pred'].values
-    
-    # Determine if predictions are binary or scores
-    is_anomaly_score = False
-    unique_values = np.unique(y_pred)
-    if not (np.array_equal(unique_values, [0, 1]) or 
-            np.array_equal(unique_values, [0]) or 
-            np.array_equal(unique_values, [1])):
-        is_anomaly_score = True
-        if not np.all((y_pred >= 0) & (y_pred <= 1)):
-            raise ValueError("y_pred must be either binary (0/1) or anomaly scores in range [0, 1]")
-
-    # Read configuration from JSON using pandas
-    try:
-        config_df = pd.read_json(conf_file, orient='records')
-    except ValueError as e:
-        raise ValueError(f"Invalid JSON format in configuration file: {str(e)}")
-
-    # Convert pandas DataFrame to format expected by compute_metrics
-    metrics = []
-    metrics_params = {}
-    
-    for _, row in config_df.iterrows():
-        metric_name = row['name']
-        try:
-            metric_func = getattr(tsadmetrics, metric_name)
-        except AttributeError:
-            raise ValueError(f"Metric function '{metric_name}' not found in tsadmetrics module")
-        
-        metrics.append((metric_name, metric_func))
-        
-        # Handle params (convert from pandas Series to dict if needed)
-        params = row.get('params', {})
-        if pd.notna(params) and params:  # Check for non-empty params
-            if isinstance(params, pd.Series):
-                metrics_params[metric_name] = params.to_dict()
-            else:
-                metrics_params[metric_name] = params
-
-    # Compute metrics
-    metrics_df = compute_metrics(
-        y_true=y_true,
-        y_pred=y_pred,
-        metrics=metrics,
-        metrics_params=metrics_params,
-        is_anomaly_score=is_anomaly_score,
-        verbose=False
-    )
-    metrics_df.to_csv(output_dir+'/computed_metrics.csv', index=False)
-

tsadmetrics/validation.py

@@ -1,35 +0,0 @@
-import numpy as np
-
-def check_gt_binary_array(arr):
-    if len(arr.shape) != 1:
-        raise ValueError("Ground truth input must be a 1D binary array.")
-    if not np.all(np.isin(arr, [0, 1])):
-        raise ValueError("Ground truth input array must contain only binary values (0 or 1).")
-    return True
-
-def check_pred_binary_array(arr):
-    if len(arr.shape) != 1:
-        raise ValueError("Prediction input must be a 1D binary array.")
-    if not np.all(np.isin(arr, [0, 1])):
-        raise ValueError("Prediction input array must contain only binary values (0 or 1).")
-    return True
-def check_same_length(arr1, arr2):
-    if len(arr1) != len(arr2):
-        raise ValueError("Ground truth and prediction arrays must have the same length.")
-    return True
-
-def check_pred_continuous_array(arr):
-    if len(arr.shape) != 1:
-        raise ValueError("Prediction input must be a 1D continuous array.")
-    if not np.all((arr >= 0) & (arr <= 1)):
-        raise ValueError("All values in the array must be in the range [0, 1].")
-    return True
-
-def validate_binary_inputs(y_true, y_pred):
-    check_gt_binary_array(y_true)
-    check_pred_binary_array(y_pred)
-    check_same_length(y_true, y_pred)
-
-def validate_non_binary_inputs(y_true, y_anomaly_scores):
-    check_gt_binary_array(y_true)
-    check_same_length(y_true, y_anomaly_scores)