anomaly-pipeline 0.1.27__py3-none-any.whl → 0.1.61__py3-none-any.whl

anomaly_pipeline/helpers/Preprocessing.py

@@ -15,102 +15,303 @@ def create_full_calendar_and_interpolate(
         group_columns,
         variable,
         date_column,
-        freq
+        freq,
+        min_records,
+        max_records
     ):
-    """
-    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 = []
+    success_metrics = []
+    dropped_metrics = []
 
     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()
-
+        # Create a dictionary of the group keys for structured reporting
+        # This maps {col1: val1, col2: val2}
+        current_group_info = {
+            col: group_key[i] if isinstance(group_key, (tuple, list)) else group_key 
+            for i, col in enumerate(group_columns)
+        }
+        
+        # 1. Calendar Generation
+        min_date, max_date = group[date_column].min(), group[date_column].max()
         full_dates = pd.date_range(start=min_date, end=max_date, freq=freq)
+        
+        if max_records is not None and len(full_dates) > max_records:
+            full_dates = full_dates[-max_records:]
 
-        # 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)}
+        # 2. Expansion
+        calendar_dict = current_group_info.copy()
         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()
+        # 3. Merge
+        merged = full_calendar.merge(group, on=group_columns + [date_column], how="left")
         
+        total_len = len(merged)
+        interpolated_count = merged[variable].isna().sum()
+        interpolation_rate = interpolated_count / total_len if total_len > 0 else 0
+
+        # --- Check 1: Min Records ---
+        if total_len < min_records:
+            drop_entry = current_group_info.copy()
+            drop_entry.update({
+                "reason": "Below Min Records",
+                "details": f"Total records {total_len} < {min_records}",
+                "dropped_records": total_len
+            })
+            dropped_metrics.append(drop_entry)
+            continue
 
-        # ---- Step 4: Interpolate numeric columns ----
-        numeric_cols = merged.select_dtypes(include=[np.number]).columns
+        # --- Check 2: Max Interpolation Rate ---
+        if interpolation_rate > 0.25:
+            drop_entry = current_group_info.copy()
+            drop_entry.update({
+                "reason": "High Interpolation",
+                "details": f"{interpolation_rate:.1%} > 25%",
+                "dropped_records": total_len
+            })
+            dropped_metrics.append(drop_entry)
+            continue
 
-        for col in numeric_cols:
-            merged[col] = merged[col].interpolate(method="linear", limit_direction="both")
+        # --- Success: Interpolate ---
+        merged["is_missing_record"] = merged[variable].isna()
+        merged[variable] = merged[variable].interpolate(method="linear", limit_direction="both")
 
+        success_entry = current_group_info.copy()
+        success_entry.update({
+            "initial_records": len(group),
+            "interpolated_count": interpolated_count
+            "final_records": total_len,
+            "interpolation_pct": round(interpolation_rate * 100, 2)
+        })
+        success_metrics.append(success_entry)
         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
+    # Convert lists of dicts to DataFrames
+    final_df = pd.concat(full_group_data, ignore_index=True) if full_group_data else pd.DataFrame()
+    success_report = pd.DataFrame(success_metrics)
+    exclusion_report = pd.DataFrame(dropped_metrics)
+    
+    return final_df, success_report, exclusion_report
+
+
+def print_anomaly_stats(final_results, success_report, exclusion_report,group_columns,interpolation_method="linear"):
+    # 1. Calculate Global Counts
+    total_records = len(final_results)
+    total_anomalies = final_results['is_Anomaly'].fillna(False).astype(bool).sum()
+    anomaly_rate = (total_anomalies / total_records) * 100 if total_records > 0 else 0
+
+    # 2. Extract specific stats from reports
+    # If exclusion_report is passed but empty, len() returns 0
+    num_excluded = len(exclusion_report)
+    total_groups = len(success_report) + num_excluded
+    evaluated_groups = len(success_report)
+    
+    # Interpolation stats
+    total_interpolated_records = success_report['interpolated_count'].sum() if not success_report.empty else 0
+    groups_with_interpolation = success_report[success_report['interpolated_count'] > 0].shape[0] if not success_report.empty else 0
+
+    # 3. Handle Exclusion stats (check if empty to avoid filtering errors)
+    if num_excluded > 0:
+        missing_data_exclusions = exclusion_report[exclusion_report['reason'] == "High Interpolation"].shape[0]
+        insufficient_history_exclusions = exclusion_report[exclusion_report['reason'] == "Below Min Records"].shape[0]
+    else:
+        missing_data_exclusions = 0
+        insufficient_history_exclusions = 0
 
+    # --- START PRINTING ---
+    print("\n" + "="*55)
+    print(f"{'ANOMALY DETECTION EXECUTIVE SUMMARY':^55}")
+    print("="*55)
+    
+    stats_table = [
+        ["Total Groups", f"{total_groups:,}"],
+        ["Total Records", f"{total_records:,}"],
+        ["Evaluated Groups", f"{evaluated_groups:,}"],
+        ["Evaluated Records", f"{total_records:,}"],
+        ["Evaluated Anomalies", f"{total_anomalies:,}"],
+        ["Anomaly Rate", f"{anomaly_rate:.2f}%"]
+    ]
+    
+    for label, val in stats_table:
+        print(f"{label:<25} : {val:>25}")
+    
+    print("-" * 55)
 
-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
+    # Interpolation Details
+    print(f"INTERPOLATION REPORT:")
+    print(f"{total_interpolated_records:,} records were missing from {groups_with_interpolation} groups")
+    print(f"Values were interpolated using the {interpolation_method} method.")
+    print(f"Total {total_interpolated_records:,} additional records are added to the data.")
+    
+    # Show 5 examples of interpolated records
+    if 'is_interpolated' in final_results.columns:
+        interpolated_samples = final_results[final_results['is_interpolated'] == True].head(5)
+        if not interpolated_samples.empty:
+            print("\nExample Interpolated Records:")
+            # Only show group columns, timestamp (ds), and value (y)
+            cols_to_show = group_columns + ['ds', 'y']
+            print(interpolated_samples[cols_to_show].to_string(index=False))
+    
+    print("-" * 55)
 
-    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)
+    # Exclusion Details
+    print(f"EXCLUSION SUMMARY:")
+    if num_excluded > 0:
+        print(f"- {missing_data_exclusions} groups had >25% missing data and could not be interpolated.")
+        print(f"- {insufficient_history_exclusions} groups lacked the minimum historical data to train.")
+        print(f"See exclusion_report for full list of IDs.")
+    else:
+        print("- No groups were excluded from this run.")
 
-    # --- CHANGE START: Group by Rate ---
-    print(f"Top 5 Groups by Anomaly Rate ({' > '.join(group_columns)}):")
+    print("-" * 55)
     
-    # 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)
+    # Group Breakdown
+    print(f"TOP 5 GROUPS BY ANOMALY RATE ({' > '.join(group_columns)}):")
+    group_stats = final_results.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'])
+        # Handle tuple-based index for multi-grouping
+        group_label = label if isinstance(label, (str, int)) else " | ".join(map(str, label))
+        print(f" - {group_label:<30} : {row['mean']*100:>6.2f}% ({int(row['sum'])} anomalies)")
+    
+    print("="*55 + "\n")
+
+def calculate_ensemble_scores(df, variable):
+    """
+    Calculates the normalized consensus score across all anomaly models.
+    """
+    
+    # Identify all columns that are model flags (is_..._anomaly)
+    anomaly_flags = [col for col in df.columns if col.startswith('is_') and col.endswith('_anomaly') and col != 'is_Anomaly']
+    
+    # 1. Total Votes (Count of True)
+    df['Anomaly_Votes'] = df[anomaly_flags].sum(axis=1).astype(int)
+
+    # 2. Total Models active for that row (Count of non-NaN values)
+    df['Vote_Cnt'] = df[anomaly_flags].notna().sum(axis=1).astype(int)
+    
+    # 3. Anomaly Votes Score Display (x out of N)
+    df['Anomaly_Votes_Display'] = df['Anomaly_Votes'].astype(int).astype(str) + " out of " + df['Vote_Cnt'].astype(int).astype(str)
+    
+    # 5. Final Boolean Consensus (e.g., majority rule)
+    df['is_Anomaly'] = df['Anomaly_Votes'] / df['Vote_Cnt'] >= 0.5
+
+    # 6. Scale all the model scores to be between -1 and 1
+    try:
+        df['Percentile_score_scaled'] = np.where(df['is_Percentile_anomaly'].isna()==False,
+                                                 abs(df[variable] - (df['Percentile_high'] + df['Percentile_low'])/2)/((df['Percentile_high'] - df['Percentile_low'])/2) - 1,
+                                                 np.nan)
+        df['Percentile_score_scaled'] = df['Percentile_score_scaled']/abs(df['Percentile_score_scaled']).max()                                                       
+    except:
+        pass
+
+    try:
+        df['SD_score_scaled'] = np.where(df['is_SD_anomaly'].isna()==False,
+                                         abs(df[variable] - (df['SD2_high'] + df['SD2_low'])/2)/((df['SD2_high'] - df['SD2_low'])/2) - 1,
+                                         np.nan)
+        df['SD_score_scaled'] = df['SD_score_scaled']/abs(df['SD_score_scaled']).max()                                                       
+    except:
+        pass
+
+    try:
+        df['MAD_score_scaled'] = np.where(df['is_MAD_anomaly'].isna()==False,
+                                          abs(df[variable] - (df['MAD_high'] + df['MAD_low'])/2)/((df['MAD_high'] - df['MAD_low'])/2) - 1,
+                                          np.nan)
+        df['MAD_score_scaled'] = df['MAD_score_scaled']/abs(df['MAD_score_scaled']).max()                                                       
+    except:
+        pass
+
+    try:
+        df['IQR_score_scaled'] = np.where(df['is_IQR_anomaly'].isna()==False,
+                                          abs(df[variable] - (df['IQR_high'] + df['IQR_low'])/2)/((df['IQR_high'] - df['IQR_low'])/2) - 1,
+                                          np.nan)
+        df['IQR_score_scaled'] = df['IQR_score_scaled']/abs(df['IQR_score_scaled']).max()                                                       
+    except:
+        pass
+
+    try:
+        df['EWMA_score_scaled'] = np.where(df['is_EWMA_anomaly'].isna()==False,
+                                           abs(df[variable] - (df['EWMA_high'] + df['EWMA_low'])/2)/((df['EWMA_high'] - df['EWMA_low'])/2) - 1,
+                                           np.nan)
+        df['EWMA_score_scaled'] = df['EWMA_score_scaled']/abs(df['EWMA_score_scaled']).max()                                                       
+    except:
+        pass
+
+    try:
+        df['FB_score_scaled'] = np.where(df['is_FB_anomaly'].isna()==False,
+                                         abs(df[variable] - (df['FB_high'] + df['FB_low'])/2)/((df['FB_high'] - df['FB_low'])/2) - 1,
+                                         np.nan)
+        df['FB_score_scaled'] = df['FB_score_scaled']/abs(df['FB_score_scaled']).max()                                                       
+    except:
+        pass
+
+    try:
+        df['IsoForest_score_scaled'] = np.where(df['is_IsolationForest_anomaly'].isna()==False,
+                                                df['IsolationForest_score'] - df['IsolationForest_score_low'],
+                                                np.nan)
+        df['IsoForest_score_scaled'] = df['IsoForest_score_scaled']/abs(df['IsoForest_score_scaled']).max()
+    except:
+        pass
+
+    try:
+        df['dbscan_score_scaled'] = np.where(df['is_DBSCAN_anomaly'].isna()==False, df['dbscan_score_high'] - df['dbscan_score'], np.nan)
+        df['dbscan_score_scaled'] = df['dbscan_score_scaled']/abs(df['dbscan_score_scaled']).max()                                                       
+    except:
+        pass
+    
+    score_scaled_cols = []
+    for col in df.columns.to_list():
+        if '_score_scaled' in col:
+            score_scaled_cols.append(col)
+
+    df['Anomaly_Score'] = df[score_scaled_cols].mean(axis=1)
+    # Rescale all non anomalies between 0 and 0.5 and anomalies between 0.5 and 1.0
+    if len(df[df['is_Anomaly'] == True]) >= 1:
+        # df.loc[df['is_Anomaly'] == True, 'Anomaly_Score'] = ((df.loc[df['is_Anomaly'] == True, 'Anomaly_Score'] + 1) * 0.245) + 0.51
         
-        # 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 ---
+        is_anomaly_min = df[df['is_Anomaly'] == True]['Anomaly_Score'].min()
+        is_anomaly_max = df[df['is_Anomaly'] == True]['Anomaly_Score'].max()
+        # Scale to [0, 0.49] based on actual data range
+        if is_anomaly_max == is_anomaly_min:
+            df.loc[df['is_Anomaly'] == True, 'Anomaly_Score'] = df.loc[df['is_Anomaly'] == True, 'Anomaly_Score'] * 0 + 0.51
+        else:
+            df.loc[df['is_Anomaly'] == True, 'Anomaly_Score'] = (((df.loc[df['is_Anomaly'] == True, 'Anomaly_Score'] - is_anomaly_min) / (is_anomaly_max - is_anomaly_min)) * 0.48) + 0.52
     
-    print("="*45 + "\n")
+    if len(df[df['is_Anomaly'] == False]) >= 1:
+        not_anomaly_min = df[df['is_Anomaly'] == False]['Anomaly_Score'].min()
+        not_anomaly_max = df[df['is_Anomaly'] == False]['Anomaly_Score'].max()
+        # Scale to [0, 0.49] based on actual data range
+        if not_anomaly_max == not_anomaly_min:
+            df.loc[df['is_Anomaly'] == False, 'Anomaly_Score'] = df.loc[df['is_Anomaly'] == False, 'Anomaly_Score'] * 0 # Default to 0 if constant
+        else:
+            df.loc[df['is_Anomaly'] == False, 'Anomaly_Score'] = ((df.loc[df['is_Anomaly'] == False, 'Anomaly_Score'] - not_anomaly_min) / (not_anomaly_max - not_anomaly_min)) * 0.48
+    
+    df['Anomaly_Score_Display'] = np.where(df['is_Anomaly'] == True, np.ceil(100 * df['Anomaly_Score']), np.floor(100 * df['Anomaly_Score'])).astype(int)
+    
+    # 7. Reposition is_Anomaly column to the end
+    df['is_Anomaly'] = df.pop('is_Anomaly')
+
+    return df
 
+
+
+def min_records_extraction(freq,eval_period):
+    freq_upper = freq.upper()
+    
+    if freq_upper.startswith('W'):
+        annual_count = 52
+    elif freq_upper.startswith('D') or freq_upper.startswith('B'):
+        annual_count = 365
+    elif freq_upper.startswith('M'):
+        annual_count = 12
+    else:
+        # Fallback to weekly if custom/unknown
+        annual_count = 52
+
+    # Logic: 1 year for min, 2 years for max
+    min_records = annual_count + eval_period
+    #max_records = (2 * annual_count) + eval_period
+    
+    return min_records

anomaly_pipeline/helpers/STD.py

@@ -3,6 +3,70 @@ import numpy as np
 from .Preprocessing import classify
 
 def detect_outliers_sd(group, variable, date_column, eval_period):
+    
+    """
+    # 📈 Standard-Deviation–Based Outlier Detection (Expanding Window)
+
+    ## **Function:** `detect_outliers_sd`
+
+    This function detects anomalies in a time series using a mean ± 2 standard deviation (SD) rule, applied in a train–test, expanding-window framework.
+
+    ---
+
+    ## 🔍 **What the Function Does**
+
+    ### **1. Minimum Data Requirement**
+    - Requires **at least 10 observations**
+    - Returns an empty DataFrame if insufficient data is provided
+
+    ---
+
+    ## 🏋️ **Training Phase**
+    *(Initial fixed window)*
+
+    - Uses all observations **prior to the evaluation period**
+    - Computes:
+      - **Mean**
+      - **Standard Deviation**
+      - **Lower bound:** `max(mean − 2 × SD, 0)`
+      - **Upper bound:** `mean + 2 × SD`
+    - Flags anomalies where values fall **outside the 2-SD range**
+    - Labels rows as **TRAIN**
+
+    ---
+
+    ## 🔁 **Evaluation Phase**
+    *(Expanding window)*
+
+    For each step in the evaluation period:
+    - Expands the training window to include all prior observations
+    - Recomputes **mean and SD dynamically**
+    - Recalculates anomaly bounds
+    - Tests the current observation against updated bounds
+    - Labels rows as **TEST**
+
+    ---
+
+    ## 🚨 **Anomaly Classification**
+
+    Each observation receives:
+    - **`SD_anomaly`** → categorical label via `classify()`
+    - **`is_SD_anomaly`** → boolean flag  
+      - `True` if outside ±2 SD  
+      - `False` otherwise
+
+    ---
+
+    ## 📊 **Output Columns Added**
+
+    - **Mean**
+    - **SD**
+    - **SD2_low**
+    - **SD2_high**
+    - **set** (`TRAIN` or `TEST`)
+    - **SD_anomaly**
+    - **is_SD_anomaly**"""
+    
     n = len(group)
     # checking the min_size requirements
     if n < 10:

anomaly_pipeline/helpers/__init__.py

@@ -1 +1,13 @@
-from .help_info import help_info
+from .help_anomaly import help_anomaly, get_example_df
+from .evaluation_info import evaluation_info
+from .evaluation_plots import (
+    anomaly_overview_plot, 
+    anomaly_percentile_plot,
+    anomaly_sd_plot, 
+    anomaly_mad_plot, 
+    anomaly_iqr_plot, 
+    anomaly_ewma_plot, 
+    anomaly_fb_plot, 
+    anomaly_dbscan_plot, 
+    anomaly_isolation_forest_plot
+)

anomaly_pipeline/helpers/evaluation_info.py

@@ -1,8 +1,15 @@
 import pandas as pd
 import numpy as np
 from IPython.display import display, Markdown
-from anomaly_pipeline.helpers.evaluation_plots import anomaly_eval_plot, anomaly_percentile_plot,\
-    anomaly_sd_plot, anomaly_mad_plot, anomaly_iqr_plot, anomaly_ewma_plot, anomaly_fb_plot, anomaly_dbscan_plot, anomaly_isolation_forest_timeseries_plot
+from .evaluation_plots import (anomaly_overview_plot, 
+                               anomaly_percentile_plot,
+                               anomaly_sd_plot, 
+                               anomaly_mad_plot, 
+                               anomaly_iqr_plot, 
+                               anomaly_ewma_plot, 
+                               anomaly_fb_plot, 
+                               anomaly_dbscan_plot, 
+                               anomaly_isolation_forest_plot)
 
 
 def evaluation_info(
@@ -10,7 +17,7 @@ def evaluation_info(
     group_columns,
     variable,
     date_column,
-    eval_period=12,
+    eval_period,
     models_to_plot=[]
     ):
     
@@ -42,7 +49,7 @@ def evaluation_info(
         interpolation_msg = ""
     
     no_eval_groups = (
-        eval_df.groupby(['taxonomy', 'channel'])['is_Anomaly']\
+        eval_df.groupby(group_columns)['is_Anomaly']\
         .agg(is_all_na=lambda x: x.isna().all(), historical_data_points='size')\
         .reset_index()
     )
@@ -81,7 +88,7 @@ To increase the chance of evaluating these records, lower the `eval_period` para
     display(Markdown(eval_msg1))
     
     if interpolated_cnt >= 1:
-        display(eval_df[eval_df['is_missing_record'] == True].sample(5))
+        display(eval_df[eval_df['is_missing_record'] == True].sample(min(interpolated_cnt, 5)))
     
     display(Markdown(eval_msg2))
     
@@ -102,20 +109,21 @@ To increase the chance of evaluating these records, lower the `eval_period` para
         
             for model in models_to_plot:
                 if model == 'overall':
-                    anomaly_eval_plot(group_df, group_columns, variable, date_column, eval_period=12, show_anomaly_scores_on_main_plot=False)
+                    anomaly_overview_plot(group_df, group_columns, variable, date_column, eval_period=12, show_anomaly_scores_on_main_plot=False)
                 elif model == 'percentile':
-                    anomaly_percentile_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
-                elif model == 'iqr':            
-                    anomaly_iqr_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
-                elif model == 'mad':
-                    anomaly_mad_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
+                    anomaly_percentile_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
                 elif model == 'std':
-                    anomaly_sd_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
+                    anomaly_sd_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
+                elif model == 'mad':
+                    anomaly_mad_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
+                elif model == 'iqr':            
+                    anomaly_iqr_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
                 elif model == 'ewma':
-                    anomaly_ewma_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
+                    anomaly_ewma_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
                 elif model == 'prophet':
-                    anomaly_fb_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
-                elif model == 'dbscan':
-                    anomaly_dbscan_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
+                    anomaly_fb_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
                 elif model == 'isolation_forest':
-                    anomaly_isolation_forest_timeseries_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, final_anomalies=False, eval_period=12)
+                    anomaly_isolation_forest_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
+                elif model == 'dbscan':
+                    anomaly_dbscan_plot(group=group_df, group_columns=group_columns, variable=variable, date_column=date_column, eval_period=eval_period, final_anomalies=False)
+