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

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

validmind/tests/data_validation/IQROutliersTable.py

@@ -12,42 +12,46 @@ from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableM
 @dataclass
 class IQROutliersTable(Metric):
     """
-    Determines and summarizes outliers in numerical features using Interquartile Range method.
-
-    **Purpose**: The "Interquartile Range Outliers Table" (IQROutliersTable) metric has been designed for identifying
-    and summarizing outliers within numerical features of a dataset using the Interquartile Range (IQR) method. The
-    purpose of this exercise is crucial in the pre-processing of data as outliers can substantially distort the
-    statistical analysis and debilitate the performance of machine learning models.
-
-    **Test Mechanism**: The IQR, which is the range separating the first quartile (25th percentile) from the third
-    quartile (75th percentile), is calculated for each numerical feature within the dataset. An outlier is defined as a
-    data point falling below the "Q1 - 1.5 * IQR" or above "Q3 + 1.5 * IQR" range. The metric then computes the number
-    of outliers along with their minimum, 25th percentile, median, 75th percentile, and maximum values for each
-    numerical feature. If no specific features are chosen, the metric will apply to all numerical features in the
-    dataset. The default outlier threshold is set to 1.5, following the standard definition of outliers in statistical
-    analysis, although it can be customized by the user.
-
-    **Signs of High Risk**:
-    - High risk is indicated by a large number of outliers in multiple features.
-    - Outliers that are significantly distanced from the mean value of variables could potentially signal high risk.
-    - Data entry errors or other data quality issues could be manifested through extremely high or low outlier values.
-
-    **Strengths**:
-    - It yields a comprehensive summary of outliers for each numerical feature within the dataset. This enables the
-    user to pinpoint features with potential quality issues.
-    - The IQR method is not overly affected by extremely high or low outlier values as it is based on quartile
-    calculations.
-    - The versatility of this metric grants the ability to customize the method to work on selected features and set a
-    defined threshold for outliers.
-
-    **Limitations**:
-    - The metric might cause false positives if the variable of interest veers away from a normal or near-normal
-    distribution, notably in the case of skewed distributions.
-    - It does not extend to provide interpretation or recommendations for tackling outliers and relies on the user or a
-    data scientist to conduct further analysis of the results.
-    - As it only functions on numerical features, it cannot be used for categorical data.
-    - For data that has undergone heavy pre-processing, was manipulated, or inherently possesses a high kurtosis (heavy
-    tails), the pre-set threshold may not be optimal for outlier detection.
+    Determines and summarizes outliers in numerical features using the Interquartile Range method.
+
+    ### Purpose
+
+    The "Interquartile Range Outliers Table" (IQROutliersTable) metric is designed to identify and summarize outliers
+    within numerical features of a dataset using the Interquartile Range (IQR) method. This exercise is crucial in the
+    pre-processing of data because outliers can substantially distort statistical analysis and impact the performance
+    of machine learning models.
+
+    ### Test Mechanism
+
+    The IQR, which is the range separating the first quartile (25th percentile) from the third quartile (75th
+    percentile), is calculated for each numerical feature within the dataset. An outlier is defined as a data point
+    falling below the "Q1 - 1.5 * IQR" or above "Q3 + 1.5 * IQR" range. The test computes the number of outliers and
+    their summary statistics (minimum, 25th percentile, median, 75th percentile, and maximum values) for each numerical
+    feature. If no specific features are chosen, the test applies to all numerical features in the dataset. The default
+    outlier threshold is set to 1.5 but can be customized by the user.
+
+    ### Signs of High Risk
+
+    - A large number of outliers in multiple features.
+    - Outliers significantly distanced from the mean value of variables.
+    - Extremely high or low outlier values indicative of data entry errors or other data quality issues.
+
+    ### Strengths
+
+    - Provides a comprehensive summary of outliers for each numerical feature, helping pinpoint features with potential
+    quality issues.
+    - The IQR method is robust to extremely high or low outlier values as it is based on quartile calculations.
+    - Can be customized to work on selected features and set thresholds for outliers.
+
+    ### Limitations
+
+    - Might cause false positives if the variable deviates from a normal or near-normal distribution, especially for
+    skewed distributions.
+    - Does not provide interpretation or recommendations for addressing outliers, relying on further analysis by users
+    or data scientists.
+    - Only applicable to numerical features, not categorical data.
+    - Default thresholds may not be optimal for data with heavy pre-processing, manipulation, or inherently high
+    kurtosis (heavy tails).
     """
 
     name = "iqr_outliers_table"

validmind/tests/data_validation/IsolationForestOutliers.py

@@ -17,24 +17,30 @@ class IsolationForestOutliers(Metric):
     """
     Detects outliers in a dataset using the Isolation Forest algorithm and visualizes results through scatter plots.
 
-    **Purpose**: The `IsolationForestOutliers` test is designed to identify anomalies or outliers in the model's
-    dataset using the isolation forest algorithm. This algorithm assumes that anomalous data points can be isolated
-    more quickly due to their distinctive properties. By creating isolation trees and identifying instances with
-    shorter average path lengths, the test is able to pick out data points that differ from the majority.
-
-    **Test Mechanism**: The test uses the isolation forest algorithm, which builds an ensemble of isolation trees by
-    randomly selecting features and splitting the data based on random thresholds. It isolates anomalies rather than
-    focusing on normal data points. For each pair of variables, a scatter plot is generated which distinguishes the
-    identified outliers from the inliers. The results of the test can be visualized using these scatter plots,
-    illustrating the distinction between outliers and inliers.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    The IsolationForestOutliers test is designed to identify anomalies or outliers in the model's dataset using the
+    isolation forest algorithm. This algorithm assumes that anomalous data points can be isolated more quickly due to
+    their distinctive properties. By creating isolation trees and identifying instances with shorter average path
+    lengths, the test is able to pick out data points that differ from the majority.
+
+    ### Test Mechanism
+
+    The test uses the isolation forest algorithm, which builds an ensemble of isolation trees by randomly selecting
+    features and splitting the data based on random thresholds. It isolates anomalies rather than focusing on normal
+    data points. For each pair of variables, a scatter plot is generated which distinguishes the identified outliers
+    from the inliers. The results of the test can be visualized using these scatter plots, illustrating the distinction
+    between outliers and inliers.
+
+    ### Signs of High Risk
+
     - The presence of high contamination, indicating a large number of anomalies
     - Inability to detect clusters of anomalies that are close in the feature space
     - Misclassifying normal instances as anomalies
     - Failure to detect actual anomalies
 
-    **Strengths**:
+    ### Strengths
+
     - Ability to handle large, high-dimensional datasets
     - Efficiency in isolating anomalies instead of normal instances
     - Insensitivity to the underlying distribution of data
@@ -42,7 +48,8 @@ class IsolationForestOutliers(Metric):
     distinctive properties
     - Visually presents the test results for better understanding and interpretability
 
-    **Limitations**:
+    ### Limitations
+
     - Difficult to detect anomalies that are close to each other or prevalent in datasets
     - Dependency on the contamination parameter which may need fine-tuning to be effective
     - Potential failure in detecting collective anomalies if they behave similarly to normal data