validmind 2.5.8__py3-none-any.whl → 2.5.18__py3-none-any.whl

validmind/tests/model_validation/statsmodels/RegressionModelForecastPlotLevels.py

@@ -14,49 +14,52 @@ from validmind.vm_models import Figure, Metric
 @dataclass
 class RegressionModelForecastPlotLevels(Metric):
     """
-    Compares and visualizes forecasted and actual values of regression models on both raw and transformed datasets.
-
-    **Purpose:**
-    The `RegressionModelForecastPlotLevels` metric is designed to visually assess a series of regression models'
-    performance. It achieves this by contrasting the models' forecasts with the observed data from the respective
-    training and test datasets. The gauge of accuracy here involves determining the extent of closeness between
-    forecasted and actual values. Accordingly, if any transformations are specified, the metric will handle
-    transforming the data before making this comparison.
-
-    **Test Mechanism:**
-    The `RegressionModelForecastPlotLevels` class in Python initiates with a `transformation` parameter, which default
-    aggregates to None. Initially, the class checks for the presence of model objects and raises a `ValueError` if none
-    are found. Each model is then processed, creating predictive forecasts for both its training and testing datasets.
-    These forecasts are then contrasted with the actual values and plotted. In situations where a specified
-    transformation, like "integrate," is specified, the class navigates the transformation steps (performing cumulative
-    sums to generate a novel series, for instance). Finally, plots are produced that compare observed and forecasted
-    values for both the raw and transformed datasets.
-
-    **Signs of High Risk:**
-    Indications of high risk or failure in the model's performance can be derived from checking the generated plots.
-    When the forecasted values dramatically deviate from the observed values in either the training or testing
-    datasets, it suggests a high risk situation. A significant deviation could be a symptom of either overfitting or
-    underfitting, both scenarios are worrying. Such discrepancies could inhibit the model's ability to create precise,
-    generalized results.
-
-    **Strengths:**
-
-    - Visual Evaluations: The metric provides a visual and comparative way of assessing multiple regression models at
-    once. This allows easier interpretation and evaluation of their forecasting accuracy.
-    - Transformation Handling: This metric can handle transformations like "integrate," enhancing its breadth and
-    flexibility in evaluating different models.
-    - Detailed Perspective: By looking at the performance on both datasets (training and testing), the metric may give
-    a detailed overview of the model.
-
-    **Limitations:**
-
-    - Subjectivity: Relying heavily on visual interpretations; assessments may differ from person to person.
-    - Limited Transformation Capability: Currently, only the "integrate" transformation is supported, implying complex
-    transformations might go unchecked or unhandled.
-    - Overhead: The plotting mechanism may become computationally costly when applying to extensive datasets,
-    increasing runtime.
-    - Numerical Measurement: Although visualization is instrumental, a corresponding numerical measure would further
-    reinforce the observations. However, this metric does not provide numerical measures.
+    Assesses the alignment between forecasted and observed values in regression models through visual plots, including
+    handling data transformations.
+
+    ### Purpose
+
+    The `RegressionModelForecastPlotLevels` test aims to visually assess the performance of a series of regression
+    models by comparing their forecasted values against the actual observed values in both training and test datasets.
+    This test helps determine the accuracy of the models and can handle specific data transformations before making the
+    comparison, providing a comprehensive evaluation of model performance.
+
+    ### Test Mechanism
+
+    The test mechanism involves initializing the `RegressionModelForecastPlotLevels` class with an optional
+    `transformation` parameter. The class then:
+
+    - Checks for the presence of model objects and raises a `ValueError` if none are found.
+    - Processes each model to generate predictive forecasts for both training and testing datasets.
+    - Contrasts these forecasts with the actual observed values.
+    - Produces plots to visually compare forecasted and observed values for both raw and transformed datasets.
+    - Handles specified transformations (e.g., "integrate") by performing cumulative sums to create a new series before
+    plotting.
+
+    ### Signs of High Risk
+
+    - Significant deviation between forecasted and observed values in training or testing datasets.
+    - Patterns suggesting overfitting or underfitting.
+    - Large discrepancies in the plotted forecasts, indicating potential issues with model generalizability and
+    precision.
+
+    ### Strengths
+
+    - **Visual Evaluations**: Provides an intuitive, visual way to assess multiple regression models, aiding in easier
+    interpretation and evaluation of forecast accuracy.
+    - **Transformation Handling**: Can process specified data transformations such as "integrate," enhancing
+    flexibility.
+    - **Detailed Perspective**: Assesses performance on both training and testing datasets, offering a comprehensive
+    view of model behavior.
+
+    ### Limitations
+
+    - **Subjectivity**: Relies heavily on visual interpretation, which may vary between individuals.
+    - **Limited Transformation Capability**: Supports only the "integrate" transformation; other complex
+    transformations might not be handled.
+    - **Overhead**: Plotting can be computationally intensive for large datasets, increasing runtime.
+    - **Numerical Measurement**: Does not provide a numerical metric to quantify forecast accuracy, relying solely on
+    visual assessment.
     """
 
     name = "regression_forecast_plot_levels"

validmind/tests/model_validation/statsmodels/RegressionModelSensitivityPlot.py

@@ -16,44 +16,46 @@ logger = get_logger(__name__)
 @dataclass
 class RegressionModelSensitivityPlot(Metric):
     """
-    Tests the sensitivity of a regression model to variations in independent variables by applying shocks and
-    visualizing the effects.
-
-    **Purpose**: The Regression Sensitivity Plot metric is designed to perform sensitivity analysis on regression
-    models. This metric aims to measure the impact of slight changes (shocks) applied to individual variables on the
-    system's outcome while keeping all other variables constant. By doing so, it analyzes the effects of each
-    independent variable on the dependent variable within the regression model and helps identify significant risk
-    factors that could substantially influence the model's output.
-
-    **Test Mechanism**: This metric operates by initially applying shocks of varying magnitudes, defined by specific
-    parameters, to each of the model's features, one at a time. With all other variables held constant, a new
-    prediction is made for each dataset subjected to shocks. Any changes in the model's predictions are directly
-    attributed to the shocks applied. In the event that the transformation parameter is set to "integrate", initial
-    predictions and target values undergo transformation via an integration function before being plotted. Lastly, a
-    plot demonstrating observed values against predicted values for each model is generated, showcasing a distinct line
-    graph illustrating predictions for each shock.
-
-    **Signs of High Risk**:
-    - If the plot exhibits drastic alterations in model predictions consequent to minor shocks to an individual
-    variable, it may indicate high risk. This underscores potentially high model sensitivity to changes in that
-    variable, suggesting over-dependence on that variable for predictions.
-    - Unusually high or unpredictable shifts in response to shocks may also denote potential model instability or
+    Assesses the sensitivity of a regression model to changes in independent variables by applying shocks and
+    visualizing the impact.
+
+    ### Purpose
+
+    The Regression Sensitivity Plot test is designed to perform sensitivity analysis on regression models. This test
+    aims to measure the impact of slight changes (shocks) applied to individual variables on the system's outcome while
+    keeping all other variables constant. By doing so, it analyzes the effects of each independent variable on the
+    dependent variable within the regression model, helping identify significant risk factors that could substantially
+    influence the model's output.
+
+    ### Test Mechanism
+
+    This test operates by initially applying shocks of varying magnitudes, defined by specific parameters, to each of
+    the model's features, one at a time. With all other variables held constant, a new prediction is made for each
+    dataset subjected to shocks. Any changes in the model's predictions are directly attributed to the shocks applied.
+    If the transformation parameter is set to "integrate," initial predictions and target values undergo transformation
+    via an integration function before being plotted. Finally, a plot demonstrating observed values against predicted
+    values for each model is generated, showcasing a distinct line graph illustrating predictions for each shock.
+
+    ### Signs of High Risk
+
+    - Drastic alterations in model predictions due to minor shocks to an individual variable, indicating high
+    sensitivity and potential over-dependence on that variable.
+    - Unusually high or unpredictable shifts in response to shocks, suggesting potential model instability or
     overfitting.
 
-    **Strengths**:
-    - The metric allows identification of variables strongly influencing the model outcomes, paving the way for
-    understanding feature importance.
-    - It generates visual plots which make the results easily interpretable even to non-technical stakeholders.
-    - Beneficial in identifying overfitting and detecting unstable models that over-react to minor changes in variables.
-
-    **Limitations**:
-    - The metric operates on the assumption that all other variables remain unchanged during the application of a
-    shock. However, real-world situations where variables may possess intricate interdependencies may not always
-    reflect this.
-    - It is best compatible with linear models and may not effectively evaluate the sensitivity of non-linear model
-    configurations.
-    - The metric does not provide a numerical risk measure. It offers only a visual representation, which may invite
-    subjectivity in interpretation.
+    ### Strengths
+
+    - Helps identify variables that strongly influence model outcomes, aiding in understanding feature importance.
+    - Generates visual plots, making results easily interpretable even to non-technical stakeholders.
+    - Useful in identifying overfitting and detecting unstable models that react excessively to minor variable changes.
+
+    ### Limitations
+
+    - Operates on the assumption that all other variables remain unchanged during the application of a shock, which may
+    not reflect real-world interdependencies.
+    - Best compatible with linear models and may not effectively evaluate the sensitivity of non-linear models.
+    - Provides a visual representation without a numerical risk measure, potentially introducing subjectivity in
+    interpretation.
     """
 
     name = "regression_sensitivity_plot"

validmind/tests/model_validation/statsmodels/RegressionModelSummary.py

@@ -17,36 +17,38 @@ class RegressionModelSummary(Metric):
     """
     Evaluates regression model performance using metrics including R-Squared, Adjusted R-Squared, MSE, and RMSE.
 
-    **Purpose**: This metric test evaluates the performance of regression models by measuring their predictive ability
-    with regards to dependent variables given changes in the independent variables. Its measurement tools include
-    conventional regression metrics such as R-Squared, Adjusted R-Squared, Mean Squared Error (MSE), and Root Mean
-    Squared Error (RMSE).
-
-    **Test Mechanism**: This test employs the 'train_ds' attribute of the model to gather and analyze the training
-    data. Initially, it fetches the independent variables and uses the model to make predictions on these given
-    features. Subsequently, it calculates several standard regression performance metrics including R-Square, Adjusted
-    R-Squared, Mean Squared Error (MSE), and Root Mean Squared Error (RMSE), which quantify the approximation of the
-    predicted responses to the actual responses.
-
-    **Signs of High Risk**:
-    - Low R-Squared and Adjusted R-Squared values. A poor fit between the model predictions and the true responses is
-    indicated by low values of these metrics, suggesting the model explains a small fraction of the variance in the
-    target variable.
-    - High MSE and RMSE values represent a high prediction error and point to poor model performance.
-
-    **Strengths**:
+    ### Purpose
+
+    The Regression Model Summary test evaluates the performance of regression models by measuring their predictive
+    ability regarding dependent variables given changes in the independent variables. It uses conventional regression
+    metrics such as R-Squared, Adjusted R-Squared, Mean Squared Error (MSE), and Root Mean Squared Error (RMSE) to
+    assess the model's accuracy and fit.
+
+    ### Test Mechanism
+
+    This test employs the 'train_ds' attribute of the model to gather and analyze the training data. Initially, it
+    fetches the independent variables and uses the model to make predictions on these given features. Subsequently, it
+    calculates several standard regression performance metrics including R-Squared, Adjusted R-Squared, Mean Squared
+    Error (MSE), and Root Mean Squared Error (RMSE), which quantify the approximation of the predicted responses to the
+    actual responses.
+
+    ### Signs of High Risk
+
+    - Low R-Squared and Adjusted R-Squared values.
+    - High MSE and RMSE values.
+
+    ### Strengths
+
     - Offers an extensive evaluation of regression models by combining four key measures of model accuracy and fit.
     - Provides a comprehensive view of the model's performance.
-    - Both the R-Squared and Adjusted R-Squared measures are readily interpretable. They represent the proportion of
-    total variation in the dependent variable that can be explained by the independent variables.
-
-    **Limitations**:
-    - Applicable exclusively to regression models. It is not suited for evaluating binary classification models or time
-    series models, thus limiting its scope.
-    - Although RMSE and MSE are sound measures of prediction error, they might be sensitive to outliers, potentially
-    leading to an overestimation of the model's prediction error.
-    - A high R-squared or adjusted R-squared may not necessarily indicate a good model, especially in cases where the
-    model is possibly overfitting the data.
+    - Both the R-Squared and Adjusted R-Squared measures are readily interpretable.
+
+    ### Limitations
+
+    - Applicable exclusively to regression models.
+    - RMSE and MSE might be sensitive to outliers.
+    - A high R-Squared or Adjusted R-Squared may not necessarily indicate a good model, especially in cases of
+    overfitting.
     """
 
     name = "regression_model_summary"

validmind/tests/model_validation/statsmodels/RegressionPermutationFeatureImportance.py

@@ -21,28 +21,35 @@ logger = get_logger(__name__)
 class RegressionPermutationFeatureImportance(Metric):
     """
     Assesses the significance of each feature in a model by evaluating the impact on model performance when feature
-    values are randomly rearranged. Specifically designed for use with statsmodels, this metric offers insight into the
-    importance of features based on the decrease in model's predictive accuracy, typically R².
+    values are randomly rearranged.
 
-    **Purpose**: The primary purpose of this metric is to determine which features significantly impact the performance
-    of a regression model developed using statsmodels. The metric measures how much the prediction accuracy deteriorates
+    ### Purpose
+
+    The primary purpose of this metric is to determine which features significantly impact the performance of a
+    regression model developed using statsmodels. The metric measures how much the prediction accuracy deteriorates
     when each feature's values are permuted.
 
-    **Test Mechanism**: This metric shuffles the values of each feature one at a time in the dataset, computes the model's
-    performance after each permutation, and compares it to the baseline performance. A significant decrease in performance
+    ### Test Mechanism
+
+    This metric shuffles the values of each feature one at a time in the dataset, computes the model's performance
+    after each permutation, and compares it to the baseline performance. A significant decrease in performance
     indicates the importance of the feature.
 
-    **Signs of High Risk**:
-    - Significant reliance on a feature that when permuted leads to a substantial decrease in performance, suggesting
+    ### Signs of High Risk
+
+    - Significant reliance on a feature that, when permuted, leads to a substantial decrease in performance, suggesting
     overfitting or high model dependency on that feature.
     - Features identified as unimportant despite known impacts from domain knowledge, suggesting potential issues in
     model training or data preprocessing.
 
-    **Strengths**:
-    - Directly assesses the impact of each feature on model performance, providing clear insights into model dependencies.
+    ### Strengths
+
+    - Directly assesses the impact of each feature on model performance, providing clear insights into model
+    dependencies.
     - Model-agnostic within the scope of statsmodels, applicable to any regression model that outputs predictions.
 
-    **Limitations**:
+    ### Limitations
+
     - The metric is specific to statsmodels and cannot be used with other types of models without adaptation.
     - It does not capture interactions between features, which can lead to underestimating the importance of correlated
     features.

validmind/tests/model_validation/statsmodels/ScorecardHistogram.py

@@ -2,136 +2,104 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-from dataclasses import dataclass
-
 import plotly.graph_objects as go
 from matplotlib import cm
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
 
 
-@dataclass
-class ScorecardHistogram(Metric):
+@tags("visualization", "credit_risk", "logistic_regression")
+@tasks("classification")
+def ScorecardHistogram(dataset, title="Histogram of Scores", score_column="score"):
     """
-    Creates histograms of credit scores, from both default and non-default instances, generated by a credit-risk model.
-
-    **Purpose**: The Scorecard Histogram test metric provides a visual interpretation of the credit scores generated by
-    a machine learning model for credit-risk classification tasks. It aims to compare the alignment of the model's
-    scoring decisions with the actual outcomes of credit loan applications. It helps in identifying potential
-    discrepancies between the model's predictions and real-world risk levels.
-
-    **Test Mechanism**: This metric uses logistic regression to generate a histogram of credit scores for both default
-    (negative class) and non-default (positive class) instances. Using both training and test datasets, the metric
-    calculates the credit score of each instance with a scorecard method, considering the impact of different features
-    on the likelihood of default. İncludes the default point to odds (PDO) scaling factor and predefined target score
-    and odds settings. Histograms for training and test sets are computed and plotted separately to offer insights into
-    the model's generalizability to unseen data.
-
-    **Signs of High Risk**:
-    - Discrepancies between the distributions of training and testing data, indicating a model's poor generalisation
+    The Scorecard Histogram test evaluates the distribution of credit scores between default and non-default instances,
+    providing critical insights into the performance and generalizability of credit-risk models.
+
+    ### Purpose
+
+    The Scorecard Histogram test metric provides a visual interpretation of the credit scores generated by a machine
+    learning model for credit-risk classification tasks. It aims to compare the alignment of the model's scoring
+    decisions with the actual outcomes of credit loan applications. It helps in identifying potential discrepancies
+    between the model's predictions and real-world risk levels.
+
+    ### Test Mechanism
+
+    This metric uses logistic regression to generate a histogram of credit scores for both default (negative class) and
+    non-default (positive class) instances. Using both training and test datasets, the metric calculates the credit
+    score of each instance with a scorecard method, considering the impact of different features on the likelihood of
+    default. It includes the default point to odds (PDO) scaling factor and predefined target score and odds settings.
+    Histograms for training and test sets are computed and plotted separately to offer insights into the model's
+    generalizability to unseen data.
+
+    ### Signs of High Risk
+
+    - Discrepancies between the distributions of training and testing data, indicating a model's poor generalization
     ability
-    - Skewed distributions favouring specific scores or classes, representing potential bias
+    - Skewed distributions favoring specific scores or classes, representing potential bias
+
+    ### Strengths
 
-    **Strengths**:
     - Provides a visual interpretation of the model's credit scoring system, enhancing comprehension of model behavior
     - Enables a direct comparison between actual and predicted scores for both training and testing data
     - Its intuitive visualization helps understand the model's ability to differentiate between positive and negative
     classes
     - Can unveil patterns or anomalies not easily discerned through numerical metrics alone
 
-    **Limitations**:
-    - Despite its value for visual interpretation, it doesn't quantify the performance of the model, and therefore may
+    ### Limitations
+
+    - Despite its value for visual interpretation, it doesn't quantify the performance of the model and therefore may
     lack precision for thorough model evaluation
     - The quality of input data can strongly influence the metric, as bias or noise in the data will affect both the
     score calculation and resultant histogram
     - Its specificity to credit scoring models limits its applicability across a wider variety of machine learning
     tasks and models
-    - The metric's effectiveness is somewhat tied to the subjective interpretation of the analyst, since it relies on
-    the analyst's judgment of the characteristics and implications of the plot.
+    - The metric's effectiveness is somewhat tied to the subjective interpretation of the analyst, relying on their
+    judgment of the characteristics and implications of the plot.
     """
 
-    name = "scorecard_histogram"
-    required_inputs = ["datasets"]
-    tasks = ["classification"]
-    tags = ["tabular_data", "visualization", "credit_risk"]
+    if score_column not in dataset.df.columns:
+        raise ValueError(
+            f"The required column '{score_column}' is not present in the dataset with input_id {dataset.input_id}"
+        )
 
-    default_params = {
-        "title": "Histogram of Scores",
-        "score_column": "score",
-    }
+    df = dataset.df
 
-    @staticmethod
-    def plot_score_histogram(dataframes, dataset_titles, score_col, target_col, title):
-        figures = []
-        # Generate a colormap and convert to Plotly-accepted color format
-        # Adjust 'viridis' to any other matplotlib colormap if desired
-        colormap = cm.get_cmap("viridis")
-
-        for _, (df, dataset_title) in enumerate(zip(dataframes, dataset_titles)):
-            fig = go.Figure()
-
-            # Get unique classes and assign colors
-            classes = sorted(df[target_col].unique())
-            colors = [
-                colormap(i / len(classes))[:3] for i in range(len(classes))
-            ]  # RGB
-            color_dict = {
-                cls: f"rgb({int(rgb[0]*255)}, {int(rgb[1]*255)}, {int(rgb[2]*255)})"
-                for cls, rgb in zip(classes, colors)
-            }
-
-            for class_value in sorted(df[target_col].unique()):
-                scores_class = df[df[target_col] == class_value][score_col]
-                fig.add_trace(
-                    go.Histogram(
-                        x=scores_class,
-                        opacity=0.75,
-                        name=f"{dataset_title} {target_col} = {class_value}",
-                        marker=dict(
-                            color=color_dict[class_value],
-                        ),
-                    )
-                )
-            fig.update_layout(
-                barmode="overlay",
-                title_text=f"{title} - {dataset_title}",
-                xaxis_title="Score",
-                yaxis_title="Frequency",
-                legend_title=target_col,
-            )
-            figures.append(fig)
-        return figures
-
-    def run(self):
-        title = self.params["title"]
-        score_column = self.params["score_column"]
-        dataset_titles = [dataset.input_id for dataset in self.inputs.datasets]
-        target_column = self.inputs.datasets[0].target_column
-
-        dataframes = []
-        metric_value = {"score_histogram": {}}
-        for dataset in self.inputs.datasets:
-            if score_column not in dataset.df.columns:
-                raise ValueError(
-                    f"The required column '{score_column}' is not present in the dataset with input_id {dataset.input_id}"
-                )
-
-            dataframes.append(dataset.df.copy())
-            metric_value["score_histogram"][dataset.input_id] = list(
-                dataset.df[score_column]
-            )
+    fig = _plot_score_histogram(df, score_column, dataset.target_column, title)
 
-        figures = self.plot_score_histogram(
-            dataframes, dataset_titles, score_column, target_column, title
-        )
+    return fig
 
-        figures_list = [
-            Figure(
-                for_object=self,
-                key=f"score_histogram_{title.replace(' ', '_')}_{i+1}",
-                figure=fig,
-            )
-            for i, fig in enumerate(figures)
-        ]
 
-        return self.cache_results(metric_value=metric_value, figures=figures_list)
+def _plot_score_histogram(df, score_col, target_col, title):
+    # Generate a colormap and convert to Plotly-accepted color format
+    # Adjust 'viridis' to any other matplotlib colormap if desired
+    colormap = cm.get_cmap("viridis")
+
+    fig = go.Figure()
+
+    # Get unique classes and assign colors
+    classes = sorted(df[target_col].unique())
+    colors = [colormap(i / len(classes))[:3] for i in range(len(classes))]  # RGB
+    color_dict = {
+        cls: f"rgb({int(rgb[0]*255)}, {int(rgb[1]*255)}, {int(rgb[2]*255)})"
+        for cls, rgb in zip(classes, colors)
+    }
+
+    for class_value in sorted(df[target_col].unique()):
+        scores_class = df[df[target_col] == class_value][score_col]
+        fig.add_trace(
+            go.Histogram(
+                x=scores_class,
+                opacity=0.75,
+                name=f"{target_col} = {class_value}",
+                marker=dict(
+                    color=color_dict[class_value],
+                ),
+            )
+        )
+        fig.update_layout(
+            barmode="overlay",
+            title_text=f"{title}",
+            xaxis_title="Score",
+            yaxis_title="Frequency",
+        )
+    return fig

validmind/tests/ongoing_monitoring/FeatureDrift.py

@@ -16,37 +16,41 @@ def FeatureDrift(
     datasets, bins=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9], feature_columns=None
 ):
     """
-    **Purpose**:
+    Evaluates changes in feature distribution over time to identify potential model drift.
+
+    ### Purpose
 
     The Feature Drift test aims to evaluate how much the distribution of features has shifted over time between two
     datasets, typically training and monitoring datasets. It uses the Population Stability Index (PSI) to quantify this
-    change, providing insights into the model's robustness and the necessity for retraining or feature engineering.
+    change, providing insights into the model’s robustness and the necessity for retraining or feature engineering.
 
-    **Test Mechanism**:
+    ### Test Mechanism
 
     This test calculates the PSI by:
+
     - Bucketing the distributions of each feature in both datasets.
     - Comparing the percentage of observations in each bucket between the two datasets.
     - Aggregating the differences across all buckets for each feature to produce the PSI score for that feature.
 
     The PSI score is interpreted as:
+
     - PSI < 0.1: No significant population change.
     - PSI < 0.2: Moderate population change.
     - PSI >= 0.2: Significant population change.
 
-    **Signs of High Risk**:
+    ### Signs of High Risk
 
     - PSI >= 0.2 for any feature, indicating a significant distribution shift.
     - Consistently high PSI scores across multiple features.
     - Sudden spikes in PSI in recent monitoring data compared to historical data.
 
-    **Strengths**:
+    ### Strengths
 
     - Provides a quantitative measure of feature distribution changes.
     - Easily interpretable thresholds for decision-making.
     - Helps in early detection of data drift, prompting timely interventions.
 
-    **Limitations**:
+    ### Limitations
 
     - May not capture more intricate changes in data distribution nuances.
     - Assumes that bucket thresholds (quantiles) adequately represent distribution shifts.