validmind 2.5.6__py3-none-any.whl → 2.5.15__py3-none-any.whl

validmind/tests/model_validation/statsmodels/PredictionProbabilitiesHistogram.py

@@ -2,134 +2,102 @@
 # 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.errors import SkipTestError
+from validmind import tags, tasks
+
+
+@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.

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"