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

validmind/tests/model_validation/statsmodels/KolmogorovSmirnov.py

@@ -13,40 +13,39 @@ from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableM
 @dataclass
 class KolmogorovSmirnov(Metric):
     """
-    Executes a feature-wise Kolmogorov-Smirnov test to evaluate alignment with normal distribution in datasets.
-
-    **Purpose**: This metric employs the Kolmogorov-Smirnov (KS) test to evaluate the distribution of a dataset's
-    features. It specifically gauges whether the data from each feature aligns with a normal distribution, a common
-    presumption in many statistical methods and machine learning models.
-
-    **Test Mechanism**: This KS test calculates the KS statistic and the corresponding p-value for each column in a
-    dataset. It achieves this by contrasting the cumulative distribution function of the dataset's feature with an
-    ideal normal distribution. Subsequently, a feature-by-feature KS statistic and p-value are stored in a dictionary.
-    The specific threshold p-value (the value below which we reject the hypothesis that the data is drawn from a normal
-    distribution) is not firmly set within this implementation, allowing for definitional flexibility depending on the
-    specific application.
-
-    **Signs of High Risk**:
-    - Elevated KS statistic for a feature combined with a low p-value. This suggests a significant divergence between
-    the feature's distribution and a normal one.
-    - Features with notable deviations. These could create problems if the applicable model makes assumptions about
-    normal data distribution, thereby representing a risk.
-
-    **Strengths**:
-    - The KS test is acutely sensitive to differences in the location and shape of the empirical cumulative
-    distribution functions of two samples.
-    - It is non-parametric and does not presuppose any specific data distribution, making it adaptable to a range of
-    datasets.
-    - With its focus on individual features, it offers detailed insights into data distribution.
-
-    **Limitations**:
-    - The sensitivity of the KS test to disparities in data distribution tails can be excessive. Such sensitivity might
-    prompt false alarms about non-normal distributions, particularly in situations where these tail tendencies are
-    irrelevant to the model.
-    - It could become less effective when applied to multivariate distributions, considering that it's primarily
-    configured for univariate distributions.
-    - As a goodness-of-fit test, the KS test does not identify specific types of non-normality, such as skewness or
-    kurtosis, that could directly impact model fitting.
+    Assesses whether each feature in the dataset aligns with a normal distribution using the Kolmogorov-Smirnov test.
+
+    ### Purpose
+
+    The Kolmogorov-Smirnov (KS) test evaluates the distribution of features in a dataset to determine their alignment
+    with a normal distribution. This is important because many statistical methods and machine learning models assume
+    normality in the data distribution.
+
+    ### Test Mechanism
+
+    This test calculates the KS statistic and corresponding p-value for each feature in the dataset. It does so by
+    comparing the cumulative distribution function of the feature with an ideal normal distribution. The KS statistic
+    and p-value for each feature are then stored in a dictionary. The p-value threshold to reject the normal
+    distribution hypothesis is not preset, providing flexibility for different applications.
+
+    ### Signs of High Risk
+
+    - Elevated KS statistic for a feature combined with a low p-value, indicating a significant divergence from a
+    normal distribution.
+    - Features with notable deviations that could create problems if the model assumes normality in data distribution.
+
+    ### Strengths
+
+    - The KS test is sensitive to differences in the location and shape of empirical cumulative distribution functions.
+    - It is non-parametric and adaptable to various datasets, as it does not assume any specific data distribution.
+    - Provides detailed insights into the distribution of individual features.
+
+    ### Limitations
+
+    - The test's sensitivity to disparities in the tails of data distribution might cause false alarms about
+    non-normality.
+    - Less effective for multivariate distributions, as it is designed for univariate distributions.
+    - Does not identify specific types of non-normality, such as skewness or kurtosis, which could impact model fitting.
     """
 
     name = "kolmogorov_smirnov"

validmind/tests/model_validation/statsmodels/Lilliefors.py

@@ -14,44 +14,47 @@ class Lilliefors(Metric):
     """
     Assesses the normality of feature distributions in an ML model's training dataset using the Lilliefors test.
 
-    **Purpose**: The purpose of this metric is to utilize the Lilliefors test, named in honor of the Swedish
-    statistician Hubert Lilliefors, in order to assess whether the features of the machine learning model's training
-    dataset conform to a normal distribution. This is done because the assumption of normal distribution plays a vital
-    role in numerous statistical procedures as well as numerous machine learning models. Should the features fail to
-    follow a normal distribution, some model types may not operate at optimal efficiency. This can potentially lead to
-    inaccurate predictions.
-
-    **Test Mechanism**: The application of this test happens across all feature columns within the training dataset.
-    For each feature, the Lilliefors test returns a test statistic and p-value. The test statistic quantifies how far
-    the feature's distribution is from an ideal normal distribution, whereas the p-value aids in determining the
-    statistical relevance of this deviation. The final results are stored within a dictionary, the keys of which
-    correspond to the name of the feature column, and the values being another dictionary which houses the test
-    statistic and p-value.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    The purpose of this metric is to utilize the Lilliefors test, named in honor of the Swedish statistician Hubert
+    Lilliefors, in order to assess whether the features of the machine learning model's training dataset conform to a
+    normal distribution. This is done because the assumption of normal distribution plays a vital role in numerous
+    statistical procedures as well as numerous machine learning models. Should the features fail to follow a normal
+    distribution, some model types may not operate at optimal efficiency. This can potentially lead to inaccurate
+    predictions.
+
+    ### Test Mechanism
+
+    The application of this test happens across all feature columns within the training dataset. For each feature, the
+    Lilliefors test returns a test statistic and p-value. The test statistic quantifies how far the feature's
+    distribution is from an ideal normal distribution, whereas the p-value aids in determining the statistical
+    relevance of this deviation. The final results are stored within a dictionary, the keys of which correspond to the
+    name of the feature column, and the values being another dictionary which houses the test statistic and p-value.
+
+    ### Signs of High Risk
 
     - If the p-value corresponding to a specific feature sinks below a pre-established significance level, generally
     set at 0.05, then it can be deduced that the distribution of that feature significantly deviates from a normal
     distribution. This can present a high risk for models that assume normality, as these models may perform
     inaccurately or inefficiently in the presence of such a feature.
 
-    **Strengths**:
+    ### Strengths
 
     - One advantage of the Lilliefors test is its utility irrespective of whether the mean and variance of the normal
     distribution are known in advance. This makes it a more robust option in real-world situations where these values
     might not be known.
-    - Second, the test has the ability to screen every feature column, offering a holistic view of the dataset.
+    - The test has the ability to screen every feature column, offering a holistic view of the dataset.
 
-    **Limitations**:
+    ### Limitations
 
     - Despite the practical applications of the Lilliefors test in validating normality, it does come with some
     limitations.
-    - Firstly, it is only capable of testing unidimensional data, thus rendering it ineffective for datasets with
-    interactions between features or multi-dimensional phenomena.
-    - Additionally, the test might not be as sensitive as some other tests (like the Anderson-Darling test) in
-    detecting deviations from a normal distribution.
-    - Lastly, like any other statistical test, Lilliefors test may also produce false positives or negatives. Hence,
-    banking solely on this test, without considering other characteristics of the data, may give rise to risks.
+    - It is only capable of testing unidimensional data, thus rendering it ineffective for datasets with interactions
+    between features or multi-dimensional phenomena.
+    - The test might not be as sensitive as some other tests (like the Anderson-Darling test) in detecting deviations
+    from a normal distribution.
+    - Like any other statistical test, Lilliefors test may also produce false positives or negatives. Hence, banking
+    solely on this test, without considering other characteristics of the data, may give rise to risks.
     """
 
     name = "lilliefors_test"

validmind/tests/model_validation/statsmodels/PredictionProbabilitiesHistogram.py

@@ -2,134 +2,101 @@
 # 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 PredictionProbabilitiesHistogram(Metric):
+@tags("visualization", "credit_risk", "logistic_regression")
+@tasks("classification")
+def PredictionProbabilitiesHistogram(
+    dataset, model, title="Histogram of Predictive Probabilities"
+):
     """
-    Generates and visualizes histograms of the Probability of Default predictions for both positive and negative
-    classes in training and testing datasets.
-
-    **Purpose**: This code is designed to generate histograms that display the Probability of Default (PD) predictions
-    for positive and negative classes in both the training and testing datasets. By doing so, it evaluates the
-    performance of a logistic regression model, particularly in the context of credit risk prediction.
-
-    **Test Mechanism**: The metric executes these steps to run the test:
-    - Firstly, it extracts the target column from both the train and test datasets.
-    - The model's predict function is then used to calculate probabilities.
-    - These probabilities are added as a new column to the training and testing dataframes.
-    - Histograms are generated for each class (0 or 1 in binary classification scenarios) within the training and
-    testing datasets.
-    - To enhance visualization, the histograms are set to have different opacities.
-    - The four histograms (two for training data and two for testing) are overlaid on two different subplot frames (one
-    for training and one for testing data).
-    - The test returns a plotly graph object displaying the visualization.
-
-    **Signs of High Risk**: Several indicators could suggest a high risk or failure in the model's performance. These
-    include:
-    - Significant discrepancies observed between the histograms of training and testing data.
+    Assesses the predictive probability distribution for binary classification to evaluate model performance and
+    potential overfitting or bias.
+
+    ### Purpose
+
+    The Prediction Probabilities Histogram test is designed to generate histograms displaying the Probability of
+    Default (PD) predictions for both positive and negative classes in training and testing datasets. This helps in
+    evaluating the performance of a logistic regression model, particularly for credit risk prediction.
+
+    ### Test Mechanism
+
+    The metric follows these steps to execute the test:
+    - Extracts the target column from both the train and test datasets.
+    - Uses the model's predict function to calculate probabilities.
+    - Adds these probabilities as a new column to the training and testing dataframes.
+    - Generates histograms for each class (0 or 1) within the training and testing datasets.
+    - Sets different opacities for the histograms to enhance visualization.
+    - Overlays the four histograms (two for training and two for testing) on two different subplot frames.
+    - Returns a plotly graph object displaying the visualization.
+
+    ### Signs of High Risk
+
+    - Significant discrepancies between the histograms of training and testing data.
     - Large disparities between the histograms for the positive and negative classes.
-    - These issues could signal potential overfitting or bias in the model.
-    - Unevenly distributed probabilities may also indicate that the model does not accurately predict outcomes.
-
-    **Strengths**: This metric and test offer several benefits, including:
-    - The visual representation of the PD predictions made by the model, which aids in understanding the model's
-    behaviour.
-    - The ability to assess both the training and testing datasets, adding depth to the validation of the model.
-    - Highlighting disparities between multiple classes, providing potential insights into class imbalance or data
-    skewness issues.
-    - Particularly beneficial for credit risk prediction, it effectively visualizes the spread of risk across different
-    classes.
-
-    **Limitations**: Despite its strengths, the test has several limitations:
-    - It is specifically tailored for binary classification scenarios, where the target variable only has two classes;
-    as such, it isn't suited for multi-class classification tasks.
-    - This metric is mainly applicable for logistic regression models. It might not be effective or accurate when used
-    on other model types.
-    - While the test provides a robust visual representation of the model's PD predictions, it does not provide a
-    quantifiable measure or score to assess model performance.
+    - Potential overfitting or bias indicated by significant issues.
+    - Unevenly distributed probabilities suggesting inaccurate model predictions.
+
+    ### Strengths
+
+    - Offers a visual representation of the PD predictions made by the model, aiding in understanding its behavior.
+    - Assesses both the training and testing datasets, adding depth to model validation.
+    - Highlights disparities between classes, providing insights into class imbalance or data skewness.
+    - Effectively visualizes risk spread, which is particularly beneficial for credit risk prediction.
+
+    ### Limitations
+
+    - Specifically tailored for binary classification scenarios and not suited for multi-class classification tasks.
+    - Mainly applicable to logistic regression models, and may not be effective for other model types.
+    - Provides a robust visual representation but lacks a quantifiable measure to assess model performance.
     """
 
-    name = "prediction_probabilities_histogram"
-    required_inputs = ["model", "datasets"]
-    tasks = ["classification"]
-    tags = ["tabular_data", "visualization", "credit_risk", "logistic_regression"]
-
-    default_params = {"title": "Histogram of Predictive Probabilities"}
-
-    @staticmethod
-    def plot_prob_histogram(dataframes, dataset_titles, 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 i, (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)
-            }
-
-            # Ensure classes are plotted in the specified order
-            for class_value in sorted(df[target_col].unique()):
-                fig.add_trace(
-                    go.Histogram(
-                        x=df[df[target_col] == class_value]["probabilities"],
-                        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="Probability",
-                yaxis_title="Frequency",
-            )
-            figures.append(fig)
-        return figures
-
-    def run(self):
-        dataset_titles = [dataset.input_id for dataset in self.inputs.datasets]
-        target_column = self.inputs.datasets[0].target_column
-        title = self.params.get("title", self.default_params["title"])
-
-        dataframes = []
-        metric_value = {"prob_histogram": {}}
-        for _, dataset in enumerate(self.inputs.datasets):
-            df = dataset.df.copy()
-            y_prob = dataset.y_prob(self.inputs.model)
-            df["probabilities"] = y_prob
-            dataframes.append(df)
-            metric_value["prob_histogram"][dataset.input_id] = list(df["probabilities"])
-
-        figures = self.plot_prob_histogram(
-            dataframes, dataset_titles, target_column, title
-        )
+    df = dataset.df
+    df["probabilities"] = dataset.y_prob(model)
 
-        figures_list = [
-            Figure(
-                for_object=self,
-                key=f"prob_histogram_{title.replace(' ', '_')}_{i+1}",
-                figure=fig,
-            )
-            for i, fig in enumerate(figures)
-        ]
+    fig = _plot_prob_histogram(df, dataset.target_column, title)
+
+    return fig
+
+
+def _plot_prob_histogram(df, target_col, title):
 
-        return self.cache_results(metric_value=metric_value, figures=figures_list)
+    # 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)
+    }
+
+    # Ensure classes are plotted in the specified order
+    for class_value in sorted(df[target_col].unique()):
+        fig.add_trace(
+            go.Histogram(
+                x=df[df[target_col] == class_value]["probabilities"],
+                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="Probability",
+        yaxis_title="Frequency",
+    )
+
+    return fig

validmind/tests/model_validation/statsmodels/RegressionCoeffs.py

@@ -0,0 +1,100 @@
+# 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 plotly.graph_objects as go
+from scipy import stats
+
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
+
+
+@tags("tabular_data", "visualization", "model_training")
+@tasks("regression")
+def RegressionCoeffs(model):
+    """
+    Assesses the significance and uncertainty of predictor variables in a regression model through visualization of
+    coefficients and their 95% confidence intervals.
+
+    ### Purpose
+
+    The `RegressionCoeffs` metric visualizes the estimated regression coefficients alongside their 95% confidence intervals,
+    providing insights into the impact and significance of predictor variables on the response variable. This visualization
+    helps to understand the variability and uncertainty in the model's estimates, aiding in the evaluation of the
+    significance of each predictor.
+
+    ### Test Mechanism
+
+    The function operates by extracting the estimated coefficients and their standard errors from the regression model.
+    Using these, it calculates the confidence intervals at a 95% confidence level, which indicates the range within which
+    the true coefficient value is expected to fall 95% of the time. The confidence intervals are computed using the
+    Z-value associated with the 95% confidence level. The coefficients and their confidence intervals are then visualized
+    in a bar plot. The x-axis represents the predictor variables, the y-axis represents the estimated coefficients, and
+    the error bars depict the confidence intervals.
+
+    ### Signs of High Risk
+
+    - The confidence interval for a coefficient contains the zero value, suggesting that the predictor may not significantly
+    contribute to the model.
+    - Multiple coefficients with confidence intervals that include zero, potentially indicating issues with model reliability.
+    - Very wide confidence intervals, which may suggest high uncertainty in the coefficient estimates and potential model
+    instability.
+
+    ### Strengths
+
+    - Provides a clear visualization that allows for easy interpretation of the significance and impact of predictor
+    variables.
+    - Includes confidence intervals, which provide additional information about the uncertainty surrounding each coefficient
+    estimate.
+
+    ### Limitations
+
+    - The method assumes normality of residuals and independence of observations, assumptions that may not always hold true
+    in practice.
+    - It does not address issues related to multi-collinearity among predictor variables, which can affect the interpretation
+    of coefficients.
+    - This metric is limited to regression tasks using tabular data and is not applicable to other types of machine learning
+    tasks or data structures.
+    """
+
+    if model.library != "statsmodels":
+        raise SkipTestError("Only statsmodels are supported for this metric")
+
+    # Extract estimated coefficients and standard errors
+    coefficients = model.regression_coefficients()
+    coef = pd.to_numeric(coefficients["coef"])
+    std_err = pd.to_numeric(coefficients["std err"])
+
+    # Calculate confidence intervals
+    confidence_level = 0.95  # 95% confidence interval
+    z_value = stats.norm.ppf((1 + confidence_level) / 2)  # Calculate Z-value
+    lower_ci = coef - z_value * std_err
+    upper_ci = coef + z_value * std_err
+
+    # Create a bar plot with confidence intervals
+    fig = go.Figure()
+
+    fig.add_trace(
+        go.Bar(
+            x=list(coefficients["Feature"].values),
+            y=coef,
+            name="Estimated Coefficients",
+            error_y=dict(
+                type="data",
+                symmetric=False,
+                arrayminus=lower_ci,
+                array=upper_ci,
+                visible=True,
+            ),
+        )
+    )
+
+    fig.update_layout(
+        title=f"{model.input_id} Coefficients with Confidence Intervals",
+        xaxis_title="Predictor Variables",
+        yaxis_title="Coefficients",
+    )
+
+    return (fig, coefficients)

validmind/tests/model_validation/statsmodels/RegressionFeatureSignificance.py

@@ -19,31 +19,36 @@ class RegressionFeatureSignificance(Metric):
     """
     Assesses and visualizes the statistical significance of features in a set of regression models.
 
-    **Purpose**:
+    ### Purpose
+
     The Regression Feature Significance metric assesses the significance of each feature in a given set of regression
     models. It creates a visualization displaying p-values for every feature of each model, assisting model developers
     in understanding which features are most influential in their models.
 
-    **Test Mechanism**:
+    ### Test Mechanism
+
     The test mechanism involves going through each fitted regression model in a given list, extracting the model
     coefficients and p-values for each feature, and then plotting these values. The x-axis on the plot contains the
     p-values while the y-axis denotes the coefficients of each feature. A vertical red line is drawn at the threshold
     for p-value significance, which is 0.05 by default. Any features with p-values to the left of this line are
     considered statistically significant at the chosen level.
 
-    **Signs of High Risk**:
+    ### Signs of High Risk
+
     - Any feature with a high p-value (greater than the threshold) is considered a potential high risk, as it suggests
     the feature is not statistically significant and may not be reliably contributing to the model's predictions.
     - A high number of such features may indicate problems with the model validation, variable selection, and overall
     reliability of the model predictions.
 
-    **Strengths**:
+    ### Strengths
+
     - Helps identify the features that significantly contribute to a model's prediction, providing insights into the
     feature importance.
     - Provides tangible, easy-to-understand visualizations to interpret the feature significance.
     - Facilitates comparison of feature importance across multiple models.
 
-    **Limitations**:
+    ### Limitations
+
     - This metric assumes model features are independent, which may not always be the case. Multicollinearity (high
     correlation amongst predictors) can cause high variance and unreliable statistical tests of significance.
     - The p-value strategy for feature selection doesn't take into account the magnitude of the effect, focusing solely
@@ -54,7 +59,7 @@ class RegressionFeatureSignificance(Metric):
     """
 
     name = "regression_feature_significance"
-    required_inputs = ["models"]
+    required_inputs = ["model"]
 
     default_params = {"fontsize": 10, "p_threshold": 0.05}
     tasks = ["regression"]
@@ -70,10 +75,10 @@ class RegressionFeatureSignificance(Metric):
         p_threshold = self.params["p_threshold"]
 
         # Check models list is not empty
-        if not self.inputs.models:
-            raise ValueError("List of models must be provided in the models parameter")
+        if not self.inputs.model:
+            raise ValueError("Model must be provided in the models parameter")
 
-        figures = self._plot_pvalues(self.inputs.models, fontsize, p_threshold)
+        figures = self._plot_pvalues(self.inputs.model, fontsize, p_threshold)
 
         return self.cache_results(figures=figures)
 

validmind/tests/model_validation/statsmodels/RegressionModelForecastPlot.py

@@ -19,26 +19,30 @@ class RegressionModelForecastPlot(Metric):
     Generates plots to visually compare the forecasted outcomes of one or more regression models against actual
     observed values over a specified date range.
 
-    **Purpose:** The "regression_forecast_plot" is intended to visually depict the performance of one or more
-    regression models by comparing the model's forecasted outcomes against actual observed values within a specified
-    date range. This metric is especially useful in time-series models or any model where the outcome changes over
-    time, allowing direct comparison of predicted vs actual values.
+    ### Purpose
 
-    **Test Mechanism:** This test generates a plot for each fitted model in the list. The x-axis represents the date
-    ranging from the specified "start_date" to the "end_date", while the y-axis shows the value of the outcome
-    variable. Two lines are plotted: one representing the forecasted values and the other representing the observed
-    values. The "start_date" and "end_date" can be parameters of this test; if these parameters are not provided, they
-    are set to the minimum and maximum date available in the dataset. The test verifies that the provided date range is
-    within the limits of the available data.
+    The "regression_forecast_plot" is intended to visually depict the performance of one or more regression models by
+    comparing the model's forecasted outcomes against actual observed values within a specified date range. This metric
+    is especially useful in time-series models or any model where the outcome changes over time, allowing direct
+    comparison of predicted vs actual values.
 
-    **Signs of High Risk:**
+    ### Test Mechanism
+
+    This test generates a plot for each fitted model in the list. The x-axis represents the date ranging from the
+    specified "start_date" to the "end_date", while the y-axis shows the value of the outcome variable. Two lines are
+    plotted: one representing the forecasted values and the other representing the observed values. The "start_date"
+    and "end_date" can be parameters of this test; if these parameters are not provided, they are set to the minimum
+    and maximum date available in the dataset. The test verifies that the provided date range is within the limits of
+    the available data.
+
+    ### Signs of High Risk
 
     - High risk or failure signs could be deduced visually from the plots if the forecasted line significantly deviates
     from the observed line, indicating the model's predicted values are not matching actual outcomes.
     - A model that struggles to handle the edge conditions like maximum and minimum data points could also be
     considered a sign of risk.
 
-    **Strengths:**
+    ### Strengths
 
     - Visualization: The plot provides an intuitive and clear illustration of how well the forecast matches the actual
     values, making it straightforward even for non-technical stakeholders to interpret.
@@ -46,7 +50,7 @@ class RegressionModelForecastPlot(Metric):
     - Model Evaluation: It can be useful in identifying overfitting or underfitting situations, as these will manifest
     as discrepancies between the forecasted and observed values.
 
-    **Limitations:**
+    ### Limitations
 
     - Interpretation Bias: Interpretation of the plot is subjective and can lead to different conclusions by different
     evaluators.