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

validmind/tests/data_validation/DescriptiveStatistics.py

@@ -16,38 +16,45 @@ class DescriptiveStatistics(Metric):
     Performs a detailed descriptive statistical analysis of both numerical and categorical data within a model's
     dataset.
 
-    **Purpose**: The purpose of the Descriptive Statistics metric is to provide a comprehensive summary of both
-    numerical and categorical data within a dataset. This involves statistics such as count, mean, standard deviation,
-    minimum and maximum values for numerical data. For categorical data, it calculates the count, number of unique
-    values, most common value and its frequency, and the proportion of the most frequent value relative to the total.
-    The goal is to visualize the overall distribution of the variables in the dataset, aiding in understanding the
-    model's behavior and predicting its performance.
-
-    **Test Mechanism**: The testing mechanism utilizes two in-built functions of pandas dataframes: describe() for
-    numerical fields and value_counts() for categorical fields. The describe() function pulls out several summary
-    statistics, while value_counts() accounts for unique values. The resulting data is formatted into two distinct
-    tables, one for numerical and another for categorical variable summaries. These tables provide a clear summary of
-    the main characteristics of the variables, which can be instrumental in assessing the model's performance.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    The purpose of the Descriptive Statistics metric is to provide a comprehensive summary of both numerical and
+    categorical data within a dataset. This involves statistics such as count, mean, standard deviation, minimum and
+    maximum values for numerical data. For categorical data, it calculates the count, number of unique values, most
+    common value and its frequency, and the proportion of the most frequent value relative to the total. The goal is to
+    visualize the overall distribution of the variables in the dataset, aiding in understanding the model's behavior
+    and predicting its performance.
+
+    ### Test Mechanism
+
+    The testing mechanism utilizes two in-built functions of pandas dataframes: `describe()` for numerical fields and
+    `value_counts()` for categorical fields. The `describe()` function pulls out several summary statistics, while
+    `value_counts()` accounts for unique values. The resulting data is formatted into two distinct tables, one for
+    numerical and another for categorical variable summaries. These tables provide a clear summary of the main
+    characteristics of the variables, which can be instrumental in assessing the model's performance.
+
+    ### Signs of High Risk
+
     - Skewed data or significant outliers can represent high risk. For numerical data, this may be reflected via a
     significant difference between the mean and median (50% percentile).
     - For categorical data, a lack of diversity (low count of unique values), or overdominance of a single category
     (high frequency of the top value) can indicate high risk.
 
-    **Strengths**:
-    - This metric provides a comprehensive summary of the dataset, shedding light on the distribution and
-    characteristics of the variables under consideration.
+    ### Strengths
+
+    - Provides a comprehensive summary of the dataset, shedding light on the distribution and characteristics of the
+    variables under consideration.
     - It is a versatile and robust method, applicable to both numerical and categorical data.
-    - It helps highlight crucial anomalies such as outliers, extreme skewness, or lack of diversity, which are vital in
+    - Helps highlight crucial anomalies such as outliers, extreme skewness, or lack of diversity, which are vital in
     understanding model behavior during testing and validation.
 
-    **Limitations**:
+    ### Limitations
+
     - While this metric offers a high-level overview of the data, it may fail to detect subtle correlations or complex
     patterns.
-    - It does not offer any insights on the relationship between variables.
+    - Does not offer any insights on the relationship between variables.
     - Alone, descriptive statistics cannot be used to infer properties about future unseen data.
-    - It should be used in conjunction with other statistical tests to provide a comprehensive understanding of the
+    - Should be used in conjunction with other statistical tests to provide a comprehensive understanding of the
     model's data.
     """
 

validmind/tests/data_validation/Duplicates.py

@@ -21,35 +21,43 @@ class Duplicates(ThresholdTest):
     """
     Tests dataset for duplicate entries, ensuring model reliability via data quality verification.
 
-    **Purpose**: The 'Duplicates' metric is designed to check for duplicate rows within the dataset provided to the
-    model. It serves as a measure of data quality, ensuring that the model isn't merely memorizing duplicate entries or
-    being swayed by redundant information. This is an important step in the pre-processing of data for both
-    classification and regression tasks.
-
-    **Test Mechanism**: This metric operates by checking each row for duplicates in the dataset. If a text column is
-    specified in the dataset, the test is conducted on this column; if not, the test is run on all feature columns. The
-    number and percentage of duplicates are calculated and returned in a DataFrame. Additionally, a test is passed if
-    the total count of duplicates falls below a specified minimum threshold.
-
-    **Signs of High Risk**:
-    - A high number of duplicate rows in the dataset. This can lead to overfitting where the model performs well on the
-    training data but poorly on unseen data.
-    - A high percentage of duplicate rows in the dataset. A large proportion of duplicate values could indicate that
-    there's a problem with data collection or processing.
-
-    **Strengths**:
+    ### Purpose
+
+    The 'Duplicates' test is designed to check for duplicate rows within the dataset provided to the model. It serves
+    as a measure of data quality, ensuring that the model isn't merely memorizing duplicate entries or being swayed by
+    redundant information. This is an important step in the pre-processing of data for both classification and
+    regression tasks.
+
+    ### Test Mechanism
+
+    This test operates by checking each row for duplicates in the dataset. If a text column is specified in the
+    dataset, the test is conducted on this column; if not, the test is run on all feature columns. The number and
+    percentage of duplicates are calculated and returned in a DataFrame. Additionally, a test is passed if the total
+    count of duplicates falls below a specified minimum threshold.
+
+    ### Signs of High Risk
+
+    - A high number of duplicate rows in the dataset, which can lead to overfitting where the model performs well on
+    the training data but poorly on unseen data.
+    - A high percentage of duplicate rows in the dataset, indicating potential problems with data collection or
+    processing.
+
+    ### Strengths
+
     - Assists in improving the reliability of the model's training process by ensuring the training data is not
-    contaminated with duplicate entries which can distort statistical analyses.
-    - Provides both absolute number and percentage value of duplicate rows, giving a thorough overview of data quality
+    contaminated with duplicate entries, which can distort statistical analyses.
+    - Provides both absolute numbers and percentage values of duplicate rows, giving a thorough overview of data
+    quality.
     - Highly customizable as it allows for setting a user-defined minimum threshold to determine if the test has been
     passed.
 
-    **Limitations**:
-    - This test does not distinguish between benign duplicates (i.e., coincidental identical entries in different rows)
-    and problematic duplicates originating from data collection or processing errors.
-    - Since the test becomes more computationally intensive as the size of the dataset increases, it might not be
-    suitable for very large datasets.
-    - It can only check for exact duplicates and may miss semantically similar information packaged differently.
+    ### Limitations
+
+    - Does not distinguish between benign duplicates (i.e., coincidental identical entries in different rows) and
+    problematic duplicates originating from data collection or processing errors.
+    - The test becomes more computationally intensive as the size of the dataset increases, which might not be suitable
+    for very large datasets.
+    - Can only check for exact duplicates and may miss semantically similar information packaged differently.
     """
 
     name = "duplicates"

validmind/tests/data_validation/EngleGrangerCoint.py

@@ -10,41 +10,43 @@ from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableM
 
 class EngleGrangerCoint(Metric):
     """
-    Validates co-integration in pairs of time series data using the Engle-Granger test and classifies them as
-    'Cointegrated' or 'Not cointegrated'.
-
-    **Purpose**: The intent of this Engle-Granger cointegration test is to explore and quantify the degree of
-    co-movement between pairs of time series variables in a dataset. This is particularly useful in enhancing the
-    accuracy of predictive regressions whenever the underlying variables are co-integrated, i.e., they move together
-    over time.
-
-    **Test Mechanism**: The test first drops any non-applicable values from the input dataset and then iterates over
-    each pair of variables to apply the Engle-Granger cointegration test. The test generates a 'p' value, which is then
-    compared against a pre-specified threshold (0.05 by default). The pair is labeled as 'Cointegrated' if the 'p'
-    value is less than or equal to the threshold or 'Not cointegrated' otherwise. A summary table is returned by the
-    metric showing cointegration results for each variable pair.
-
-    **Signs of High Risk**:
-    - A high risk might be indicated if a significant number of variables that were hypothesized to be cointegrated do
-    not pass the test.
-    - Another sign of high risk is if a considerable number of 'p' values are close to the threshold. This is a risk
-    because minor fluctuations in the data can switch the decision between 'Cointegrated' and 'Not cointegrated'.
-
-    **Strengths**:
-    - The Engle-Granger cointegration test provides an effective way to analyze relationships between time series,
-    particularly in contexts where it's essential to check if variables are moving together in a statistically
-    significant manner.
-    - It is useful in various domains, especially finance or economics. Here, predictive models often hinge on
-    understanding how different variables move together over time.
-
-    **Limitations**:
-    - The Engle-Granger cointegration test assumes that the time series are integrated of the same order, which isn't
-    always true in multivariate time series datasets.
+    Assesses the degree of co-movement between pairs of time series data using the Engle-Granger cointegration test.
+
+    ### Purpose
+
+    The intent of this Engle-Granger cointegration test is to explore and quantify the degree of co-movement between
+    pairs of time series variables in a dataset. This is particularly useful in enhancing the accuracy of predictive
+    regressions whenever the underlying variables are co-integrated, i.e., they move together over time.
+
+    ### Test Mechanism
+
+    The test first drops any non-applicable values from the input dataset and then iterates over each pair of variables
+    to apply the Engle-Granger cointegration test. The test generates a 'p' value, which is then compared against a
+    pre-specified threshold (0.05 by default). The pair is labeled as 'Cointegrated' if the 'p' value is less than or
+    equal to the threshold or 'Not cointegrated' otherwise. A summary table is returned by the metric showing
+    cointegration results for each variable pair.
+
+    ### Signs of High Risk
+
+    - A significant number of hypothesized cointegrated variables do not pass the test.
+    - A considerable number of 'p' values are close to the threshold, indicating minor data fluctuations can switch the
+    decision between 'Cointegrated' and 'Not cointegrated'.
+
+    ### Strengths
+
+    - Provides an effective way to analyze relationships between time series, particularly in contexts where it's
+    essential to check if variables move together in a statistically significant manner.
+    - Useful in various domains, especially finance or economics, where predictive models often hinge on understanding
+    how different variables move together over time.
+
+    ### Limitations
+
+    - Assumes that the time series are integrated of the same order, which isn't always true in multivariate time
+    series datasets.
     - The presence of non-stationary characteristics in the series or structural breaks can result in falsely positive
     or negative cointegration results.
-    - The test may not perform well for small sample sizes due to lack of statistical power. Therefore, it should be
-    used with caution, and whenever possible, supplemented with other predictive indicators for a more robust model
-    evaluation.
+    - May not perform well for small sample sizes due to lack of statistical power and should be supplemented with
+    other predictive indicators for a more robust model evaluation.
     """
 
     type = "dataset"

validmind/tests/data_validation/FeatureTargetCorrelationPlot.py

@@ -2,108 +2,96 @@
 # 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 numpy as np
 import plotly.graph_objects as go
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
 
 
-@dataclass
-class FeatureTargetCorrelationPlot(Metric):
+@tags("tabular_data", "visualization", "correlation")
+@tasks("classification", "regression")
+def FeatureTargetCorrelationPlot(dataset, fig_height=600):
     """
-    Visualizes the correlation between input features and model's target output in a color-coded horizontal bar plot.
+    Visualizes the correlation between input features and the model's target output in a color-coded horizontal bar
+    plot.
 
-    **Purpose**: This test is designed to graphically illustrate the correlations between distinct input features and
-    the target output of a Machine Learning model. Understanding how each feature influences the model's predictions is
-    crucial - a higher correlation indicates stronger influence of the feature on the target variable. This correlation
-    study is especially advantageous during feature selection and for comprehending the model's operation.
+    ### Purpose
 
-    **Test Mechanism**: This FeatureTargetCorrelationPlot test computes and presents the correlations between the
-    features and the target variable using a specific dataset. These correlations are calculated, graphically
-    represented in a horizontal bar plot, and color-coded based on the strength of the correlation. A hovering template
-    can also be utilized for informative tooltips. It is possible to specify the features to be analyzed and adjust the
-    graph's height according to need.
+    This test is designed to graphically illustrate the correlations between distinct input features and the target
+    output of a Machine Learning model. Understanding how each feature influences the model's predictions is crucial—a
+    higher correlation indicates a stronger influence of the feature on the target variable. This correlation study is
+    especially advantageous during feature selection and for comprehending the model's operation.
+
+    ### Test Mechanism
+
+    This FeatureTargetCorrelationPlot test computes and presents the correlations between the features and the target
+    variable using a specific dataset. These correlations are calculated and are then graphically represented in a
+    horizontal bar plot, color-coded based on the strength of the correlation. A hovering template can also be utilized
+    for informative tooltips. It is possible to specify the features to be analyzed and adjust the graph's height
+    according to need.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - There are no strong correlations (either positive or negative) between features and the target variable. This
     could suggest high risk as the supplied features do not appear to significantly impact the prediction output.
     - The presence of duplicated correlation values might hint at redundancy in the feature set.
 
-    **Strengths**:
+    ### Strengths
+
     - Provides visual assistance to interpreting correlations more effectively.
     - Gives a clear and simple tour of how each feature affects the model's target variable.
     - Beneficial for feature selection and grasping the model's prediction nature.
     - Precise correlation values for each feature are offered by the hover template, contributing to a granular-level
     comprehension.
 
-    **Limitations**:
+    ### Limitations
+
     - The test only accepts numerical data, meaning variables of other types need to be prepared beforehand.
     - The plot assumes all correlations to be linear, thus non-linear relationships might not be captured effectively.
     - Not apt for models that employ complex feature interactions, like Decision Trees or Neural Networks, as the test
     may not accurately reflect their importance.
     """
 
-    name = "feature_target_correlation_plot"
-    required_inputs = ["dataset"]
-    default_params = {"features": None, "fig_height": 600}
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "visualization", "feature_importance", "correlation"]
+    # Filter DataFrame based on features and target_column
+    df = dataset.df[dataset.feature_columns + [dataset.target_column]]
 
-    def run(self):
-        fig_height = self.params["fig_height"]
+    fig = _visualize_feature_target_correlation(df, dataset.target_column, fig_height)
 
-        if self.params["features"] is None:
-            features = self.inputs.dataset.feature_columns
-        else:
-            features = self.params["features"]
+    return fig
 
-        target_column = self.inputs.dataset.target_column
 
-        # Filter DataFrame based on features and target_column
-        df = self.inputs.dataset.df[features + [target_column]]
+def _visualize_feature_target_correlation(df, target_column, fig_height):
+    # Compute correlations with the target variable
+    correlations = (
+        df.corr(numeric_only=True)[target_column].drop(target_column).to_frame()
+    )
+    correlations = correlations.loc[:, ~correlations.columns.duplicated()]
 
-        figure = self.visualize_feature_target_correlation(
-            df, target_column, fig_height
-        )
+    correlations = correlations.sort_values(by=target_column, ascending=True)
 
-        return self.cache_results(figures=figure)
+    # Create a gradual color map from red (1) to blue (-1)
+    color_map = np.linspace(1, -1, len(correlations))
+    colors = [
+        f"rgb({int(255 * (1 - val))}, 0, {int(255 * (1 + val))})" for val in color_map
+    ]
 
-    def visualize_feature_target_correlation(self, df, target_column, fig_height):
-        # Compute correlations with the target variable
-        correlations = (
-            df.corr(numeric_only=True)[target_column].drop(target_column).to_frame()
-        )
-        correlations = correlations.loc[:, ~correlations.columns.duplicated()]
-
-        correlations = correlations.sort_values(by=target_column, ascending=True)
-
-        # Create a gradual color map from red (1) to blue (-1)
-        color_map = np.linspace(1, -1, len(correlations))
-        colors = [
-            f"rgb({int(255 * (1 - val))}, 0, {int(255 * (1 + val))})"
-            for val in color_map
-        ]
-
-        # Create a horizontal bar plot with gradual color mapping
-        fig = go.Figure(
-            data=go.Bar(
-                x=correlations[target_column],
-                y=correlations.index,
-                orientation="h",
-                marker=dict(color=colors),
-                hovertemplate="Feature: %{y}<br>Correlation: %{x:.2f}<extra></extra>",  # Hover template for tooltips
-            )
+    # Create a horizontal bar plot with gradual color mapping
+    fig = go.Figure(
+        data=go.Bar(
+            x=correlations[target_column],
+            y=correlations.index,
+            orientation="h",
+            marker=dict(color=colors),
+            hovertemplate="Feature: %{y}<br>Correlation: %{x:.2f}<extra></extra>",  # Hover template for tooltips
         )
-
-        # Set the title and axis labels
-        fig.update_layout(
-            title=f"Correlations of Features vs Target Variable ({target_column})",
-            xaxis_title="",
-            yaxis_title="",
-            height=fig_height,  # Adjust the height value as needed
-        )
-
-        figure = Figure(for_object=self, key=self.key, figure=fig)
-        return [figure]
+    )
+
+    # Set the title and axis labels
+    fig.update_layout(
+        title=f"Correlations of Features vs Target Variable ({target_column})",
+        xaxis_title="",
+        yaxis_title="",
+        height=fig_height,  # Adjust the height value as needed
+    )
+    return fig

validmind/tests/data_validation/HighCardinality.py

@@ -22,26 +22,33 @@ class HighCardinality(ThresholdTest):
     """
     Assesses the number of unique values in categorical columns to detect high cardinality and potential overfitting.
 
-    **Purpose**: The “High Cardinality” test is used to evaluate the number of unique values present in the categorical
-    columns of a dataset. In this context, high cardinality implies the presence of a large number of unique,
-    non-repetitive values in the dataset.
+    ### Purpose
 
-    **Test Mechanism**: The test first infers the dataset's type and then calculates an initial numeric threshold based
-    on the test parameters. It only considers columns classified as "Categorical". For each of these columns, the
-    number of distinct values (n_distinct) and the percentage of distinct values (p_distinct) are calculated. The test
-    will pass if n_distinct is less than the calculated numeric threshold. Lastly, the results, which include details
-    such as column name, number of distinct values, and pass/fail status, are compiled into a table.
+    The “High Cardinality” test is used to evaluate the number of unique values present in the categorical columns of a
+    dataset. In this context, high cardinality implies the presence of a large number of unique, non-repetitive values
+    in the dataset.
+
+    ### Test Mechanism
+
+    The test first infers the dataset's type and then calculates an initial numeric threshold based on the test
+    parameters. It only considers columns classified as "Categorical". For each of these columns, the number of
+    distinct values (n_distinct) and the percentage of distinct values (p_distinct) are calculated. The test will pass
+    if n_distinct is less than the calculated numeric threshold. Lastly, the results, which include details such as
+    column name, number of distinct values, and pass/fail status, are compiled into a table.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A large number of distinct values (high cardinality) in one or more categorical columns implies a high risk.
     - A column failing the test (n_distinct >= num_threshold) is another indicator of high risk.
 
-    **Strengths**:
+    ### Strengths
+
     - The High Cardinality test is effective in early detection of potential overfitting and unwanted noise.
     - It aids in identifying potential outliers and inconsistencies, thereby improving data quality.
-    - The test can be applied to both, classification and regression task types, demonstrating its versatility.
+    - The test can be applied to both classification and regression task types, demonstrating its versatility.
+
+    ### Limitations
 
-    **Limitations**:
     - The test is restricted to only "Categorical" data types and is thus not suitable for numerical or continuous
     features, limiting its scope.
     - The test does not consider the relevance or importance of unique values in categorical features, potentially

validmind/tests/data_validation/HighPearsonCorrelation.py

@@ -22,36 +22,41 @@ class HighPearsonCorrelation(ThresholdTest):
     """
     Identifies highly correlated feature pairs in a dataset suggesting feature redundancy or multicollinearity.
 
-    **Purpose**: The High Pearson Correlation test measures the linear relationship between features in a dataset, with
-    the main goal of identifying high correlations that might indicate feature redundancy or multicollinearity.
-    Identification of such issue allows developers and risk management teams to properly deal with potential impacts on
-    the machine learning model's performance and interpretability.
+    ### Purpose
 
-    **Test Mechanism**: The test works by generating pairwise Pearson correlations for all features in the dataset,
-    then sorting and eliminating duplicate and self-correlations. It assigns a Pass or Fail based on whether the
-    absolute value of the correlation coefficient surpasses a pre-set threshold (defaulted at 0.3). It lastly returns
-    the top ten strongest correlations regardless of passing or failing status.
+    The High Pearson Correlation test measures the linear relationship between features in a dataset, with the main
+    goal of identifying high correlations that might indicate feature redundancy or multicollinearity. Identification
+    of such issues allows developers and risk management teams to properly deal with potential impacts on the machine
+    learning model's performance and interpretability.
+
+    ### Test Mechanism
+
+    The test works by generating pairwise Pearson correlations for all features in the dataset, then sorting and
+    eliminating duplicate and self-correlations. It assigns a Pass or Fail based on whether the absolute value of the
+    correlation coefficient surpasses a pre-set threshold (defaulted at 0.3). It lastly returns the top ten strongest
+    correlations regardless of passing or failing status.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A high risk indication would be the presence of correlation coefficients exceeding the threshold.
     - If the features share a strong linear relationship, this could lead to potential multicollinearity and model
     overfitting.
     - Redundancy of variables can undermine the interpretability of the model due to uncertainty over the authenticity
     of individual variable's predictive power.
 
-    **Strengths**:
-    - The High Pearson Correlation test provides a quick and simple means of identifying relationships between feature
-    pairs.
-    - It generates a transparent output which not only displays pairs of correlated variables but also delivers the
-    Pearson correlation coefficient and a Pass or Fail status for each.
-    - It aids early identification of potential multicollinearity issues that may disrupt model training.
-
-    **Limitations**:
-    - The Pearson correlation test can only delineate linear relationships. It fails to shed light on nonlinear
-    relationships or dependencies.
-    - It is sensitive to outliers where a few outliers could notably affect the correlation coefficient.
-    - It is limited to identifying redundancy only within feature pairs. When three or more variables are linearly
-    dependent, it may fail to spot this complex relationship.
+    ### Strengths
+
+    - Provides a quick and simple means of identifying relationships between feature pairs.
+    - Generates a transparent output that displays pairs of correlated variables, the Pearson correlation coefficient,
+    and a Pass or Fail status for each.
+    - Aids in early identification of potential multicollinearity issues that may disrupt model training.
+
+    ### Limitations
+
+    - Can only delineate linear relationships, failing to shed light on nonlinear relationships or dependencies.
+    - Sensitive to outliers where a few outliers could notably affect the correlation coefficient.
+    - Limited to identifying redundancy only within feature pairs; may fail to spot more complex relationships among
+    three or more variables.
     - The top 10 result filter might not fully capture the richness of the data; an option to configure the number of
     retained results could be helpful.
     """

validmind/tests/data_validation/IQROutliersBarPlot.py

@@ -12,14 +12,18 @@ from validmind.vm_models import Figure, Metric
 @dataclass
 class IQROutliersBarPlot(Metric):
     """
-    Visualizes outlier distribution across percentiles in numerical data using Interquartile Range (IQR) method.
+    Visualizes outlier distribution across percentiles in numerical data using the Interquartile Range (IQR) method.
 
-    **Purpose**: The InterQuartile Range Outliers Bar Plot (IQROutliersBarPlot) metric aims to visually analyze and
-    evaluate the extent of outliers in numeric variables based on percentiles. Its primary purpose is to clarify the
-    dataset's distribution, flag possible abnormalities in it and gauge potential risks associated with processing
-    potentially skewed data, which can affect the machine learning model's predictive prowess.
+    ### Purpose
 
-    **Test Mechanism**: The examination invokes a series of steps:
+    The InterQuartile Range Outliers Bar Plot (IQROutliersBarPlot) metric aims to visually analyze and evaluate the
+    extent of outliers in numeric variables based on percentiles. Its primary purpose is to clarify the dataset's
+    distribution, flag possible abnormalities in it, and gauge potential risks associated with processing potentially
+    skewed data, which can affect the machine learning model's predictive prowess.
+
+    ### Test Mechanism
+
+    The examination invokes a series of steps:
 
     1. For every numeric feature in the dataset, the 25th percentile (Q1) and 75th percentile (Q3) are calculated
     before deriving the Interquartile Range (IQR), the difference between Q1 and Q3.
@@ -31,8 +35,7 @@ class IQROutliersBarPlot(Metric):
     5. These counts are employed to construct a bar plot for the feature, showcasing the distribution of outliers
     across different percentiles.
 
-    **Signs of High Risk**: High risk or a potential lapse in the model's performance could be unveiled by the
-    following signs:
+    ### Signs of High Risk
 
     - A prevalence of outliers in the data, potentially skewing its distribution.
     - Outliers dominating higher percentiles (75-100) which implies the presence of extreme values, capable of severely
@@ -40,7 +43,7 @@ class IQROutliersBarPlot(Metric):
     - Certain features harboring most of their values as outliers, which signifies that these features might not
     contribute positively to the model's forecasting ability.
 
-    **Strengths**:
+    ### Strengths
 
     - Effectively identifies outliers in the data through visual means, facilitating easier comprehension and offering
     insights into the outliers' possible impact on the model.
@@ -48,7 +51,7 @@ class IQROutliersBarPlot(Metric):
     - Task-agnostic in nature; it is viable for both classification and regression tasks.
     - Can handle large datasets as its operation does not hinge on computationally heavy operations.
 
-    **Limitations**:
+    ### Limitations
 
     - Its application is limited to numerical variables and does not extend to categorical ones.
     - Relies on a predefined threshold (default being 1.5) for outlier identification, which may not be suitable for