validmind 2.7.5__py3-none-any.whl → 2.7.6__py3-none-any.whl

validmind/tests/ongoing_monitoring/ScoreBandsDrift.py

@@ -0,0 +1,210 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+import pandas as pd
+import numpy as np
+from typing import List
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset, VMModel
+
+
+@tags("visualization", "credit_risk", "scorecard")
+@tasks("classification")
+def ScoreBandsDrift(
+    datasets: List[VMDataset],
+    model: VMModel,
+    score_column: str = "score",
+    score_bands: list = None,
+    drift_threshold: float = 20.0,
+):
+    """
+    Analyzes drift in population distribution and default rates across score bands.
+
+    ### Purpose
+
+    The Score Bands Drift test is designed to evaluate changes in score-based risk segmentation
+    over time. By comparing population distribution and default rates across score bands between
+    reference and monitoring datasets, this test helps identify whether the model's risk
+    stratification remains stable in production. This is crucial for understanding if the model's
+    scoring behavior maintains its intended risk separation and whether specific score ranges
+    have experienced significant shifts.
+
+    ### Test Mechanism
+
+    This test proceeds by segmenting scores into predefined bands and analyzing three key metrics
+    across these bands: population distribution, predicted default rates, and observed default
+    rates. For each band, it computes these metrics for both reference and monitoring datasets
+    and quantifies drift as percentage changes. The test provides both detailed band-by-band
+    comparisons and overall stability assessment, with special attention to bands showing
+    significant drift.
+
+    ### Signs of High Risk
+
+    - Large shifts in population distribution across bands
+    - Significant changes in default rates within bands
+    - Inconsistent drift patterns between adjacent bands
+    - Divergence between predicted and observed rates
+    - Systematic shifts in risk concentration
+    - Empty or sparse score bands in monitoring data
+
+    ### Strengths
+
+    - Provides comprehensive view of score-based drift
+    - Identifies specific score ranges with instability
+    - Enables comparison of multiple risk metrics
+    - Includes both distribution and performance drift
+    - Supports business-relevant score segmentation
+    - Maintains interpretable drift thresholds
+
+    ### Limitations
+
+    - Sensitive to choice of score band boundaries
+    - Requires sufficient samples in each band
+    - Cannot suggest optimal band adjustments
+    - May not capture within-band distribution changes
+    - Limited to predefined scoring metrics
+    - Complex interpretation with multiple drift signals
+    """
+    # Validate score column
+    if score_column not in datasets[0].df.columns:
+        raise ValueError(
+            f"Score column '{score_column}' not found in reference dataset"
+        )
+    if score_column not in datasets[1].df.columns:
+        raise ValueError(
+            f"Score column '{score_column}' not found in monitoring dataset"
+        )
+
+    # Default score bands if none provided
+    if score_bands is None:
+        score_bands = [410, 440, 470]
+
+    # Create band labels
+    band_labels = [
+        f"{score_bands[i]}-{score_bands[i+1]}" for i in range(len(score_bands) - 1)
+    ]
+    band_labels.insert(0, f"<{score_bands[0]}")
+    band_labels.append(f">{score_bands[-1]}")
+
+    # Process reference and monitoring datasets
+    def process_dataset(dataset, model):
+        df = dataset.df.copy()
+        df["score_band"] = pd.cut(
+            df[score_column],
+            bins=[-np.inf] + score_bands + [np.inf],
+            labels=band_labels,
+        )
+        y_pred = dataset.y_pred(model)
+
+        results = {}
+        total_population = len(df)
+
+        # Store min and max scores
+        min_score = df[score_column].min()
+        max_score = df[score_column].max()
+
+        for band in band_labels:
+            band_mask = df["score_band"] == band
+            population = band_mask.sum()
+
+            results[band] = {
+                "Population (%)": population / total_population * 100,
+                "Predicted Default Rate (%)": (
+                    y_pred[band_mask].sum() / population * 100 if population > 0 else 0
+                ),
+                "Observed Default Rate (%)": (
+                    df[band_mask][dataset.target_column].sum() / population * 100
+                    if population > 0
+                    else 0
+                ),
+            }
+
+        results["min_score"] = min_score
+        results["max_score"] = max_score
+        return results
+
+    # Get metrics for both datasets
+    ref_results = process_dataset(datasets[0], model)
+    mon_results = process_dataset(datasets[1], model)
+
+    # Create the three comparison tables
+    tables = {}
+    all_passed = True
+
+    metrics = [
+        ("Population Distribution (%)", "Population (%)"),
+        ("Predicted Default Rates (%)", "Predicted Default Rate (%)"),
+        ("Observed Default Rates (%)", "Observed Default Rate (%)"),
+    ]
+
+    for table_name, metric in metrics:
+        rows = []
+        metric_passed = True
+
+        for band in band_labels:
+            ref_val = ref_results[band][metric]
+            mon_val = mon_results[band][metric]
+
+            # Calculate drift - using absolute difference when reference is 0
+            drift = (
+                abs(mon_val - ref_val)
+                if ref_val == 0
+                else ((mon_val - ref_val) / abs(ref_val)) * 100
+            )
+            passed = abs(drift) < drift_threshold
+            metric_passed &= passed
+
+            rows.append(
+                {
+                    "Score Band": band,
+                    "Reference": round(ref_val, 4),
+                    "Monitoring": round(mon_val, 4),
+                    "Drift (%)": round(drift, 2),
+                    "Pass/Fail": "Pass" if passed else "Fail",
+                }
+            )
+
+        # Add total row for all metrics
+        if metric == "Population (%)":
+            ref_total = 100.0
+            mon_total = 100.0
+            drift_total = 0.0
+            passed_total = True
+        else:
+            ref_total = sum(
+                ref_results[band][metric] * (ref_results[band]["Population (%)"] / 100)
+                for band in band_labels
+            )
+            mon_total = sum(
+                mon_results[band][metric] * (mon_results[band]["Population (%)"] / 100)
+                for band in band_labels
+            )
+            # Apply same drift calculation to totals
+            drift_total = (
+                abs(mon_total - ref_total)
+                if ref_total == 0
+                else ((mon_total - ref_total) / abs(ref_total)) * 100
+            )
+            passed_total = abs(drift_total) < drift_threshold
+
+        # Format total row with score ranges
+        total_label = (
+            f"Total ({ref_results['min_score']:.0f}-{ref_results['max_score']:.0f})"
+        )
+
+        rows.append(
+            {
+                "Score Band": total_label,
+                "Reference": round(ref_total, 4),
+                "Monitoring": round(mon_total, 4),
+                "Drift (%)": round(drift_total, 2),
+                "Pass/Fail": "Pass" if passed_total else "Fail",
+            }
+        )
+
+        metric_passed &= passed_total
+        tables[table_name] = pd.DataFrame(rows)
+        all_passed &= metric_passed
+
+    return tables, all_passed

validmind/tests/ongoing_monitoring/ScorecardHistogramDrift.py

@@ -0,0 +1,207 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from scipy import stats
+from typing import List
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset
+
+
+@tags("visualization", "credit_risk", "logistic_regression")
+@tasks("classification")
+def ScorecardHistogramDrift(
+    datasets: List[VMDataset],
+    score_column: str = "score",
+    title: str = "Scorecard Histogram Drift",
+    drift_pct_threshold: float = 20.0,
+):
+    """
+    Compares score distributions between reference and monitoring datasets for each class.
+
+    ### Purpose
+
+    The Scorecard Histogram Drift test is designed to evaluate changes in the model's scoring
+    patterns over time. By comparing score distributions between reference and monitoring datasets
+    for each class, this test helps identify whether the model's scoring behavior remains stable
+    in production. This is crucial for understanding if the model's risk assessment maintains
+    consistent patterns and whether specific score ranges have experienced significant shifts
+    in their distribution.
+
+    ### Test Mechanism
+
+    This test proceeds by generating histograms of scores for each class in both reference and
+    monitoring datasets. It analyzes distribution characteristics through multiple statistical
+    moments: mean, variance, skewness, and kurtosis. The test quantifies drift as percentage
+    changes in these moments between datasets, providing both visual and numerical assessments
+    of distribution stability. Special attention is paid to class-specific distribution changes.
+
+    ### Signs of High Risk
+
+    - Significant shifts in score distribution shapes
+    - Large drifts in distribution moments exceeding threshold
+    - Changes in the relative positioning of class distributions
+    - Appearance of new modes or peaks in monitoring data
+    - Unexpected changes in score spread or concentration
+    - Systematic shifts in class-specific scoring patterns
+
+    ### Strengths
+
+    - Provides class-specific distribution analysis
+    - Identifies detailed changes in scoring patterns
+    - Enables visual comparison of distributions
+    - Includes comprehensive moment analysis
+    - Supports multiple class evaluation
+    - Maintains interpretable score scale
+
+    ### Limitations
+
+    - Sensitive to binning choices in visualization
+    - Requires sufficient samples per class
+    - Cannot suggest score adjustments
+    - May not capture subtle distribution changes
+    - Complex interpretation with multiple classes
+    - Limited to univariate score analysis
+    """
+    # Verify score column exists
+    if score_column not in datasets[0].df.columns:
+        raise ValueError(
+            f"Score column '{score_column}' not found in reference dataset"
+        )
+    if score_column not in datasets[1].df.columns:
+        raise ValueError(
+            f"Score column '{score_column}' not found in monitoring dataset"
+        )
+
+    # Get reference and monitoring data
+    df_ref = datasets[0].df
+    df_mon = datasets[1].df
+
+    # Get unique classes
+    classes = sorted(df_ref[datasets[0].target_column].unique())
+
+    # Create subplots with more horizontal space for legends
+    fig = make_subplots(
+        rows=len(classes),
+        cols=1,
+        subplot_titles=[f"Class {cls}" for cls in classes],
+        horizontal_spacing=0.15,
+    )
+
+    # Define colors
+    ref_color = "rgba(31, 119, 180, 0.8)"  # Blue with 0.8 opacity
+    mon_color = "rgba(255, 127, 14, 0.8)"  # Orange with 0.8 opacity
+
+    # Dictionary to store tables for each class
+    tables = {}
+    all_passed = True  # Track overall pass/fail
+
+    # Add histograms and create tables for each class
+    for i, class_value in enumerate(classes, start=1):
+        # Get scores for current class
+        ref_scores = df_ref[df_ref[datasets[0].target_column] == class_value][
+            score_column
+        ]
+        mon_scores = df_mon[df_mon[datasets[1].target_column] == class_value][
+            score_column
+        ]
+
+        # Calculate distribution moments
+        ref_stats = {
+            "Mean": np.mean(ref_scores),
+            "Variance": np.var(ref_scores),
+            "Skewness": stats.skew(ref_scores),
+            "Kurtosis": stats.kurtosis(ref_scores),
+        }
+
+        mon_stats = {
+            "Mean": np.mean(mon_scores),
+            "Variance": np.var(mon_scores),
+            "Skewness": stats.skew(mon_scores),
+            "Kurtosis": stats.kurtosis(mon_scores),
+        }
+
+        # Create table for this class
+        table_data = []
+        class_passed = True  # Track pass/fail for this class
+
+        for stat_name in ["Mean", "Variance", "Skewness", "Kurtosis"]:
+            ref_val = ref_stats[stat_name]
+            mon_val = mon_stats[stat_name]
+            drift = (
+                ((mon_val - ref_val) / abs(ref_val)) * 100 if ref_val != 0 else np.inf
+            )
+            passed = abs(drift) < drift_pct_threshold
+            class_passed &= passed  # Update class pass/fail
+
+            table_data.append(
+                {
+                    "Statistic": stat_name,
+                    "Reference": round(ref_val, 4),
+                    "Monitoring": round(mon_val, 4),
+                    "Drift (%)": round(drift, 2),
+                    "Pass/Fail": "Pass" if passed else "Fail",
+                }
+            )
+
+        tables[f"Class {class_value}"] = pd.DataFrame(table_data)
+        all_passed &= class_passed  # Update overall pass/fail
+
+        # Reference dataset histogram
+        fig.add_trace(
+            go.Histogram(
+                x=ref_scores,
+                name=f"Reference - Class {class_value}",
+                marker_color=ref_color,
+                showlegend=True,
+                legendrank=i * 2 - 1,
+            ),
+            row=i,
+            col=1,
+        )
+
+        # Monitoring dataset histogram
+        fig.add_trace(
+            go.Histogram(
+                x=mon_scores,
+                name=f"Monitoring - Class {class_value}",
+                marker_color=mon_color,
+                showlegend=True,
+                legendrank=i * 2,
+            ),
+            row=i,
+            col=1,
+        )
+
+    # Update layout
+    fig.update_layout(
+        title_text=title,
+        barmode="overlay",
+        height=300 * len(classes),
+        width=1000,
+        showlegend=True,
+    )
+
+    # Update axes labels and add separate legends for each subplot
+    for i in range(len(classes)):
+        fig.update_xaxes(title_text="Score", row=i + 1, col=1)
+        fig.update_yaxes(title_text="Frequency", row=i + 1, col=1)
+
+        # Add separate legend for each subplot
+        fig.update_layout(
+            **{
+                f'legend{i+1 if i > 0 else ""}': dict(
+                    yanchor="middle",
+                    y=1 - (i / len(classes)) - (0.5 / len(classes)),
+                    xanchor="left",
+                    x=1.05,
+                    tracegroupgap=5,
+                )
+            }
+        )
+
+    return fig, tables, all_passed

validmind/tests/ongoing_monitoring/TargetPredictionDistributionPlot.py

@@ -2,15 +2,16 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-import matplotlib.pyplot as plt
-import seaborn as sns
-
+import plotly.graph_objects as go
+import plotly.figure_factory as ff
+import pandas as pd
+from scipy.stats import skew, kurtosis
 from validmind import tags, tasks
 
 
 @tags("visualization")
 @tasks("monitoring")
-def TargetPredictionDistributionPlot(datasets, model):
+def TargetPredictionDistributionPlot(datasets, model, drift_pct_threshold=20):
     """
     Assesses differences in prediction distributions between a reference dataset and a monitoring dataset to identify
     potential data drift.
@@ -45,23 +46,99 @@ def TargetPredictionDistributionPlot(datasets, model):
     - Less effective if the differences in distributions are subtle and not easily visible.
     """
 
+    # Get predictions
     pred_ref = datasets[0].y_prob_df(model)
     pred_ref.columns = ["Reference Prediction"]
     pred_monitor = datasets[1].y_prob_df(model)
     pred_monitor.columns = ["Monitoring Prediction"]
 
-    fig = plt.figure()
-    plot = sns.kdeplot(
-        pred_ref["Reference Prediction"], fill=True, label="Reference Prediction"
+    # Calculate distribution moments
+    moments = pd.DataFrame(
+        {
+            "Statistic": ["Mean", "Std", "Skewness", "Kurtosis"],
+            "Reference": [
+                pred_ref["Reference Prediction"].mean(),
+                pred_ref["Reference Prediction"].std(),
+                skew(pred_ref["Reference Prediction"]),
+                kurtosis(pred_ref["Reference Prediction"]),
+            ],
+            "Monitoring": [
+                pred_monitor["Monitoring Prediction"].mean(),
+                pred_monitor["Monitoring Prediction"].std(),
+                skew(pred_monitor["Monitoring Prediction"]),
+                kurtosis(pred_monitor["Monitoring Prediction"]),
+            ],
+        }
+    )
+
+    # Calculate drift percentage with direction
+    moments["Drift (%)"] = (
+        (moments["Monitoring"] - moments["Reference"])
+        / moments["Reference"].abs()
+        * 100
+    ).round(2)
+
+    # Add Pass/Fail column based on absolute drift
+    moments["Pass/Fail"] = (
+        moments["Drift (%)"]
+        .abs()
+        .apply(lambda x: "Pass" if x < drift_pct_threshold else "Fail")
+    )
+
+    # Set Statistic as index but keep it as a column
+    moments = moments.set_index("Statistic", drop=False)
+
+    # Create KDE for both distributions
+    ref_kde = ff.create_distplot(
+        [pred_ref["Reference Prediction"].values],
+        ["Reference"],
+        show_hist=False,
+        show_rug=False,
     )
-    plot = sns.kdeplot(
-        pred_monitor["Monitoring Prediction"], fill=True, label="Monitor Prediction"
+    monitor_kde = ff.create_distplot(
+        [pred_monitor["Monitoring Prediction"].values],
+        ["Monitoring"],
+        show_hist=False,
+        show_rug=False,
     )
-    plot.set(
-        xlabel="Prediction", title="Distribution of Reference & Monitor Predictions"
+
+    # Create new figure
+    fig = go.Figure()
+
+    # Add reference distribution
+    fig.add_trace(
+        go.Scatter(
+            x=ref_kde.data[0].x,
+            y=ref_kde.data[0].y,
+            fill="tozeroy",
+            name="Reference Prediction",
+            line=dict(color="blue", width=2),
+            opacity=0.6,
+        )
+    )
+
+    # Add monitoring distribution
+    fig.add_trace(
+        go.Scatter(
+            x=monitor_kde.data[0].x,
+            y=monitor_kde.data[0].y,
+            fill="tozeroy",
+            name="Monitor Prediction",
+            line=dict(color="red", width=2),
+            opacity=0.6,
+        )
+    )
+
+    # Update layout
+    fig.update_layout(
+        title="Distribution of Reference & Monitor Predictions",
+        xaxis_title="Prediction",
+        yaxis_title="Density",
+        showlegend=True,
+        template="plotly_white",
+        hovermode="x unified",
     )
-    plot.legend()
 
-    plt.close()
+    pass_fail_bool = (moments["Pass/Fail"] == "Pass").all()
 
-    return fig
+    return ({"Distribution Moments": moments}, fig, pass_fail_bool)

validmind/vm_models/dataset/dataset.py

@@ -369,10 +369,6 @@ class VMDataset(VMInput):
         # reset feature columns to exclude the new extra column
         self._set_feature_columns()
 
-        logger.info(
-            f"Extra column {column_name} with {len(column_values)} values added to the dataset"
-        )
-
     @property
     def df(self) -> pd.DataFrame:
         """

{validmind-2.7.5.dist-info → validmind-2.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: validmind
-Version: 2.7.5
+Version: 2.7.6
 Summary: ValidMind Library
 License: Commercial License
 Author: Andres Rodriguez
@@ -44,7 +44,7 @@ Requires-Dist: python-dotenv
 Requires-Dist: ragas (>=0.2.3) ; extra == "all" or extra == "llm"
 Requires-Dist: rouge (>=1)
 Requires-Dist: rpy2 (>=3.5.10,<4.0.0) ; extra == "all" or extra == "r-support"
-Requires-Dist: scikit-learn (!=1.6.0)
+Requires-Dist: scikit-learn (<1.6.0)
 Requires-Dist: scipy
 Requires-Dist: scorecardpy (>=0.1.9.6,<0.2.0.0)
 Requires-Dist: seaborn

{validmind-2.7.5.dist-info → validmind-2.7.6.dist-info}/RECORD

@@ -1,5 +1,5 @@
 validmind/__init__.py,sha256=U-S6pV31O3sVsbcEzlriz0tootyfvPnPOu4PHzXz9tM,2688
-validmind/__version__.py,sha256=lBcjVwt4I0-VUeE_7gM1gQBbtKOi9jGT3DavJbzcYnQ,22
+validmind/__version__.py,sha256=6xG2XfctNZV_iMAbDf3PscewWwjPfwfmAC2zaeMR2KI,22
 validmind/ai/test_descriptions.py,sha256=OpdMyLkZqlvegxjKfg2iJ0o4PwjnRv4_kEzePyuQiYs,7345
 validmind/ai/test_result_description/config.yaml,sha256=E1gPd-uv-MzdrWZA_rP6LSk8pVmkYijx6v78hZ8ceL0,787
 validmind/ai/test_result_description/context.py,sha256=ebKulFMpXTDLqd6lOHAsG200GmLNnhnu7sMDnbo2Dhc,2339
@@ -20,7 +20,7 @@ validmind/datasets/cluster/digits.py,sha256=E600pX6QPrqndfr73kwZ1sTNk0hC5kNj4Fhs
 validmind/datasets/credit_risk/__init__.py,sha256=vK0wyUcA2mpjasNR-EaBj_0MdPhJw5KK8xlrKj_xl68,295
 validmind/datasets/credit_risk/datasets/lending_club_biased.csv.gz,sha256=PdsyEqHtfShtfl_xoNWva2Ofyfx5hmrLhowPka4hLew,6266192
 validmind/datasets/credit_risk/datasets/lending_club_loan_data_2007_2014_clean.csv.gz,sha256=bAgdfmUxjYOdZMPvoHtKr_GLoXNAX04KUTfjn2L62eE,5493810
-validmind/datasets/credit_risk/lending_club.py,sha256=vBqEx3pK1Q7WpRIHRg692FcgJOv_Z1G7UprhlOPdlfE,25547
+validmind/datasets/credit_risk/lending_club.py,sha256=m8VnZSkNo5ja-y-WSc7MbUavlGKKY2YqfGOV3Pzcg_4,34630
 validmind/datasets/credit_risk/lending_club_bias.py,sha256=8_Xf1qxCTUPv1wYHYkjabO2WtQsfVudJ6eje3phQUrc,4461
 validmind/datasets/llm/rag/__init__.py,sha256=v8BygB6rGECoMIXv2_I1lVUAfPJ_gVo0GgVKhzk60h4,264
 validmind/datasets/llm/rag/datasets/rfp_existing_questions_client_1.csv,sha256=8Ae8TD5Yh6rQ67HMCu7iKipj5tyOOhzylZqLppAeKzs,24095
@@ -113,7 +113,7 @@ validmind/tests/data_validation/Duplicates.py,sha256=HAEHRFwFZovJU-wBWea0KJREsJC
 validmind/tests/data_validation/EngleGrangerCoint.py,sha256=kNBbxLYweF8qTF5JVRzcyXq3aKLhkN_1iv3mwwskTBU,4503
 validmind/tests/data_validation/FeatureTargetCorrelationPlot.py,sha256=OwEEavtIY23HRH1CcdCJnTlbj1hn9mCLe9mG8Yw0EOs,4249
 validmind/tests/data_validation/HighCardinality.py,sha256=nXANbDQPogdFzYLJ9xJIdjWjNJ7yhteAdkcUWrm4Lrg,3362
-validmind/tests/data_validation/HighPearsonCorrelation.py,sha256=hc-DvaFz4Ew1Lc6uV3xiPAL7M_srwro-MeHVafmxxsk,3537
+validmind/tests/data_validation/HighPearsonCorrelation.py,sha256=KiWKgkqHY387GaYS7HmgHQFuwKiV95Su3eXS-h8paJs,3703
 validmind/tests/data_validation/IQROutliersBarPlot.py,sha256=8E7onPlknLcci_zHrM1RbZJnYLrLhFMWblwadCqFozQ,4978
 validmind/tests/data_validation/IQROutliersTable.py,sha256=_YoqYw-rATiPuY9sOYJAT1jKdGm_VFnYqfbugMkoM6w,3962
 validmind/tests/data_validation/IsolationForestOutliers.py,sha256=bjkPF4Dczt-dzPZsElGZPv6G_fRkSB9sSeCwj42tZrg,3881
@@ -266,10 +266,21 @@ validmind/tests/model_validation/statsmodels/RegressionPermutationFeatureImporta
 validmind/tests/model_validation/statsmodels/ScorecardHistogram.py,sha256=0hnB6icasRKT_Cl0YxMEpIuaUKgi5scXHmV_nP9RmkI,4650
 validmind/tests/model_validation/statsmodels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 validmind/tests/model_validation/statsmodels/statsutils.py,sha256=s1J7lHJ4kAcp_gGI0LAsaIFxbSqPrqXanxgtDI_Kig0,495
-validmind/tests/ongoing_monitoring/FeatureDrift.py,sha256=qsBoolRGgW6sdUa8F-c4gsf6liFTyO4hCY-2lJv7YNY,6234
-validmind/tests/ongoing_monitoring/PredictionAcrossEachFeature.py,sha256=QDaYzf2b3n4yU_Rq3kBRJA49jIl1RP-n2d4KikZ76_c,3323
-validmind/tests/ongoing_monitoring/PredictionCorrelation.py,sha256=15GqFODz986m0c-62fc1UffSRLndGv4WiB2Uz503zak,3449
-validmind/tests/ongoing_monitoring/TargetPredictionDistributionPlot.py,sha256=KVJvMGpNg0fsCJ9ZkUmlRZ-L1Gy9xLj1YS_C-p5bsXc,2498
+validmind/tests/ongoing_monitoring/CalibrationCurveDrift.py,sha256=VHWKOE317SMv6I_9Ua8unsV9CalpMVZqPLn8HGp9wqo,7843
+validmind/tests/ongoing_monitoring/ClassDiscriminationDrift.py,sha256=ZdqrZf9Wr5gWhMICEx2RopL3CE-CJekDWNForo1JdHM,5706
+validmind/tests/ongoing_monitoring/ClassImbalanceDrift.py,sha256=tdzhDbA2WrAFjUJmKYWraXCYArAK0hZOk9Fp2AyU0AY,5059
+validmind/tests/ongoing_monitoring/ClassificationAccuracyDrift.py,sha256=C1FqCd_3C5J9BhgOlxtAtS6onOkxdF39-22XI-R5yEQ,4990
+validmind/tests/ongoing_monitoring/ConfusionMatrixDrift.py,sha256=RokHTnbKGzDx5dsuXSuTT9kC-yIPEkjfq67bCM1UYug,6946
+validmind/tests/ongoing_monitoring/CumulativePredictionProbabilitiesDrift.py,sha256=rXbK344BXCk-MI0ERylewMF8lL1jXdgoQZWdoYQexpk,6199
+validmind/tests/ongoing_monitoring/FeatureDrift.py,sha256=Mgry31V2juaIWGyPVBJUxeHD5zC1PJpAWYQImwcrNJc,6191
+validmind/tests/ongoing_monitoring/PredictionAcrossEachFeature.py,sha256=ngIS8Ybp4GzAqIZdVMxH4PvKtulMkxfsh6lSM6Gp1g0,3052
+validmind/tests/ongoing_monitoring/PredictionCorrelation.py,sha256=W2nEdmGTvNN6v3y3Xscsh2V8lwtWxdcCHjwuyrn_91o,5020
+validmind/tests/ongoing_monitoring/PredictionProbabilitiesHistogramDrift.py,sha256=qGLWPzWUHFatC1LC2JkMTSJaiPLR5G1KRzWe8cbWSLY,7130
+validmind/tests/ongoing_monitoring/PredictionQuantilesAcrossFeatures.py,sha256=MMICygVYq2sN9w52apo3H6ajhWezNkKgTkTM93gYC_U,3251
+validmind/tests/ongoing_monitoring/ROCCurveDrift.py,sha256=ST8QvyPnjSI4_qv7N0n-c157Ej6oGykCzaAVj35i3FQ,5121
+validmind/tests/ongoing_monitoring/ScoreBandsDrift.py,sha256=FewqXl8eeZZR2Z_4qZxZGjnh8mRVcOsC7-prl3lBTT0,7496
+validmind/tests/ongoing_monitoring/ScorecardHistogramDrift.py,sha256=7hD4JSyTKik1NHVG-FJ02IMcqWnoqAjox1JvYJZDoFg,7258
+validmind/tests/ongoing_monitoring/TargetPredictionDistributionPlot.py,sha256=osC9QUPYJjR4hU3EnfVr7S5r5oLCh8txn3bgDl8CaB4,4863
 validmind/tests/output.py,sha256=1kY9FJWUOpZ2BofxKQ5scxkg10Pvb24_OxypegHeh04,4029
 validmind/tests/prompt_validation/Bias.py,sha256=UFtC7l8aXBkyzfpvZ2db2JlO5SZOssp2mCrUk5HKyTY,5702
 validmind/tests/prompt_validation/Clarity.py,sha256=KA1hFtsUHO02epDEIc4W1LtuU3BoXCg3xkQsuIUKeuI,4825
@@ -303,7 +314,7 @@ validmind/unit_metrics/regression/RootMeanSquaredError.py,sha256=uIDsSpy75Z7W3zu
 validmind/utils.py,sha256=WvjKXskGmVGupEVYvEiy5-0cBT_jwpKfpH2HsCfy_B8,18655
 validmind/vm_models/__init__.py,sha256=lcqf9q2aRzrVrNN6R--81IkrnSa6BXPbhJ8SnkT_hcI,702
 validmind/vm_models/dataset/__init__.py,sha256=U4CxZjdoc0dd9u2AqBl5PJh1UVbzXWNrmundmjLF-qE,346
-validmind/vm_models/dataset/dataset.py,sha256=Zzquc3FhPGTMZhFxNlAIHf4AGXq5idpJmr-fkXUpi6A,26498
+validmind/vm_models/dataset/dataset.py,sha256=F6_rc5pjccRLnB7UcIMiGMbD-qMVUW5v4TnZTNSXTbo,26370
 validmind/vm_models/dataset/utils.py,sha256=VMcPEgwW9oW5D0MCa_MqXCq_sEzzsLLRmS4RaYrsif0,5530
 validmind/vm_models/figure.py,sha256=7VNOIsbOsUKyXvgxaY10H_Wvy2HEFte3nwdx09SZu20,6297
 validmind/vm_models/input.py,sha256=qLdqz_bktr4v0YcPha2vFdDvmkC-btT1pH9zBIkt1OY,1046
@@ -316,8 +327,8 @@ validmind/vm_models/test_suite/runner.py,sha256=Cpl9WKwHzJD5Zvrh71FzbEhGZkHM0x0M
 validmind/vm_models/test_suite/summary.py,sha256=Ug3nMvpPL2DSTDujWagWMCrFiW9oDy0AqJL_zXN8pH0,4642
 validmind/vm_models/test_suite/test.py,sha256=uImjmPlBlLrlVPavsUzbaDK55bvpOn3PuFyWeyYyTac,3908
 validmind/vm_models/test_suite/test_suite.py,sha256=5Jppt2UXSMgvJ6FO5LIAKA4oN_-hh9SMr8APAFJzk9g,5080
-validmind-2.7.5.dist-info/LICENSE,sha256=XonPUfwjvrC5Ombl3y-ko0Wubb1xdG_7nzvIbkZRKHw,35772
-validmind-2.7.5.dist-info/METADATA,sha256=O6Wiic_-q2EBgaNPpb6hBTaa-tvW9QbZ9WVL-ZiB_4k,6124
-validmind-2.7.5.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-validmind-2.7.5.dist-info/entry_points.txt,sha256=HuW7YyOv9u_OEWpViQXtv0nfoI67uieJHawKWA4Hv9A,76
-validmind-2.7.5.dist-info/RECORD,,
+validmind-2.7.6.dist-info/LICENSE,sha256=XonPUfwjvrC5Ombl3y-ko0Wubb1xdG_7nzvIbkZRKHw,35772
+validmind-2.7.6.dist-info/METADATA,sha256=ce1HwawW3_UDY7y7PJjoRgx6Fp2Ta9FgIuJur5T3w1o,6123
+validmind-2.7.6.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+validmind-2.7.6.dist-info/entry_points.txt,sha256=HuW7YyOv9u_OEWpViQXtv0nfoI67uieJHawKWA4Hv9A,76
+validmind-2.7.6.dist-info/RECORD,,