Initial commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

.gitignore

@@ -0,0 +1 @@
+models/granite_tsfm

HP_list.py

@@ -0,0 +1,283 @@
+Multi_algo_HP_dict = {
+    'IForest': {
+        'n_estimators': [25, 50, 100, 150, 200],
+        'max_features': [0.2, 0.4, 0.6, 0.8, 1.0]
+    },
+    'LOF': {
+        'n_neighbors': [10, 20, 30, 40, 50],
+        'metric': ['minkowski', 'manhattan', 'euclidean']
+    },    
+    'PCA': {
+        'n_components': [0.25, 0.5, 0.75, None]
+    },        
+    'HBOS': {
+        'n_bins': [5, 10, 20, 30, 40],
+        'tol': [0.1, 0.3, 0.5, 0.7]
+    },
+    'OCSVM': {
+        'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],
+        'nu': [0.1, 0.3, 0.5, 0.7]
+    },        
+    'MCD': {
+        'support_fraction': [0.2, 0.4, 0.6, 0.8, None]
+    },
+    'KNN': {
+        'n_neighbors': [10, 20, 30, 40, 50],
+        'method': ['largest', 'mean', 'median']
+    },        
+    'KMeansAD': {
+        'n_clusters': [10, 20, 30, 40],
+        'window_size': [10, 20, 30, 40]
+    },
+    'COPOD': {
+        'HP': [None]
+    },    
+    'CBLOF': {
+        'n_clusters': [4, 8, 16, 32],
+        'alpha': [0.6, 0.7, 0.8, 0.9]
+    },
+    'EIF': {
+        'n_trees': [25, 50, 100, 200]
+    },   
+    'RobustPCA': {
+        'max_iter': [500, 1000, 1500]
+    },
+    'AutoEncoder': {
+        'hidden_neurons': [[64, 32], [32, 16], [128, 64]]
+    },
+    'CNN': {
+        'window_size': [50, 100, 150],
+        'num_channel': [[32, 32, 40], [16, 32, 64]]
+    },
+    'LSTMAD': {
+        'window_size': [50, 100, 150],
+        'lr': [0.0004, 0.0008]
+    },  
+    'TranAD': {
+        'win_size': [5, 10, 50],
+        'lr': [1e-3, 1e-4]
+    },  
+    'AnomalyTransformer': {
+        'win_size': [50, 100, 150],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },  
+    'OmniAnomaly': {
+        'win_size': [5, 50, 100],
+        'lr': [0.002, 0.0002]
+    },
+    'USAD': {
+        'win_size': [5, 50, 100],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },  
+    'Donut': {
+        'win_size': [60, 90, 120],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },  
+    'TimesNet': {
+        'win_size': [32, 96, 192],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },
+    'FITS': {
+        'win_size': [100, 200],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },    
+    'OFA': {
+        'win_size': [50, 100, 150]
+    },
+    'Time_RCD': {
+        'win_size': 7000
+    },
+    'TSPulse': {
+        'win_size': [64, 128, 256],
+        'batch_size': [32, 64, 128],
+        'aggregation_length': [32, 64, 128],
+        'aggr_function': ['max', 'mean'],
+        'smoothing_length': [4, 8, 16]
+    }
+}
+
+
+Optimal_Multi_algo_HP_dict = {
+    'IForest': {'n_estimators': 25, 'max_features': 0.8},
+    'LOF': {'n_neighbors': 50, 'metric': 'euclidean'},    
+    'PCA': {'n_components': 0.25},        
+    'HBOS': {'n_bins': 30, 'tol': 0.5},
+    'OCSVM': {'kernel': 'rbf', 'nu': 0.1},        
+    'MCD': {'support_fraction': 0.8},
+    'KNN': {'n_neighbors': 50, 'method': 'mean'},        
+    'KMeansAD': {'n_clusters': 10, 'window_size': 40},
+    'KShapeAD': {'n_clusters': 20, 'window_size': 40},
+    'COPOD': {'n_jobs':1},    
+    'CBLOF': {'n_clusters': 4, 'alpha': 0.6},
+    'EIF': {'n_trees': 50},   
+    'RobustPCA': {'max_iter': 1000},
+    'AutoEncoder': {'hidden_neurons': [128, 64]},
+    'CNN': {'window_size': 50, 'num_channel': [32, 32, 40]},
+    'LSTMAD': {'window_size': 150, 'lr': 0.0008},  
+    'TranAD': {'win_size': 10, 'lr': 0.001},  
+    'AnomalyTransformer': {'win_size': 50, 'lr': 0.001},  
+    'OmniAnomaly': {'win_size': 100, 'lr': 0.002},
+    'USAD': {'win_size': 100, 'lr': 0.001},  
+    'Donut': {'win_size': 60, 'lr': 0.001},  
+    'TimesNet': {'win_size': 96, 'lr': 0.0001},
+    'FITS': {'win_size': 100, 'lr': 0.001},
+    'OFA': {'win_size': 50},
+    'Time_RCD': {'win_size':5000, 'batch_size': 1},
+    'DADA': {'win_size': 100, 'batch_size': 64},
+    'TSPulse': {'win_size': 96 , 'batch_size': 64, 'aggregation_length': 64, 'aggr_function': 'max', 'smoothing_length': 8}
+}
+
+
+Uni_algo_HP_dict = {
+    'Sub_IForest': {
+        'periodicity': [1, 2, 3],
+        'n_estimators': [25, 50, 100, 150, 200]
+    },
+    'IForest': {
+        'n_estimators': [25, 50, 100, 150, 200]
+    },
+    'Sub_LOF': {
+        'periodicity': [1, 2, 3],
+        'n_neighbors': [10, 20, 30, 40, 50]
+    }, 
+    'LOF': {
+        'n_neighbors': [10, 20, 30, 40, 50]
+    }, 
+    'POLY': {
+        'periodicity': [1, 2, 3],
+        'power': [1, 2, 3, 4]
+    },
+    'MatrixProfile': {
+        'periodicity': [1, 2, 3]
+    },
+    'NORMA': {
+        'periodicity': [1, 2, 3],
+        'clustering': ['hierarchical', 'kshape']
+    },
+    'SAND': {
+        'periodicity': [1, 2, 3]
+    }, 
+    'Series2Graph': {
+        'periodicity': [1, 2, 3]
+    },
+    'Sub_PCA': {
+        'periodicity': [1, 2, 3],
+        'n_components': [0.25, 0.5, 0.75, None]
+    },
+    'Sub_HBOS': {
+        'periodicity': [1, 2, 3],
+        'n_bins': [5, 10, 20, 30, 40]
+    },
+    'Sub_OCSVM': {
+        'periodicity': [1, 2, 3],
+        'kernel': ['linear', 'poly', 'rbf', 'sigmoid']
+    },
+    'Sub_MCD': {
+        'periodicity': [1, 2, 3],
+        'support_fraction': [0.2, 0.4, 0.6, 0.8, None]
+    },
+    'Sub_KNN': {
+        'periodicity': [1, 2, 3],
+        'n_neighbors': [10, 20, 30, 40, 50],
+    },
+    'KMeansAD_U': {
+        'periodicity': [1, 2, 3],
+        'n_clusters': [10, 20, 30, 40],
+    },
+    'KShapeAD': {
+        'periodicity': [1, 2, 3]
+    },
+    'AutoEncoder': {
+        'window_size': [50, 100, 150],
+        'hidden_neurons': [[64, 32], [32, 16], [128, 64]]
+    },
+    'CNN': {
+        'window_size': [50, 100, 150],
+        'num_channel': [[32, 32, 40], [16, 32, 64]]
+    },
+    'LSTMAD': {
+        'window_size': [50, 100, 150],
+        'lr': [0.0004, 0.0008]
+    },  
+    'TranAD': {
+        'win_size': [5, 10, 50],
+        'lr': [1e-3, 1e-4]
+    },
+    'AnomalyTransformer': {
+        'win_size': [50, 100, 150],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },  
+    'OmniAnomaly': {
+        'win_size': [5, 50, 100],
+        'lr': [0.002, 0.0002]
+    },
+    'USAD': {
+        'win_size': [5, 50, 100],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },  
+    'Donut': {
+        'win_size': [60, 90, 120],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },  
+    'TimesNet': {
+        'win_size': [32, 96, 192],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },
+    'FITS': {
+        'win_size': [100, 200],
+        'lr': [1e-3, 1e-4, 1e-5]
+    },
+    'OFA': {
+        'win_size': [50, 100, 150]
+    },    
+    # 'Time_RCD': {
+        # 'win_size': [1000, 2000, 3000, 4000, 5000, 6000, 8000, 10000],
+        # 'batch_size': [32, 64, 128]
+    # }
+}
+
+Optimal_Uni_algo_HP_dict = {
+    'Sub_IForest': {'periodicity': 1, 'n_estimators': 150},
+    'IForest': {'n_estimators': 200},
+    'Sub_LOF': {'periodicity': 2, 'n_neighbors': 30},
+    'LOF': {'n_neighbors': 50},
+    'POLY': {'periodicity': 1, 'power': 4},
+    'MatrixProfile': {'periodicity': 1},
+    'NORMA': {'periodicity': 1, 'clustering': 'kshape'},
+    'SAND': {'periodicity': 1},
+    'Series2Graph': {'periodicity': 1},
+    'SR': {'periodicity': 1},
+    'Sub_PCA': {'periodicity': 1, 'n_components': None},
+    'Sub_HBOS': {'periodicity': 1, 'n_bins': 10},
+    'Sub_OCSVM': {'periodicity': 2, 'kernel': 'rbf'},        
+    'Sub_MCD': {'periodicity': 3, 'support_fraction': None},
+    'Sub_KNN': {'periodicity': 2, 'n_neighbors': 50}, 
+    'KMeansAD_U': {'periodicity': 2, 'n_clusters': 10},
+    'KShapeAD': {'periodicity': 1},
+    'FFT': {},
+    'Left_STAMPi': {},
+    'AutoEncoder': {'window_size': 100, 'hidden_neurons': [128, 64]},
+    'CNN': {'window_size': 50, 'num_channel': [32, 32, 40]},
+    'LSTMAD': {'window_size': 100, 'lr': 0.0008},  
+    'TranAD': {'win_size': 10, 'lr': 0.0001},
+    'AnomalyTransformer': {'win_size': 50, 'lr': 0.001},  
+    'OmniAnomaly': {'win_size': 5, 'lr': 0.002},
+    'USAD': {'win_size': 100, 'lr': 0.001},
+    'Donut': {'win_size': 60, 'lr': 0.0001},  
+    'TimesNet': {'win_size': 32, 'lr': 0.0001},
+    'FITS': {'win_size': 100, 'lr': 0.0001},
+    'OFA': {'win_size': 50},
+    'Lag_Llama': {'win_size': 96},
+    'Chronos': {'win_size': 100},
+    'TimesFM': {'win_size': 96},
+    'MOMENT_ZS': {'win_size': 64},
+    'MOMENT_FT': {'win_size': 64},
+    'M2N2': {},
+    'DADA': {'win_size': 100},
+    'Time_MOE': {'win_size':96},
+    'Time_RCD': {'win_size':5000, 'batch_size': 64},
+    'Time_RCD_Reconstruction': {'win_size':5000, 'batch_size': 128},
+    'Time_RCD_Reconstruction_Anomaly_Head': {'win_size':5000, 'batch_size': 128},
+    'Time_RCD_Reconstruction_Random_Mask_Anomaly_Head': {'win_size':5000, 'batch_size': 128},
+    'TSPulse': {'win_size':96, 'batch_size': 64, 'aggregation_length': 64, 'aggr_function': 'max', 'smoothing_length': 8}
+}

README.md

@@ -0,0 +1,13 @@
+---
+title: Time RCD
+emoji: 🐠
+colorFrom: purple
+colorTo: blue
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,237 @@
+import io
+import zipfile
+from pathlib import Path
+from typing import List, Tuple
+
+import gradio as gr
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from huggingface_hub import HfHubHTTPError, hf_hub_download
+
+from model_wrapper import run_Time_RCD
+
+REPO_ID = "thu-sail-lab/Time-RCD"
+
+CHECKPOINT_FILES = [
+    "checkpoints/full_mask_anomaly_head_pretrain_checkpoint_best.pth",
+    "checkpoints/dataset_10_20.pth",
+    "checkpoints/full_mask_10_20.pth",
+    "checkpoints/dataset_15_56.pth",
+    "checkpoints/full_mask_15_56.pth",
+]
+
+
+def ensure_checkpoints() -> None:
+    """Ensure that the required checkpoint files are present locally."""
+    missing = [path for path in CHECKPOINT_FILES if not Path(path).exists()]
+    if not missing:
+        return
+
+    try:
+        zip_path = hf_hub_download(
+            repo_id=REPO_ID,
+            filename="checkpoints.zip",
+            repo_type="model",
+            cache_dir=".cache/hf",
+        )
+    except HfHubHTTPError:
+        zip_path = hf_hub_download(
+            repo_id=REPO_ID,
+            filename="checkpoints.zip",
+            repo_type="dataset",
+            cache_dir=".cache/hf",
+        )
+
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        zf.extractall(".")
+
+
+def load_timeseries(file_obj, feature_columns: List[str] | None = None) -> Tuple[pd.DataFrame, np.ndarray]:
+    """Load the uploaded file into a numeric dataframe and numpy array."""
+    path = Path(file_obj.name)
+    if path.suffix.lower() == ".npy":
+        data = np.load(path, allow_pickle=False)
+        if data.ndim == 1:
+            data = data.reshape(-1, 1)
+        if not isinstance(data, np.ndarray):
+            raise ValueError("Loaded data is not a numpy array.")
+        df = pd.DataFrame(data)
+        return df, data.astype(np.float32)
+
+    if path.suffix.lower() not in {".csv", ".txt"}:
+        raise ValueError("Unsupported file type. Please upload a .csv, .txt, or .npy file.")
+
+    df = pd.read_csv(path)
+    numeric_df = df.select_dtypes(include=np.number)
+    if numeric_df.empty:
+        raise ValueError("No numeric columns detected. Ensure your file contains numeric values.")
+
+    if feature_columns:
+        missing = [col for col in feature_columns if col not in numeric_df.columns]
+        if missing:
+            raise ValueError(f"Selected columns not found in the file: {', '.join(missing)}")
+        numeric_df = numeric_df[feature_columns]
+
+    array = numeric_df.to_numpy(dtype=np.float32)
+    if array.ndim == 1:
+        array = array.reshape(-1, 1)
+
+    return numeric_df, array
+
+
+def infer(
+    file_obj,
+    is_multivariate: bool,
+    window_size: int,
+    batch_size: int,
+    mask_type: str,
+    multi_size: str,
+    feature_columns: List[str],
+) -> Tuple[str, pd.DataFrame, plt.Figure]:
+    """Run Time-RCD inference and produce outputs for the Gradio UI."""
+    ensure_checkpoints()
+    numeric_df, array = load_timeseries(file_obj, feature_columns or None)
+
+    kwargs = {
+        "Multi": is_multivariate,
+        "win_size": window_size,
+        "batch_size": batch_size,
+        "random_mask": mask_type,
+        "size": multi_size,
+        "device": "cpu",
+    }
+
+    scores, logits = run_Time_RCD(array, **kwargs)
+    score_vector = np.asarray(scores).reshape(-1)
+    logit_vector = np.asarray(logits).reshape(-1)
+
+    valid_length = min(len(score_vector), len(numeric_df))
+    score_series = pd.Series(score_vector[:valid_length], index=numeric_df.index[:valid_length], name="anomaly_score")
+    logit_series = pd.Series(logit_vector[:valid_length], index=numeric_df.index[:valid_length], name="anomaly_logit")
+
+    result_df = numeric_df.iloc[:valid_length, :].copy()
+    result_df["anomaly_score"] = score_series
+    result_df["anomaly_logit"] = logit_series
+
+    top_indices = score_series.nlargest(5).index.tolist()
+    highlight_message = (
+        "Top anomaly indices (by score): " + ", ".join(str(idx) for idx in top_indices)
+        if len(top_indices) > 0
+        else "No anomalies detected."
+    )
+
+    figure = build_plot(result_df)
+
+    return highlight_message, result_df, figure
+
+
+def build_plot(result_df: pd.DataFrame) -> plt.Figure:
+    """Create a matplotlib plot of the first feature vs. anomaly score."""
+    fig, ax_primary = plt.subplots(figsize=(10, 4))
+    index = result_df.index
+    feature_cols = [col for col in result_df.columns if col not in {"anomaly_score", "anomaly_logit"}]
+
+    primary_col = feature_cols[0]
+    ax_primary.plot(index, result_df[primary_col], label=f"{primary_col}", color="#1f77b4", linewidth=1.0)
+    ax_primary.set_xlabel("Index")
+    ax_primary.set_ylabel("Value")
+    ax_primary.grid(alpha=0.2)
+
+    ax_secondary = ax_primary.twinx()
+    ax_secondary.plot(index, result_df["anomaly_score"], label="Anomaly Score", color="#d62728", linewidth=1.0)
+    ax_secondary.set_ylabel("Anomaly Score")
+
+    fig.tight_layout()
+    return fig
+
+
+def build_interface() -> gr.Blocks:
+    """Define the Gradio UI."""
+    with gr.Blocks(title="Time-RCD Zero-Shot Anomaly Detection") as demo:
+        gr.Markdown(
+            "# Time-RCD Zero-Shot Anomaly Detection\n"
+            "Upload a time series to run zero-shot anomaly detection with the pretrained Time-RCD checkpoints. "
+            "You can choose univariate or multivariate mode, adjust the window size, and configure mask settings."
+        )
+
+        with gr.Row():
+            file_input = gr.File(label="Upload time series file (.csv, .txt, .npy)", file_types=[".csv", ".txt", ".npy"])
+            column_selector = gr.Textbox(
+                label="Columns to use (comma-separated, optional)",
+                placeholder="e.g. value,feature_1,feature_2",
+            )
+
+        with gr.Row():
+            multivariate = gr.Radio(
+                choices=["Univariate", "Multivariate"],
+                value="Univariate",
+                label="Data type",
+            )
+            window_size_in = gr.Slider(
+                minimum=128,
+                maximum=8192,
+                value=2048,
+                step=128,
+                label="Window size",
+            )
+            batch_size_in = gr.Slider(
+                minimum=1,
+                maximum=128,
+                value=16,
+                step=1,
+                label="Batch size",
+            )
+
+        with gr.Row():
+            mask_type_in = gr.Radio(
+                choices=["random_mask", "full_mask"],
+                value="random_mask",
+                label="Mask type (multivariate only)",
+            )
+            multi_size_in = gr.Radio(
+                choices=["full", "small"],
+                value="full",
+                label="Multivariate model size",
+            )
+
+        run_button = gr.Button("Run Inference", variant="primary")
+
+        result_message = gr.Textbox(label="Summary", interactive=False)
+        result_dataframe = gr.DataFrame(label="Anomaly Scores", interactive=False)
+        plot_output = gr.Plot(label="Series vs. Anomaly Score")
+
+        def _submit(file_obj, multivariate_choice, win, batch, mask, size, columns_text):
+            if file_obj is None:
+                raise gr.Error("Please upload a time series file.")
+
+            feature_columns = [col.strip() for col in columns_text.split(",") if col.strip()] if columns_text else []
+            is_multi = multivariate_choice == "Multivariate"
+            summary, df, fig = infer(
+                file_obj=file_obj,
+                is_multivariate=is_multi,
+                window_size=int(win),
+                batch_size=int(batch),
+                mask_type=mask,
+                multi_size=size,
+                feature_columns=feature_columns,
+            )
+            return summary, df, fig
+
+        run_button.click(
+            fn=_submit,
+            inputs=[file_input, multivariate, window_size_in, batch_size_in, mask_type_in, multi_size_in, column_selector],
+            outputs=[result_message, result_dataframe, plot_output],
+        )
+
+    return demo
+
+
+demo = build_interface()
+
+if __name__ == "__main__":
+    demo.launch()
+

evaluation/__init__.py

@@ -0,0 +1 @@
+

evaluation/affiliation/__init__.py

@@ -0,0 +1 @@
+

evaluation/affiliation/_affiliation_zone.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from ._integral_interval import interval_intersection
+
+def t_start(j, Js = [(1,2),(3,4),(5,6)], Trange = (1,10)):
+    """
+    Helper for `E_gt_func`
+    
+    :param j: index from 0 to len(Js) (included) on which to get the start
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included
+    :return: generalized start such that the middle of t_start and t_stop 
+    always gives the affiliation zone
+    """
+    b = max(Trange)
+    n = len(Js)
+    if j == n:
+        return(2*b - t_stop(n-1, Js, Trange))
+    else:
+        return(Js[j][0])
+
+def t_stop(j, Js = [(1,2),(3,4),(5,6)], Trange = (1,10)):
+    """
+    Helper for `E_gt_func`
+    
+    :param j: index from 0 to len(Js) (included) on which to get the stop
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included
+    :return: generalized stop such that the middle of t_start and t_stop 
+    always gives the affiliation zone
+    """
+    if j == -1:
+        a = min(Trange)
+        return(2*a - t_start(0, Js, Trange))
+    else:
+        return(Js[j][1])
+
+def E_gt_func(j, Js, Trange):
+    """
+    Get the affiliation zone of element j of the ground truth
+    
+    :param j: index from 0 to len(Js) (excluded) on which to get the zone
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included, can 
+    be (-math.inf, math.inf) for distance measures
+    :return: affiliation zone of element j of the ground truth represented
+    as a couple
+    """
+    range_left = (t_stop(j-1, Js, Trange) + t_start(j, Js, Trange))/2
+    range_right = (t_stop(j, Js, Trange) + t_start(j+1, Js, Trange))/2
+    return((range_left, range_right))
+
+def get_all_E_gt_func(Js, Trange):
+    """
+    Get the affiliation partition from the ground truth point of view
+    
+    :param Js: ground truth events, as a list of couples
+    :param Trange: range of the series where Js is included, can 
+    be (-math.inf, math.inf) for distance measures
+    :return: affiliation partition of the events
+    """
+    # E_gt is the limit of affiliation/attraction for each ground truth event
+    E_gt = [E_gt_func(j, Js, Trange) for j in range(len(Js))]
+    return(E_gt)
+
+def affiliation_partition(Is = [(1,1.5),(2,5),(5,6),(8,9)], E_gt = [(1,2.5),(2.5,4.5),(4.5,10)]):
+    """
+    Cut the events into the affiliation zones
+    The presentation given here is from the ground truth point of view,
+    but it is also used in the reversed direction in the main function.
+    
+    :param Is: events as a list of couples
+    :param E_gt: range of the affiliation zones
+    :return: a list of list of intervals (each interval represented by either 
+    a couple or None for empty interval). The outer list is indexed by each
+    affiliation zone of `E_gt`. The inner list is indexed by the events of `Is`.
+    """
+    out = [None] * len(E_gt)
+    for j in range(len(E_gt)):
+        E_gt_j = E_gt[j]
+        discarded_idx_before = [I[1] < E_gt_j[0] for I in Is]  # end point of predicted I is before the begin of E
+        discarded_idx_after = [I[0] > E_gt_j[1] for I in Is] # start of predicted I is after the end of E
+        kept_index = [not(a or b) for a, b in zip(discarded_idx_before, discarded_idx_after)]
+        Is_j = [x for x, y in zip(Is, kept_index)]
+        out[j] = [interval_intersection(I, E_gt[j]) for I in Is_j]
+    return(out)

evaluation/affiliation/_integral_interval.py

@@ -0,0 +1,464 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import math
+from .generics import _sum_wo_nan
+"""
+In order to shorten the length of the variables,
+the general convention in this file is to let:
+    - I for a predicted event (start, stop),
+    - Is for a list of predicted events,
+    - J for a ground truth event,
+    - Js for a list of ground truth events.
+"""
+
+def interval_length(J = (1,2)):
+    """
+    Length of an interval
+    
+    :param J: couple representating the start and stop of an interval, or None
+    :return: length of the interval, and 0 for a None interval
+    """
+    if J is None:
+        return(0)
+    return(J[1] - J[0])
+
+def sum_interval_lengths(Is = [(1,2),(3,4),(5,6)]):
+    """
+    Sum of length of the intervals
+    
+    :param Is: list of intervals represented by starts and stops
+    :return: sum of the interval length
+    """
+    return(sum([interval_length(I) for I in Is]))
+
+def interval_intersection(I = (1, 3), J = (2, 4)): 
+    """
+    Intersection between two intervals I and J
+    I and J should be either empty or represent a positive interval (no point)
+    
+    :param I: an interval represented by start and stop
+    :param J: a second interval of the same form
+    :return: an interval representing the start and stop of the intersection (or None if empty)
+    """
+    if I is None:
+        return(None)
+    if J is None:
+        return(None)
+        
+    I_inter_J = (max(I[0], J[0]), min(I[1], J[1]))
+    if I_inter_J[0] >= I_inter_J[1]:
+        return(None)
+    else:
+        return(I_inter_J)
+
+def interval_subset(I = (1, 3), J = (0, 6)):
+    """
+    Checks whether I is a subset of J
+    
+    :param I: an non empty interval represented by start and stop
+    :param J: a second non empty interval of the same form
+    :return: True if I is a subset of J
+    """
+    if (I[0] >= J[0]) and (I[1] <= J[1]):
+        return True
+    else:
+        return False
+
+def cut_into_three_func(I, J):
+    """
+    Cut an interval I into a partition of 3 subsets:
+        the elements before J,
+        the elements belonging to J,
+        and the elements after J
+    
+    :param I: an interval represented by start and stop, or None for an empty one
+    :param J: a non empty interval
+    :return: a triplet of three intervals, each represented by either (start, stop) or None
+    """
+    if I is None:
+        return((None, None, None))
+    
+    I_inter_J = interval_intersection(I, J)
+    if I == I_inter_J:
+        I_before = None
+        I_after = None
+    elif I[1] <= J[0]:
+        I_before = I
+        I_after = None
+    elif I[0] >= J[1]:
+        I_before = None
+        I_after = I
+    elif (I[0] <= J[0]) and (I[1] >= J[1]):
+        I_before = (I[0], I_inter_J[0])
+        I_after = (I_inter_J[1], I[1])
+    elif I[0] <= J[0]:
+        I_before = (I[0], I_inter_J[0])
+        I_after = None
+    elif I[1] >= J[1]:
+        I_before = None
+        I_after = (I_inter_J[1], I[1])
+    else:
+        raise ValueError('unexpected unconsidered case')
+    return(I_before, I_inter_J, I_after)
+  
+def get_pivot_j(I, J):
+    """
+    Get the single point of J that is the closest to I, called 'pivot' here,
+    with the requirement that I should be outside J
+    
+    :param I: a non empty interval (start, stop)
+    :param J: another non empty interval, with empty intersection with I
+    :return: the element j of J that is the closest to I
+    """
+    if interval_intersection(I, J) is not None:
+        raise ValueError('I and J should have a void intersection')
+
+    j_pivot = None # j_pivot is a border of J
+    if max(I) <= min(J):
+        j_pivot = min(J)
+    elif min(I) >= max(J):
+        j_pivot = max(J)
+    else:
+        raise ValueError('I should be outside J')
+    return(j_pivot)
+
+def integral_mini_interval(I, J):
+    """
+    In the specific case where interval I is located outside J,
+    integral of distance from x to J over the interval x \in I.
+    This is the *integral* i.e. the sum.
+    It's not the mean (not divided by the length of I yet)
+    
+    :param I: a interval (start, stop), or None
+    :param J: a non empty interval, with empty intersection with I
+    :return: the integral of distances d(x, J) over x \in I
+    """
+    if I is None:
+        return(0)
+
+    j_pivot = get_pivot_j(I, J)
+    a = min(I)
+    b = max(I)
+    return((b-a)*abs((j_pivot - (a+b)/2)))
+
+def integral_interval_distance(I, J):
+    """
+    For any non empty intervals I, J, compute the
+    integral of distance from x to J over the interval x \in I.
+    This is the *integral* i.e. the sum. 
+    It's not the mean (not divided by the length of I yet)
+    The interval I can intersect J or not
+    
+    :param I: a interval (start, stop), or None
+    :param J: a non empty interval
+    :return: the integral of distances d(x, J) over x \in I
+    """
+    # I and J are single intervals (not generic sets)
+    # I is a predicted interval in the range of affiliation of J
+    
+    def f(I_cut):
+        return(integral_mini_interval(I_cut, J))
+    # If I_middle is fully included into J, it is
+    # the distance to J is always 0
+    def f0(I_middle):
+        return(0)
+
+    cut_into_three = cut_into_three_func(I, J)
+    # Distance for now, not the mean:
+    # Distance left: Between cut_into_three[0] and the point min(J)
+    d_left = f(cut_into_three[0])
+    # Distance middle: Between cut_into_three[1] = I inter J, and J
+    d_middle = f0(cut_into_three[1])
+    # Distance right: Between cut_into_three[2] and the point max(J)
+    d_right = f(cut_into_three[2])
+    # It's an integral so summable
+    return(d_left + d_middle + d_right)
+
+def integral_mini_interval_P_CDFmethod__min_piece(I, J, E):
+    """
+    Helper of `integral_mini_interval_Pprecision_CDFmethod`
+    In the specific case where interval I is located outside J,
+    compute the integral $\int_{d_min}^{d_max} \min(m, x) dx$, with:
+    - m the smallest distance from J to E,
+    - d_min the smallest distance d(x, J) from x \in I to J
+    - d_max the largest distance d(x, J) from x \in I to J
+    
+    :param I: a single predicted interval, a non empty interval (start, stop)
+    :param J: ground truth interval, a non empty interval, with empty intersection with I
+    :param E: the affiliation/influence zone for J, represented as a couple (start, stop)
+    :return: the integral $\int_{d_min}^{d_max} \min(m, x) dx$
+    """
+    if interval_intersection(I, J) is not None:
+        raise ValueError('I and J should have a void intersection')
+    if not interval_subset(J, E):
+        raise ValueError('J should be included in E')
+    if not interval_subset(I, E):
+        raise ValueError('I should be included in E')
+
+    e_min = min(E)
+    j_min = min(J)
+    j_max = max(J)
+    e_max = max(E)
+    i_min = min(I)
+    i_max = max(I)
+  
+    d_min = max(i_min - j_max, j_min - i_max)
+    d_max = max(i_max - j_max, j_min - i_min)
+    m = min(j_min - e_min, e_max - j_max)
+    A = min(d_max, m)**2 - min(d_min, m)**2
+    B = max(d_max, m) - max(d_min, m)
+    C = (1/2)*A + m*B
+    return(C)
+
+def integral_mini_interval_Pprecision_CDFmethod(I, J, E):
+    """
+    Integral of the probability of distances over the interval I.
+    In the specific case where interval I is located outside J,
+    compute the integral $\int_{x \in I} Fbar(dist(x,J)) dx$.
+    This is the *integral* i.e. the sum (not the mean)
+    
+    :param I: a single predicted interval, a non empty interval (start, stop)
+    :param J: ground truth interval, a non empty interval, with empty intersection with I
+    :param E: the affiliation/influence zone for J, represented as a couple (start, stop)
+    :return: the integral $\int_{x \in I} Fbar(dist(x,J)) dx$
+    """
+    integral_min_piece = integral_mini_interval_P_CDFmethod__min_piece(I, J, E)
+  
+    e_min = min(E)
+    j_min = min(J)
+    j_max = max(J)
+    e_max = max(E)
+    i_min = min(I)
+    i_max = max(I)
+    d_min = max(i_min - j_max, j_min - i_max)
+    d_max = max(i_max - j_max, j_min - i_min)
+    integral_linear_piece = (1/2)*(d_max**2 - d_min**2)
+    integral_remaining_piece = (j_max - j_min)*(i_max - i_min)
+    
+    DeltaI = i_max - i_min
+    DeltaE = e_max - e_min
+    
+    output = DeltaI - (1/DeltaE)*(integral_min_piece + integral_linear_piece + integral_remaining_piece)
+    return(output)
+
+def integral_interval_probaCDF_precision(I, J, E):
+    """
+    Integral of the probability of distances over the interval I.
+    Compute the integral $\int_{x \in I} Fbar(dist(x,J)) dx$.
+    This is the *integral* i.e. the sum (not the mean)
+    
+    :param I: a single (non empty) predicted interval in the zone of affiliation of J
+    :param J: ground truth interval
+    :param E: affiliation/influence zone for J
+    :return: the integral $\int_{x \in I} Fbar(dist(x,J)) dx$
+    """
+    # I and J are single intervals (not generic sets)
+    def f(I_cut):
+        if I_cut is None:
+            return(0)
+        else:
+            return(integral_mini_interval_Pprecision_CDFmethod(I_cut, J, E))
+            
+    # If I_middle is fully included into J, it is
+    # integral of 1 on the interval I_middle, so it's |I_middle|
+    def f0(I_middle):
+        if I_middle is None:
+            return(0)
+        else:
+            return(max(I_middle) - min(I_middle))
+    
+    cut_into_three = cut_into_three_func(I, J)
+    # Distance for now, not the mean:
+    # Distance left: Between cut_into_three[0] and the point min(J)
+    d_left = f(cut_into_three[0])
+    # Distance middle: Between cut_into_three[1] = I inter J, and J
+    d_middle = f0(cut_into_three[1])
+    # Distance right: Between cut_into_three[2] and the point max(J)
+    d_right = f(cut_into_three[2])
+    # It's an integral so summable
+    return(d_left + d_middle + d_right)
+
+def cut_J_based_on_mean_func(J, e_mean):
+    """
+    Helper function for the recall.
+    Partition J into two intervals: before and after e_mean
+    (e_mean represents the center element of E the zone of affiliation)
+    
+    :param J: ground truth interval
+    :param e_mean: a float number (center value of E)
+    :return: a couple partitionning J into (J_before, J_after)
+    """
+    if J is None:
+        J_before = None
+        J_after = None
+    elif e_mean >= max(J):
+        J_before = J
+        J_after = None
+    elif e_mean <= min(J):
+        J_before = None
+        J_after = J
+    else: # e_mean is across J
+        J_before = (min(J), e_mean)
+        J_after = (e_mean, max(J))
+        
+    return((J_before, J_after))
+
+def integral_mini_interval_Precall_CDFmethod(I, J, E):
+    """
+    Integral of the probability of distances over the interval J.
+    In the specific case where interval J is located outside I,
+    compute the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$.
+    This is the *integral* i.e. the sum (not the mean)
+    
+    :param I: a single (non empty) predicted interval
+    :param J: ground truth (non empty) interval, with empty intersection with I
+    :param E: the affiliation/influence zone for J, represented as a couple (start, stop)
+    :return: the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$
+    """
+    # The interval J should be located outside I 
+    # (so it's either the left piece or the right piece w.r.t I)
+    i_pivot = get_pivot_j(J, I)
+    e_min = min(E)
+    e_max = max(E)
+    e_mean = (e_min + e_max) / 2
+    
+    # If i_pivot is outside E (it's possible), then
+    # the distance is worst that any random element within E,
+    # so we set the recall to 0
+    if i_pivot <= min(E):
+        return(0)
+    elif i_pivot >= max(E):
+        return(0)
+    # Otherwise, we have at least i_pivot in E and so d < M so min(d,M)=d
+    
+    cut_J_based_on_e_mean = cut_J_based_on_mean_func(J, e_mean)
+    J_before = cut_J_based_on_e_mean[0]
+    J_after = cut_J_based_on_e_mean[1]
+  
+    iemin_mean = (e_min + i_pivot)/2
+    cut_Jbefore_based_on_iemin_mean = cut_J_based_on_mean_func(J_before, iemin_mean)
+    J_before_closeE = cut_Jbefore_based_on_iemin_mean[0] # before e_mean and closer to e_min than i_pivot ~ J_before_before
+    J_before_closeI = cut_Jbefore_based_on_iemin_mean[1] # before e_mean and closer to i_pivot than e_min ~ J_before_after
+    
+    iemax_mean = (e_max + i_pivot)/2
+    cut_Jafter_based_on_iemax_mean = cut_J_based_on_mean_func(J_after, iemax_mean)
+    J_after_closeI = cut_Jafter_based_on_iemax_mean[0] # after e_mean and closer to i_pivot than e_max ~ J_after_before
+    J_after_closeE = cut_Jafter_based_on_iemax_mean[1] # after e_mean and closer to e_max than i_pivot ~ J_after_after
+    
+    if J_before_closeE is not None:
+        j_before_before_min = min(J_before_closeE) # == min(J)
+        j_before_before_max = max(J_before_closeE)
+    else:
+        j_before_before_min = math.nan
+        j_before_before_max = math.nan
+  
+    if J_before_closeI is not None:
+        j_before_after_min = min(J_before_closeI) # == j_before_before_max if existing
+        j_before_after_max = max(J_before_closeI) # == max(J_before)
+    else:
+        j_before_after_min = math.nan
+        j_before_after_max = math.nan
+   
+    if J_after_closeI is not None:
+        j_after_before_min = min(J_after_closeI) # == min(J_after)
+        j_after_before_max = max(J_after_closeI) 
+    else:
+        j_after_before_min = math.nan
+        j_after_before_max = math.nan
+    
+    if J_after_closeE is not None:
+        j_after_after_min = min(J_after_closeE) # == j_after_before_max if existing
+        j_after_after_max = max(J_after_closeE) # == max(J)
+    else:
+        j_after_after_min = math.nan
+        j_after_after_max = math.nan
+  
+    # <-- J_before_closeE --> <-- J_before_closeI --> <-- J_after_closeI --> <-- J_after_closeE -->
+    # j_bb_min       j_bb_max j_ba_min       j_ba_max j_ab_min      j_ab_max j_aa_min      j_aa_max
+    # (with `b` for before and `a` for after in the previous variable names)
+    
+    #                                          vs e_mean  m = min(t-e_min, e_max-t)  d=|i_pivot-t|   min(d,m)                            \int min(d,m)dt   \int d dt        \int_(min(d,m)+d)dt                                    \int_{t \in J}(min(d,m)+d)dt
+    # Case J_before_closeE & i_pivot after J   before     t-e_min                    i_pivot-t       min(i_pivot-t,t-e_min) = t-e_min    t^2/2-e_min*t     i_pivot*t-t^2/2  t^2/2-e_min*t+i_pivot*t-t^2/2 = (i_pivot-e_min)*t      (i_pivot-e_min)*tB - (i_pivot-e_min)*tA = (i_pivot-e_min)*(tB-tA)
+    # Case J_before_closeI & i_pivot after J   before     t-e_min                    i_pivot-t       min(i_pivot-t,t-e_min) = i_pivot-t  i_pivot*t-t^2/2   i_pivot*t-t^2/2  i_pivot*t-t^2/2+i_pivot*t-t^2/2 = 2*i_pivot*t-t^2      2*i_pivot*tB-tB^2 - 2*i_pivot*tA + tA^2 = 2*i_pivot*(tB-tA) - (tB^2 - tA^2)
+    # Case J_after_closeI & i_pivot after J    after      e_max-t                    i_pivot-t       min(i_pivot-t,e_max-t) = i_pivot-t  i_pivot*t-t^2/2   i_pivot*t-t^2/2  i_pivot*t-t^2/2+i_pivot*t-t^2/2 = 2*i_pivot*t-t^2      2*i_pivot*tB-tB^2 - 2*i_pivot*tA + tA^2 = 2*i_pivot*(tB-tA) - (tB^2 - tA^2)
+    # Case J_after_closeE & i_pivot after J    after      e_max-t                    i_pivot-t       min(i_pivot-t,e_max-t) = e_max-t    e_max*t-t^2/2     i_pivot*t-t^2/2  e_max*t-t^2/2+i_pivot*t-t^2/2 = (e_max+i_pivot)*t-t^2  (e_max+i_pivot)*tB-tB^2 - (e_max+i_pivot)*tA + tA^2 = (e_max+i_pivot)*(tB-tA) - (tB^2 - tA^2)
+    #
+    # Case J_before_closeE & i_pivot before J  before     t-e_min                    t-i_pivot       min(t-i_pivot,t-e_min) = t-e_min    t^2/2-e_min*t     t^2/2-i_pivot*t  t^2/2-e_min*t+t^2/2-i_pivot*t = t^2-(e_min+i_pivot)*t  tB^2-(e_min+i_pivot)*tB - tA^2 + (e_min+i_pivot)*tA = (tB^2 - tA^2) - (e_min+i_pivot)*(tB-tA)
+    # Case J_before_closeI & i_pivot before J  before     t-e_min                    t-i_pivot       min(t-i_pivot,t-e_min) = t-i_pivot  t^2/2-i_pivot*t   t^2/2-i_pivot*t  t^2/2-i_pivot*t+t^2/2-i_pivot*t = t^2-2*i_pivot*t      tB^2-2*i_pivot*tB - tA^2 + 2*i_pivot*tA = (tB^2 - tA^2) - 2*i_pivot*(tB-tA)
+    # Case J_after_closeI & i_pivot before J   after      e_max-t                    t-i_pivot       min(t-i_pivot,e_max-t) = t-i_pivot  t^2/2-i_pivot*t   t^2/2-i_pivot*t  t^2/2-i_pivot*t+t^2/2-i_pivot*t = t^2-2*i_pivot*t      tB^2-2*i_pivot*tB - tA^2 + 2*i_pivot*tA = (tB^2 - tA^2) - 2*i_pivot*(tB-tA)
+    # Case J_after_closeE & i_pivot before J   after      e_max-t                    t-i_pivot       min(t-i_pivot,e_max-t) = e_max-t    e_max*t-t^2/2     t^2/2-i_pivot*t  e_max*t-t^2/2+t^2/2-i_pivot*t = (e_max-i_pivot)*t      (e_max-i_pivot)*tB - (e_max-i_pivot)*tA = (e_max-i_pivot)*(tB-tA)
+    
+    if i_pivot >= max(J):
+        part1_before_closeE = (i_pivot-e_min)*(j_before_before_max - j_before_before_min) # (i_pivot-e_min)*(tB-tA) # j_before_before_max - j_before_before_min
+        part2_before_closeI = 2*i_pivot*(j_before_after_max-j_before_after_min) - (j_before_after_max**2 - j_before_after_min**2) # 2*i_pivot*(tB-tA) - (tB^2 - tA^2) # j_before_after_max - j_before_after_min
+        part3_after_closeI = 2*i_pivot*(j_after_before_max-j_after_before_min) - (j_after_before_max**2 - j_after_before_min**2) # 2*i_pivot*(tB-tA) - (tB^2 - tA^2) # j_after_before_max - j_after_before_min  
+        part4_after_closeE = (e_max+i_pivot)*(j_after_after_max-j_after_after_min) - (j_after_after_max**2 - j_after_after_min**2) # (e_max+i_pivot)*(tB-tA) - (tB^2 - tA^2) # j_after_after_max - j_after_after_min
+        out_parts = [part1_before_closeE, part2_before_closeI, part3_after_closeI, part4_after_closeE]
+    elif i_pivot <= min(J):
+        part1_before_closeE = (j_before_before_max**2 - j_before_before_min**2) - (e_min+i_pivot)*(j_before_before_max-j_before_before_min) # (tB^2 - tA^2) - (e_min+i_pivot)*(tB-tA) # j_before_before_max - j_before_before_min
+        part2_before_closeI = (j_before_after_max**2 - j_before_after_min**2) - 2*i_pivot*(j_before_after_max-j_before_after_min) # (tB^2 - tA^2) - 2*i_pivot*(tB-tA) # j_before_after_max - j_before_after_min
+        part3_after_closeI = (j_after_before_max**2 - j_after_before_min**2) - 2*i_pivot*(j_after_before_max - j_after_before_min) # (tB^2 - tA^2) - 2*i_pivot*(tB-tA) # j_after_before_max - j_after_before_min
+        part4_after_closeE = (e_max-i_pivot)*(j_after_after_max - j_after_after_min) # (e_max-i_pivot)*(tB-tA) # j_after_after_max - j_after_after_min
+        out_parts = [part1_before_closeE, part2_before_closeI, part3_after_closeI, part4_after_closeE]
+    else:
+        raise ValueError('The i_pivot should be outside J')
+    
+    out_integral_min_dm_plus_d = _sum_wo_nan(out_parts) # integral on all J, i.e. sum of the disjoint parts
+
+    # We have for each point t of J:
+    # \bar{F}_{t, recall}(d) = 1 - (1/|E|) * (min(d,m) + d)
+    # Since t is a single-point here, and we are in the case where i_pivot is inside E.
+    # The integral is then given by:
+    # C = \int_{t \in J} \bar{F}_{t, recall}(D(t)) dt
+    #   = \int_{t \in J} 1 - (1/|E|) * (min(d,m) + d) dt
+    #   = |J| - (1/|E|) * [\int_{t \in J} (min(d,m) + d) dt]
+    #   = |J| - (1/|E|) * out_integral_min_dm_plus_d    
+    DeltaJ = max(J) - min(J)
+    DeltaE = max(E) - min(E)
+    C = DeltaJ - (1/DeltaE) * out_integral_min_dm_plus_d
+    
+    return(C)
+
+def integral_interval_probaCDF_recall(I, J, E):
+    """
+    Integral of the probability of distances over the interval J.
+    Compute the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$.
+    This is the *integral* i.e. the sum (not the mean)
+
+    :param I: a single (non empty) predicted interval
+    :param J: ground truth (non empty) interval
+    :param E: the affiliation/influence zone for J
+    :return: the integral $\int_{y \in J} Fbar_y(dist(y,I)) dy$
+    """
+    # I and J are single intervals (not generic sets)
+    # E is the outside affiliation interval of J (even for recall!)
+    # (in particular J \subset E)
+    #
+    # J is the portion of the ground truth affiliated to I
+    # I is a predicted interval (can be outside E possibly since it's recall)
+    def f(J_cut):
+        if J_cut is None:
+            return(0)
+        else:
+            return integral_mini_interval_Precall_CDFmethod(I, J_cut, E)
+
+    # If J_middle is fully included into I, it is
+    # integral of 1 on the interval J_middle, so it's |J_middle|
+    def f0(J_middle):
+        if J_middle is None:
+            return(0)
+        else:
+            return(max(J_middle) - min(J_middle))
+    
+    cut_into_three = cut_into_three_func(J, I) # it's J that we cut into 3, depending on the position w.r.t I
+    # since we integrate over J this time.
+    #
+    # Distance for now, not the mean:
+    # Distance left: Between cut_into_three[0] and the point min(I)
+    d_left = f(cut_into_three[0])
+    # Distance middle: Between cut_into_three[1] = J inter I, and I
+    d_middle = f0(cut_into_three[1])
+    # Distance right: Between cut_into_three[2] and the point max(I)
+    d_right = f(cut_into_three[2])
+    # It's an integral so summable
+    return(d_left + d_middle + d_right)

evaluation/affiliation/_single_ground_truth_event.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import math
+from ._affiliation_zone import (
+        get_all_E_gt_func, 
+        affiliation_partition)
+from ._integral_interval import (
+        integral_interval_distance,
+        integral_interval_probaCDF_precision, 
+        integral_interval_probaCDF_recall, 
+        interval_length,
+        sum_interval_lengths)
+
+def affiliation_precision_distance(Is = [(1,2),(3,4),(5,6)], J = (2,5.5)):
+    """
+    Compute the individual average distance from Is to a single ground truth J
+    
+    :param Is: list of predicted events within the affiliation zone of J
+    :param J: couple representating the start and stop of a ground truth interval
+    :return: individual average precision directed distance number
+    """
+    if all([I is None for I in Is]): # no prediction in the current area
+        return(math.nan) # undefined
+    return(sum([integral_interval_distance(I, J) for I in Is]) / sum_interval_lengths(Is))
+
+def affiliation_precision_proba(Is = [(1,2),(3,4),(5,6)], J = (2,5.5), E = (0,8)):
+    """
+    Compute the individual precision probability from Is to a single ground truth J
+    
+    :param Is: list of predicted events within the affiliation zone of J
+    :param J: couple representating the start and stop of a ground truth interval
+    :param E: couple representing the start and stop of the zone of affiliation of J
+    :return: individual precision probability in [0, 1], or math.nan if undefined
+    """
+    if all([I is None for I in Is]): # no prediction in the current area
+        return(math.nan) # undefined
+    return(sum([integral_interval_probaCDF_precision(I, J, E) for I in Is]) / sum_interval_lengths(Is))
+
+def affiliation_recall_distance(Is = [(1,2),(3,4),(5,6)], J = (2,5.5)):
+    """
+    Compute the individual average distance from a single J to the predictions Is
+    
+    :param Is: list of predicted events within the affiliation zone of J
+    :param J: couple representating the start and stop of a ground truth interval
+    :return: individual average recall directed distance number
+    """
+    Is = [I for I in Is if I is not None] # filter possible None in Is
+    if len(Is) == 0: # there is no prediction in the current area
+        return(math.inf)
+    E_gt_recall = get_all_E_gt_func(Is, (-math.inf, math.inf))  # here from the point of view of the predictions
+    Js = affiliation_partition([J], E_gt_recall) # partition of J depending of proximity with Is
+    return(sum([integral_interval_distance(J[0], I) for I, J in zip(Is, Js)]) / interval_length(J))
+
+def affiliation_recall_proba(Is = [(1,2),(3,4),(5,6)], J = (2,5.5), E = (0,8)):
+    """
+    Compute the individual recall probability from a single ground truth J to Is
+    
+    :param Is: list of predicted events within the affiliation zone of J
+    :param J: couple representating the start and stop of a ground truth interval
+    :param E: couple representing the start and stop of the zone of affiliation of J
+    :return: individual recall probability in [0, 1]
+    """
+    Is = [I for I in Is if I is not None] # filter possible None in Is
+    if len(Is) == 0: # there is no prediction in the current area
+        return(0)
+    E_gt_recall = get_all_E_gt_func(Is, E) # here from the point of view of the predictions
+    Js = affiliation_partition([J], E_gt_recall) # partition of J depending of proximity with Is
+    return(sum([integral_interval_probaCDF_recall(I, J[0], E) for I, J in zip(Is, Js)]) / interval_length(J))

evaluation/affiliation/generics.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from itertools import groupby
+from operator import itemgetter
+import math
+import gzip
+import glob
+import os
+
+def convert_vector_to_events(vector = [0, 1, 1, 0, 0, 1, 0]):
+    """
+    Convert a binary vector (indicating 1 for the anomalous instances)
+    to a list of events. The events are considered as durations,
+    i.e. setting 1 at index i corresponds to an anomalous interval [i, i+1).
+    
+    :param vector: a list of elements belonging to {0, 1}
+    :return: a list of couples, each couple representing the start and stop of
+    each event
+    """
+    positive_indexes = [idx for idx, val in enumerate(vector) if val > 0]
+    events = []
+    for k, g in groupby(enumerate(positive_indexes), lambda ix : ix[0] - ix[1]):
+        cur_cut = list(map(itemgetter(1), g))
+        events.append((cur_cut[0], cur_cut[-1]))
+    
+    # Consistent conversion in case of range anomalies (for indexes):
+    # A positive index i is considered as the interval [i, i+1),
+    # so the last index should be moved by 1
+    events = [(x, y+1) for (x,y) in events]
+        
+    return(events)
+
+def infer_Trange(events_pred, events_gt):
+    """
+    Given the list of events events_pred and events_gt, get the
+    smallest possible Trange corresponding to the start and stop indexes 
+    of the whole series.
+    Trange will not influence the measure of distances, but will impact the
+    measures of probabilities.
+    
+    :param events_pred: a list of couples corresponding to predicted events
+    :param events_gt: a list of couples corresponding to ground truth events
+    :return: a couple corresponding to the smallest range containing the events
+    """
+    if len(events_gt) == 0:
+        raise ValueError('The gt events should contain at least one event')
+    if len(events_pred) == 0:
+        # empty prediction, base Trange only on events_gt (which is non empty)
+        return(infer_Trange(events_gt, events_gt))
+        
+    min_pred = min([x[0] for x in events_pred])
+    min_gt = min([x[0] for x in events_gt])
+    max_pred = max([x[1] for x in events_pred])
+    max_gt = max([x[1] for x in events_gt])
+    Trange = (min(min_pred, min_gt), max(max_pred, max_gt))
+    return(Trange)
+
+def has_point_anomalies(events):
+    """
+    Checking whether events contain point anomalies, i.e.
+    events starting and stopping at the same time.
+    
+    :param events: a list of couples corresponding to predicted events
+    :return: True is the events have any point anomalies, False otherwise
+    """
+    if len(events) == 0:
+        return(False)
+    return(min([x[1] - x[0] for x in events]) == 0)
+
+def _sum_wo_nan(vec):
+    """
+    Sum of elements, ignoring math.isnan ones
+    
+    :param vec: vector of floating numbers
+    :return: sum of the elements, ignoring math.isnan ones
+    """
+    vec_wo_nan = [e for e in vec if not math.isnan(e)]
+    return(sum(vec_wo_nan))
+    
+def _len_wo_nan(vec):
+    """
+    Count of elements, ignoring math.isnan ones
+    
+    :param vec: vector of floating numbers
+    :return: count of the elements, ignoring math.isnan ones
+    """
+    vec_wo_nan = [e for e in vec if not math.isnan(e)]
+    return(len(vec_wo_nan))
+
+def read_gz_data(filename = 'data/machinetemp_groundtruth.gz'):
+    """
+    Load a file compressed with gz, such that each line of the
+    file is either 0 (representing a normal instance) or 1 (representing)
+    an anomalous instance.
+    :param filename: file path to the gz compressed file
+    :return: list of integers with either 0 or 1
+    """
+    with gzip.open(filename, 'rb') as f:
+        content = f.read().splitlines()
+    content = [int(x) for x in content]
+    return(content)
+
+def read_all_as_events():
+    """
+    Load the files contained in the folder `data/` and convert
+    to events. The length of the series is kept.
+    The convention for the file name is: `dataset_algorithm.gz`
+    :return: two dictionaries:
+        - the first containing the list of events for each dataset and algorithm,
+        - the second containing the range of the series for each dataset
+    """
+    filepaths = glob.glob('data/*.gz')
+    datasets = dict()
+    Tranges = dict()
+    for filepath in filepaths:
+        vector = read_gz_data(filepath)
+        events = convert_vector_to_events(vector)
+        # ad hoc cut for those files
+        cut_filepath = (os.path.split(filepath)[1]).split('_')
+        data_name = cut_filepath[0]
+        algo_name = (cut_filepath[1]).split('.')[0]
+        if not data_name in datasets:
+            datasets[data_name] = dict()
+            Tranges[data_name] = (0, len(vector))
+        datasets[data_name][algo_name] = events
+    return(datasets, Tranges)
+
+def f1_func(p, r):
+    """
+    Compute the f1 function
+    :param p: precision numeric value
+    :param r: recall numeric value
+    :return: f1 numeric value
+    """
+    return(2*p*r/(p+r))

evaluation/affiliation/metrics.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from .generics import (
+        infer_Trange,
+        has_point_anomalies, 
+        _len_wo_nan, 
+        _sum_wo_nan,
+        read_all_as_events)
+from ._affiliation_zone import (
+        get_all_E_gt_func, 
+        affiliation_partition)
+from ._single_ground_truth_event import (
+        affiliation_precision_distance,
+        affiliation_recall_distance,
+        affiliation_precision_proba,
+        affiliation_recall_proba)
+
+def test_events(events):
+    """
+    Verify the validity of the input events
+    :param events: list of events, each represented by a couple (start, stop)
+    :return: None. Raise an error for incorrect formed or non ordered events
+    """
+    if type(events) is not list:
+        raise TypeError('Input `events` should be a list of couples')
+    if not all([type(x) is tuple for x in events]):
+        raise TypeError('Input `events` should be a list of tuples')
+    if not all([len(x) == 2 for x in events]):
+        raise ValueError('Input `events` should be a list of couples (start, stop)')
+    if not all([x[0] <= x[1] for x in events]):
+        raise ValueError('Input `events` should be a list of couples (start, stop) with start <= stop')
+    if not all([events[i][1] < events[i+1][0] for i in range(len(events) - 1)]):
+        raise ValueError('Couples of input `events` should be disjoint and ordered')
+
+def pr_from_events(events_pred, events_gt, Trange):
+    """
+    Compute the affiliation metrics including the precision/recall in [0,1],
+    along with the individual precision/recall distances and probabilities
+    
+    :param events_pred: list of predicted events, each represented by a couple
+    indicating the start and the stop of the event
+    :param events_gt: list of ground truth events, each represented by a couple
+    indicating the start and the stop of the event
+    :param Trange: range of the series where events_pred and events_gt are included,
+    represented as a couple (start, stop)
+    :return: dictionary with precision, recall, and the individual metrics
+    """
+    # testing the inputs
+    test_events(events_pred)
+    test_events(events_gt)
+    
+    # other tests
+    minimal_Trange = infer_Trange(events_pred, events_gt)
+    if not Trange[0] <= minimal_Trange[0]:
+        raise ValueError('`Trange` should include all the events')
+    if not minimal_Trange[1] <= Trange[1]:
+        raise ValueError('`Trange` should include all the events')
+    
+    if len(events_gt) == 0:
+        raise ValueError('Input `events_gt` should have at least one event')
+
+    if has_point_anomalies(events_pred) or has_point_anomalies(events_gt):
+        raise ValueError('Cannot manage point anomalies currently')
+
+    if Trange is None:
+        # Set as default, but Trange should be indicated if probabilities are used
+        raise ValueError('Trange should be indicated (or inferred with the `infer_Trange` function')
+
+    E_gt = get_all_E_gt_func(events_gt, Trange)
+    aff_partition = affiliation_partition(events_pred, E_gt)
+
+    # Computing precision distance
+    d_precision = [affiliation_precision_distance(Is, J) for Is, J in zip(aff_partition, events_gt)]
+    
+    # Computing recall distance
+    d_recall = [affiliation_recall_distance(Is, J) for Is, J in zip(aff_partition, events_gt)]
+
+    # Computing precision
+    p_precision = [affiliation_precision_proba(Is, J, E) for Is, J, E in zip(aff_partition, events_gt, E_gt)]
+
+    # Computing recall
+    p_recall = [affiliation_recall_proba(Is, J, E) for Is, J, E in zip(aff_partition, events_gt, E_gt)]
+
+    if _len_wo_nan(p_precision) > 0:
+        p_precision_average = _sum_wo_nan(p_precision) / _len_wo_nan(p_precision)
+    else:
+        p_precision_average = p_precision[0] # math.nan
+    p_recall_average = sum(p_recall) / len(p_recall)
+
+    dict_out = dict({'Affiliation_Precision': p_precision_average,
+                     'Affiliation_Recall': p_recall_average,
+                     'individual_precision_probabilities': p_precision,
+                     'individual_recall_probabilities': p_recall,
+                     'individual_precision_distances': d_precision,
+                     'individual_recall_distances': d_recall})
+    return(dict_out)
+
+def produce_all_results():
+    """
+    Produce the affiliation precision/recall for all files
+    contained in the `data` repository
+    :return: a dictionary indexed by data names, each containing a dictionary
+    indexed by algorithm names, each containing the results of the affiliation
+    metrics (precision, recall, individual probabilities and distances)
+    """
+    datasets, Tranges = read_all_as_events() # read all the events in folder `data`
+    results = dict()
+    for data_name in datasets.keys():
+        results_data = dict()
+        for algo_name in datasets[data_name].keys():
+            if algo_name != 'groundtruth':
+                results_data[algo_name] = pr_from_events(datasets[data_name][algo_name],
+                                                         datasets[data_name]['groundtruth'],
+                                                         Tranges[data_name])
+        results[data_name] = results_data
+    return(results)

evaluation/metrics.py

@@ -0,0 +1,379 @@
+import sys
+import time
+from .basic_metrics import basic_metricor, generate_curve
+from statsmodels.tsa.stattools import acf
+from scipy.signal import argrelextrema
+import numpy as np
+import multiprocessing
+
+import multiprocessing
+import numpy as np
+import torch
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+from functools import partial
+from tqdm import tqdm
+import time
+
+# ============== Parallelized Affiliation ==============
+
+def _compute_auc_roc(labels, score):
+    grader = basic_metricor()
+    try:
+        return grader.metric_ROC(labels, score)
+    except Exception:
+        return 0.0
+
+def _compute_auc_pr(labels, score):
+    grader = basic_metricor()
+    try:
+        return grader.metric_PR(labels, score)
+    except Exception:
+        return 0.0
+
+def _compute_vus(labels, score, slidingWindow, version):
+    try:
+        _, _, _, _, _, _, VUS_ROC, VUS_PR = generate_curve(labels.astype(int), score, slidingWindow, version)
+        return VUS_ROC, VUS_PR
+    except Exception:
+        return 0.0, 0.0
+
+def _compute_pointf1(labels, score):
+    # print("Evaluating F1 standard...")
+    grader = basic_metricor()
+    try:
+        # print("Using chunked parallel F1 computation...")
+        return grader.metric_standard_F1_chunked(
+            true_labels=labels, 
+            anomaly_scores=score,
+            chunk_size=25,  # Process 25 thresholds per chunk
+            num_workers=4   # Use 4 parallel workers
+        )
+    except Exception:
+        # print("F1 standard computation failed, returning zeros.")
+        return {'F1': 0.0, 'Precision': 0.0, 'Recall': 0.0}
+
+def _compute_pointf1pa(labels, score):
+    grader = basic_metricor()
+    try:
+        return grader.metric_PointF1PA_chunked(
+            label=labels, 
+            score=score,
+            chunk_size=30,  # Process 30 quantiles per chunk
+            num_workers=6   # Use 6 parallel workers
+        )
+    except Exception:
+        return {'F1_PA': 0.0, 'P_PA': 0.0, 'R_PA': 0.0}
+
+def _compute_affiliation(labels, score):
+    grader = basic_metricor()
+    try:
+        return grader.metric_Affiliation(labels, score)
+    except Exception:
+        return 0.0, 0.0, 0.0
+
+def _compute_t_score(labels, score):
+    grader = basic_metricor()
+    try:
+        return grader.metric_F1_T(labels, score)
+    except Exception:
+        return {'F1_T': 0.0, 'P_T': 0.0, 'R_T': 0.0}
+
+def _compute_f1_t(labels, score):
+    grader = basic_metricor()
+    try:
+        # Use non-parallel path here to avoid pickling issues inside thread workers
+        # metric_F1_T(use_parallel=False) runs in-process and returns a dict
+        return grader.metric_F1_T(labels, score, use_parallel=True)
+    except Exception:
+        # Always return a dict to keep downstream code consistent
+        return {'F1_T': 0.0, 'P_T': 0.0, 'R_T': 0.0}
+
+def _run_task(func, args):
+    return func(*args)
+
+
+def get_metrics_optimized(score, labels, slidingWindow=100, pred=None, version='opt', thre=250):
+    """
+    Fully optimized metrics computation with proper parallelization
+    """
+    metrics = {}
+    start_total = time.time()
+    
+    # Ensure proper data types to avoid float/integer issues
+    labels = np.asarray(labels, dtype=int)
+    score = np.asarray(score, dtype=float)
+    
+    # Determine optimal number of workers based on CPU count and workload
+    n_cores = multiprocessing.cpu_count()
+    
+    # For threshold-iterating functions (affiliation and F1_T)
+    # Use more workers since they have heavy loops
+    heavy_workers = min(n_cores - 2, 8)  # Leave some cores for system
+    
+    # For simple metrics
+    light_workers = min(n_cores // 2, 8)
+    
+    print(f"Using {heavy_workers} workers for heavy metrics, {light_workers} for light metrics")
+    
+    # Start the heavy computations first (they take longest)
+    print("Starting heavy computations (Affiliation and F1_T)...")
+    heavy_start = time.time()
+    grader = basic_metricor() 
+    with ProcessPoolExecutor(max_workers=2) as main_executor:
+        # Launch the two heaviest computations with their own internal parallelization
+        affiliation_future = main_executor.submit(
+            grader._compute_affiliation_parallel, 
+            labels, 
+            score, 
+            num_workers=heavy_workers
+        )
+        
+        # t_score_future = main_executor.submit(
+        #     grader.metric_F1_T_fast,
+        #     labels,
+        #     score,
+        #     num_workers=heavy_workers*2
+        # )
+        #
+        # While heavy computations are running, compute light metrics
+        print("Computing light metrics in parallel...")
+        light_start = time.time()
+        
+        with ThreadPoolExecutor(max_workers=light_workers) as light_executor:
+            light_futures = {
+                'auc_roc': light_executor.submit(_compute_auc_roc, labels, score),
+                'auc_pr': light_executor.submit(_compute_auc_pr, labels, score),
+                'vus': light_executor.submit(_compute_vus, labels, score, slidingWindow, version),
+                'pointf1': light_executor.submit(_compute_pointf1, labels, score),
+                'pointf1pa': light_executor.submit(_compute_pointf1pa, labels, score),
+                'f1_t': light_executor.submit(_compute_f1_t, labels, score)
+            }
+            
+            # Collect light metric results as they complete
+            light_results = {}
+            for name, future in light_futures.items():
+                try:
+                    light_results[name] = future.result()
+                    print(f"  ✓ {name} completed")
+                except Exception as e:
+                    print(f"  ✗ {name} failed: {e}")
+                    light_results[name] = None
+        
+        print(f"Light metrics completed in {time.time() - light_start:.2f}s")
+        
+        # Wait for heavy computations to complete
+        print("Waiting for heavy computations...")
+        
+        try:
+            Affiliation_F, Affiliation_P, Affiliation_R = affiliation_future.result()
+            print(f"  ✓ Affiliation completed")
+        except Exception as e:
+            print(f"  ✗ Affiliation failed: {e}")
+            Affiliation_F, Affiliation_P, Affiliation_R = 0.0, 0.0, 0.0
+        
+        # try:
+        #     T_score = t_score_future.result()
+        #     print(f"  ✓ F1_T completed")
+        # except Exception as e:
+        #     print(f"  ✗ F1_T failed: {e}")
+        #     T_score = {'F1_T': 0.0, 'P_T': 0.0, 'R_T': 0.0}
+    
+    print(f"Heavy metrics completed in {time.time() - heavy_start:.2f}s")
+    
+    # Unpack light results
+    AUC_ROC = light_results.get('auc_roc', 0.0)
+    AUC_PR = light_results.get('auc_pr', 0.0)
+    VUS_result = light_results.get('vus', (0.0, 0.0))
+    if isinstance(VUS_result, tuple):
+        VUS_ROC, VUS_PR = VUS_result
+    else:
+        VUS_ROC, VUS_PR = 0.0, 0.0
+    # print("HERE IS POINTF1: ")
+    # print(light_results.get('pointf1',)) 
+    # sys.exit()
+    PointF1 = light_results.get('pointf1', {'F1': 0.0, 'Precision': 0.0, 'Recall': 0.0})
+    PointF1PA = light_results.get('pointf1pa', {'F1_PA': 0.0, 'P_PA': 0.0, 'R_PA': 0.0})
+    T_score = light_results.get('f1_t', {'F1_T': 0.0, 'P_T': 0.0, 'R_T': 0.0})
+    # Safeguard: if upstream returned a tuple (e.g., from an older fallback), coerce to dict
+    if isinstance(T_score, tuple):
+        try:
+            T_score = {'F1_T': T_score[0], 'P_T': T_score[1], 'R_T': T_score[2]}
+        except Exception:
+            T_score = {'F1_T': 0.0, 'P_T': 0.0, 'R_T': 0.0}
+    
+    # Build final metrics dictionary
+    metrics['AUC-PR'] = AUC_PR
+    metrics['AUC-ROC'] = AUC_ROC
+    metrics['VUS-PR'] = VUS_PR
+    metrics['VUS-ROC'] = VUS_ROC
+    
+    metrics['Standard-F1'] = PointF1.get('F1', 0.0)
+    metrics['Standard-Precision'] = PointF1.get('Precision', 0.0)
+    metrics['Standard-Recall'] = PointF1.get('Recall', 0.0)
+    
+    metrics['PA-F1'] = PointF1PA.get('F1_PA', 0.0)
+    metrics['PA-Precision'] = PointF1PA.get('P_PA', 0.0)
+    metrics['PA-Recall'] = PointF1PA.get('R_PA', 0.0)
+    
+    metrics['Affiliation-F'] = Affiliation_F
+    metrics['Affiliation-P'] = Affiliation_P
+    metrics['Affiliation-R'] = Affiliation_R
+    
+    metrics['F1_T'] = T_score.get('F1_T', 0.0)
+    metrics['Precision_T'] = T_score.get('P_T', 0.0)
+    metrics['Recall_T'] = T_score.get('R_T', 0.0)
+    
+    print(f"\nTotal computation time: {time.time() - start_total:.2f}s")
+    
+    return metrics
+
+
+def get_metrics(score, labels, slidingWindow=100, pred=None, version='opt', thre=250):
+    metrics = {}
+
+    # Ensure proper data types to avoid float/integer issues
+    labels = np.asarray(labels, dtype=int)
+    score = np.asarray(score, dtype=float)
+
+    '''
+    Threshold Independent
+    '''
+    grader = basic_metricor()
+    # AUC_ROC, Precision, Recall, PointF1, PointF1PA, Rrecall, ExistenceReward, OverlapReward, Rprecision, RF, Precision_at_k = grader.metric_new(labels, score, pred, plot_ROC=False)
+    try:
+        AUC_ROC = grader.metric_ROC(labels, score)
+    except Exception:
+        AUC_ROC = 0.0
+    try:
+        AUC_PR = grader.metric_PR(labels, score)
+    except Exception:
+        AUC_PR = 0.0
+
+    # R_AUC_ROC, R_AUC_PR, _, _, _ = grader.RangeAUC(labels=labels, score=score, window=slidingWindow, plot_ROC=True)
+    try:
+        _, _, _, _, _, _,VUS_ROC, VUS_PR = generate_curve(labels.astype(int), score, slidingWindow, version, )
+    except Exception:
+        VUS_ROC, VUS_PR = 0.0, 0.0
+
+    '''
+    Threshold Dependent
+    if pred is None --> use the oracle threshold
+    '''
+
+    PointF1 = grader.metric_standard_F1(labels, score,)
+    PointF1PA = grader.metric_PointF1PA(labels, score,)
+    # EventF1PA = grader.metric_EventF1PA(labels, score,)
+    # RF1 = grader.metric_RF1(labels, score,)
+    try:
+        Affiliation_F, Affiliation_P, Affiliation_R  = grader.metric_Affiliation(labels, score)
+    except Exception:
+        Affiliation_F, Affiliation_P, Affiliation_R = 0.0, 0.0, 0.0
+    T_score = grader.metric_F1_T(labels, score)
+
+    metrics['AUC-PR'] = AUC_PR
+    metrics['AUC-ROC'] = AUC_ROC
+    metrics['VUS-PR'] = VUS_PR
+    metrics['VUS-ROC'] = VUS_ROC
+
+    metrics['Standard-F1'] = PointF1['F1']
+    metrics['Standard-Precision'] = PointF1['Precision']
+    metrics['Standard-Recall'] = PointF1['Recall']
+    metrics['PA-F1'] = PointF1PA['F1_PA']
+    metrics['PA-Precision'] = PointF1PA['P_PA']
+    metrics['PA-Recall'] = PointF1PA['R_PA']
+    # metrics['Event-based-F1'] = EventF1PA
+    # metrics['R-based-F1'] = RF1
+    metrics['Affiliation-F'] = Affiliation_F
+    metrics['Affiliation-P'] = Affiliation_P
+    metrics['Affiliation-R'] = Affiliation_R
+
+    metrics['F1_T'] = T_score['F1_T']
+    metrics['Precision_T'] = T_score['P_T']
+    metrics['Recall_T'] = T_score['R_T']
+
+    return metrics
+
+
+def get_metrics_pred(score, labels, pred, slidingWindow=100):
+    metrics = {}
+
+    # Ensure proper data types to avoid float/integer issues
+    labels = np.asarray(labels, dtype=int)
+    score = np.asarray(score, dtype=float)
+    pred = np.asarray(pred, dtype=int)
+
+    grader = basic_metricor()
+
+    PointF1 = grader.standard_F1(labels, score, preds=pred)
+    PointF1PA = grader.metric_PointF1PA(labels, score, preds=pred)
+    EventF1PA = grader.metric_EventF1PA(labels, score, preds=pred)
+    RF1 = grader.metric_RF1(labels, score, preds=pred)
+    Affiliation_F, Affiliation_P, Affiliation_R = grader.metric_Affiliation(labels, score, preds=pred)
+    VUS_R, VUS_P, VUS_F = grader.metric_VUS_pred(labels, preds=pred, windowSize=slidingWindow)
+
+    metrics['Standard-F1'] = PointF1['F1']
+    metrics['Standard-Precision'] = PointF1['Precision']
+    metrics['Standard-Recall'] = PointF1['Recall']
+    metrics['PA-F1'] = PointF1PA
+    metrics['Event-based-F1'] = EventF1PA
+    metrics['R-based-F1'] = RF1
+    metrics['Affiliation-F'] = Affiliation_F
+    metrics['Affiliation-P'] = Affiliation_P
+    metrics['Affiliation-R'] = Affiliation_R
+
+    metrics['VUS-Recall'] = VUS_R
+    metrics['VUS-Precision'] = VUS_P
+    metrics['VUS-F'] = VUS_F
+
+    return metrics
+
+def find_length_rank(data, rank=1):
+    data = data.squeeze()
+    if len(data.shape) > 1:
+        return 0
+    if rank == 0:
+        return 1
+    data = data[: min(20000, len(data))]
+
+    base = 3
+    auto_corr = acf(data, nlags=400, fft=True)[base:]
+
+    # plot_acf(data, lags=400, fft=True)
+    # plt.xlabel('Lags')
+    # plt.ylabel('Autocorrelation')
+    # plt.title('Autocorrelation Function (ACF)')
+    # plt.savefig('/data/liuqinghua/code/ts/TSAD-AutoML/AutoAD_Solution/candidate_pool/cd_diagram/ts_acf.png')
+
+    local_max = argrelextrema(auto_corr, np.greater)[0]
+
+    # print('auto_corr: ', auto_corr)
+    # print('local_max: ', local_max)
+
+    try:
+        # max_local_max = np.argmax([auto_corr[lcm] for lcm in local_max])
+        sorted_local_max = np.argsort([auto_corr[lcm] for lcm in local_max])[::-1]  # Ascending order
+        max_local_max = sorted_local_max[0]  # Default
+        if rank == 1:
+            max_local_max = sorted_local_max[0]
+        if rank == 2:
+            for i in sorted_local_max[1:]:
+                if i > sorted_local_max[0]:
+                    max_local_max = i
+                    break
+        if rank == 3:
+            id_tmp = 1
+            for i in sorted_local_max[1:]:
+                if i > sorted_local_max[0]:
+                    id_tmp = i
+                    break
+            for i in sorted_local_max[id_tmp:]:
+                if i > sorted_local_max[id_tmp]:
+                    max_local_max = i
+                    break
+        # print('sorted_local_max: ', sorted_local_max)
+        # print('max_local_max: ', max_local_max)
+        if local_max[max_local_max] < 3 or local_max[max_local_max] > 300:
+            return 125
+        return local_max[max_local_max] + base
+    except Exception:
+        return 125

evaluation/visualize.py

@@ -0,0 +1,99 @@
+from basic_metrics import metricor
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib.patches as mpatches 
+
+def plotFig(data, label, score, slidingWindow, fileName, modelName, plotRange=None):
+    grader = metricor()
+    
+    R_AUC, R_AP, R_fpr, R_tpr, R_prec = grader.RangeAUC(labels=label, score=score, window=slidingWindow, plot_ROC=True) #
+    
+    L, fpr, tpr= grader.metric_new(label, score, plot_ROC=True)
+    precision, recall, AP = grader.metric_PR(label, score)
+    
+    range_anomaly = grader.range_convers_new(label)
+    # print(range_anomaly)
+    
+    # max_length = min(len(score),len(data), 20000)
+    max_length = len(score)
+
+    if plotRange==None:
+        plotRange = [0,max_length]
+    
+    fig3 = plt.figure(figsize=(12, 10), constrained_layout=True)
+    gs = fig3.add_gridspec(3, 4)
+    
+    
+    f3_ax1 = fig3.add_subplot(gs[0, :-1])
+    plt.tick_params(labelbottom=False)
+
+    plt.plot(data[:max_length],'k')
+    for r in range_anomaly:
+        if r[0]==r[1]:
+            plt.plot(r[0],data[r[0]],'r.')
+        else:
+            plt.plot(range(r[0],r[1]+1),data[range(r[0],r[1]+1)],'r')
+    # plt.xlim([0,max_length])
+    plt.xlim(plotRange)
+    
+        
+    # L = [auc, precision, recall, f, Rrecall, ExistenceReward, 
+    #       OverlapReward, Rprecision, Rf, precision_at_k]
+    f3_ax2 = fig3.add_subplot(gs[1, :-1])
+    # plt.tick_params(labelbottom=False)
+    L1 = [ '%.2f' % elem for elem in L]
+    plt.plot(score[:max_length])
+    plt.hlines(np.mean(score)+3*np.std(score),0,max_length,linestyles='--',color='red')
+    plt.ylabel('score')
+    # plt.xlim([0,max_length])
+    plt.xlim(plotRange)
+    
+    
+    #plot the data
+    f3_ax3 = fig3.add_subplot(gs[2, :-1])
+    index = ( label + 2*(score > (np.mean(score)+3*np.std(score))))
+    cf = lambda x: 'k' if x==0 else ('r' if x == 1 else ('g' if x == 2 else 'b') )
+    cf = np.vectorize(cf)
+    
+    color = cf(index[:max_length])
+    black_patch = mpatches.Patch(color = 'black', label = 'TN')
+    red_patch = mpatches.Patch(color = 'red', label = 'FN')
+    green_patch = mpatches.Patch(color = 'green', label = 'FP')
+    blue_patch = mpatches.Patch(color = 'blue', label = 'TP')
+    plt.scatter(np.arange(max_length), data[:max_length], c=color, marker='.')
+    plt.legend(handles = [black_patch, red_patch, green_patch, blue_patch], loc= 'best')
+    # plt.xlim([0,max_length])
+    plt.xlim(plotRange)
+    
+    
+    f3_ax4 = fig3.add_subplot(gs[0, -1])
+    plt.plot(fpr, tpr)
+    # plt.plot(R_fpr,R_tpr)
+    # plt.title('R_AUC='+str(round(R_AUC,3)))
+    plt.xlabel('FPR')
+    plt.ylabel('TPR')
+    # plt.legend(['ROC','Range-ROC'])
+    
+    # f3_ax5 = fig3.add_subplot(gs[1, -1])
+    # plt.plot(recall, precision)
+    # plt.plot(R_tpr[:-1],R_prec)   # I add (1,1) to (TPR, FPR) at the end !!!
+    # plt.xlabel('Recall')
+    # plt.ylabel('Precision')
+    # plt.legend(['PR','Range-PR'])
+
+    # print('AUC=', L1[0])
+    # print('F=', L1[3])
+
+    plt.suptitle(fileName + '    window='+str(slidingWindow) +'   '+ modelName
+    +'\nAUC='+L1[0]+'     R_AUC='+str(round(R_AUC,2))+'     Precision='+L1[1]+ '     Recall='+L1[2]+'     F='+L1[3]
+    + '     ExistenceReward='+L1[5]+'   OverlapReward='+L1[6]
+    +'\nAP='+str(round(AP,2))+'     R_AP='+str(round(R_AP,2))+'     Precision@k='+L1[9]+'     Rprecision='+L1[7] + '     Rrecall='+L1[4] +'    Rf='+L1[8]
+    )
+    
+def printResult(data, label, score, slidingWindow, fileName, modelName):
+    grader = metricor()
+    R_AUC = grader.RangeAUC(labels=label, score=score, window=slidingWindow, plot_ROC=False) #
+    L= grader.metric_new(label, score, plot_ROC=False)
+    L.append(R_AUC)
+    return L
+    

model_wrapper.py

@@ -0,0 +1,532 @@
+import numpy as np
+import math
+from utils.slidingWindows import find_length_rank
+
+Unsupervise_AD_Pool = ['FFT', 'SR', 'NORMA', 'Series2Graph', 'Sub_IForest', 'IForest', 'LOF', 'Sub_LOF', 'POLY', 'MatrixProfile', 'Sub_PCA', 'PCA', 'HBOS', 
+                        'Sub_HBOS', 'KNN', 'Sub_KNN','KMeansAD', 'KMeansAD_U', 'KShapeAD', 'COPOD', 'CBLOF', 'COF', 'EIF', 'RobustPCA', 'Lag_Llama',
+                       'TimesFM', 'Chronos', 'MOMENT_ZS', 'DADA', 'Time_MOE', 'Time_RCD',  'TSPulse']
+Semisupervise_AD_Pool = ['Left_STAMPi', 'SAND', 'MCD', 'Sub_MCD', 'OCSVM', 'Sub_OCSVM', 'AutoEncoder', 'CNN', 'LSTMAD', 'TranAD', 'USAD', 'OmniAnomaly', 
+                        'AnomalyTransformer', 'TimesNet', 'FITS', 'Donut', 'OFA', 'MOMENT_FT', 'M2N2', ]
+
+def run_Unsupervise_AD(model_name, training_data, testing_data, **kwargs):
+    # Extract data_index if present, but don't pass it to all functions
+    data_index = kwargs.pop('data_index', None)
+
+    function_name = f'run_{model_name}'
+    function_to_call = globals()[function_name]
+
+
+    # Only pass data_index to functions that need it
+    if 'Reconstruction' in model_name:
+        results = function_to_call(data, data_index, **kwargs)
+    else:
+        results = function_to_call(testing_data, **kwargs)
+
+    return results
+
+def run_Semisupervise_AD(model_name, data_train, data_test, **kwargs):
+    try:
+        function_name = f'run_{model_name}'
+        function_to_call = globals()[function_name]
+        results = function_to_call(data_train, data_test, **kwargs)
+        return results
+    except KeyError:
+        error_message = f"Model function '{function_name}' is not defined."
+        print(error_message)
+        return error_message
+    except Exception as e:
+        error_message = f"An error occurred while running the model '{function_name}': {str(e)}"
+        print(error_message)
+        return error_message
+
+def run_FFT(data, ifft_parameters=5, local_neighbor_window=21, local_outlier_threshold=0.6, max_region_size=50, max_sign_change_distance=10):
+    from models.FFT import FFT
+    clf = FFT(ifft_parameters=ifft_parameters, local_neighbor_window=local_neighbor_window, local_outlier_threshold=local_outlier_threshold, max_region_size=max_region_size, max_sign_change_distance=max_sign_change_distance)
+    clf.fit(data)  
+    score = clf.decision_scores_ 
+    return score.ravel()
+
+def run_Sub_IForest(data, periodicity=1, n_estimators=100, max_features=1, n_jobs=1):
+    from models.IForest import IForest
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = IForest(slidingWindow=slidingWindow, n_estimators=n_estimators, max_features=max_features, n_jobs=n_jobs)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_IForest(train_data, test_data, slidingWindow=100, n_estimators=100, max_features=1, n_jobs=1):
+    from models.IForest import IForest
+    clf = IForest(slidingWindow=slidingWindow, n_estimators=n_estimators, max_features=max_features, n_jobs=n_jobs)
+    clf.fit(train_data)
+    score = clf.decision_function(test_data)
+    # score = clf.decision_scores_
+    return score.ravel()
+
+def run_Sub_LOF(data, periodicity=1, n_neighbors=30, metric='minkowski', n_jobs=1):
+    from models.LOF import LOF
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = LOF(slidingWindow=slidingWindow, n_neighbors=n_neighbors, metric=metric, n_jobs=n_jobs)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_LOF(train_data, test_data, slidingWindow=1, n_neighbors=30, metric='minkowski', n_jobs=1):
+    from models.LOF import LOF
+    clf = LOF(slidingWindow=slidingWindow, n_neighbors=n_neighbors, metric=metric, n_jobs=n_jobs)
+    clf.fit(train_data)
+    score = clf.decision_function(test_data)
+    return score.ravel()
+
+def run_POLY(data, periodicity=1, power=3, n_jobs=1):
+    from models.POLY import POLY
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = POLY(power=power, window = slidingWindow)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_MatrixProfile(data, periodicity=1, n_jobs=1):
+    from models.MatrixProfile import MatrixProfile
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = MatrixProfile(window=slidingWindow)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_Left_STAMPi(data_train, data):
+    from models.Left_STAMPi import Left_STAMPi
+    clf = Left_STAMPi(n_init_train=len(data_train), window_size=100)
+    clf.fit(data)
+    score = clf.decision_function(data)
+    return score.ravel()
+
+def run_SAND(data_train, data_test, periodicity=1):
+    from models.SAND import SAND
+    slidingWindow = find_length_rank(data_test, rank=periodicity)
+    clf = SAND(pattern_length=slidingWindow, subsequence_length=4*(slidingWindow))
+    clf.fit(data_test.squeeze(), online=True, overlaping_rate=int(1.5*slidingWindow), init_length=len(data_train), alpha=0.5, batch_size=max(5*(slidingWindow), int(0.1*len(data_test))))
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_KShapeAD(data, periodicity=1):
+    from models.SAND import SAND
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = SAND(pattern_length=slidingWindow, subsequence_length=4*(slidingWindow))
+    clf.fit(data.squeeze(), overlaping_rate=int(1.5*slidingWindow))
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_Series2Graph(data, periodicity=1):
+    from models.Series2Graph import Series2Graph
+    slidingWindow = find_length_rank(data, rank=periodicity)
+
+    data = data.squeeze()
+    s2g = Series2Graph(pattern_length=slidingWindow)
+    s2g.fit(data)
+    query_length = 2*slidingWindow
+    s2g.score(query_length=query_length,dataset=data)
+
+    score = s2g.decision_scores_
+    score = np.array([score[0]]*math.ceil(query_length//2) + list(score) + [score[-1]]*(query_length//2))
+    return score.ravel()
+
+def run_Sub_PCA(train_data, test_data, periodicity=1, n_components=None, n_jobs=1):
+    from models.PCA import PCA
+    slidingWindow = find_length_rank(train_data, rank=periodicity)
+    clf = PCA(slidingWindow = slidingWindow, n_components=n_components)
+    clf.fit(train_data)
+    score = clf.decision_function(test_data)
+    return score.ravel()
+
+def run_PCA(train_data, test_data, slidingWindow=100, n_components=None, n_jobs=1):
+    from models.PCA import PCA
+    clf = PCA(slidingWindow = slidingWindow, n_components=n_components)
+    clf.fit(train_data)
+    score = clf.decision_function(test_data)
+    return score.ravel()
+
+def run_NORMA(data, periodicity=1, clustering='hierarchical', n_jobs=1):
+    from models.NormA import NORMA
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = NORMA(pattern_length=slidingWindow, nm_size=3*slidingWindow, clustering=clustering)
+    clf.fit(data)
+    score = clf.decision_scores_
+    score = np.array([score[0]]*math.ceil((slidingWindow-1)/2) + list(score) + [score[-1]]*((slidingWindow-1)//2))
+    if len(score) > len(data):
+        start = len(score) - len(data)
+        score = score[start:]
+    return score.ravel()
+
+def run_Sub_HBOS(data, periodicity=1, n_bins=10, tol=0.5, n_jobs=1):
+    from models.HBOS import HBOS
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = HBOS(slidingWindow=slidingWindow, n_bins=n_bins, tol=tol)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_HBOS(data, slidingWindow=1, n_bins=10, tol=0.5, n_jobs=1):
+    from models.HBOS import HBOS
+    clf = HBOS(slidingWindow=slidingWindow, n_bins=n_bins, tol=tol)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_Sub_OCSVM(data_train, data_test, kernel='rbf', nu=0.5, periodicity=1, n_jobs=1):
+    from models.OCSVM import OCSVM
+    slidingWindow = find_length_rank(data_test, rank=periodicity)
+    clf = OCSVM(slidingWindow=slidingWindow, kernel=kernel, nu=nu)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_OCSVM(data_train, data_test, kernel='rbf', nu=0.5, slidingWindow=1, n_jobs=1):
+    from models.OCSVM import OCSVM
+    clf = OCSVM(slidingWindow=slidingWindow, kernel=kernel, nu=nu)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_Sub_MCD(data_train, data_test, support_fraction=None, periodicity=1, n_jobs=1):
+    from models.MCD import MCD
+    slidingWindow = find_length_rank(data_test, rank=periodicity)
+    clf = MCD(slidingWindow=slidingWindow, support_fraction=support_fraction)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_MCD(data_train, data_test, support_fraction=None, slidingWindow=1, n_jobs=1):
+    from models.MCD import MCD
+    clf = MCD(slidingWindow=slidingWindow, support_fraction=support_fraction)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_Sub_KNN(data, n_neighbors=10, method='largest', periodicity=1, n_jobs=1):
+    from models.KNN import KNN
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = KNN(slidingWindow=slidingWindow, n_neighbors=n_neighbors,method=method, n_jobs=n_jobs)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_KNN(data, slidingWindow=1, n_neighbors=10, method='largest', n_jobs=1):
+    from models.KNN import KNN
+    clf = KNN(slidingWindow=slidingWindow, n_neighbors=n_neighbors, method=method, n_jobs=n_jobs)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_KMeansAD(data, n_clusters=20, window_size=20, n_jobs=1):
+    from models.KMeansAD import KMeansAD
+    clf = KMeansAD(k=n_clusters, window_size=window_size, stride=1, n_jobs=n_jobs)
+    score = clf.fit_predict(data)
+    return score.ravel()
+
+def run_KMeansAD_U(data, n_clusters=20, periodicity=1,n_jobs=1):
+    from models.KMeansAD import KMeansAD
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    clf = KMeansAD(k=n_clusters, window_size=slidingWindow, stride=1, n_jobs=n_jobs)
+    score = clf.fit_predict(data)
+    return score.ravel()
+
+def run_COPOD(data, n_jobs=1):
+    from models.COPOD import COPOD
+    clf = COPOD(n_jobs=n_jobs)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_CBLOF(data, n_clusters=8, alpha=0.9, n_jobs=1):
+    from models.CBLOF import CBLOF
+    clf = CBLOF(n_clusters=n_clusters, alpha=alpha, n_jobs=n_jobs)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_COF(data, n_neighbors=30):
+    from models.COF import COF
+    clf = COF(n_neighbors=n_neighbors)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_EIF(data, n_trees=100):
+    from models.EIF import EIF
+    clf = EIF(n_trees=n_trees)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_RobustPCA(data, max_iter=1000):
+    from models.RobustPCA import RobustPCA
+    clf = RobustPCA(max_iter=max_iter)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_SR(data, periodicity=1):
+    from models.SR import SR
+    slidingWindow = find_length_rank(data, rank=periodicity)
+    return SR(data, window_size=slidingWindow)
+
+def run_AutoEncoder(data_train, data_test, window_size=100, hidden_neurons=[64, 32], n_jobs=1):
+    from models.AE import AutoEncoder
+    clf = AutoEncoder(slidingWindow=window_size, hidden_neurons=hidden_neurons, batch_size=128, epochs=50)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_CNN(data_train, data_test, window_size=100, num_channel=[32, 32, 40], lr=0.0008, n_jobs=1):
+    from models.CNN import CNN
+    clf = CNN(window_size=window_size, num_channel=num_channel, feats=data_test.shape[1], lr=lr, batch_size=128)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_LSTMAD(data_train, data_test, window_size=100, lr=0.0008):
+    from models.LSTMAD import LSTMAD
+    clf = LSTMAD(window_size=window_size, pred_len=1, lr=lr, feats=data_test.shape[1], batch_size=128)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_TranAD(data_train, data_test, win_size=10, lr=1e-3):
+    from models.TranAD import TranAD
+    clf = TranAD(win_size=win_size, feats=data_test.shape[1], lr=lr)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_AnomalyTransformer(data_train, data_test, win_size=100, lr=1e-4, batch_size=128):
+    from models.AnomalyTransformer import AnomalyTransformer
+    clf = AnomalyTransformer(win_size=win_size, input_c=data_test.shape[1], lr=lr, batch_size=batch_size)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_OmniAnomaly(data_train, data_test, win_size=100, lr=0.002):
+    from models.OmniAnomaly import OmniAnomaly
+    clf = OmniAnomaly(win_size=win_size, feats=data_test.shape[1], lr=lr)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_USAD(data_train, data_test, win_size=5, lr=1e-4):
+    from models.USAD import USAD
+    clf = USAD(win_size=win_size, feats=data_test.shape[1], lr=lr)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_Donut(data_train, data_test, win_size=120, lr=1e-4, batch_size=128):
+    from models.Donut import Donut
+    clf = Donut(win_size=win_size, input_c=data_test.shape[1], lr=lr, batch_size=batch_size)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_TimesNet(data_train, data_test, win_size=96, lr=1e-4):
+    from models.TimesNet import TimesNet
+    clf = TimesNet(win_size=win_size, enc_in=data_test.shape[1], lr=lr, epochs=50)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_FITS(data_train, data_test, win_size=100, lr=1e-3):
+    from models.FITS import FITS
+    clf = FITS(win_size=win_size, input_c=data_test.shape[1], lr=lr, batch_size=128)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_OFA(data_train, data_test, win_size=100, batch_size = 64):
+    from models.OFA import OFA
+    clf = OFA(win_size=win_size, enc_in=data_test.shape[1], epochs=10, batch_size=batch_size)
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_Lag_Llama(data, win_size=96, batch_size=64):
+    from models.Lag_Llama import Lag_Llama
+    clf = Lag_Llama(win_size=win_size, input_c=data.shape[1], batch_size=batch_size)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_Chronos(data, win_size=50, batch_size=64):
+    from models.Chronos import Chronos
+    clf = Chronos(win_size=win_size, prediction_length=1, input_c=1, model_size='base', batch_size=batch_size)
+    data =data.reshape(-1,1)
+    clf.fit(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_TimesFM(data, win_size=96):
+    from models.TimesFM import TimesFM
+    clf = TimesFM(win_size=win_size)
+    data_normalized = (data - np.mean(data, axis=0)) / np.std(data, axis=0)
+    data_normalized = data_normalized.reshape(-1,1)
+    clf.fit(data_normalized)
+    #normalizd data:
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_MOMENT_ZS(data, win_size=256):
+    from models.MOMENT import MOMENT
+    clf = MOMENT(win_size=win_size, input_c=1)
+    data = data.reshape(-1,1)
+    # Zero shot
+    clf.zero_shot(data)
+    score = clf.decision_scores_
+    return score.ravel()
+
+def run_MOMENT_FT(data_train, data_test, win_size=256):
+    from models.MOMENT import MOMENT
+    clf = MOMENT(win_size=win_size, input_c=data_test.shape[1])
+
+    # Finetune
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_M2N2(
+        data_train, data_test, win_size=12, stride=12,
+        batch_size=64, epochs=100, latent_dim=16,
+        lr=1e-3, ttlr=1e-3, normalization='Detrend',
+        gamma=0.99, th=0.9, valid_size=0.2, infer_mode='online'
+    ):
+    from models.M2N2 import M2N2
+    clf = M2N2(
+        win_size=win_size, stride=stride,
+        num_channels=data_test.shape[1],
+        batch_size=batch_size, epochs=epochs,
+        latent_dim=latent_dim,
+        lr=lr, ttlr=ttlr,
+        normalization=normalization,
+        gamma=gamma, th=th, valid_size=valid_size,
+        infer_mode=infer_mode
+    )
+    clf.fit(data_train)
+    score = clf.decision_function(data_test)
+    return score.ravel()
+
+def run_DADA(data_test, device=0, win_size=100, batch_size=32):
+    from models.DADA import DADA
+    clf = DADA(device=device, win_size=win_size, batch_size=batch_size)
+    score = clf.zero_shot(data_test)
+    return score.ravel()
+
+def run_Time_MOE(data, device=0, win_size=64, batch_size=32):
+    from models.time_moe import Time_MOE
+    clf = Time_MOE(device=device, win_size=win_size, batch_size=batch_size)
+    score = clf.zero_shot(data)
+    return score.ravel()
+
+def run_Time_RCD(data,  **kwargs):
+    Multi = kwargs.get('Multi', False)
+    win_size = kwargs.get('win_size', 5000)
+    batch_size = kwargs.get('batch_size', 64)
+    random_mask = kwargs.get('random_mask', 'random_mask')
+    size = kwargs.get('size', 'full')
+    device = kwargs.get('device', '2')  # Extract device parameter
+    """
+    Wrapper function for Time_RCD model
+    """
+    from models.TimeRCD import TimeRCDPretrainTester
+    from models.time_rcd.time_rcd_config import TimeRCDConfig, default_config
+
+    config = default_config
+    if Multi:
+        if size == 'small':
+            if random_mask == 'random_mask':
+                checkpoint_path = 'checkpoints/dataset_10_20.pth'
+            else:
+                checkpoint_path = 'checkpoints/full_mask_10_20.pth'
+            config.ts_config.patch_size = 16
+        else:
+            if random_mask == 'random_mask':
+                checkpoint_path = 'checkpoints/dataset_15_56.pth'
+            else:
+                checkpoint_path = 'checkpoints/full_mask_15_56.pth'
+            config.ts_config.patch_size = 32
+    else:
+        checkpoint_path = 'checkpoints/full_mask_anomaly_head_pretrain_checkpoint_best.pth'
+        config.ts_config.patch_size = 16
+
+    config.cuda_devices = device  # Use the device parameter properly
+    print("Using CUDA device:", config.cuda_devices)
+    config.win_size = win_size
+    config.batch_size = batch_size
+    config.ts_config.num_features = data.shape[1]
+    print(f"Checkpoint path: {checkpoint_path}")
+    cls = TimeRCDPretrainTester(checkpoint_path, config)
+    score_list, logit_list = cls.zero_shot(data)
+
+    # Concatenate across batches robustly to avoid inhomogeneous shape errors
+    score = np.concatenate([np.asarray(s).reshape(-1) for s in score_list], axis=0)
+    logit = np.concatenate([np.asarray(l).reshape(-1) for l in logit_list], axis=0)
+
+    return score, logit
+
+
+def run_TSPulse(data, win_size=256, batch_size=64, prediction_mode=None, aggregation_length=64, 
+                aggr_function="max", smoothing_length=8, least_significant_scale=0.01, 
+                least_significant_score=0.1, device=None):
+    """
+    Wrapper function for TSPulse anomaly detection model
+    
+    Parameters
+    ----------
+    data : numpy.ndarray
+        Time series data of shape (n_samples, n_features)
+    win_size : int, default=256
+        Window size (for compatibility, not directly used by TSPulse)
+    batch_size : int, default=64
+        Batch size for processing
+    prediction_mode : list, optional
+        List of prediction modes. If None, uses default time and frequency reconstruction
+    aggregation_length : int, default=64
+        Length for aggregation of scores
+    aggr_function : str, default="max"
+        Aggregation function ("max", "mean", "median")
+    smoothing_length : int, default=8
+        Length for smoothing the anomaly scores
+    least_significant_scale : float, default=0.01
+        Minimum scale for significance
+    least_significant_score : float, default=0.1
+        Minimum score for significance
+    device : str, optional
+        Device to use ("cuda" or "cpu"). Auto-detected if None.
+    
+    Returns
+    -------
+    numpy.ndarray
+        Anomaly scores of shape (n_samples,)
+    """
+    from models.TSPulse import run_TSPulse as tspulse_runner
+    
+    # Prepare kwargs for TSPulse
+    kwargs = {
+        'batch_size': batch_size,
+        'aggregation_length': aggregation_length,
+        'aggr_function': aggr_function,
+        'smoothing_length': smoothing_length,
+        'least_significant_scale': least_significant_scale,
+        'least_significant_score': least_significant_score,
+    }
+    
+    if prediction_mode is not None:
+        kwargs['prediction_mode'] = prediction_mode
+    if device is not None:
+        kwargs['device'] = device
+    
+    try:
+        # Run TSPulse anomaly detection
+        score = tspulse_runner(data, **kwargs)
+        return score.ravel()
+    except Exception as e:
+        print(f"Warning: TSPulse failed with error: {str(e)}")
+        print("Falling back to random scores")
+        # Return random scores as fallback
+        return np.random.random(len(data)) * 0.1

models/AE.py

@@ -0,0 +1,407 @@
+"""
+This function is adapted from [pyod] by [yzhao062]
+Original source: [https://github.com/yzhao062/pyod]
+"""
+
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import torch, math
+from sklearn.utils import check_array
+from sklearn.utils.validation import check_is_fitted
+from torch import nn
+from sklearn.preprocessing import MinMaxScaler
+
+from .feature import Window
+from .base import BaseDetector
+from ..utils.stat_models import pairwise_distances_no_broadcast
+from ..utils.dataset import TSDataset
+from ..utils.utility import get_activation_by_name   
+
+class InnerAutoencoder(nn.Module):
+    def __init__(self,
+                 n_features,
+                 hidden_neurons=(128, 64),
+                 dropout_rate=0.2,
+                 batch_norm=True,
+                 hidden_activation='relu'):
+
+        # initialize the super class
+        super(InnerAutoencoder, self).__init__()
+
+        # save the default values
+        self.n_features = n_features
+        self.dropout_rate = dropout_rate
+        self.batch_norm = batch_norm
+        self.hidden_activation = hidden_activation
+
+        # create the dimensions for the input and hidden layers
+        self.layers_neurons_encoder_ = [self.n_features, *hidden_neurons]
+        self.layers_neurons_decoder_ = self.layers_neurons_encoder_[::-1]
+
+        # get the object for the activations functions
+        self.activation = get_activation_by_name(hidden_activation)
+
+        # initialize encoder and decoder as a sequential
+        self.encoder = nn.Sequential()
+        self.decoder = nn.Sequential()
+
+        # fill the encoder sequential with hidden layers
+        for idx, layer in enumerate(self.layers_neurons_encoder_[:-1]):
+
+            # create a linear layer of neurons
+            self.encoder.add_module(
+                "linear" + str(idx),
+                torch.nn.Linear(layer,self.layers_neurons_encoder_[idx + 1]))
+
+            # add a batch norm per layer if wanted (leave out first layer)
+            if batch_norm:
+                self.encoder.add_module("batch_norm" + str(idx),
+                                        nn.BatchNorm1d(self.layers_neurons_encoder_[idx + 1]))
+
+            # create the activation
+            self.encoder.add_module(self.hidden_activation + str(idx),
+                                    self.activation)
+
+            # create a dropout layer
+            self.encoder.add_module("dropout" + str(idx),
+                                    torch.nn.Dropout(dropout_rate))
+
+        # fill the decoder layer
+        for idx, layer in enumerate(self.layers_neurons_decoder_[:-1]):
+
+            # create a linear layer of neurons
+            self.decoder.add_module(
+                "linear" + str(idx),
+                torch.nn.Linear(layer,self.layers_neurons_decoder_[idx + 1]))
+
+            # create a batch norm per layer if wanted (only if it is not the
+            # last layer)
+            if batch_norm and idx < len(self.layers_neurons_decoder_[:-1]) - 1:
+                self.decoder.add_module("batch_norm" + str(idx),
+                                        nn.BatchNorm1d(self.layers_neurons_decoder_[idx + 1]))
+
+            # create the activation
+            self.decoder.add_module(self.hidden_activation + str(idx),
+                                    self.activation)
+
+            # create a dropout layer (only if it is not the last layer)
+            if idx < len(self.layers_neurons_decoder_[:-1]) - 1:
+                self.decoder.add_module("dropout" + str(idx),
+                                        torch.nn.Dropout(dropout_rate))
+
+    def forward(self, x):
+        # we could return the latent representation here after the encoder
+        # as the latent representation
+        x = self.encoder(x)
+        x = self.decoder(x)
+        return x
+
+class AutoEncoder(BaseDetector):
+    """Auto Encoder (AE) is a type of neural networks for learning useful data
+    representations in an unsupervised manner. Similar to PCA, AE could be used
+    to detect outlying objects in the data by calculating the reconstruction
+    errors. See :cite:`aggarwal2015outlier` Chapter 3 for details.
+
+    Notes
+    -----
+        This is the PyTorch version of AutoEncoder.
+        The documentation is not finished!
+
+    Parameters
+    ----------
+    hidden_neurons : list, optional (default=[64, 32])
+        The number of neurons per hidden layers. So the network has the
+        structure as [n_features, 64, 32, 32, 64, n_features]
+
+    hidden_activation : str, optional (default='relu')
+        Activation function to use for hidden layers.
+        All hidden layers are forced to use the same type of activation.
+        See https://pytorch.org/docs/stable/nn.html for details.
+
+    batch_norm : boolean, optional (default=True)
+        Whether to apply Batch Normalization,
+        See https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm1d.html
+
+    learning_rate : float, optional (default=1e-3)
+        Learning rate for the optimizer. This learning_rate is given to
+        an Adam optimizer (torch.optim.Adam).
+        See https://pytorch.org/docs/stable/generated/torch.optim.Adam.html
+
+    epochs : int, optional (default=100)
+        Number of epochs to train the model.
+
+    batch_size : int, optional (default=32)
+        Number of samples per gradient update.
+
+    dropout_rate : float in (0., 1), optional (default=0.2)
+        The dropout to be used across all layers.
+
+    weight_decay : float, optional (default=1e-5)
+        The weight decay for Adam optimizer.
+        See https://pytorch.org/docs/stable/generated/torch.optim.Adam.html
+
+    preprocessing : bool, optional (default=True)
+        If True, apply standardization on the data.
+
+    loss_fn : obj, optional (default=torch.nn.MSELoss)
+        Optimizer instance which implements torch.nn._Loss.
+        One of https://pytorch.org/docs/stable/nn.html#loss-functions
+        or a custom loss. Custom losses are currently unstable.
+
+    verbose : int, optional (default=1)
+        Verbosity mode.
+
+        - 0 = silent
+        - 1 = progress bar
+        - 2 = one line per epoch.
+
+        For verbose >= 1, model summary may be printed.
+        !CURRENTLY NOT SUPPORTED.!
+
+    random_state : random_state: int, RandomState instance or None, optional
+        (default=None)
+        If int, random_state is the seed used by the random
+        number generator; If RandomState instance, random_state is the random
+        number generator; If None, the random number generator is the
+        RandomState instance used by `np.random`.
+        !CURRENTLY NOT SUPPORTED.!
+
+    contamination : float in (0., 0.5), optional (default=0.1)
+        The amount of contamination of the data set, i.e.
+        the proportion of outliers in the data set. When fitting this is used
+        to define the threshold on the decision function.
+
+    Attributes
+    ----------
+    encoding_dim_ : int
+        The number of neurons in the encoding layer.
+
+    compression_rate_ : float
+        The ratio between the original feature and
+        the number of neurons in the encoding layer.
+
+    model_ : Keras Object
+        The underlying AutoEncoder in Keras.
+
+    history_: Keras Object
+        The AutoEncoder training history.
+
+    decision_scores_ : numpy array of shape (n_samples,)
+        The outlier scores of the training data.
+        The higher, the more abnormal. Outliers tend to have higher
+        scores. This value is available once the detector is
+        fitted.
+
+    threshold_ : float
+        The threshold is based on ``contamination``. It is the
+        ``n_samples * contamination`` most abnormal samples in
+        ``decision_scores_``. The threshold is calculated for generating
+        binary outlier labels.
+
+    labels_ : int, either 0 or 1
+        The binary labels of the training data. 0 stands for inliers
+        and 1 for outliers/anomalies. It is generated by applying
+        ``threshold_`` on ``decision_scores_``.
+    """
+
+    def __init__(self,
+                 slidingWindow=100,
+                 hidden_neurons=None,
+                 hidden_activation='relu',
+                 batch_norm=True,
+                 learning_rate=1e-3,
+                 epochs=100,
+                 batch_size=32,
+                 dropout_rate=0.2,
+                 weight_decay=1e-5,
+                 # validation_size=0.1,
+                 preprocessing=True,
+                 loss_fn=None,
+                 verbose=False,
+                 # random_state=None,
+                 contamination=0.1,
+                 device=None):
+        super(AutoEncoder, self).__init__(contamination=contamination)
+
+        # save the initialization values
+        self.slidingWindow = slidingWindow
+        self.hidden_neurons = hidden_neurons
+        self.hidden_activation = hidden_activation
+        self.batch_norm = batch_norm
+        self.learning_rate = learning_rate
+        self.epochs = epochs
+        self.batch_size = batch_size
+        self.dropout_rate = dropout_rate
+        self.weight_decay = weight_decay
+        self.preprocessing = preprocessing
+        self.loss_fn = loss_fn
+        self.verbose = verbose
+        self.device = device
+
+        # create default loss functions
+        if self.loss_fn is None:
+            self.loss_fn = torch.nn.MSELoss()
+
+        # create default calculation device (support GPU if available)
+        if self.device is None:
+            self.device = torch.device(
+                "cuda:0" if torch.cuda.is_available() else "cpu")
+
+        # default values for the amount of hidden neurons
+        if self.hidden_neurons is None:
+            self.hidden_neurons = [64, 32]
+
+    # noinspection PyUnresolvedReferences
+    def fit(self, X, y=None):
+        """Fit detector. y is ignored in unsupervised methods.
+
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The input samples.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        n_samples, n_features = X.shape
+
+        if n_features == 1: 
+            # Converting time series data into matrix format
+            X = Window(window = self.slidingWindow).convert(X)
+
+        # validate inputs X and y (optional)
+        X = check_array(X)
+        self._set_n_classes(y)
+
+        n_samples, n_features = X.shape[0], X.shape[1]
+        X = MinMaxScaler(feature_range=(0,1)).fit_transform(X.T).T
+
+        # conduct standardization if needed
+        if self.preprocessing:
+            self.mean, self.std = np.mean(X, axis=0), np.std(X, axis=0)
+            self.std = np.where(self.std == 0, 1e-8, self.std)
+            train_set = TSDataset(X=X, mean=self.mean, std=self.std)
+        else:
+            train_set = TSDataset(X=X)
+
+        train_loader = torch.utils.data.DataLoader(train_set, batch_size=self.batch_size, shuffle=True, drop_last=True)
+
+        # initialize the model
+        self.model = InnerAutoencoder(
+            n_features=n_features,
+            hidden_neurons=self.hidden_neurons,
+            dropout_rate=self.dropout_rate,
+            batch_norm=self.batch_norm,
+            hidden_activation=self.hidden_activation)
+
+        # move to device and print model information
+        self.model = self.model.to(self.device)
+        if self.verbose:
+            print(self.model)
+
+        # train the autoencoder to find the best one
+        self._train_autoencoder(train_loader)
+
+        self.model.load_state_dict(self.best_model_dict)
+        self.decision_scores_ = self.decision_function(X)
+
+        self._process_decision_scores()
+        return self
+
+    def _train_autoencoder(self, train_loader):
+        """Internal function to train the autoencoder
+
+        Parameters
+        ----------
+        train_loader : torch dataloader
+            Train data.
+        """
+        optimizer = torch.optim.Adam(
+            self.model.parameters(), lr=self.learning_rate,
+            weight_decay=self.weight_decay)
+
+        self.best_loss = float('inf')
+        self.best_model_dict = None
+
+        for epoch in range(self.epochs):
+            overall_loss = []
+            for data, data_idx in train_loader:
+                data = data.to(self.device).float()
+                loss = self.loss_fn(data, self.model(data))
+
+                self.model.zero_grad()
+                loss.backward()
+                optimizer.step()
+                overall_loss.append(loss.item())
+            if self.verbose:
+                print('epoch {epoch}: training loss {train_loss} '.format(
+                    epoch=epoch, train_loss=np.mean(overall_loss)))
+
+            # track the best model so far
+            if np.mean(overall_loss) <= self.best_loss:
+                # print("epoch {ep} is the current best; loss={loss}".format(ep=epoch, loss=np.mean(overall_loss)))
+                self.best_loss = np.mean(overall_loss)
+                self.best_model_dict = self.model.state_dict()
+
+    def decision_function(self, X):
+        """Predict raw anomaly score of X using the fitted detector.
+
+        The anomaly score of an input sample is computed based on different
+        detector algorithms. For consistency, outliers are assigned with
+        larger anomaly scores.
+
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only
+            if they are supported by the base estimator.
+
+        Returns
+        -------
+        anomaly_scores : numpy array of shape (n_samples,)
+            The anomaly score of the input samples.
+        """
+        check_is_fitted(self, ['model', 'best_model_dict'])
+
+        n_samples, n_features = X.shape
+
+        if n_features == 1: 
+            # Converting time series data into matrix format
+            X = Window(window = self.slidingWindow).convert(X)
+
+        X = check_array(X)
+        X = MinMaxScaler(feature_range=(0,1)).fit_transform(X.T).T
+
+        # note the shuffle may be true but should be False
+        if self.preprocessing:
+            dataset = TSDataset(X=X, mean=self.mean, std=self.std)
+        else:
+            dataset = TSDataset(X=X)
+
+        dataloader = torch.utils.data.DataLoader(dataset,
+                                                 batch_size=self.batch_size,
+                                                 shuffle=False)
+        # enable the evaluation mode
+        self.model.eval()
+
+        # construct the vector for holding the reconstruction error
+        outlier_scores = np.zeros([X.shape[0], ])
+        with torch.no_grad():
+            for data, data_idx in dataloader:
+                data_cuda = data.to(self.device).float()
+                # this is the outlier score
+                outlier_scores[data_idx] = pairwise_distances_no_broadcast(
+                    data, self.model(data_cuda).cpu().numpy())
+
+        if outlier_scores.shape[0] < n_samples:
+            outlier_scores = np.array([outlier_scores[0]]*math.ceil((self.slidingWindow-1)/2) + 
+                        list(outlier_scores) + [outlier_scores[-1]]*((self.slidingWindow-1)//2))
+
+        return outlier_scores

models/CBLOF.py

@@ -0,0 +1,332 @@
+"""
+This function is adapted from [pyod] by [yzhao062]
+Original source: [https://github.com/yzhao062/pyod]
+"""
+
+from __future__ import division
+from __future__ import print_function
+import warnings
+
+import numpy as np
+from scipy.spatial.distance import cdist
+from sklearn.cluster import KMeans
+from sklearn.utils import check_array
+from sklearn.utils.validation import check_is_fitted
+from sklearn.utils.estimator_checks import check_estimator
+
+from ..utils.stat_models import pairwise_distances_no_broadcast
+from ..utils.utility import check_parameter    
+from .base import BaseDetector
+from ..utils.utility import zscore
+
+
+class CBLOF(BaseDetector):
+    r"""The CBLOF operator calculates the outlier score based on cluster-based
+    local outlier factor.
+
+    CBLOF takes as an input the data set and the cluster model that was
+    generated by a clustering algorithm. It classifies the clusters into small
+    clusters and large clusters using the parameters alpha and beta.
+    The anomaly score is then calculated based on the size of the cluster the
+    point belongs to as well as the distance to the nearest large cluster.
+
+    Use weighting for outlier factor based on the sizes of the clusters as
+    proposed in the original publication. Since this might lead to unexpected
+    behavior (outliers close to small clusters are not found), it is disabled
+    by default.Outliers scores are solely computed based on their distance to
+    the closest large cluster center.
+
+    By default, kMeans is used for clustering algorithm instead of
+    Squeezer algorithm mentioned in the original paper for multiple reasons.
+
+    See :cite:`he2003discovering` for details.
+
+    Parameters
+    ----------
+    n_clusters : int, optional (default=8)
+        The number of clusters to form as well as the number of
+        centroids to generate.
+
+    contamination : float in (0., 0.5), optional (default=0.1)
+        The amount of contamination of the data set,
+        i.e. the proportion of outliers in the data set. Used when fitting to
+        define the threshold on the decision function.
+
+    clustering_estimator : Estimator, optional (default=None)
+        The base clustering algorithm for performing data clustering.
+        A valid clustering algorithm should be passed in. The estimator should
+        have standard sklearn APIs, fit() and predict(). The estimator should
+        have attributes ``labels_`` and ``cluster_centers_``.
+        If ``cluster_centers_`` is not in the attributes once the model is fit,
+        it is calculated as the mean of the samples in a cluster.
+
+        If not set, CBLOF uses KMeans for scalability. See
+        https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html
+
+    alpha : float in (0.5, 1), optional (default=0.9)
+        Coefficient for deciding small and large clusters. The ratio
+        of the number of samples in large clusters to the number of samples in
+        small clusters.
+
+    beta : int or float in (1,), optional (default=5).
+        Coefficient for deciding small and large clusters. For a list
+        sorted clusters by size `|C1|, \|C2|, ..., |Cn|, beta = |Ck|/|Ck-1|`
+
+    use_weights : bool, optional (default=False)
+        If set to True, the size of clusters are used as weights in
+        outlier score calculation.
+
+    check_estimator : bool, optional (default=False)
+        If set to True, check whether the base estimator is consistent with
+        sklearn standard.
+
+        .. warning::
+            check_estimator may throw errors with scikit-learn 0.20 above.
+
+    random_state : int, RandomState or None, optional (default=None)
+        If int, random_state is the seed used by the random
+        number generator; If RandomState instance, random_state is the random
+        number generator; If None, the random number generator is the
+        RandomState instance used by `np.random`.
+
+
+    Attributes
+    ----------
+    clustering_estimator_ : Estimator, sklearn instance
+        Base estimator for clustering.
+
+    cluster_labels_ : list of shape (n_samples,)
+        Cluster assignment for the training samples.
+
+    n_clusters_ : int
+        Actual number of clusters (possibly different from n_clusters).
+
+    cluster_sizes_ : list of shape (n_clusters_,)
+        The size of each cluster once fitted with the training data.
+
+    decision_scores_ : numpy array of shape (n_samples,)
+        The outlier scores of the training data.
+        The higher, the more abnormal. Outliers tend to have higher scores.
+        This value is available once the detector is fitted.
+
+    cluster_centers_ : numpy array of shape (n_clusters_, n_features)
+        The center of each cluster.
+
+    small_cluster_labels_ : list of clusters numbers
+        The cluster assignments belonging to small clusters.
+
+    large_cluster_labels_ : list of clusters numbers
+        The cluster assignments belonging to large clusters.
+
+    threshold_ : float
+        The threshold is based on ``contamination``. It is the
+        ``n_samples * contamination`` most abnormal samples in
+        ``decision_scores_``. The threshold is calculated for generating
+        binary outlier labels.
+
+    labels_ : int, either 0 or 1
+        The binary labels of the training data. 0 stands for inliers
+        and 1 for outliers/anomalies. It is generated by applying
+        ``threshold_`` on ``decision_scores_``.
+    """
+
+    def __init__(self, n_clusters=8, contamination=0.1,
+                 clustering_estimator=None, alpha=0.9, beta=5,
+                 use_weights=False, check_estimator=False, random_state=0,
+                 n_jobs=1, normalize=True):
+        super(CBLOF, self).__init__(contamination=contamination)
+        self.n_clusters = n_clusters
+        self.clustering_estimator = clustering_estimator
+        self.alpha = alpha
+        self.beta = beta
+        self.use_weights = use_weights
+        self.check_estimator = check_estimator
+        self.random_state = random_state
+        self.normalize = normalize
+
+    # noinspection PyIncorrectDocstring
+    def fit(self, X, y=None):
+        """Fit detector. y is ignored in unsupervised methods.
+
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The input samples.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+
+        # validate inputs X and y (optional)
+        X = check_array(X)
+        self._set_n_classes(y)
+        n_samples, n_features = X.shape
+        if self.normalize: X = zscore(X, axis=1, ddof=1)
+
+        # check parameters
+        # number of clusters are default to 8
+        self._validate_estimator(default=KMeans(
+            n_clusters=self.n_clusters,
+            random_state=self.random_state))
+
+        self.clustering_estimator_.fit(X=X, y=y)
+        # Get the labels of the clustering results
+        # labels_ is consistent across sklearn clustering algorithms
+        self.cluster_labels_ = self.clustering_estimator_.labels_
+        self.cluster_sizes_ = np.bincount(self.cluster_labels_)
+
+        # Get the actual number of clusters
+        self.n_clusters_ = self.cluster_sizes_.shape[0]
+
+        if self.n_clusters_ != self.n_clusters:
+            warnings.warn("The chosen clustering for CBLOF forms {0} clusters"
+                          "which is inconsistent with n_clusters ({1}).".
+                          format(self.n_clusters_, self.n_clusters))
+
+        self._set_cluster_centers(X, n_features)
+        self._set_small_large_clusters(n_samples)
+
+        self.decision_scores_ = self._decision_function(X,
+                                                        self.cluster_labels_)
+
+        self._process_decision_scores()
+        return self
+
+    def decision_function(self, X):
+        """Predict raw anomaly score of X using the fitted detector.
+
+        The anomaly score of an input sample is computed based on different
+        detector algorithms. For consistency, outliers are assigned with
+        larger anomaly scores.
+
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only
+            if they are supported by the base estimator.
+
+        Returns
+        -------
+        anomaly_scores : numpy array of shape (n_samples,)
+            The anomaly score of the input samples.
+        """
+        check_is_fitted(self, ['decision_scores_', 'threshold_', 'labels_'])
+        X = check_array(X)
+        labels = self.clustering_estimator_.predict(X)
+        return self._decision_function(X, labels)
+
+    def _validate_estimator(self, default=None):
+        """Check the value of alpha and beta and clustering algorithm.
+        """
+        check_parameter(self.alpha, low=0, high=1, param_name='alpha',
+                        include_left=False, include_right=False)
+
+        check_parameter(self.beta, low=1, param_name='beta',
+                        include_left=False)
+
+        if self.clustering_estimator is not None:
+            self.clustering_estimator_ = self.clustering_estimator
+        else:
+            self.clustering_estimator_ = default
+
+        # make sure the base clustering algorithm is valid
+        if self.clustering_estimator_ is None:
+            raise ValueError("clustering algorithm cannot be None")
+
+        if self.check_estimator:
+            check_estimator(self.clustering_estimator_)
+
+    def _set_cluster_centers(self, X, n_features):
+        # Noted not all clustering algorithms have cluster_centers_
+        if hasattr(self.clustering_estimator_, 'cluster_centers_'):
+            self.cluster_centers_ = self.clustering_estimator_.cluster_centers_
+        else:
+            # Set the cluster center as the mean of all the samples within
+            # the cluster
+            warnings.warn("The chosen clustering for CBLOF does not have"
+                          "the center of clusters. Calculate the center"
+                          "as the mean of the clusters.")
+            self.cluster_centers_ = np.zeros([self.n_clusters_, n_features])
+            for i in range(self.n_clusters_):
+                self.cluster_centers_[i, :] = np.mean(
+                    X[np.where(self.cluster_labels_ == i)], axis=0)
+
+    def _set_small_large_clusters(self, n_samples):
+        # Sort the index of clusters by the number of samples belonging to it
+        size_clusters = np.bincount(self.cluster_labels_)
+
+        # Sort the order from the largest to the smallest
+        sorted_cluster_indices = np.argsort(size_clusters * -1)
+
+        # Initialize the lists of index that fulfill the requirements by
+        # either alpha or beta
+        alpha_list = []
+        beta_list = []
+
+        for i in range(1, self.n_clusters_):
+            temp_sum = np.sum(size_clusters[sorted_cluster_indices[:i]])
+            if temp_sum >= n_samples * self.alpha:
+                alpha_list.append(i)
+
+            if size_clusters[sorted_cluster_indices[i - 1]] / size_clusters[
+                sorted_cluster_indices[i]] >= self.beta:
+                beta_list.append(i)
+
+            # Find the separation index fulfills both alpha and beta
+        intersection = np.intersect1d(alpha_list, beta_list)
+
+        if len(intersection) > 0:
+            self._clustering_threshold = intersection[0]
+        elif len(alpha_list) > 0:
+            self._clustering_threshold = alpha_list[0]
+        elif len(beta_list) > 0:
+            self._clustering_threshold = beta_list[0]
+        else:
+            raise ValueError("Could not form valid cluster separation. Please "
+                             "change n_clusters or change clustering method")
+
+        self.small_cluster_labels_ = sorted_cluster_indices[
+                                     self._clustering_threshold:]
+        self.large_cluster_labels_ = sorted_cluster_indices[
+                                     0:self._clustering_threshold]
+
+        # No need to calculate small cluster center
+        # self.small_cluster_centers_ = self.cluster_centers_[
+        #     self.small_cluster_labels_]
+
+        self._large_cluster_centers = self.cluster_centers_[
+            self.large_cluster_labels_]
+
+    def _decision_function(self, X, labels):
+        # Initialize the score array
+        scores = np.zeros([X.shape[0], ])
+
+        small_indices = np.where(
+            np.isin(labels, self.small_cluster_labels_))[0]
+        large_indices = np.where(
+            np.isin(labels, self.large_cluster_labels_))[0]
+
+        if small_indices.shape[0] != 0:
+            # Calculate the outlier factor for the samples in small clusters
+            dist_to_large_center = cdist(X[small_indices, :],
+                                         self._large_cluster_centers)
+
+            scores[small_indices] = np.min(dist_to_large_center, axis=1)
+
+        if large_indices.shape[0] != 0:
+            # Calculate the outlier factor for the samples in large clusters
+            large_centers = self.cluster_centers_[labels[large_indices]]
+
+            scores[large_indices] = pairwise_distances_no_broadcast(
+                X[large_indices, :], large_centers)
+
+        if self.use_weights:
+            # Weights are calculated as the number of elements in the cluster
+            scores = scores * self.cluster_sizes_[labels]
+
+        return scores.ravel()

models/CNN.py

@@ -0,0 +1,273 @@
+from typing import Dict
+import torchinfo
+import tqdm, math
+import numpy as np
+import torch
+from torch import nn, optim
+from torch.utils.data import DataLoader
+
+from ..utils.utility import get_activation_by_name
+from ..utils.torch_utility import EarlyStoppingTorch, get_gpu
+from ..utils.dataset import ForecastDataset
+
+class AdaptiveConcatPool1d(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.ap = torch.nn.AdaptiveAvgPool1d(1)
+        self.mp = torch.nn.AdaptiveAvgPool1d(1)
+    
+    def forward(self, x):
+        return torch.cat([self.ap(x), self.mp(x)], 1)
+
+class CNNModel(nn.Module):
+    def __init__(self,
+                 n_features,
+                 num_channel=[32, 32, 40],
+                 kernel_size=3,
+                 stride=1,
+                 predict_time_steps=1,
+                 dropout_rate=0.25,
+                 hidden_activation='relu',
+                 device='cpu'):
+
+        # initialize the super class
+        super(CNNModel, self).__init__()
+
+        # save the default values
+        self.n_features = n_features
+        self.dropout_rate = dropout_rate
+        self.hidden_activation = hidden_activation
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.predict_time_steps = predict_time_steps
+        self.num_channel = num_channel
+        self.device = device
+
+        # get the object for the activations functions
+        self.activation = get_activation_by_name(hidden_activation)
+
+        # initialize encoder and decoder as a sequential
+        self.conv_layers = nn.Sequential()
+        prev_channels = self.n_features
+
+        for idx, out_channels in enumerate(self.num_channel[:-1]):
+            self.conv_layers.add_module(
+                "conv" + str(idx),
+                torch.nn.Conv1d(prev_channels, self.num_channel[idx + 1], 
+                self.kernel_size, self.stride))
+            self.conv_layers.add_module(self.hidden_activation + str(idx),
+                                    self.activation)
+            self.conv_layers.add_module("pool" + str(idx), nn.MaxPool1d(kernel_size=2))
+            prev_channels = out_channels
+
+        self.fc = nn.Sequential(
+            AdaptiveConcatPool1d(),
+            torch.nn.Flatten(),
+            torch.nn.Linear(2*self.num_channel[-1], self.num_channel[-1]),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(dropout_rate),
+            torch.nn.Linear(self.num_channel[-1], self.n_features)
+        )
+
+    def forward(self, x):
+        b, l, c = x.shape
+        x = x.view(b, c, l)
+        x = self.conv_layers(x)     # [128, feature, 23]
+
+        outputs = torch.zeros(self.predict_time_steps, b, self.n_features).to(self.device)
+        for t in range(self.predict_time_steps):
+            decoder_input = self.fc(x)
+            outputs[t] = torch.squeeze(decoder_input, dim=-2)
+
+        return outputs
+    
+class CNN():
+    def __init__(self,
+                 window_size=100,
+                 pred_len=1,
+                 batch_size=128,
+                 epochs=50,
+                 lr=0.0008,
+                 feats=1,
+                 num_channel=[32, 32, 40],
+                 validation_size=0.2):
+        super().__init__()
+        self.__anomaly_score = None
+        
+        cuda = True
+        self.y_hats = None
+        
+        self.cuda = cuda
+        self.device = get_gpu(self.cuda)
+        
+        self.window_size = window_size
+        self.pred_len = pred_len
+        self.batch_size = batch_size
+        self.epochs = epochs
+        
+        self.feats = feats
+        self.num_channel = num_channel
+        self.lr = lr
+        self.validation_size = validation_size
+        
+        self.model = CNNModel(n_features=feats, num_channel=num_channel, predict_time_steps=self.pred_len, device=self.device).to(self.device)
+        
+        self.optimizer = optim.Adam(self.model.parameters(), lr=lr)
+        self.scheduler = optim.lr_scheduler.StepLR(self.optimizer, step_size=5, gamma=0.75)
+        self.loss = nn.MSELoss()
+        self.save_path = None
+        self.early_stopping = EarlyStoppingTorch(save_path=self.save_path, patience=3)
+        
+        self.mu = None
+        self.sigma = None
+        self.eps = 1e-10
+        
+    def fit(self, data):
+        tsTrain = data[:int((1-self.validation_size)*len(data))]
+        tsValid = data[int((1-self.validation_size)*len(data)):]
+
+        train_loader = DataLoader(
+            ForecastDataset(tsTrain, window_size=self.window_size, pred_len=self.pred_len),
+            batch_size=self.batch_size,
+            shuffle=True)
+        
+        valid_loader = DataLoader(
+            ForecastDataset(tsValid, window_size=self.window_size, pred_len=self.pred_len),
+            batch_size=self.batch_size,
+            shuffle=False)
+        
+        for epoch in range(1, self.epochs + 1):
+            self.model.train(mode=True)
+            avg_loss = 0
+            loop = tqdm.tqdm(enumerate(train_loader),total=len(train_loader),leave=True)
+            for idx, (x, target) in loop:
+                x, target = x.to(self.device), target.to(self.device)
+
+                # print('x: ', x.shape)       # (bs, win, feat)
+                # print('target: ', target.shape)     # # (bs, pred_len, feat)
+                # print('len(tsTrain): ', len(tsTrain))
+                # print('len(train_loader): ', len(train_loader))
+
+                self.optimizer.zero_grad()
+                
+                output = self.model(x)
+                output = output.view(-1, self.feats*self.pred_len)
+                target = target.view(-1, self.feats*self.pred_len)
+
+                loss = self.loss(output, target)
+                loss.backward()
+
+                self.optimizer.step()
+                
+                avg_loss += loss.cpu().item()
+                loop.set_description(f'Training Epoch [{epoch}/{self.epochs}]')
+                loop.set_postfix(loss=loss.item(), avg_loss=avg_loss/(idx+1))
+            
+            
+            self.model.eval()
+            scores = []
+            avg_loss = 0
+            loop = tqdm.tqdm(enumerate(valid_loader),total=len(valid_loader),leave=True)
+            with torch.no_grad():
+                for idx, (x, target) in loop:
+                    x, target = x.to(self.device), target.to(self.device)
+
+                    output = self.model(x)
+                    
+                    output = output.view(-1, self.feats*self.pred_len)
+                    target = target.view(-1, self.feats*self.pred_len)
+                    
+                    loss = self.loss(output, target)
+                    avg_loss += loss.cpu().item()
+                    loop.set_description(f'Validation Epoch [{epoch}/{self.epochs}]')
+                    loop.set_postfix(loss=loss.item(), avg_loss=avg_loss/(idx+1))
+                    
+                    mse = torch.sub(output, target).pow(2)
+                    scores.append(mse.cpu())
+                    
+            
+            valid_loss = avg_loss/max(len(valid_loader), 1)
+            self.scheduler.step()
+            
+            self.early_stopping(valid_loss, self.model)
+            if self.early_stopping.early_stop or epoch == self.epochs - 1:
+                # fitting Gaussian Distribution
+                if len(scores) > 0:
+                    scores = torch.cat(scores, dim=0)
+                    self.mu = torch.mean(scores)
+                    self.sigma = torch.var(scores)
+                    print(self.mu.size(), self.sigma.size())
+                if self.early_stopping.early_stop:
+                    print("   Early stopping<<<")
+                break
+
+    def decision_function(self, data):
+        test_loader = DataLoader(
+            ForecastDataset(data, window_size=self.window_size, pred_len=self.pred_len),
+            batch_size=self.batch_size,
+            shuffle=False
+        )
+        
+        self.model.eval()
+        scores = []
+        y_hats = []
+        loop = tqdm.tqdm(enumerate(test_loader),total=len(test_loader),leave=True)
+        with torch.no_grad():
+            for idx, (x, target) in loop:
+                x, target = x.to(self.device), target.to(self.device)
+                output = self.model(x)
+                
+                output = output.view(-1, self.feats*self.pred_len)
+                target = target.view(-1, self.feats*self.pred_len)
+
+                mse = torch.sub(output, target).pow(2)
+
+                y_hats.append(output.cpu())
+                scores.append(mse.cpu())
+                loop.set_description(f'Testing: ')
+
+        scores = torch.cat(scores, dim=0)
+        # scores = 0.5 * (torch.log(self.sigma + self.eps) + (scores - self.mu)**2 / (self.sigma+self.eps))
+        
+        scores = scores.numpy()
+        scores = np.mean(scores, axis=1)
+        
+        y_hats = torch.cat(y_hats, dim=0)
+        y_hats = y_hats.numpy()
+        
+        l, w = y_hats.shape
+        
+        # new_scores = np.zeros((l - self.pred_len, w))
+        # for i in range(w):
+        #     new_scores[:, i] = scores[self.pred_len - i:l-i, i]
+        # scores = np.mean(new_scores, axis=1)
+        # scores = np.pad(scores, (0, self.pred_len - 1), 'constant', constant_values=(0,0))
+        
+        # new_y_hats = np.zeros((l - self.pred_len, w))
+        # for i in range(w):
+        #     new_y_hats[:, i] = y_hats[self.pred_len - i:l-i, i]
+        # y_hats = np.mean(new_y_hats, axis=1)
+        # y_hats = np.pad(y_hats, (0, self.pred_len - 1), 'constant',constant_values=(0,0))
+
+        assert scores.ndim == 1
+        # self.y_hats = y_hats
+        
+        print('scores: ', scores.shape)
+        if scores.shape[0] < len(data):
+            padded_decision_scores_ = np.zeros(len(data))
+            padded_decision_scores_[: self.window_size+self.pred_len-1] = scores[0]
+            padded_decision_scores_[self.window_size+self.pred_len-1 : ] = scores
+
+        self.__anomaly_score = padded_decision_scores_
+        return padded_decision_scores_
+
+    def anomaly_score(self) -> np.ndarray:
+        return self.__anomaly_score
+    
+    def get_y_hat(self) -> np.ndarray:
+        return self.y_hats
+    
+    def param_statistic(self, save_file):
+        model_stats = torchinfo.summary(self.model, (self.batch_size, self.window_size), verbose=0)
+        with open(save_file, 'w') as f:
+            f.write(str(model_stats))

models/COF.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+"""
+This function is adapted from [pyod] by [yzhao062]
+Original source: [https://github.com/yzhao062/pyod]
+"""
+
+from __future__ import division
+from __future__ import print_function
+
+import warnings
+from operator import itemgetter
+
+import numpy as np
+from scipy.spatial import distance_matrix
+from scipy.spatial import minkowski_distance
+from sklearn.utils import check_array
+
+from .base import BaseDetector
+from ..utils.utility import check_parameter
+
+
+class COF(BaseDetector):
+    """Connectivity-Based Outlier Factor (COF) COF uses the ratio of average
+    chaining distance of data point and the average of average chaining
+    distance of k nearest neighbor of the data point, as the outlier score
+    for observations.
+
+    See :cite:`tang2002enhancing` for details.
+    
+    Two version of COF are supported:
+
+    - Fast COF: computes the entire pairwise distance matrix at the cost of a
+      O(n^2) memory requirement.
+    - Memory efficient COF: calculates pairwise distances incrementally.
+      Use this implementation when it is not feasible to fit the n-by-n 
+      distance in memory. This leads to a linear overhead because many 
+      distances will have to be recalculated.
+
+    Parameters
+    ----------
+    contamination : float in (0., 0.5), optional (default=0.1)
+        The amount of contamination of the data set, i.e.
+        the proportion of outliers in the data set. Used when fitting to
+        define the threshold on the decision function.
+
+    n_neighbors : int, optional (default=20)
+        Number of neighbors to use by default for k neighbors queries.
+        Note that n_neighbors should be less than the number of samples.
+        If n_neighbors is larger than the number of samples provided,
+        all samples will be used.
+        
+    method : string, optional (default='fast')
+        Valid values for method are:
+            
+        - 'fast' Fast COF, computes the full pairwise distance matrix up front.
+        - 'memory' Memory-efficient COF, computes pairwise distances only when
+          needed at the cost of computational speed.
+
+    Attributes
+    ----------
+    decision_scores_ : numpy array of shape (n_samples,)
+        The outlier scores of the training data.
+        The higher, the more abnormal. Outliers tend to have higher
+        scores. This value is available once the detector is
+        fitted.
+
+    threshold_ : float
+        The threshold is based on ``contamination``. It is the
+        ``n_samples * contamination`` most abnormal samples in
+        ``decision_scores_``. The threshold is calculated for generating
+        binary outlier labels.
+
+    labels_ : int, either 0 or 1
+        The binary labels of the training data. 0 stands for inliers
+        and 1 for outliers/anomalies. It is generated by applying
+        ``threshold_`` on ``decision_scores_``.
+
+    n_neighbors_: int
+        Number of neighbors to use by default for k neighbors queries.
+    """
+
+    def __init__(self, contamination=0.1, n_neighbors=20, method="fast"):
+        super(COF, self).__init__(contamination=contamination)
+        if isinstance(n_neighbors, int):
+            check_parameter(n_neighbors, low=1, param_name='n_neighbors')
+        else:
+            raise TypeError(
+                "n_neighbors should be int. Got %s" % type(n_neighbors))
+        self.n_neighbors = n_neighbors
+        self.method = method
+
+    def fit(self, X, y=None):
+        """Fit detector. y is ignored in unsupervised methods.
+
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The input samples.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        X = check_array(X)
+        self.n_train_ = X.shape[0]
+        self.n_neighbors_ = self.n_neighbors
+
+        if self.n_neighbors_ >= self.n_train_:
+            self.n_neighbors_ = self.n_train_ - 1
+            warnings.warn(
+                "n_neighbors is set to the number of training points "
+                "minus 1: {0}".format(self.n_neighbors_))
+
+            check_parameter(self.n_neighbors_, 1, self.n_train_,
+                            include_left=True, include_right=True)
+
+        self._set_n_classes(y)
+        self.decision_scores_ = self.decision_function(X)
+        self._process_decision_scores()
+
+        return self
+
+    def decision_function(self, X):
+        """Predict raw anomaly score of X using the fitted detector.
+        The anomaly score of an input sample is computed based on different
+        detector algorithms. For consistency, outliers are assigned with
+        larger anomaly scores.
+
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only
+            if they are supported by the base estimator.
+
+        Returns
+        -------
+        anomaly_scores : numpy array of shape (n_samples,)
+            The anomaly score of the input samples.
+        """
+        if self.method.lower() == "fast":
+            return self._cof_fast(X)
+        elif self.method.lower() == "memory":
+            return self._cof_memory(X)
+        else:
+            raise ValueError("method should be set to either \'fast\' or \'memory\'. Got %s" % self.method)
+
+    def _cof_memory(self, X):
+        """
+        Connectivity-Based Outlier Factor (COF) Algorithm
+        This function is called internally to calculate the
+        Connectivity-Based Outlier Factor (COF) as an outlier
+        score for observations.
+        This function uses a memory efficient implementation at the cost of 
+        speed.
+        :return: numpy array containing COF scores for observations.
+                 The greater the COF, the greater the outlierness.
+        """
+        #dist_matrix = np.array(distance_matrix(X, X))
+        sbn_path_index = np.zeros((X.shape[0],self.n_neighbors_), dtype=np.int64)
+        ac_dist, cof_ = np.zeros((X.shape[0])), np.zeros((X.shape[0]))
+        for i in range(X.shape[0]):
+            #sbn_path = np.argsort(dist_matrix[i])
+            sbn_path = np.argsort(minkowski_distance(X[i,:],X,p=2))
+            sbn_path_index[i,:] = sbn_path[1: self.n_neighbors_ + 1]
+            cost_desc = np.zeros((self.n_neighbors_))
+            for j in range(self.n_neighbors_):
+                #cost_desc.append(
+                #    np.min(dist_matrix[sbn_path[j + 1]][sbn_path][:j + 1]))
+                cost_desc[j] = np.min(minkowski_distance(X[sbn_path[j + 1]],X,p=2)[sbn_path][:j + 1])
+            acd = np.zeros((self.n_neighbors_))
+            for _h, cost_ in enumerate(cost_desc):
+                neighbor_add1 = self.n_neighbors_ + 1
+                acd[_h] = ((2. * (neighbor_add1 - (_h + 1))) / (neighbor_add1 * self.n_neighbors_)) * cost_
+            ac_dist[i] = np.sum(acd)
+        for _g in range(X.shape[0]):
+            cof_[_g] = (ac_dist[_g] * self.n_neighbors_) / np.sum(ac_dist[sbn_path_index[_g]])
+        return np.nan_to_num(cof_)
+    
+    def _cof_fast(self, X):
+        """
+        Connectivity-Based Outlier Factor (COF) Algorithm
+        This function is called internally to calculate the
+        Connectivity-Based Outlier Factor (COF) as an outlier
+        score for observations.
+        This function uses a fast implementation at the cost of memory.
+        :return: numpy array containing COF scores for observations.
+                 The greater the COF, the greater the outlierness.
+        """
+        dist_matrix = np.array(distance_matrix(X, X))
+        sbn_path_index, ac_dist, cof_ = [], [], []
+        for i in range(X.shape[0]):
+            sbn_path = np.argsort(dist_matrix[i])
+            sbn_path_index.append(sbn_path[1: self.n_neighbors_ + 1])
+            cost_desc = []
+            for j in range(self.n_neighbors_):
+                cost_desc.append(
+                    np.min(dist_matrix[sbn_path[j + 1]][sbn_path][:j + 1]))
+            acd = []
+            for _h, cost_ in enumerate(cost_desc):
+                neighbor_add1 = self.n_neighbors_ + 1
+                acd.append(((2. * (neighbor_add1 - (_h + 1))) / (
+                        neighbor_add1 * self.n_neighbors_)) * cost_)
+            ac_dist.append(np.sum(acd))
+        for _g in range(X.shape[0]):
+            cof_.append((ac_dist[_g] * self.n_neighbors_) /
+                        np.sum(itemgetter(*sbn_path_index[_g])(ac_dist)))
+        return np.nan_to_num(cof_)

models/COPOD.py

@@ -0,0 +1,205 @@
+"""
+This function is adapted from [pyod] by [yzhao062]
+Original source: [https://github.com/yzhao062/pyod]
+"""
+
+from __future__ import division
+from __future__ import print_function
+import warnings
+
+import numpy as np
+
+from joblib import Parallel, delayed
+from scipy.stats import skew as skew_sp
+from sklearn.utils.validation import check_is_fitted
+from sklearn.utils import check_array
+
+from .base import BaseDetector
+from ..utils.stat_models import column_ecdf
+from ..utils.utility import _partition_estimators
+from ..utils.utility import zscore
+
+def skew(X, axis=0):
+    return np.nan_to_num(skew_sp(X, axis=axis))
+
+def _parallel_ecdf(n_dims, X):
+    """Private method to calculate ecdf in parallel.    
+    Parameters
+    ----------
+    n_dims : int
+        The number of dimensions of the current input matrix
+
+    X : numpy array
+        The subarray for building the ECDF
+
+    Returns
+    -------
+    U_l_mat : numpy array
+        ECDF subarray.
+
+    U_r_mat : numpy array
+        ECDF subarray.
+    """
+    U_l_mat = np.zeros([X.shape[0], n_dims])
+    U_r_mat = np.zeros([X.shape[0], n_dims])
+
+    for i in range(n_dims):
+        U_l_mat[:, i: i + 1] = column_ecdf(X[:, i: i + 1])
+        U_r_mat[:, i: i + 1] = column_ecdf(X[:, i: i + 1] * -1)
+    return U_l_mat, U_r_mat
+
+class COPOD(BaseDetector):
+    """COPOD class for Copula Based Outlier Detector.
+    COPOD is a parameter-free, highly interpretable outlier detection algorithm
+    based on empirical copula models.
+    See :cite:`li2020copod` for details.
+
+    Parameters
+    ----------
+    contamination : float in (0., 0.5), optional (default=0.1)
+        The amount of contamination of the data set, i.e.
+        the proportion of outliers in the data set. Used when fitting to
+        define the threshold on the decision function.
+        
+    n_jobs : optional (default=1)
+        The number of jobs to run in parallel for both `fit` and
+        `predict`. If -1, then the number of jobs is set to the
+        number of cores.
+
+    Attributes
+    ----------
+    decision_scores_ : numpy array of shape (n_samples,)
+        The outlier scores of the training data.
+        The higher, the more abnormal. Outliers tend to have higher
+        scores. This value is available once the detector is
+        fitted.
+    threshold_ : float
+        The threshold is based on ``contamination``. It is the
+        ``n_samples * contamination`` most abnormal samples in
+        ``decision_scores_``. The threshold is calculated for generating
+        binary outlier labels.
+    labels_ : int, either 0 or 1
+        The binary labels of the training data. 0 stands for inliers
+        and 1 for outliers/anomalies. It is generated by applying
+        ``threshold_`` on ``decision_scores_``.
+    """
+
+    def __init__(self, contamination=0.1, n_jobs=1, normalize=True):
+        super(COPOD, self).__init__(contamination=contamination)
+
+        #TODO: Make it parameterized for n_jobs
+        self.n_jobs = n_jobs
+        self.normalize = normalize
+
+    def fit(self, X, y=None):
+        """Fit detector. y is ignored in unsupervised methods.
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The input samples.
+        y : Ignored
+            Not used, present for API consistency by convention.
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        X = check_array(X)
+        if self.normalize: X = zscore(X, axis=1, ddof=1)
+
+        self._set_n_classes(y)
+        self.decision_scores_ = self.decision_function(X)
+        self.X_train = X
+        self._process_decision_scores()
+        return self
+
+    def decision_function(self, X):
+        """Predict raw anomaly score of X using the fitted detector.
+         For consistency, outliers are assigned with larger anomaly scores.
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only
+            if they are supported by the base estimator.
+        Returns
+        -------
+        anomaly_scores : numpy array of shape (n_samples,)
+            The anomaly score of the input samples.
+        """
+        # use multi-thread execution
+        if self.n_jobs != 1:
+            return self._decision_function_parallel(X)
+        if hasattr(self, 'X_train'):
+            original_size = X.shape[0]
+            X = np.concatenate((self.X_train, X), axis=0)
+        self.U_l = -1 * np.log(column_ecdf(X))
+        self.U_r = -1 * np.log(column_ecdf(-X))
+
+        skewness = np.sign(skew(X, axis=0))
+        self.U_skew = self.U_l * -1 * np.sign(
+            skewness - 1) + self.U_r * np.sign(skewness + 1)
+        self.O = np.maximum(self.U_skew, np.add(self.U_l, self.U_r) / 2)
+        if hasattr(self, 'X_train'):
+            decision_scores_ = self.O.sum(axis=1)[-original_size:]
+        else:
+            decision_scores_ = self.O.sum(axis=1)
+        return decision_scores_.ravel()
+
+    def _decision_function_parallel(self, X):
+        """Predict raw anomaly score of X using the fitted detector.
+         For consistency, outliers are assigned with larger anomaly scores.
+        Parameters
+        ----------
+        X : numpy array of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only
+            if they are supported by the base estimator.
+        Returns
+        -------
+        anomaly_scores : numpy array of shape (n_samples,)
+            The anomaly score of the input samples.
+        """
+        if hasattr(self, 'X_train'):
+            original_size = X.shape[0]
+            X = np.concatenate((self.X_train, X), axis=0)
+
+        n_samples, n_features = X.shape[0], X.shape[1]
+
+        if n_features < 2:
+            raise ValueError(
+                'n_jobs should not be used on one dimensional dataset')
+
+        if n_features <= self.n_jobs:
+            self.n_jobs = n_features
+            warnings.warn("n_features <= n_jobs; setting them equal instead.")
+
+        n_jobs, n_dims_list, starts = _partition_estimators(n_features,
+                                                            self.n_jobs)
+
+        all_results = Parallel(n_jobs=n_jobs, max_nbytes=None,
+                               verbose=True)(
+            delayed(_parallel_ecdf)(
+                n_dims_list[i],
+                X[:, starts[i]:starts[i + 1]],
+            )
+            for i in range(n_jobs))
+
+        # recover the results
+        self.U_l = np.zeros([n_samples, n_features])
+        self.U_r = np.zeros([n_samples, n_features])
+
+        for i in range(n_jobs):
+            self.U_l[:, starts[i]:starts[i + 1]] = all_results[i][0]
+            self.U_r[:, starts[i]:starts[i + 1]] = all_results[i][1]
+
+        self.U_l = -1 * np.log(self.U_l)
+        self.U_r = -1 * np.log(self.U_r)
+
+        skewness = np.sign(skew(X, axis=0))
+        self.U_skew = self.U_l * -1 * np.sign(
+            skewness - 1) + self.U_r * np.sign(skewness + 1)
+        self.O = np.maximum(self.U_skew, np.add(self.U_l, self.U_r) / 2)
+        if hasattr(self, 'X_train'):
+            decision_scores_ = self.O.sum(axis=1)[-original_size:]
+        else:
+            decision_scores_ = self.O.sum(axis=1)
+        return decision_scores_.ravel()

models/Chronos.py

@@ -0,0 +1,94 @@
+"""
+This function is adapted from [chronos-forecasting] by [lostella et al.]
+Original source: [https://github.com/amazon-science/chronos-forecasting]
+"""
+
+from autogluon.timeseries import TimeSeriesPredictor
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
+import pandas as pd
+import tempfile
+
+from .base import BaseDetector
+
+
+class Chronos(BaseDetector):
+    def __init__(self, 
+                 win_size=100,
+                 model_size = 'base',  # [tiny, small, base]
+                 prediction_length=1, 
+                 input_c=1, 
+                 batch_size=128):
+
+        self.model_name = 'Chronos'
+        self.model_size = model_size
+        self.win_size = win_size
+        self.prediction_length = prediction_length
+        self.input_c = input_c
+        self.batch_size = batch_size
+        self.score_list = []
+
+    def fit(self, data):
+
+        for channel in range(self.input_c):
+            
+            data_channel = data[:, channel].reshape(-1, 1)
+            data_win, data_target = self.create_dataset(data_channel, slidingWindow=self.win_size, predict_time_steps=self.prediction_length)
+            # print('data_win: ', data_win.shape)         # (2330, 100)
+            # print('data_target: ', data_target.shape)   # (2330, 1)
+
+            train_data = []
+            count = 0
+            for id in range(data_win.shape[0]):
+                for tt in range(data_win.shape[1]):
+                    train_data.append([id, count, data_win[id, tt]])
+                    count += 1
+            train_data = pd.DataFrame(train_data, columns=['item_id', 'timestamp', 'target'])
+
+            with tempfile.TemporaryDirectory() as temp_dir:
+
+                predictor = TimeSeriesPredictor(prediction_length=self.prediction_length, path=temp_dir).fit(
+                        train_data, 
+                        hyperparameters={
+                        "Chronos": {
+                        "model_path": self.model_size,   # base
+                        "device": "cuda",
+                        "batch_size": self.batch_size}},
+                        skip_model_selection=True,
+                        verbosity=0)
+
+                predictions = predictor.predict(train_data)['mean'].to_numpy().reshape(-1, self.prediction_length)
+                print('predictions: ', predictions.shape)
+
+                ### using mse as the anomaly score
+                scores = (data_target.squeeze() - predictions.squeeze()) ** 2
+                self.score_list.append(scores)
+
+        scores_merge = np.mean(np.array(self.score_list), axis=0)
+        # print('scores_merge: ', scores_merge.shape)
+
+        padded_decision_scores = np.zeros(len(data))
+        padded_decision_scores[: self.win_size+self.prediction_length-1] = scores_merge[0]
+        padded_decision_scores[self.win_size+self.prediction_length-1 : ]=scores_merge
+
+        self.decision_scores_ = padded_decision_scores
+
+
+    def decision_function(self, X):
+        """
+        Not used, present for API consistency by convention.
+        """        
+        pass
+
+    def create_dataset(self, X, slidingWindow, predict_time_steps=1):
+        Xs, ys = [], []
+        for i in range(len(X) - slidingWindow - predict_time_steps+1):
+            
+            tmp = X[i : i + slidingWindow + predict_time_steps].ravel()
+            # tmp= MinMaxScaler(feature_range=(0,1)).fit_transform(tmp.reshape(-1,1)).ravel()
+            
+            x = tmp[:slidingWindow]
+            y = tmp[slidingWindow:]
+            Xs.append(x)
+            ys.append(y)
+        return np.array(Xs), np.array(ys)

models/DADA.py

@@ -0,0 +1,141 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+import math
+import tqdm
+import os
+from transformers import AutoTokenizer
+from typing import Optional, Tuple
+
+# Add debugging prints to understand the import issue
+import sys
+# print(f"Python path: {sys.path}")
+# print(f"Current working directory: {os.getcwd()}")
+# print(f"Current file location: {__file__}")
+# print(f"Current file directory: {os.path.dirname(__file__)}")
+#
+# # Check if the utils directory exists
+# utils_path = os.path.join(os.path.basename(os.path.dirname(__file__)), "utils")
+# print(f"Utils path: {utils_path}")
+# print(f"Utils directory exists: {os.path.exists(utils_path)}")
+# print(f"Utils directory contents: {os.listdir(utils_path) if os.path.exists(utils_path) else 'Directory not found'}")
+#
+# # Check if dataset.py exists
+# dataset_path = os.path.join(utils_path, "dataset.py")
+# print(f"Dataset file path: {dataset_path}")
+# print(f"Dataset file exists: {os.path.exists(dataset_path)}")
+
+# Try different import approaches
+
+os.chdir("/home/lihaoyang/Huawei/TSB-AD/TSB_AD")
+
+try:
+    from utils.dataset import ReconstructDataset
+    print("Relative import successful")
+except ImportError as e:
+    print(f"Relative import failed: {e}")
+
+    # Try absolute import
+    try:
+        from TSB_AD.utils.dataset import ReconstructDataset
+        print("Absolute import successful")
+    except ImportError as e2:
+        print(f"Absolute import failed: {e2}")
+
+        # Try adding parent directory to path
+        try:
+            parent_dir = os.path.dirname(os.path.dirname(__file__))
+            if parent_dir not in sys.path:
+                sys.path.insert(0, parent_dir)
+            from utils.dataset import ReconstructDataset
+            print("Import with modified path successful")
+        except ImportError as e3:
+            print(f"Import with modified path failed: {e3}")
+
+from .base import BaseDetector
+
+# ...existing code...
+
+class DADA(BaseDetector):
+    def __init__(self, device, args=None, win_size=64, batch_size=32):
+        self.win_size = win_size
+        self.batch_size = batch_size
+        self.device = torch.device(f'cuda:{device}' if torch.cuda.is_available() else 'cpu')
+        self.model = self._build_model().to(self.device)
+
+    def _build_model(self):
+        from transformers import AutoModel, AutoConfig
+        import os
+        
+        # Try multiple possible paths
+        possible_paths = [
+            os.environ.get("DADA_MODEL_PATH"),  # Environment variable
+            "/home/lihaoyang/Huawei/DADA/DADA/",  # Original Linux path
+            "./DADA",  # Relative path
+            "DADA"  # Hugging Face model name
+        ]
+        
+        for path in possible_paths:
+            if path is None:
+                continue
+            try:
+                # Try loading config first
+                config = AutoConfig.from_pretrained(path, trust_remote_code=True)
+                model = AutoModel.from_pretrained(path, config=config, trust_remote_code=True)
+                print(f"Successfully loaded DADA model from: {path}")
+                return model
+            except Exception as e:
+                print(f"Failed to load from {path}: {e}")
+                continue
+        
+        raise ValueError("DADA model not found. Please set DADA_MODEL_PATH environment variable or ensure the model is available at one of the expected locations.")
+
+    # def _acquire_device(self):
+    #     if True:
+    #         os.environ["CUDA_VISIBLE_DEVICES"] = str(
+    #             self.args.gpu) if not self.args.use_multi_gpu else self.args.devices
+    #         device = torch.device('cuda:{}'.format(self.args.gpu))
+    #         print('Use GPU: cuda:{}'.format(self.args.gpu))
+    #     else:
+    #         device = torch.device('cpu')
+    #         print('Use CPU')
+    #     return device
+
+    def decision_function(self, x: torch.Tensor) -> torch.Tensor:
+        pass
+
+    def fit(self, data: torch.Tensor, labels: Optional[torch.Tensor] = None) -> None:
+        pass
+    
+    def zero_shot(self, data):
+        
+        test_loader = DataLoader(
+            dataset= ReconstructDataset(data, window_size=self.win_size, stride=self.win_size, normalize=True),
+            batch_size=self.batch_size,
+            shuffle=False)
+        
+        loop = tqdm.tqdm(enumerate(test_loader),total=len(test_loader),leave=True)
+
+        test_scores = []
+        test_labels = []
+        self.model.eval()
+        self.model.to(self.device)
+        
+        with torch.no_grad():
+            for i, (batch_x, batch_y) in loop:
+                batch_x = batch_x.float().to(self.device)
+                score = self.model.infer(batch_x, norm=0)
+                score = score.detach().cpu().numpy()
+                test_scores.append(score)
+                test_labels.append(batch_y)
+
+        test_scores = np.concatenate(test_scores, axis=0).reshape(-1, 1)
+        test_labels = np.concatenate(test_labels, axis=0).reshape(-1, 1)
+
+        print("Test scores shape:", test_scores.shape)
+        print("Test labels shape:", test_labels.shape)
+
+        return test_scores.reshape(-1) 

models/Donut.py

@@ -0,0 +1,419 @@
+"""
+This function is adapted from [donut] by [haowen-xu]
+Original source: [https://github.com/NetManAIOps/donut]
+"""
+
+from typing import Dict
+import numpy as np
+import torchinfo
+import torch
+from torch import nn, optim
+import tqdm
+import os, math
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from typing import Tuple, Sequence, Union, Callable
+
+from ..utils.torch_utility import EarlyStoppingTorch, get_gpu
+from ..utils.dataset import ReconstructDataset    
+
+class DonutModel(nn.Module):
+    def __init__(self, input_dim, hidden_dim, latent_dim, mask_prob) -> None:
+        super().__init__()
+
+        """
+        Xu2018
+
+        :param input_dim: Should be window_size * features
+        :param hidden_dims:
+        :param latent_dim:
+        """
+
+        self.latent_dim = latent_dim
+        self.mask_prob = mask_prob
+        
+        encoder = VaeEncoder(input_dim, hidden_dim, latent_dim)
+        decoder = VaeEncoder(latent_dim, hidden_dim, input_dim)
+        
+        self.vae = VAE(encoder=encoder, decoder=decoder, logvar_out=False)
+    
+    def forward(self, inputs: torch.Tensor) -> Tuple[torch.Tensor, ...]:
+        # x: (B, T, D)
+        x = inputs
+        B, T, D = x.shape
+
+        if self.training:
+            # Randomly mask some inputs
+            mask = torch.empty_like(x)
+            mask.bernoulli_(1 - self.mask_prob)
+            x = x * mask
+        else:
+            mask = None
+
+        # Run the VAE
+        x = x.view(x.shape[0], -1)  
+        mean_z, std_z, mean_x, std_x, sample_z = self.vae(x, return_latent_sample=True)
+
+        # Reshape the outputs
+        mean_x = mean_x.view(B, T, D)
+        std_x = std_x.view(B, T, D)
+        return mean_z, std_z, mean_x, std_x, sample_z, mask
+
+def sample_normal(mu: torch.Tensor, std_or_log_var: torch.Tensor, log_var: bool = False, num_samples: int = 1):
+    # ln(σ) = 0.5 * ln(σ^2) -> σ = e^(0.5 * ln(σ^2))
+    if log_var:
+        sigma = std_or_log_var.mul(0.5).exp_()
+    else:
+        sigma = std_or_log_var
+
+    if num_samples == 1:
+        eps = torch.randn_like(mu)  # also copies device from mu
+    else:
+        eps = torch.rand((num_samples,) + mu.shape, dtype=mu.dtype, device=mu.device)
+        mu = mu.unsqueeze(0)
+        sigma = sigma.unsqueeze(0)
+    # z = μ + σ * ϵ, with ϵ ~ N(0,I)
+    return eps.mul(sigma).add_(mu)
+
+def normal_standard_normal_kl(mean: torch.Tensor, std_or_log_var: torch.Tensor, log_var: bool = False) -> torch.Tensor:
+    if log_var:
+        kl_loss = torch.sum(1 + std_or_log_var - mean.pow(2) - std_or_log_var.exp(), dim=-1)
+    else:
+        kl_loss = torch.sum(1 + torch.log(std_or_log_var.pow(2)) - mean.pow(2) - std_or_log_var.pow(2), dim=-1)
+    return -0.5 * kl_loss
+    
+
+def normal_normal_kl(mean_1: torch.Tensor, std_or_log_var_1: torch.Tensor, mean_2: torch.Tensor,
+                     std_or_log_var_2: torch.Tensor, log_var: bool = False) -> torch.Tensor:
+    if log_var:
+        return 0.5 * torch.sum(std_or_log_var_2 - std_or_log_var_1 + (torch.exp(std_or_log_var_1)
+                               + (mean_1 - mean_2)**2) / torch.exp(std_or_log_var_2) - 1, dim=-1)
+
+    return torch.sum(torch.log(std_or_log_var_2) - torch.log(std_or_log_var_1) \
+                     + 0.5 * (std_or_log_var_1**2 + (mean_1 - mean_2)**2) / std_or_log_var_2**2 - 0.5, dim=-1)
+
+
+class VAELoss(torch.nn.modules.loss._Loss):
+    def __init__(self, size_average=None, reduce=None, reduction: str = 'mean', logvar_out: bool = True):
+        super(VAELoss, self).__init__(size_average, reduce, reduction)
+        self.logvar_out = logvar_out
+
+    def forward(self, predictions: Tuple[torch.Tensor, ...], targets: Tuple[torch.Tensor, ...], *args, **kwargs) \
+            -> torch.Tensor:
+        z_mean, z_std_or_log_var, x_dec_mean, x_dec_std = predictions[:4]
+        if len(predictions) > 4:
+            z_prior_mean, z_prior_std_or_logvar = predictions[4:]
+        else:
+            z_prior_mean, z_prior_std_or_logvar = None, None
+
+        y, = targets
+
+        # Gaussian nnl loss assumes multivariate normal with diagonal sigma
+        # Alternatively we can use torch.distribution.Normal(x_dec_mean, x_dec_std).log_prob(y).sum(-1)
+        # or torch.distribution.MultivariateNormal(mean, cov).log_prob(y).sum(-1)
+        # with cov = torch.eye(feat_dim).repeat([1,bz,1,1])*std.pow(2).unsqueeze(-1).
+        # However setting up a distribution seems to be an unnecessary computational overhead.
+        # However, this requires pytorch version > 1.9!!!
+        nll_gauss = F.gaussian_nll_loss(x_dec_mean, y, x_dec_std.pow(2), reduction='none').sum(-1)
+        # For pytorch version < 1.9 use:
+        # nll_gauss = -torch.distribution.Normal(x_dec_mean, x_dec_std).log_prob(y).sum(-1)
+
+        # get KL loss
+        if z_prior_mean is None and z_prior_std_or_logvar is None:
+            # If a prior is not given, we assume standard normal
+            kl_loss = normal_standard_normal_kl(z_mean, z_std_or_log_var, log_var=self.logvar_out)
+        else:
+            if z_prior_mean is None:
+                z_prior_mean = torch.tensor(0, dtype=z_mean.dtype, device=z_mean.device)
+            if z_prior_std_or_logvar is None:
+                value = 0 if self.logvar_out else 1
+                z_prior_std_or_logvar = torch.tensor(value, dtype=z_std_or_log_var.dtype, device=z_std_or_log_var.device)
+
+            kl_loss = normal_normal_kl(z_mean, z_std_or_log_var, z_prior_mean, z_prior_std_or_logvar,
+                                       log_var=self.logvar_out)
+
+        # Combine
+        final_loss = nll_gauss + kl_loss
+
+        if self.reduction == 'none':
+            return final_loss
+        elif self.reduction == 'mean':
+            return torch.mean(final_loss)
+        elif self.reduction == 'sum':
+            return torch.sum(final_loss)
+
+
+class MaskedVAELoss(VAELoss):
+    def __init__(self, size_average=None, reduce=None, reduction: str = 'mean'):
+        super(MaskedVAELoss, self).__init__(size_average, reduce, reduction, logvar_out=False)
+
+    def forward(self, predictions: Tuple[torch.Tensor, ...], targets: Tuple[torch.Tensor, ...], *args, **kwargs) \
+            -> torch.Tensor:
+        mean_z, std_z, mean_x, std_x, sample_z, mask = predictions
+        actual_x, = targets
+
+        if mask is None:
+            mean_z = mean_z.unsqueeze(1)
+            std_z = std_z.unsqueeze(1)
+            return super(MaskedVAELoss, self).forward((mean_z, std_z, mean_x, std_x), (actual_x,), *args, **kwargs)
+
+        # If the loss is masked, one of the terms in the kl loss is weighted, so we can't compute it exactly
+        # anymore and have to use a MC approximation like for the output likelihood
+        nll_output = torch.sum(mask * F.gaussian_nll_loss(mean_x, actual_x, std_x**2, reduction='none'), dim=-1)
+
+        # This is p(z), i.e., the prior likelihood of Z. The paper assumes p(z) = N(z| 0, I), we drop constants
+        beta = torch.mean(mask, dim=(1, 2)).unsqueeze(-1)
+        nll_prior = beta * 0.5 * torch.sum(sample_z * sample_z, dim=-1, keepdim=True)
+
+        nll_approx = torch.sum(F.gaussian_nll_loss(mean_z, sample_z, std_z**2, reduction='none'), dim=-1, keepdim=True)
+
+        final_loss = nll_output + nll_prior - nll_approx
+
+        if self.reduction == 'none':
+            return final_loss
+        elif self.reduction == 'mean':
+            return torch.mean(final_loss)
+        elif self.reduction == 'sum':
+            return torch.sum(final_loss)
+
+class MLP(torch.nn.Module):
+    def __init__(self, input_features: int, hidden_layers: Union[int, Sequence[int]], output_features: int,
+                 activation: Callable = torch.nn.Identity(), activation_after_last_layer: bool = False):
+        super(MLP, self).__init__()
+
+        self.activation = activation
+        self.activation_after_last_layer = activation_after_last_layer
+
+        if isinstance(hidden_layers, int):
+            hidden_layers = [hidden_layers]
+
+        layers = [input_features] + list(hidden_layers) + [output_features]
+        self.layers = torch.nn.ModuleList([torch.nn.Linear(inp, out) for inp, out in zip(layers[:-1], layers[1:])])
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        out = x
+        for layer in self.layers[:-1]:
+            out = layer(out)
+            out = self.activation(out)
+
+        out = self.layers[-1](out)
+        if self.activation_after_last_layer:
+            out = self.activation(out)
+
+        return out
+
+class VaeEncoder(nn.Module):
+    def __init__(self, input_dim: int, hidden_dim: int, latent_dim: int):
+        super(VaeEncoder, self).__init__()
+        
+        self.latent_dim = latent_dim
+
+        self.mlp = MLP(input_dim, hidden_dim, 2*latent_dim, activation=torch.nn.ReLU(), activation_after_last_layer=False)
+        self.softplus = torch.nn.Softplus()
+
+    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        # x: (B, T, D)
+        mlp_out = self.mlp(x)
+
+        mean, std = mlp_out.tensor_split(2, dim=-1)
+        std = self.softplus(std)
+
+        return mean, std
+    
+class VAE(torch.nn.Module):
+    """
+    VAE Implementation that supports normal distribution with diagonal cov matrix in the latent space
+    and the output
+    """
+
+    def __init__(self, encoder: torch.nn.Module, decoder: torch.nn.Module, logvar_out: bool = True):
+        super(VAE, self).__init__()
+
+        self.encoder = encoder
+        self.decoder = decoder
+        self.log_var = logvar_out
+
+    def forward(self, x: torch.Tensor, return_latent_sample: bool = False, num_samples: int = 1,
+                force_sample: bool = False) -> Tuple[torch.Tensor, ...]:
+        z_mu, z_std_or_log_var = self.encoder(x)
+
+        if self.training or num_samples > 1 or force_sample:
+            z_sample = sample_normal(z_mu, z_std_or_log_var, log_var=self.log_var, num_samples=num_samples)
+        else:
+            z_sample = z_mu
+
+        x_dec_mean, x_dec_std = self.decoder(z_sample)
+
+        if not return_latent_sample:
+            return z_mu, z_std_or_log_var, x_dec_mean, x_dec_std
+
+        return z_mu, z_std_or_log_var, x_dec_mean, x_dec_std, z_sample
+
+
+
+class Donut():
+    def __init__(self,
+                 win_size=120,
+                 input_c=1,
+                 batch_size=128,     # 32, 128
+                 grad_clip=10.0,
+                 num_epochs=50,
+                 mc_samples=1024,
+                 hidden_dim=100,
+                 latent_dim=8,
+                 inject_ratio=0.01,
+                 lr=1e-4,
+                 l2_coff=1e-3,
+                 patience=3,
+                 validation_size=0):
+        super().__init__()
+        self.__anomaly_score = None
+        
+        self.cuda = True
+        self.device = get_gpu(self.cuda)
+        
+        self.win_size = win_size
+        self.input_c = input_c
+        self.batch_size = batch_size
+        self.grad_clip = grad_clip
+        self.num_epochs = num_epochs
+        self.mc_samples = mc_samples
+        self.validation_size = validation_size
+        
+        input_dim = self.win_size*self.input_c
+        
+        self.model = DonutModel(input_dim=input_dim, hidden_dim=hidden_dim, latent_dim=latent_dim, mask_prob=inject_ratio).to(self.device)
+        self.optimizer = optim.AdamW(self.model.parameters(), lr=lr, weight_decay=l2_coff)
+        self.scheduler = optim.lr_scheduler.StepLR(self.optimizer, step_size=10, gamma=0.75)
+        self.vaeloss = MaskedVAELoss()
+        
+        self.save_path = None
+        self.early_stopping = EarlyStoppingTorch(save_path=self.save_path, patience=patience)
+        
+    def train(self, train_loader, epoch):
+        self.model.train(mode=True)
+        avg_loss = 0
+        loop = tqdm.tqdm(enumerate(train_loader),total=len(train_loader),leave=True)
+        for idx, (x, target) in loop:
+            x, target = x.to(self.device), target.to(self.device)
+            self.optimizer.zero_grad()
+
+            # print('x: ', x.shape)
+            
+            output = self.model(x)
+            loss = self.vaeloss(output, (target,))
+            loss.backward()
+            
+            torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.grad_clip)
+            self.optimizer.step()
+            
+            avg_loss += loss.cpu().item()
+            loop.set_description(f'Training Epoch [{epoch}/{self.num_epochs}]')
+            loop.set_postfix(loss=loss.item(), avg_loss=avg_loss/(idx+1))
+        
+        return avg_loss/max(len(train_loader), 1)
+                
+    def valid(self, valid_loader, epoch):
+        self.model.eval()
+        avg_loss = 0
+        loop = tqdm.tqdm(enumerate(valid_loader),total=len(valid_loader),leave=True)
+        with torch.no_grad():
+            for idx, (x, target) in loop:
+                x, target = x.to(self.device), target.to(self.device)
+                output = self.model(x)
+                loss = self.vaeloss(output, (target,))
+                avg_loss += loss.cpu().item()
+                loop.set_description(f'Validation Epoch [{epoch}/{self.num_epochs}]')
+                loop.set_postfix(loss=loss.item(), avg_loss=avg_loss/(idx+1))
+                
+        return avg_loss/max(len(valid_loader), 1)
+        
+    def fit(self, data):
+        tsTrain = data[:int((1-self.validation_size)*len(data))]
+        tsValid = data[int((1-self.validation_size)*len(data)):]
+
+        train_loader = DataLoader(
+            dataset=ReconstructDataset(tsTrain, window_size=self.win_size),
+            batch_size=self.batch_size,
+            shuffle=True
+        )
+        
+        valid_loader = DataLoader(
+            dataset=ReconstructDataset(tsValid, window_size=self.win_size),
+            batch_size=self.batch_size,
+            shuffle=False
+        )
+                    
+        for epoch in range(1, self.num_epochs + 1):
+            train_loss = self.train(train_loader, epoch)
+            if len(valid_loader) > 0:
+                valid_loss = self.valid(valid_loader, epoch)
+            self.scheduler.step()
+            
+            if len(valid_loader) > 0:
+                self.early_stopping(valid_loss, self.model)
+            else:
+                self.early_stopping(train_loss, self.model)
+            if self.early_stopping.early_stop:
+                print("   Early stopping<<<")
+                break
+
+        
+    def decision_function(self, data):
+        
+        test_loader = DataLoader(
+            dataset=ReconstructDataset(data, window_size=self.win_size),
+            batch_size=self.batch_size,
+            shuffle=False
+        )
+        
+        self.model.eval()
+        scores = []
+        loop = tqdm.tqdm(enumerate(test_loader),total=len(test_loader),leave=True)
+        with torch.no_grad():
+            for idx, (x, _) in loop:
+                x = x.to(self.device)
+                x_vae = x.view(x.shape[0], -1)
+                B, T, D = x.shape
+
+                res = self.model.vae(x_vae, return_latent_sample=False, num_samples=self.mc_samples)
+                z_mu, z_std, x_dec_mean, x_dec_std = res
+
+                x_dec_mean = x_dec_mean.view(self.mc_samples, B, T, D)
+                x_dec_std = x_dec_std.view(self.mc_samples, B, T, D)                
+                nll_output = torch.sum(F.gaussian_nll_loss(x_dec_mean[:, :, -1, :], x[:, -1, :].unsqueeze(0),
+                                                   x_dec_std[:, :, -1, :]**2, reduction='none'), dim=(0, 2))
+                nll_output /= self.mc_samples
+
+
+                scores.append(nll_output.cpu())
+                loop.set_description(f'Testing: ')
+
+        scores = torch.cat(scores, dim=0)
+        scores = scores.numpy()
+        
+        assert scores.ndim == 1
+        
+        import shutil
+        if self.save_path and os.path.exists(self.save_path):
+            shutil.rmtree(self.save_path)
+            
+        self.__anomaly_score = scores
+
+        if self.__anomaly_score.shape[0] < len(data):
+            self.__anomaly_score = np.array([self.__anomaly_score[0]]*math.ceil((self.win_size-1)/2) + 
+                        list(self.__anomaly_score) + [self.__anomaly_score[-1]]*((self.win_size-1)//2))
+        
+        return self.__anomaly_score
+
+    def anomaly_score(self) -> np.ndarray:
+        return self.__anomaly_score
+    
+    def get_y_hat(self) -> np.ndarray:
+        return super().get_y_hat
+    
+    def param_statistic(self, save_file):
+        model_stats = torchinfo.summary(self.model, (self.batch_size, self.win_size), verbose=0)
+        with open(save_file, 'w') as f:
+            f.write(str(model_stats))
+