anomaly-pipeline 0.1.27__py3-none-any.whl

anomaly_pipeline/helpers/iso_forest_general.py

@@ -0,0 +1,50 @@
+import pandas as pd
+from sklearn.ensemble import IsolationForest
+
+def detect_outliers_isf_general(group, variable, contamination=0.03, random_state=42, eval_period=12):
+    n = len(group)
+    if n < 10:
+        return pd.DataFrame(columns=group.columns)
+
+    group = group.copy()
+    train_size = n - eval_period
+
+    # Initialize columns
+    group['set'] = ""
+    group['IsolationForest_score_general'] = 0.0
+    group['is_IsolationForest_anomaly_general'] = False
+
+    # --- 1. HANDLE TRAINING DATA (Initial Block) ---
+    # Baseline ISF using all data available before eval_period
+    initial_train = group[[variable]].iloc[:train_size]
+    
+    iso = IsolationForest(contamination=contamination, random_state=random_state)
+    
+    # Fit and predict the initial block
+    group.loc[group.index[:train_size], 'IsolationForest_score_general'] = iso.fit_predict(initial_train) # Note: this is actually the cluster label
+    # We use decision_function for the raw anomaly score
+    group.loc[group.index[:train_size], 'IsolationForest_score_general'] = iso.decision_function(initial_train)
+    group.loc[group.index[:train_size], 'is_IsolationForest_anomaly_general'] = iso.predict(initial_train) == -1
+    group.loc[group.index[:train_size], 'set'] = "TRAIN"
+
+    # --- 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 window)
+        current_train = group[[variable]].iloc[:i]
+        
+        # Re-fit the model on all data known up to point i
+        iso_expanding = IsolationForest(contamination=contamination, random_state=random_state)
+        iso_expanding.fit(current_train)
+        
+        # Test the current point i
+        current_point = group[[variable]].iloc[[i]]
+        
+        group.iloc[i, group.columns.get_loc('IsolationForest_score_general')] = iso_expanding.decision_function(current_point)[0]
+        group.iloc[i, group.columns.get_loc('is_IsolationForest_anomaly_general')] = iso_expanding.predict(current_point)[0] == -1
+        group.iloc[i, group.columns.get_loc('set')] = "TEST"
+
+    # Cast boolean column properly
+    group['is_IsolationForest_anomaly_general'] = group['is_IsolationForest_anomaly_general'].astype(bool)
+    
+    return group

anomaly_pipeline/helpers/iso_forest_timeseries.py

@@ -0,0 +1,123 @@
+import pandas as pd
+import numpy as np
+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 detect_time_series_anomalies_isoforest(
+    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)
+    
+    '''
+    Iterate over each of the evaluation periods, fitting the model to all the data before the evaluation period
+    and then getting the predicted anomaly score for the given evaluation period
+    '''
+    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 on the entire model_group DF
+                for lag in lags:
+                    model_group[f'lag{lag}'] = model_group[variable].shift(lag)
+
+                # Get rolling stats features for the entire model_group DF
+                rolling_stats_features = []    
+                for w in [int(np.ceil(max(lags)/4)), int(np.ceil(max(lags)/2)), int(max(lags))]:
+                    if w >= 3:
+                        rolling_stats_features.append('roll_mean' + str(w))
+                        rolling_stats_features.append('roll_std' + str(w))
+                        model_group['roll_mean' + str(w)] = model_group[variable].shift(1).rolling(w).mean()
+                        model_group['roll_std' + str(w)] = model_group[variable].shift(1).rolling(w).std()
+
+                # Get trend feature
+                model_group['trend'] = group.index
+
+                # Drop records with NAs
+                model_group = model_group.copy().dropna()
+
+                # Split into train and test (train and test now both have all the features
+                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]
+
+                # Create and fit the model
+                iso_forest_model = IsolationForest(
+                    n_estimators=200,
+                    contamination=0.01,
+                    random_state=42
+                    )
+                iso_forest_model.fit(train[features])
+
+                train['IsolationForest_score_timeseries'] = iso_forest_model.decision_function(train[features])
+                anomaly_threshold = min(0,
+                    train[train['IsolationForest_score_timeseries'] > 0]['IsolationForest_score_timeseries'].mean() - 3 * train[train['IsolationForest_score_timeseries'] > 0]['IsolationForest_score_timeseries'].std())
+                test['IsolationForest_score_timeseries'] = iso_forest_model.decision_function(test[features])
+                test['contamination_anomaly'] = iso_forest_model.predict(test[features])  # -1 = anomaly, 1 = normal
+                test['anomaly_threshold'] = anomaly_threshold
+                test['threshold_anomaly'] = np.where(test['IsolationForest_score_timeseries'] < anomaly_threshold, -1, 1)
+
+                test['is_IsolationForest_anomaly_timeseries'] = np.where((test['contamination_anomaly'] == -1) & (test['threshold_anomaly'] == -1), True, False)
+                test = test[[variable, date_column, 'IsolationForest_score_timeseries', 'is_IsolationForest_anomaly_timeseries']]
+                test_anom.append(test)
+            except:
+                pass
+        try:
+            test_anom = pd.concat(test_anom)
+            group = group.merge(test_anom[[variable, date_column, 'IsolationForest_score_timeseries', 'is_IsolationForest_anomaly_timeseries']], on=[variable, date_column], how='left')
+        except:
+            print("Error in Isolation Forest process")
+            group["IsolationForest_score_timeseries"] = np.nan
+            group["is_IsolationForest_anomaly_timeseries"] = np.nan
+    
+    except:
+        group["IsolationForest_score_timeseries"] = np.nan
+        group["is_IsolationForest_anomaly_timeseries"] = np.nan
+        # Get string or object dtype columns from group that would identify the group
+        group_id = key_series.select_dtypes(include=['object', 'string']).columns.tolist()
+        group_id = " ".join(key_series[group_id].reset_index(drop=True).iloc[0].to_list())
+        print(f'Isolation Forest Anomaly Detection failed for {group_id}')
+    
+    return group

anomaly_pipeline/helpers/percentile.py

@@ -0,0 +1,65 @@
+import pandas as pd
+import numpy as np
+
+from .Preprocessing import classify
+
+
+# Anomaly category columns (optional, keep if you still want string labels)
+
+
+def detect_outliers_percentile(group, variable,date_column,eval_period):
+    n = len(group)
+    if n < 10:
+        # Optional: log specific keys if they exist in your scope
+        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]
+    
+    low = initial_train.quantile(0.05)
+    high= initial_train.quantile(0.95)
+    
+    # Assign initial bounds to the training rows
+    group.loc[group.index[:train_size], 'set'] = "TRAIN"
+    group.loc[group.index[:train_size], 'Percentile_low'] = low
+    group.loc[group.index[:train_size], 'Percentile_high'] = high
+    group.loc[group.index[:train_size], 'Percentile_anomaly'] = group[variable].iloc[:train_size].apply(
+        lambda x: classify(x, low, high)
+    )
+    group.loc[group.index[:train_size], 'is_Percentile_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]
+        
+        LOW = current_train.quantile(0.05)
+        HIGH  = current_train.quantile(0.95)
+    
+        # Test the current point i
+        current_val = group[variable].iloc[i]
+        group.iloc[i, group.columns.get_loc('set')] = "TEST"
+        group.iloc[i, group.columns.get_loc('Percentile_low')] = LOW
+        group.iloc[i, group.columns.get_loc('Percentile_high')] = HIGH
+        group.iloc[i, group.columns.get_loc('Percentile_anomaly')] = classify(current_val, LOW, HIGH)
+        group.iloc[i, group.columns.get_loc('is_Percentile_anomaly')] = (current_val < LOW) or (current_val > HIGH)
+
+    # Cast boolean column properly
+    group['is_Percentile_anomaly'] = group['is_Percentile_anomaly'].astype(bool)
+    # FINAL SAFETY CHECK
+    group[date_column] = pd.to_datetime(group[date_column])
+    
+    return group
+
+   

anomaly_pipeline/main.py

@@ -0,0 +1,63 @@
+from .pipeline import run_pipeline
+
+def timeseries_anomaly_detection(master_data, group_columns, variable,
+         date_column="week_start", freq="W-MON",
+         max_records=104, min_records=15,
+         contamination=0.03, random_state=42,
+         alpha=0.3, sigma=1.5, eval_period=12,
+         interval_width=0.90, mad_threshold = 2, mad_scale_factor = 0.6745):
+    
+    """
+    Performs anomaly detection on grouped time-series data.
+
+    This function identifies outliers within specific groups of data by analyzing 
+    historical trends, applying statistical thresholds, and calculating 
+    prediction intervals.
+
+    Args:
+        master_data (pd.DataFrame): The input dataset containing the time series.
+        group_columns (list[str]): Columns used to partition the data (e.g., ['store_id', 'item_id']).
+        variable (str): The target numerical column to analyze for anomalies.
+        date_column (str): The column containing datetime information. Defaults to 'week_start'.
+        freq (str): Frequency of the time series (Pandas offset alias). Defaults to 'W-MON'.
+        max_records (int): Maximum historical records to consider for the model. Defaults to 104.
+        min_records (int): Minimum records required to perform detection. Defaults to 15.
+        contamination (float): Expected proportion of outliers in the data (0 to 0.5). Defaults to 0.03.
+        random_state (int): Seed for reproducibility in stochastic models. Defaults to 42.
+        alpha (float): Smoothing factor for trend calculations. Defaults to 0.3.
+        sigma (float): Standard deviation multiplier for thresholding. Defaults to 1.5.
+        eval_periods (int): Number of recent periods to evaluate for anomalies. Defaults to 12.
+        interval_width (float): The confidence level for the prediction interval (0 to 1). Defaults to 0.9.
+
+    Returns:
+        pd.DataFrame: The original dataframe appended with anomaly flags and scores.
+    """
+
+    return run_pipeline(
+        master_data=master_data,
+        group_columns=group_columns,
+        variable=variable,
+        date_column=date_column,
+        freq=freq,
+        max_records=max_records,
+        min_records=min_records,
+        contamination=contamination,
+        random_state=random_state,
+        alpha=alpha,
+        sigma=sigma,
+        eval_period=eval_period,
+        interval_width=interval_width,
+        mad_threshold = mad_threshold, 
+        mad_scale_factor = mad_scale_factor
+        
+    )
+    
+    print("Anomaly pipeline successfully invoked via python -m!")
+
+# change test_weeks to eval_periods: automate min_records based on eval_periods, 
+# max_records = max_records + eval_records
+# freq_daily: max_records based on frequency (for version 2) 104 for weekly
+# split all the 5 functions and parametrize all the variables 
+# change interval_width name to prophet_CI
+# change FB_anomaly column to high low and none insted of -1, 1, 0
+

anomaly_pipeline/pipeline.py

@@ -0,0 +1,253 @@
+import pandas as pd
+import numpy as np
+from datetime import date
+from joblib import Parallel, delayed
+from .helpers.percentile import detect_outliers_percentile
+from .helpers.STD import detect_outliers_sd
+from .helpers.MAD import detect_outliers_mad
+from .helpers.IQR import detect_outliers_iqr
+from .helpers.iso_forest_general import detect_outliers_isf_general
+from .helpers.ewma import ewma_with_anomalies_rolling_group
+from .helpers.fb_prophet import detect_time_series_anomalies_fb_walkforward
+from .helpers.iso_forest_timeseries import detect_time_series_anomalies_isoforest
+from .helpers.DB_scan import detect_time_series_anomalies_dbscan
+from .helpers.Preprocessing import create_full_calendar_and_interpolate, print_anomaly_stats
+
+def process_group(model, name, group, group_columns, variable,
+                  date_column, alpha, sigma, eval_period, interval_width, contamination, random_state):
+
+    if model == "ISF_general":
+        return detect_outliers_isf_general(group, variable, contamination, random_state, eval_period)
+
+    if model == "EWMA":
+        return ewma_with_anomalies_rolling_group(
+            group, group_columns, variable, date_column, alpha, sigma, eval_period
+        )
+
+    if model == "FB":
+        return detect_time_series_anomalies_fb_walkforward(
+            group, variable, date_column, eval_period, interval_width
+        )
+    
+    if model == 'ISF_timeseries':
+        return detect_time_series_anomalies_isoforest(
+            group, variable, date_column, eval_period
+        )
+    
+    if model == 'DBSCAN':
+        return detect_time_series_anomalies_dbscan(
+            group, variable, date_column, eval_period
+        )
+    
+
+def run_pipeline(master_data, group_columns, variable,
+                 date_column, freq,
+                 max_records, min_records,
+                 contamination, random_state,
+                 alpha, sigma, eval_period,
+                 interval_width, mad_threshold, mad_scale_factor):
+
+    # preprocess calendar
+    final_data = create_full_calendar_and_interpolate(
+        master_data,
+        group_columns,
+        variable,
+        date_column,
+        freq
+    )
+
+    groups = list(final_data.groupby(group_columns))
+
+  # Run in parallel (use all cores: n_jobs=-1)
+
+        ## Percentile
+    results_percentile  = []
+    results_SD = []
+    results_IQR = []
+    results_MAD = []
+    for name, group in groups:
+        # percentile
+        res_percentile = detect_outliers_percentile(group, variable, date_column, eval_period)
+        results_percentile.append(res_percentile)
+        
+        # SD
+        res_SD = detect_outliers_sd(group, variable, date_column, eval_period)
+        results_SD.append(res_SD)
+        
+        # MAD
+        res_MAD =  detect_outliers_mad(group, variable, date_column, mad_threshold, mad_scale_factor, eval_period)
+        results_MAD.append(res_MAD)
+        
+        # IQR
+        res_IQR = detect_outliers_iqr(group, variable, date_column, eval_period)
+        results_IQR.append(res_IQR)
+
+    anomaly_key_channel_percentile = pd.concat(results_percentile, ignore_index=True)
+    
+    #print("anomaly_key_channel_percentile data frame created")
+    #print(anomaly_key_channel_percentile.head())
+    
+    anomaly_key_channel_SD = pd.concat(results_SD, ignore_index=True)
+    SD_cols = group_columns+[date_column]+['Mean', 'SD', 'SD2_low', 'SD2_high','SD_anomaly',
+       'is_SD_anomaly']
+    anomaly_key_channel_SD_final =  anomaly_key_channel_SD[SD_cols]
+    
+    #print("anomaly_key_channel_SD data frame created")
+    #print(anomaly_key_channel_SD.head())
+    
+    anomaly_key_channel_MAD = pd.concat(results_MAD, ignore_index=True)
+    MAD_cols = group_columns+[date_column]+['Median', 'MAD', 'MAD_low', 'MAD_high','is_MAD_anomaly',
+       'MAD_anomaly']
+    anomaly_key_channel_MAD_final =  anomaly_key_channel_MAD[MAD_cols]
+    
+    #print("anomaly_key_channel_MAD data frame created")
+    #print(anomaly_key_channel_MAD.head())
+    
+    anomaly_key_channel_IQR = pd.concat(results_IQR, ignore_index=True)
+    IQR_cols = group_columns+[date_column]+['Q1', 'Q3', 'IQR', 'IQR_low', 'IQR_high','IQR_anomaly',
+       'is_IQR_anomaly']
+    anomaly_key_channel_IQR_final =  anomaly_key_channel_IQR[IQR_cols]
+    
+    #print("anomaly_key_channel_IQR data frame created")
+    #print(anomaly_key_channel_IQR.head())
+                                    
+    
+        ## ISF_general
+    results_ISF_general = Parallel(n_jobs=-1, verbose=0)(delayed(process_group)('ISF_general', name, group, group_columns, variable,date_column, alpha, sigma, eval_period, interval_width, contamination, random_state) for name, group in groups)
+
+
+        # Combine results back
+    anomaly_key_channel_ISF_general= (
+                pd.concat(results_ISF_general)
+                  .sort_values(by=group_columns+[date_column])
+            )
+    #print("anomaly_key_channel_ISF_general data frame created")
+    #print(anomaly_key_channel_ISF_general.head())
+    
+     ## EWMA
+    results_EWMA = Parallel(n_jobs=-1, verbose=0)(
+                delayed(process_group)('EWMA', name, group,group_columns, variable, date_column,
+                                       alpha, sigma, eval_period, interval_width, contamination, random_state) for name, group in groups)
+
+
+                # Combine results back
+    anomaly_key_channel_EWMA= (
+                    pd.concat(results_EWMA)
+                      .sort_values(by=group_columns+[date_column])
+                )
+    #print("anomaly_key_channel_EWMA data frame created")
+    #print(anomaly_key_channel_EWMA.head())
+    EWMA_cols = group_columns+[date_column]+['alpha', 'sigma', 'EWMA_forecast',
+       'STD', 'EWMA_high', 'EWMA_low','is_EWMA_anomaly']
+
+    anomaly_key_channel_EWMA_final =  anomaly_key_channel_EWMA[EWMA_cols]
+        
+
+        ## FB
+
+    results_fb = Parallel(n_jobs=-1, verbose=0)(delayed(process_group)('FB', name, group,group_columns, variable,date_column,
+                                  alpha, sigma, eval_period, interval_width, contamination, random_state) for name, group in groups)
+
+
+        # Combine results back
+    anomaly_key_channel_fb= (
+                pd.concat(results_fb)
+                  .sort_values(by=group_columns+[date_column])
+            )
+
+    #print("anomaly_key_channel_fb data frame created")
+    #print(anomaly_key_channel_fb.head())
+    FB_cols = group_columns+[date_column]+["FB_forecast","FB_low","FB_high",
+                                                            "FB_residual","FB_anomaly","is_FB_anomaly"]
+
+    anomaly_key_channel_fb_final =  anomaly_key_channel_fb[FB_cols]
+        
+       
+        ## Isolation Forest timeseries
+    results_ISF_timeseries = Parallel(n_jobs=-1, verbose=0)(
+    delayed(process_group)('ISF_timeseries', name, group,group_columns, variable, date_column,
+                                       alpha, sigma, eval_period, interval_width, contamination, random_state) for name, group in groups)
+
+
+        # Combine results back
+    anomaly_key_channel_ISF_timeseries= (
+            pd.concat(results_ISF_timeseries)
+              .sort_values(by=group_columns+[date_column])
+        )
+    #print(anomaly_key_channel_ISF_timeseries.head())
+    ISF_cols = group_columns+[date_column]+["IsolationForest_score_timeseries", "is_IsolationForest_anomaly_timeseries"]
+    anomaly_key_channel_ISF_timeseries_final =  anomaly_key_channel_ISF_timeseries[ISF_cols]
+    
+    #print("anomaly_key_channel_ISF_timeseries data frame created")
+    #print(anomaly_key_channel_ISF_timeseries.head())
+    
+       ## DB Scan 
+    results_DB = Parallel(n_jobs=-1, verbose=0)(
+    delayed(process_group)('DBSCAN', name, group,group_columns, variable, date_column,
+                                       alpha, sigma, eval_period, interval_width, contamination, random_state) for name, group in groups)
+    
+     # Combine results back
+    anomaly_key_channel_DB= (
+                pd.concat(results_DB)
+                  .sort_values(by=group_columns+[date_column])
+            )
+        
+    
+    #print("anomaly_key_channel_DB data frame created")
+    #print(anomaly_key_channel_DB.head())
+    
+    DB_cols = group_columns+[date_column]+["dbscan_score", "is_DBSCAN_anomaly"]
+    anomaly_key_channel_DB_final =  anomaly_key_channel_DB[DB_cols]
+
+        # combine ISF general and timeseries data frames
+    anomaly_key_channel_ISF = anomaly_key_channel_ISF_general.merge(anomaly_key_channel_ISF_timeseries_final, 
+                                                                     on= group_columns+[date_column], how= 'inner') 
+    
+   
+    # Column 1 Logic: If 'type' is train, take from 'col_A', else take from 'col_B'
+    anomaly_key_channel_ISF['IsolationForest_score'] = np.where(anomaly_key_channel_ISF['set'] == 'TRAIN', 
+                               anomaly_key_channel_ISF['IsolationForest_score_general'], 
+                               anomaly_key_channel_ISF['IsolationForest_score_timeseries'])
+
+    # Column 2 Logic: If 'type' is train, take from 'IsolationForest_general', else take from 'IsolationForest_timeseries'
+    anomaly_key_channel_ISF['is_IsolationForest_anomaly'] = np.where(anomaly_key_channel_ISF['set'] == 'TRAIN', 
+                               anomaly_key_channel_ISF['is_IsolationForest_anomaly_general'], 
+                               anomaly_key_channel_ISF['is_IsolationForest_anomaly_timeseries'])
+    
+    ISF_cols = group_columns+[date_column]+['IsolationForest_score', 'is_IsolationForest_anomaly']
+    anomaly_key_channel_ISF_final =  anomaly_key_channel_ISF[ISF_cols]
+    
+    
+    #print("anomaly_key_channel_ISF data frame created")
+    #print(anomaly_key_channel_ISF.head())
+    
+    
+    # combine all the data frames       
+        
+    anomaly = anomaly_key_channel_percentile.merge(anomaly_key_channel_SD_final,  on= group_columns+[date_column], how='inner')
+    anomaly = anomaly.merge(anomaly_key_channel_MAD_final,  on= group_columns+[date_column], how='inner')
+    anomaly = anomaly.merge(anomaly_key_channel_IQR_final,  on= group_columns+[date_column], how='inner')
+    anomaly = anomaly.merge(anomaly_key_channel_EWMA_final,  on= group_columns+[date_column], how='inner')
+    anomaly = anomaly.merge(anomaly_key_channel_fb_final, on= group_columns+[date_column], how= 'inner')  
+    anomaly = anomaly.merge(anomaly_key_channel_ISF_final, on= group_columns+[date_column], how= 'inner')  
+    anomaly = anomaly.merge(anomaly_key_channel_DB_final, on= group_columns+[date_column], how= 'inner')  
+
+        # ---- Unified anomaly flag (majority voting) ----
+    anomaly_flags = [
+            'is_Percentile_anomaly',
+            'is_SD_anomaly', 'is_MAD_anomaly', 
+            'is_IQR_anomaly',  
+            'is_EWMA_anomaly', 'is_FB_anomaly','is_IsolationForest_anomaly','is_DBSCAN_anomaly']
+
+    anomaly['Anomaly_Votes'] = anomaly[anomaly_flags].sum(axis=1)
+        # Majority rule: anomaly if flagged by at least half the methods
+    anomaly['is_Anomaly'] = anomaly['Anomaly_Votes'] >= 4
+        
+        # Add refresh_date as the first column
+    anomaly.insert(0, 'refresh_date', pd.to_datetime(date.today()))
+    
+    print(anomaly.head())
+    
+    print_anomaly_stats(anomaly, group_columns)
+
+    return anomaly

anomaly_pipeline-0.1.27.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: anomaly_pipeline
+Version: 0.1.27
+Requires-Dist: pandas
+Requires-Dist: numpy<2
+Requires-Dist: joblib
+Requires-Dist: prophet
+Requires-Dist: scikit-learn
+Requires-Dist: google-cloud-bigquery
+Requires-Dist: google-cloud-storage
+Requires-Dist: statsmodels
+Requires-Dist: plotly
+Requires-Dist: pandas-gbq
+Requires-Dist: gcsfs
+Dynamic: requires-dist

anomaly_pipeline-0.1.27.dist-info/RECORD

@@ -0,0 +1,24 @@
+anomaly_pipeline/__init__.py,sha256=ED-UPADjbdS8xjK41KmWVYcFIn6q_cN-SwBx-dRI-nM,77
+anomaly_pipeline/main.py,sha256=khiatXxr01XYHB8SrIfyTnlaCu008MA6ORGiI_2Tjr4,2925
+anomaly_pipeline/pipeline.py,sha256=3Lf9b0Vok-mqWDLhhZeN9emgx5i30stPrU8XOmKpmEw,11204
+anomaly_pipeline/helpers/DB_scan.py,sha256=80PLlubpcwY6dOUx5rm569hvFlGNa1rtvjs74US9oIk,8134
+anomaly_pipeline/helpers/IQR.py,sha256=VlYU6Yf-4KQmVroLvzwd220jn5BUNJEchsVE4_KxKm4,2824
+anomaly_pipeline/helpers/MAD.py,sha256=XDG8r9o1JNi7YZ2NKwNzqmu_Oyz2OPP2rThCuw8WZhs,3377
+anomaly_pipeline/helpers/Preprocessing.py,sha256=VsAohcAW1wTKDdNAF1xNF4j4I2gyZ8rOC1HjyK0NpGk,3933
+anomaly_pipeline/helpers/STD.py,sha256=SZ1UaS_Aa5ay6qWNzKpBXpQIloUuPlliOrfr7yHba4k,2769
+anomaly_pipeline/helpers/__init__.py,sha256=aDAAxiNAusL4rwcn9XbkUIApp3i02UXolB_CWvbbY_0,32
+anomaly_pipeline/helpers/baseline.py,sha256=h9t_LWcAw17P9qmoRQMceukGzOOr-gFLuHfVbipQB7M,3824
+anomaly_pipeline/helpers/cluster_functions.py,sha256=Nhk2YdKVynrKywEILg_5B2xD4zrCZ_ICWw3oOdTDHuA,13040
+anomaly_pipeline/helpers/evaluation_info.py,sha256=SXa1LkznNQXTOcFCbryRmRJMSNC_Fa2CU-HhFnyTIKY,6219
+anomaly_pipeline/helpers/evaluation_plots.py,sha256=xfyVlE7B4E376EL4AF8A4T5kUfqzPShGOSy548psT6M,21230
+anomaly_pipeline/helpers/ewma.py,sha256=YprdcvR17EQ4X9pJo5OusaD3jNaaoHvQLHRHHt25CGk,3562
+anomaly_pipeline/helpers/fb_prophet.py,sha256=-ivBIgMBPT4DG-hbGXPMB1-aiEBfLw2LQvy6eXKzELQ,3182
+anomaly_pipeline/helpers/help_info.py,sha256=QuRd206KQ8etRnlODH9Ek_zmXUvHSBwVQtukqf0iKSc,37012
+anomaly_pipeline/helpers/iso_forest_general.py,sha256=nonZl2wcLyHe0E50mqQUw_IB3tuMochmZKQNd0xMFVk,2350
+anomaly_pipeline/helpers/iso_forest_timeseries.py,sha256=SWf6g0mwLohIRdMvGfMCAcfWi5FPPokiV7dM8Un5qpE,5900
+anomaly_pipeline/helpers/percentile.py,sha256=eLk0PgY7m7z7VKTLfXg8ykKii0ciAJvlGOYXpv84mOE,2523
+anomaly_pipeline-0.1.27.dist-info/METADATA,sha256=YIIJMpsDchA8L2Jp0T4wBXpxwcL5r-UiJ35gLP6BRCs,371
+anomaly_pipeline-0.1.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+anomaly_pipeline-0.1.27.dist-info/entry_points.txt,sha256=c7aMFN_VdyQk_gKp9S2-bz4AF3eBActUectAElnEdMo,92
+anomaly_pipeline-0.1.27.dist-info/top_level.txt,sha256=3QhrLt05iNbxIQhnAA0vmIkRQje4Hc_STGY_Tukx3Vg,17
+anomaly_pipeline-0.1.27.dist-info/RECORD,,

anomaly_pipeline-0.1.27.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

anomaly_pipeline-0.1.27.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+run_anomaly_pipeline = anomaly_pipeline.main:timeseries_anomaly_detection

anomaly_pipeline-0.1.27.dist-info/top_level.txt

@@ -0,0 +1 @@
+anomaly_pipeline