anomaly-pipeline 0.1.27__py3-none-any.whl

anomaly_pipeline/__init__.py

@@ -0,0 +1,2 @@
+from .main import timeseries_anomaly_detection
+from .helpers import help_info

anomaly_pipeline/helpers/DB_scan.py

@@ -0,0 +1,188 @@
+import pandas as pd
+import numpy as np
+import sklearn
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import DBSCAN
+from sklearn.neighbors import NearestNeighbors
+from sklearn.ensemble import IsolationForest
+from statsmodels.tsa.stattools import acf
+
+
+def get_dynamic_lags(series: pd.Series) -> list:
+    
+    n = len(series)
+    
+    # Determine Max Lags (Max is min(50% of data, a hard cap of 60))
+    nlags = min(int(n * 0.5), 60)
+    
+    if nlags < 5:
+        return [1, 2, 3]
+
+    # Calculate ACF and Confidence Intervals, get the 10 most-significant lags
+    autocorrelations, confint = acf(series.dropna(), nlags=nlags, alpha=0.25, fft=True)
+    autocorr_values = autocorrelations[1:]
+    conf_limit = confint[1:, 1] - autocorr_values
+    is_significant = np.abs(autocorr_values) > conf_limit
+    significant_autocorr = autocorr_values[is_significant]
+    significant_lags_indices = np.where(is_significant)[0] + 1
+    ranked_indices = np.argsort(np.abs(significant_autocorr))[::-1]
+    top_lags_indices = ranked_indices[:10]
+    top_lags = significant_lags_indices[top_lags_indices].tolist()
+    base_lags = [1, 2, 3]
+    dynamic_lags = sorted(list(set(base_lags + top_lags)))[:10]
+    
+    return dynamic_lags
+
+def find_optimal_epsilon(X_scaled: np.ndarray, k: int) -> float:
+    """
+    Finds the optimal epsilon by calculating the distance to the k-th nearest neighbor
+    and taking a high percentile (90-95th) of those distances as the cutoff.
+    This serves as a programmatic proxy for the 'elbow' method in a rolling window.
+    """
+    if len(X_scaled) < k:
+        return 1.0 # Fallback 
+
+    # Find the distance to the k-th (min_samples) neighbor for every point
+    # n_neighbors is k+1 because the first distance is 0 (to itself)
+    neigh = NearestNeighbors(n_neighbors=k + 1) 
+    neigh.fit(X_scaled)
+    
+    # distances matrix: [n_samples, k+1]
+    distances, indices = neigh.kneighbors(X_scaled)
+    
+    # We are interested in the distance to the k-th neighbor (index k)
+    # This k-distance is the required radius for a point to be a core point's neighbor.
+    k_distances = distances[:, k] 
+    
+    # The elbow is hard to find programmatically. A robust proxy for the density
+    # threshold is to take a high percentile (e.g., 95th) of the k-distances. 
+    # This sets epsilon such that 95% of your *training* points would be considered
+    # part of a cluster's neighborhood.
+    optimal_eps = np.percentile(k_distances, 95) 
+    
+    # Ensure a minimum value if data is extremely sparse
+    return max(optimal_eps, 0.1)
+
+
+def detect_time_series_anomalies_dbscan(
+    group,
+    variable,
+    date_column,
+    eval_period,
+    ):
+    
+    group[date_column] = pd.to_datetime(group[date_column])
+    group = group.copy().sort_values(date_column).reset_index(drop=True)
+    
+    # --- Default DBSCAN Parameters ---
+    # These parameters often need tuning, but these are reasonable starting points:
+    DEFAULT_EPS = 0.5 # Neighborhood radius (critical parameter)
+    
+    try:
+        test_anom = []
+
+        for t in list(range(eval_period - 1, -1, -1)):
+
+            try:
+                # Boundary between rolling train and rolling forecast region
+                cutoff_date = group[date_column].max() - pd.Timedelta(weeks=t)
+
+                # Get train set to determine lags
+                model_group = group.copy()
+                train = model_group[model_group[date_column] <= cutoff_date].copy()
+                lags = get_dynamic_lags(train[variable])
+
+                # Create lag features and rolling stats for the entire DF
+                rolling_stats_features = []
+                for lag in lags:
+                    model_group[f'lag{lag}'] = model_group[variable].shift(lag)
+
+                for w in [int(np.ceil(max(lags)/4)), int(np.ceil(max(lags)/2)), int(max(lags))]:
+                    if w >= 3:
+                        rolling_stats_features.extend([f'roll_mean_{w}', f'roll_std_{w}'])
+                        model_group[f'roll_mean_{w}'] = model_group[variable].shift(1).rolling(w).mean()
+                        model_group[f'roll_std_{w}'] = model_group[variable].shift(1).rolling(w).std()
+
+                model_group['trend'] = group.index
+                model_group = model_group.copy().dropna()
+
+                # Split into train and test
+                train = model_group[model_group[date_column] <= cutoff_date].copy()
+                test = model_group[model_group[date_column] == cutoff_date].copy()
+
+                # Identify all model features (lags, rolling stats, trend, and the variable itself)
+                features = [f'lag{i}' for i in lags] + rolling_stats_features + ['trend'] + [variable]
+
+                # Fit the scaler ONLY on the training data to avoid data leakage
+                scaler = StandardScaler()
+                
+                # Fit the scaler on the train data features
+                scaler.fit(train[features])
+                
+                # Transform both train and test sets
+                train_scaled = scaler.transform(train[features])
+                test_scaled = scaler.transform(test[features])
+
+                # Determine min_samples based on feature space dimension
+                min_samples = max(2 * len(features), 3)
+                
+                # Find optimal epsilon
+                calculated_eps = find_optimal_epsilon(train_scaled, k=min_samples)
+
+                # --- DBSCAN MODEL ---
+                dbscan_model = DBSCAN(
+                    eps=calculated_eps, 
+                    min_samples=min_samples,
+                    n_jobs=-1
+                )
+
+                # Fit DBSCAN on the scaled training data
+                dbscan_model.fit(train_scaled)
+
+                # Since DBSCAN doesn't have a direct predict() method for new data points,
+                # the simplest (and common) proxy is to treat the test point as unassigned noise,
+                # which requires complex distance logic.
+                
+                neigh = NearestNeighbors(n_neighbors=min_samples)
+                neigh.fit(train_scaled)
+                
+                # Find the distance of the test point to its nearest neighbors in the train set
+                distances, indices = neigh.kneighbors(test_scaled)
+                
+                # Anomaly check: If the distance to the min_samples-th neighbor is > eps, it's noise.
+                # Use the distance to the k-th neighbor (index min_samples-1)
+                k_distance = distances[:, min_samples - 1] 
+                
+                # Flag as anomaly if the k-distance is greater than the trained eps threshold
+                test['dbscan_score'] = k_distance - calculated_eps
+                test['is_DBSCAN_anomaly'] = np.where(k_distance > calculated_eps, True, False)
+                
+                test = test[[variable, date_column, 'dbscan_score', 'is_DBSCAN_anomaly']]
+                test_anom.append(test)
+
+            except Exception as e:
+                print(f"Error in iteration {t}: {e}")
+                pass
+            
+        try:
+            test_anom = pd.concat(test_anom)
+            group = group.merge(test_anom[[variable, date_column, 'dbscan_score', 'is_DBSCAN_anomaly']], on=[variable, date_column], how='left')
+            # group["is_DBSCAN_anomaly"] = group["is_DBSCAN_anomaly"].fillna(False)
+        except:
+            print("Error in DBSCAN process")
+            group['dbscan_score'] = np.nan
+            group["is_DBSCAN_anomaly"] = np.nan
+
+    except Exception as e:
+        # Fallback error handling
+        # Replace key_series with group for robustness if key_series is not defined
+        try:
+             group_id_cols = group.select_dtypes(include=['object', 'string']).columns.tolist()
+             group_id = " ".join(group[group_id_cols].reset_index(drop=True).iloc[0].astype(str).to_list())
+        except:
+             group_id = "Unknown Group ID"
+        print(f'DBSCAN Anomaly Detection failed for {group_id}. Error: {e}')
+        group['dbscan_score'] = np.nan
+        group["is_DBSCAN_anomaly"] = np.nan
+        
+    return group

anomaly_pipeline/helpers/IQR.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import numpy as np
+from .Preprocessing import classify
+
+def detect_outliers_iqr(group, variable, date_column, eval_period):
+    n = len(group)
+    if n < 10:
+        return pd.DataFrame(columns=group.columns)
+
+    group = group.copy()
+    # Explicitly ensure date_column is datetime right at the start
+    group[date_column] = pd.to_datetime(group[date_column])
+    train_size = n - eval_period
+
+    # --- 1. HANDLE TRAINING DATA (Initial Block) ---
+    # Calculate baseline IQR using all data available before eval_period
+    initial_train = group[variable].iloc[:train_size]
+    
+    q1 = initial_train.quantile(0.25)
+    q3 = initial_train.quantile(0.75)
+    iqr = q3 - q1
+    
+    low = max(q1 - 1.5 * iqr, 0)
+    high = q3 + 1.5 * iqr
+
+    # Assign initial bounds to the training rows
+    group.loc[group.index[:train_size], 'Q1'] = q1
+    group.loc[group.index[:train_size], 'Q3'] = q3
+    group.loc[group.index[:train_size], 'IQR'] = iqr
+    group.loc[group.index[:train_size], 'IQR_low'] = low
+    group.loc[group.index[:train_size], 'IQR_high'] = high
+    group.loc[group.index[:train_size], 'set'] = "TRAIN"
+    group.loc[group.index[:train_size], 'IQR_anomaly'] = group[variable].iloc[:train_size].apply(
+        lambda x: classify(x, low, high)
+    )
+    group.loc[group.index[:train_size], 'is_IQR_anomaly'] = (
+        (group[variable].iloc[:train_size] < low) | 
+        (group[variable].iloc[:train_size] > high)
+    )
+
+    
+    # --- 2. HANDLE EVALUATION DATA (Expanding Window) ---
+    # Iterate through the eval period, increasing the training set one point at a time
+    for i in range(train_size, n):
+        # Data available up to this point (expanding)
+        current_train = group[variable].iloc[:i]
+        
+        Q1 = current_train.quantile(0.25)
+        Q3 = current_train.quantile(0.75)
+        IQR = Q3 - Q1
+        
+        lower_q = max(Q1 - 1.5 * IQR, 0)
+        upper_q = Q3 + 1.5 * IQR
+        
+        # Test the current point i
+        current_val = group[variable].iloc[i]
+        group.iloc[i, group.columns.get_loc('Q1')] = Q1
+        group.iloc[i, group.columns.get_loc('Q3')] = Q3
+        group.iloc[i, group.columns.get_loc('IQR')] = IQR
+        group.iloc[i, group.columns.get_loc('IQR_low')] = lower_q
+        group.iloc[i, group.columns.get_loc('IQR_high')] = upper_q
+        group.iloc[i, group.columns.get_loc('set')] = "TEST"
+        group.iloc[i, group.columns.get_loc('IQR_anomaly')] = classify(current_val, lower_q, upper_q)
+        group.iloc[i, group.columns.get_loc('is_IQR_anomaly')] = (current_val < lower_q) or (current_val > upper_q)
+
+    # Cast boolean column properly
+    group['is_IQR_anomaly'] = group['is_IQR_anomaly'].astype(bool)
+    # FINAL SAFETY CHECK
+    group[date_column] = pd.to_datetime(group[date_column])
+    
+    return group

anomaly_pipeline/helpers/MAD.py

@@ -0,0 +1,88 @@
+import pandas as pd
+import numpy as np
+from .Preprocessing import classify
+
+
+
+def detect_outliers_mad(group, variable, date_column, mad_threshold, mad_scale_factor, eval_period):
+    n = len(group)
+    if n < 10:
+        return pd.DataFrame(columns=group.columns)
+
+    group = group.copy()
+    # Explicitly ensure date_column is datetime right at the start
+    group[date_column] = pd.to_datetime(group[date_column])
+    train_size = n - eval_period
+
+    # Initialize columns to store the expanding window metrics
+    group['Median'] = np.nan
+    group['MAD'] = np.nan
+    group['MAD_low'] = np.nan
+    group['MAD_high'] = np.nan
+    group['set'] = ""
+    group['is_MAD_anomaly'] = False
+
+    # --- 1. HANDLE TRAINING DATA (Initial Block) ---
+    initial_train = group[variable].iloc[:train_size]
+    median = initial_train.median()
+    mad = np.median(np.abs(initial_train - median))
+
+    if mad == 0:
+        lower_mad = median
+        upper_mad = median
+    else:
+        margin = mad_threshold * mad / mad_scale_factor
+        lower_mad = max(median - margin, 0)
+        upper_mad = median + margin
+
+    # Assign baseline values to the training block
+    train_idx = group.index[:train_size]
+    group.loc[train_idx, 'Median'] = median
+    group.loc[train_idx, 'MAD'] = mad
+    group.loc[train_idx, 'MAD_low'] = lower_mad
+    group.loc[train_idx, 'MAD_high'] = upper_mad
+    group.loc[train_idx, 'set'] = "TRAIN"
+    group.loc[train_idx, 'MAD_anomaly'] = group[variable].iloc[:train_size].apply(
+        lambda x: classify(x, lower_mad, upper_mad)
+    )
+    group.loc[train_idx, 'is_MAD_anomaly'] = (group[variable].iloc[:train_size] < lower_mad) | \
+                                             (group[variable].iloc[:train_size] > upper_mad)
+   
+
+    # --- 2. HANDLE EVALUATION DATA (Expanding Window) ---
+    for i in range(train_size, n):
+        # Recursive growth: use all data up to the current point i
+        current_train = group[variable].iloc[:i]
+        
+        curr_median = current_train.median()
+        curr_mad = np.median(np.abs(current_train - curr_median))
+        
+        if curr_mad == 0:
+            lower_mad = curr_median
+            upper_mad = curr_median
+        else:
+            margin = mad_threshold * curr_mad / mad_scale_factor
+            lower_mad = max(curr_median - margin, 0)
+            upper_mad = curr_median + margin
+            
+        # Test current point i
+        current_val = group[variable].iloc[i]
+        
+        group.iloc[i, group.columns.get_loc('Median')] = curr_median
+        group.iloc[i, group.columns.get_loc('MAD')] = curr_mad
+        group.iloc[i, group.columns.get_loc('MAD_low')] = lower_mad
+        group.iloc[i, group.columns.get_loc('MAD_high')] = upper_mad
+        group.iloc[i, group.columns.get_loc('set')] = "TEST"
+        group.iloc[i, group.columns.get_loc('MAD_anomaly')] = classify(current_val, lower_mad, upper_mad)
+        group.iloc[i, group.columns.get_loc('is_MAD_anomaly')] = (current_val < lower_mad) or (current_val > upper_mad)
+
+    # If you have your classify function available:
+    # group['MAD_anomaly'] = group.apply(lambda row: classify(row[variable], row['MAD_low'], row['MAD_high']), axis=1)
+
+    group['is_MAD_anomaly'] = group['is_MAD_anomaly'].astype(bool)
+    # FINAL SAFETY CHECK
+    group[date_column] = pd.to_datetime(group[date_column])
+    
+    return group
+    
+   

anomaly_pipeline/helpers/Preprocessing.py

@@ -0,0 +1,116 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime
+
+def classify(val,lower,upper):
+    if val < lower:
+        return 'low'
+    elif val > upper:
+        return 'high'
+    else:
+        return 'none'
+
+def create_full_calendar_and_interpolate(
+        master_data,
+        group_columns,
+        variable,
+        date_column,
+        freq
+    ):
+    """
+    Creates a complete weekly date range for each group,
+    merges with the master data, marks missing rows,
+    and fills missing values using linear interpolation.
+
+    Parameters
+    ----------
+    master_data : pd.DataFrame
+    group_columns : list
+        One or multiple columns that define a group.
+    date_column : str
+        Name of the date column (must be datetime-like)
+    missing_check_cols : list
+        Columns used to detect missing values.
+        If None → ALL numeric columns will be used.
+    freq : str
+        Frequency for calendar generation (default weekly Mondays).
+    """
+
+    # Ensure datetime
+    master_data[date_column] = pd.to_datetime(master_data[date_column])
+
+    full_group_data = []
+
+    for group_key, group in master_data.groupby(group_columns):
+
+        # ---- Step 1: Create full calendar for this group ----
+        min_date = group[date_column].min()
+        max_date = group[date_column].max()
+
+        full_dates = pd.date_range(start=min_date, end=max_date, freq=freq)
+
+        # Build calendar DF dynamically using group_columns
+        calendar_dict = {col: group_key[i] if isinstance(group_key, tuple) else group_key
+                         for i, col in enumerate(group_columns)}
+        calendar_dict[date_column] = full_dates
+
+        full_calendar = pd.DataFrame(calendar_dict)
+
+        # ---- Step 2: Join with actual group data ----
+        merged = full_calendar.merge(
+            group,
+            on=group_columns + [date_column],
+            how="left"
+        )
+
+        # ---- Step 3: Mark missing rows based on selected columns ----
+        merged["is_missing_record"] = merged[variable].isna()
+        
+
+        # ---- Step 4: Interpolate numeric columns ----
+        numeric_cols = merged.select_dtypes(include=[np.number]).columns
+
+        for col in numeric_cols:
+            merged[col] = merged[col].interpolate(method="linear", limit_direction="both")
+
+        full_group_data.append(merged)
+
+    final_df = pd.concat(full_group_data, ignore_index=True)
+    #print(f"The number of records missing {final_df['is_missing_record'].sum()}")
+    return final_df
+
+
+def print_anomaly_stats(df, group_columns):
+    # Calculate global stats
+    total_records = len(df)
+    # Ensure is_anomaly is treated as boolean for counting
+    total_anomalies = df['is_Anomaly'].fillna(False).astype(bool).sum()
+    anomaly_rate = (total_anomalies / total_records) * 100
+
+    print("\n" + "="*45)
+    print(f"{'ANOMALY DETECTION SUMMARY':^45}")
+    print("="*45)
+    print(f"{'Total Records:':<25} {total_records:,}")
+    print(f"{'Total Anomalies:':<25} {total_anomalies:,}")
+    print(f"{'Overall Anomaly Rate:':<25} {anomaly_rate:.2f}%")
+    print("-" * 45)
+
+    # --- CHANGE START: Group by Rate ---
+    print(f"Top 5 Groups by Anomaly Rate ({' > '.join(group_columns)}):")
+    
+    # 1. Group by keys
+    # 2. Calculate mean (rate) and count (to show absolute numbers too)
+    group_stats = df.groupby(group_columns)['is_Anomaly'].agg(['mean', 'sum']).sort_values(by='mean', ascending=False).head(5)
+    
+    for label, row in group_stats.iterrows():
+        # Handle single vs multiple group columns for clean printing
+        group_label = label if isinstance(label, str) else " | ".join(map(str, label))
+        rate_pct = row['mean'] * 100
+        count = int(row['sum'])
+        
+        # Print the Rate % and the absolute count in brackets for context
+        print(f" - {group_label:<25} : {rate_pct:>6.2f}% ({count:>3} anomalies)")
+    # --- CHANGE END ---
+    
+    print("="*45 + "\n")
+

anomaly_pipeline/helpers/STD.py

@@ -0,0 +1,70 @@
+import pandas as pd
+import numpy as np
+from .Preprocessing import classify
+
+def detect_outliers_sd(group, variable, date_column, eval_period):
+    n = len(group)
+    # checking the min_size requirements
+    if n < 10:
+        return pd.DataFrame(columns=group.columns)
+
+    group = group.copy()
+    # Explicitly ensure date_column is datetime right at the start
+    group[date_column] = pd.to_datetime(group[date_column])
+    train_size = n - eval_period
+
+    # --- 1. HANDLE TRAINING DATA (Initial Block) ---
+    # Calculate baseline IQR using all data available before eval_period
+    initial_train = group[variable].iloc[:train_size]
+    
+     # SD-based bounds
+    mean = initial_train.mean()
+    std = initial_train .std()
+    
+    lower_2sd = max(mean - 2*std,0)
+    upper_2sd = mean + 2*std
+
+    # Assign initial bounds to the training rows
+    group.loc[group.index[:train_size], "Mean"] = mean
+    group.loc[group.index[:train_size], 'SD'] = std
+    group.loc[group.index[:train_size], 'SD2_low'] = lower_2sd 
+    group.loc[group.index[:train_size], 'SD2_high'] = upper_2sd
+    group.loc[group.index[:train_size], 'set'] = "TRAIN"
+    group.loc[group.index[:train_size], 'SD_anomaly'] = group[variable].iloc[:train_size].apply(
+        lambda x: classify(x, lower_2sd , upper_2sd)
+    )
+    group.loc[group.index[:train_size], 'is_SD_anomaly'] = (
+        (group[variable].iloc[:train_size] < lower_2sd) | 
+        (group[variable].iloc[:train_size] > upper_2sd)
+    )
+
+    
+    # --- 2. HANDLE EVALUATION DATA (Expanding Window) ---
+    # Iterate through the eval period, increasing the training set one point at a time
+    for i in range(train_size, n):
+        # Data available up to this point (expanding)
+        current_train = group[variable].iloc[:i]
+        
+        MEAN = current_train.mean()
+        STD = current_train.std()
+        
+        LOWER_2SD = max(MEAN - 2*STD,0)
+        UPPER_2SD = MEAN + 2*STD
+        
+        # Test the current point i
+        current_val = group[variable].iloc[i]
+        group.iloc[i, group.columns.get_loc("Mean")] = MEAN
+        group.iloc[i, group.columns.get_loc('SD')] = STD
+        group.iloc[i, group.columns.get_loc('SD2_low')] = LOWER_2SD
+        group.iloc[i, group.columns.get_loc('SD2_high')] = UPPER_2SD
+        group.iloc[i, group.columns.get_loc('set')] = "TEST"
+        group.iloc[i, group.columns.get_loc('SD_anomaly')] = classify(current_val, LOWER_2SD, UPPER_2SD)
+        group.iloc[i, group.columns.get_loc('is_SD_anomaly')] = (current_val < LOWER_2SD) or (current_val > UPPER_2SD)
+
+    # Cast boolean column properly
+    group['is_SD_anomaly'] = group['is_SD_anomaly'].astype(bool)
+    # FINAL SAFETY CHECK
+    group[date_column] = pd.to_datetime(group[date_column])
+    
+    return group
+   

anomaly_pipeline/helpers/__init__.py

@@ -0,0 +1 @@
+from .help_info import help_info

anomaly_pipeline/helpers/baseline.py

@@ -0,0 +1,112 @@
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import IsolationForest
+
+# Anomaly category columns (optional, keep if you still want string labels)
+
+
+def remove_outliers_iqr_and_sd(group, variable,contamination=0.03, random_state=42):
+    if len(group) < 10:
+        # Return empty DataFrame to exclude this group entirely
+        print(f"the {group[key].unique()} has {len(group)} records.Hence dropping from the analysis")
+        return pd.DataFrame(columns=group.columns)
+    # Quantile-based bounds
+    min_value = group[variable].min()
+    max_value = group[variable].max()
+    Q1 = group[variable].quantile(0.25)
+    Q3 = group[variable].quantile(0.75)
+    median = group[variable].quantile(0.5)
+    IQR = Q3 - Q1
+    low_percentile = group[variable].quantile(0.05)
+    high_percentile = group[variable].quantile(0.95)
+    lower_q = max(Q1 - 1.5 * IQR,0)
+    upper_q = Q3 + 1.5 * IQR
+    
+    group["MIN_value"]= min_value
+    group["MAX_value"]= max_value
+    group["Percentile_low"]=low_percentile
+    group["Percentile_high"]=high_percentile
+    
+    # SD-based bounds
+    mean = group[variable].mean()
+    std = group[variable].std()
+    
+    lower_1sd = max(mean - 1*std, 0)
+    upper_1sd = mean + 1*std
+    group["Mean"]=mean
+    group["SD"]=std
+    group['SD1_low'] = lower_1sd
+    group['SD1_high'] = upper_1sd
+
+    lower_2sd = max(mean - 2*std,0)
+    upper_2sd = mean + 2*std
+    #group["mean"]=mean
+    #group["std"]=std
+    group['SD2_low'] = lower_2sd
+    group['SD2_high'] = upper_2sd
+    
+
+    lower_3sd = max(mean - 3 * std,0)
+    upper_3sd = mean + 3 * std
+    group['SD3_low'] = lower_3sd
+    group['SD3_high'] = upper_3sd
+    
+     
+    # MAD-based bounds
+    abs_dev = np.abs(group[variable] - median)
+    mad = np.median(abs_dev)
+    threshold_v1 = 2.5
+    threshold_v2 = 2.5
+    scale_factor = 0.6745
+
+    if mad == 0:
+        lower_mad_v1 = median
+        upper_mad_v1= median
+        lower_mad_v2 = median
+        upper_mad_v2 = median
+    else:
+        margin_v1 = threshold_v1 * mad / scale_factor
+        lower_mad_v1 = max(median - margin_v1,0)
+        upper_mad_v1 = median + margin_v1
+        margin_v2 = threshold_v2 * mad / scale_factor
+        lower_mad_v2 = max(median - margin_v2,0)
+        upper_mad_v2 = median + margin_v2
+    
+    group["Median"]=median
+    group['MAD'] = mad
+    #group['MAD2.5_low'] = lower_mad_v1
+    #group['MAD2.5_high'] = upper_mad_v1
+    group['MAD_low'] = lower_mad_v2
+    group['MAD_high'] = upper_mad_v2
+    
+    
+    group["Q1"]=Q1
+    group["Q3"]= Q3
+    group["IQR"]=IQR
+    group['IQR_low'] = lower_q
+    group['IQR_high'] = upper_q
+    
+    """
+     # ---- Isolation Forest ----
+    iso = IsolationForest(contamination=contamination, random_state=random_state)
+    preds = iso.fit_predict(group[[variable]])
+    scores = iso.decision_function(group[[variable]])
+    
+    group["IsolationForest_score"] = scores
+    """
+    
+    group['Percentile_anomaly'] = group[variable].apply(lambda val: classify(val, low_percentile, high_percentile))
+    group['SD_anomaly'] = group[variable].apply(lambda val: classify(val, lower_2sd, upper_2sd))
+    group['MAD_anomaly'] = group[variable].apply(lambda val: classify(val, lower_mad_v2, upper_mad_v2))
+    group['IQR_anomaly'] = group[variable].apply(lambda val: classify(val, lower_q, upper_q))
+     
+    # Boolean anomaly flags
+    
+    group['is_Percentile_anomaly'] = (group[variable] < low_percentile) | (group[variable] > high_percentile)
+    group['is_SD_anomaly'] = (group[variable] < lower_2sd) | (group[variable] > upper_2sd)
+    group['is_MAD_anomaly'] = (group[variable] < lower_mad_v2) | (group[variable] > upper_mad_v2)
+    group['is_IQR_anomaly'] = (group[variable] < lower_q) | (group[variable] > upper_q)
+    #group["is_IsolationForest_anomaly"] = preds == -1
+
+    return group
+