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

validmind/tests/data_validation/BivariateScatterPlots.py

@@ -3,109 +3,80 @@
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
 import itertools
-from dataclasses import dataclass
 
 import plotly.express as px
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
 
 
-@dataclass
-class BivariateScatterPlots(Metric):
+@tags("tabular_data", "numerical_data", "visualization")
+@tasks("classification")
+def BivariateScatterPlots(dataset):
     """
-    Generates bivariate scatterplots to visually inspect relationships between pairs of predictor variables in machine
-    learning classification tasks.
-
-    **Purpose**: This metric is intended for visual inspection and monitoring of relationships between pairs of
-    variables in a machine learning model targeting classification tasks. It is especially useful for understanding how
-    predictor variables (features) behave in relation to each other and how they are distributed for different classes
-    of the target variable, which could inform feature selection, model-building strategies, and even alert to possible
-    biases and irregularities in the data.
-
-    **Test Mechanism**: This metric operates by creating a scatter plot for each pair of the selected features in the
-    dataset. If the parameters "selected_columns" are not specified, an error will be thrown. The metric offers
-    flexibility by allowing the user to filter on a specific target class - specified by the "target_filter" parameter
-    - for more granified insights. Each scatterplot is then color-coded based on the category of the target variable
-    for better visual differentiation. The seaborn scatterplot library is used for generating the plots.
-
-    **Signs of High Risk**:
-    - Visual patterns which might suggest non-linear relationships, substantial skewness, multicollinearity,
-    clustering, or isolated outlier points in the scatter plot.
-    - Such issues could affect the assumptions and performance of some models, especially the ones assuming linearity
-    like linear regression or logistic regression.
-
-    **Strengths**:
-    - Scatterplots are simple and intuitive for users to understand, providing a visual tool to pinpoint complex
-    relationships between two variables.
-    - They are useful for outlier detection, identification of variable associations and trends, including non-linear
-    patterns which can be overlooked by other linear-focused metrics or tests.
-    - The implementation also supports visualizing binary or multi-class classification datasets.
-
-    **Limitations**:
-    - Scatterplots are limited to bivariate analysis - the relationship of two variables at a time - and might not
-    reveal the full picture in higher dimensions or where interactions are present.
-    - They are not ideal for very large datasets as points will overlap and render the visualization less informative.
-    - Scatterplots are more of an exploratory tool rather than a formal statistical test, so they don't provide any
-    quantitative measure of model quality or performance.
-    - Interpretation of scatterplots relies heavily on the domain knowledge and judgment of the viewer, which can
-    introduce subjective bias.
+    Generates bivariate scatterplots to visually inspect relationships between pairs of numerical predictor variables
+    in machine learning classification tasks.
+
+    ### Purpose
+
+    This function is intended for visual inspection and monitoring of relationships between pairs of numerical
+    variables in a machine learning model targeting classification tasks. It helps in understanding how predictor
+    variables (features) interact with each other, which can inform feature selection, model-building strategies, and
+    identify potential biases or irregularities in the data.
+
+    ### Test Mechanism
+
+    The function creates scatter plots for each pair of numerical features in the dataset. It first filters out
+    non-numerical and binary features, ensuring the plots focus on meaningful numerical relationships. The resulting
+    scatterplots are color-coded uniformly to avoid visual distraction, and the function returns a tuple of Plotly
+    figure objects, each representing a scatter plot for a pair of features.
+
+    ### Signs of High Risk
+
+    - Visual patterns suggesting non-linear relationships, multicollinearity, clustering, or outlier points in the
+    scatter plots.
+    - Such issues could affect the assumptions and performance of certain models, especially those assuming linearity,
+    like logistic regression.
+
+    ### Strengths
+
+    - Scatterplots provide an intuitive and visual tool to explore relationships between two variables.
+    - They are useful for identifying outliers, variable associations, and trends, including non-linear patterns.
+    - Supports visualization of binary or multi-class classification datasets, focusing on numerical features.
+
+    ### Limitations
+
+    - Scatterplots are limited to bivariate analysis, showing relationships between only two variables at a time.
+    - Not ideal for very large datasets where overlapping points can reduce the clarity of the visualization.
+    - Scatterplots are exploratory tools and do not provide quantitative measures of model quality or performance.
+    - Interpretation is subjective and relies on the domain knowledge and judgment of the viewer.
     """
+    figures = []
 
-    name = "bivariate_scatter_plots"
-    required_inputs = ["dataset"]
-    default_params = {"selected_columns": None}
-    tasks = ["classification"]
-    tags = [
-        "tabular_data",
-        "categorical_data",
-        "binary_classification",
-        "multiclass_classification",
-        "visualization",
+    # Select numerical features
+    features = dataset.feature_columns_numeric
+
+    # Select non-binary features
+    features = [
+        feature for feature in features if len(dataset.df[feature].unique()) > 2
     ]
 
-    def plot_bivariate_scatter(self, columns):
-        figures = []
-        df = self.inputs.dataset.df
-
-        # Generate all pairs of columns
-        features_pairs = list(itertools.combinations(columns, 2))
-
-        for x, y in features_pairs:
-            fig = px.scatter(
-                df,
-                x=x,
-                y=y,
-                title=f"{x} and {y}",
-                labels={x: x, y: y},
-                opacity=0.7,
-                color_discrete_sequence=["blue"],  # Use the same color for all points
-            )
-            fig.update_traces(marker=dict(color="blue"))
-
-            figures.append(
-                Figure(for_object=self, key=f"{self.key}:{x}_{y}", figure=fig)
-            )
-
-        return figures
-
-    def run(self):
-        selected_columns = self.params["selected_columns"]
-
-        if selected_columns is None:
-            # Use all columns if selected_columns is not provided
-            selected_columns = self.inputs.dataset.df.columns.tolist()
-        else:
-            # Check if all selected columns exist in the dataframe
-            missing_columns = [
-                col
-                for col in selected_columns
-                if col not in self.inputs.dataset.df.columns
-            ]
-            if missing_columns:
-                raise ValueError(
-                    f"The following selected columns are not in the dataframe: {missing_columns}"
-                )
-
-        figures = self.plot_bivariate_scatter(selected_columns)
-
-        return self.cache_results(figures=figures)
+    df = dataset.df[features]
+
+    # Generate all pairs of columns
+    features_pairs = list(itertools.combinations(df.columns, 2))
+
+    for x, y in features_pairs:
+        fig = px.scatter(
+            df,
+            x=x,
+            y=y,
+            title=f"{x} and {y}",
+            labels={x: x, y: y},
+            opacity=0.7,
+            color_discrete_sequence=["blue"],  # Use the same color for all points
+        )
+        fig.update_traces(marker=dict(color="blue"))
+
+        figures.append(fig)
+
+    return tuple(figures)

validmind/tests/data_validation/ChiSquaredFeaturesTable.py

@@ -2,140 +2,98 @@
 # 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 pandas as pd
 from scipy.stats import chi2_contingency
 
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+from validmind import tags, tasks
 
 
-@dataclass
-class ChiSquaredFeaturesTable(Metric):
+@tags("tabular_data", "categorical_data", "statistical_test")
+@tasks("classification")
+def ChiSquaredFeaturesTable(dataset, p_threshold=0.05):
     """
-    Executes Chi-Squared test for each categorical feature against a target column to assess significant association.
-
-    **Purpose**: The `ChiSquaredFeaturesTable` metric is used to carry out a Chi-Squared test of independence for each
-    categorical feature variable against a designated target column. The primary goal is to determine if a significant
-    association exists between the categorical features and the target variable. This method typically finds its use in
-    the context of Model Risk Management to understand feature relevance and detect potential bias in a classification
-    model.
-
-    **Test Mechanism**: The testing process generates a contingency table for each categorical variable and the target
-    variable, after which a Chi-Squared test is performed. Using this approach, the Chi-Squared statistic and the
-    p-value for each feature are calculated. The p-value threshold is a modifiable parameter, and a test will qualify
-    as passed if the p-value is less than or equal to this threshold. If not, the test is labeled as failed. The
-    outcome for each feature - comprising the variable name, Chi-squared statistic, p-value, threshold, and pass/fail
-    status - is incorporated into a final summary table.
-
-    **Signs of High Risk**:
-    - High p-values (greater than the set threshold) for specific variables could indicate a high risk.
-    - These high p-values allude to the absence of a statistically significant relationship between the feature and the
-    target variables, resulting in a 'Fail' status.
-    - A categorical feature lacking a relevant association with the target variable could be a warning that the machine
-    learning model might not be performing optimally.
-
-    **Strengths**:
-    - The test allows for a comprehensive understanding of the interaction between a model's input features and the
-    target output, thus validating the relevance of categorical features.
-    - It also produces an unambiguous 'Pass/Fail' output for each categorical feature.
-    - The opportunity to adjust the p-value threshold contributes to flexibility in accommodating different statistical
-    standards.
-
-    **Limitations**:
-    - The metric presupposes that data is tabular and categorical, which may not always be the case with all datasets.
-    - It is distinctively designed for classification tasks, hence unsuitable for regression scenarios.
-    - The Chi-squared test, akin to any hypothesis testing-based test, cannot identify causal relationships, but only
-    associations.
-    - Furthermore, the test hinges on an adjustable p-value threshold, and varying threshold selections might lead to
-    different conclusions regarding feature relevance.
+    Assesses the statistical association between categorical features and a target variable using the Chi-Squared test.
+
+    ### Purpose
+
+    The `ChiSquaredFeaturesTable` function is designed to evaluate the relationship between categorical features and a
+    target variable in a dataset. It performs a Chi-Squared test of independence for each categorical feature to
+    determine whether a statistically significant association exists with the target variable. This is particularly
+    useful in Model Risk Management for understanding the relevance of features and identifying potential biases in a
+    classification model.
+
+    ### Test Mechanism
+
+    The function creates a contingency table for each categorical feature and the target variable, then applies the
+    Chi-Squared test to compute the Chi-squared statistic and the p-value. The results for each feature include the
+    variable name, Chi-squared statistic, p-value, p-value threshold, and a pass/fail status based on whether the
+    p-value is below the specified threshold. The output is a DataFrame summarizing these results, sorted by p-value to
+    highlight the most statistically significant associations.
+
+    ### Signs of High Risk
+
+    - High p-values (greater than the set threshold) indicate a lack of significant association between a feature and
+    the target variable, resulting in a 'Fail' status.
+    - Features with a 'Fail' status might not be relevant for the model, which could negatively impact model
+    performance.
+
+    ### Strengths
+
+    - Provides a clear, statistical assessment of the relationship between categorical features and the target variable.
+    - Produces an easily interpretable summary with a 'Pass/Fail' outcome for each feature, helping in feature
+    selection.
+    - The p-value threshold is adjustable, allowing for flexibility in statistical rigor.
+
+    ### Limitations
+
+    - Assumes the dataset is tabular and consists of categorical variables, which may not be suitable for all datasets.
+    - The test is designed for classification tasks and is not applicable to regression problems.
+    - As with all hypothesis tests, the Chi-Squared test can only detect associations, not causal relationships.
+    - The choice of p-value threshold can affect the interpretation of feature relevance, and different thresholds may
+    lead to different conclusions.
     """
 
-    name = "chi_squared_features_table"
-    required_inputs = ["dataset"]
-    default_params = {"cat_features": None, "p_threshold": 0.05}
-    tasks = ["classification"]
-    tags = [
-        "tabular_data",
-        "categorical_data",
-        "statistical_test",
-        "binary_classification",
-        "multiclass_classification",
-    ]
-
-    def run(self):
-        target_column = self.inputs.dataset.target_column
-        cat_features = self.params["cat_features"]
-        p_threshold = self.params["p_threshold"]
-
-        # Ensure cat_features is provided
-        if not cat_features:
-            cat_features = self.inputs.dataset.feature_columns_categorical
-
-        df = self.inputs.dataset.df
-
-        chi_squared_results = self.chi_squared_categorical_feature_selection(
-            df, cat_features, target_column, p_threshold
-        )
+    target_column = dataset.target_column
 
-        return self.cache_results(
-            {
-                "chi_squared_results": chi_squared_results.to_dict(orient="records"),
-            }
-        )
+    features = dataset.feature_columns_categorical
+
+    results_df = _chi_squared_categorical_feature_selection(
+        dataset.df, features, target_column, p_threshold
+    )
+
+    return results_df
 
-    def chi_squared_categorical_feature_selection(
-        self, df, cat_features, target, p_threshold
-    ):
-        # Ensure the columns exist in the dataframe
-        for var in cat_features:
-            if var not in df.columns:
-                raise ValueError(f"The column '{var}' does not exist in the dataframe.")
-        if target not in df.columns:
-            raise ValueError(
-                f"The target column '{target}' does not exist in the dataframe."
-            )
-
-        results = []
-
-        for var in cat_features:
-            # Create a contingency table
-            contingency_table = pd.crosstab(df[var], df[target])
-
-            # Perform the Chi-Square test
-            chi2, p, _, _ = chi2_contingency(contingency_table)
-
-            # Add the result to the list of results
-            results.append(
-                [var, chi2, p, p_threshold, "Pass" if p <= p_threshold else "Fail"]
-            )
-
-        # Convert results to a DataFrame and return
-        results_df = pd.DataFrame(
-            results,
-            columns=[
-                "Variable",
-                "Chi-squared statistic",
-                "p-value",
-                "Threshold",
-                "Pass/Fail",
-            ],
-        )
 
-        # Sort by p-value in ascending order
-        results_df = results_df.sort_values(by="p-value")
-
-        return results_df
-
-    def summary(self, metric_value):
-        chi_squared_results_table = metric_value["chi_squared_results"]
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=chi_squared_results_table,
-                    metadata=ResultTableMetadata(
-                        title="Chi-Squared Test Results for Categorical Features"
-                    ),
-                )
-            ]
+def _chi_squared_categorical_feature_selection(df, features, target, p_threshold):
+
+    results = []
+
+    for var in features:
+        # Create a contingency table
+        contingency_table = pd.crosstab(df[var], df[target])
+
+        # Perform the Chi-Square test
+        chi2, p, _, _ = chi2_contingency(contingency_table)
+
+        # Add the result to the list of results
+        results.append(
+            [var, chi2, p, p_threshold, "Pass" if p <= p_threshold else "Fail"]
         )
+
+    # Convert results to a DataFrame and return
+    results_df = pd.DataFrame(
+        results,
+        columns=[
+            "Variable",
+            "Chi-squared statistic",
+            "p-value",
+            "Threshold",
+            "Pass/Fail",
+        ],
+    )
+
+    # Sort by p-value in ascending order
+    results_df = results_df.sort_values(by="p-value")
+
+    return results_df

validmind/tests/data_validation/ClassImbalance.py

@@ -28,17 +28,20 @@ class ClassImbalance(ThresholdTest):
     """
     Evaluates and quantifies class distribution imbalance in a dataset used by a machine learning model.
 
-    **Purpose**: The ClassImbalance test is designed to evaluate the distribution of target classes in a dataset that's
-    utilized by a machine learning model. Specifically, it aims to ensure that the classes aren't overly skewed, which
-    could lead to bias in the model's predictions. It's crucial to have a balanced training dataset to avoid creating a
-    model that's biased with high accuracy for the majority class and low accuracy for the minority class.
+    ### Purpose
 
-    **Test Mechanism**: This ClassImbalance test operates by calculating the frequency (expressed as a percentage) of
-    each class in the target column of the dataset. It then checks whether each class appears in at least a set minimum
-    percentage of the total records. This minimum percentage is a modifiable parameter, but the default value is set to
-    10%.
+    The Class Imbalance test is designed to evaluate the distribution of target classes in a dataset that's utilized by
+    a machine learning model. Specifically, it aims to ensure that the classes aren't overly skewed, which could lead
+    to bias in the model's predictions. It's crucial to have a balanced training dataset to avoid creating a model
+    that's biased with high accuracy for the majority class and low accuracy for the minority class.
 
-    **Signs of High Risk**:
+    ### Test Mechanism
+
+    This Class Imbalance test operates by calculating the frequency (expressed as a percentage) of each class in the
+    target column of the dataset. It then checks whether each class appears in at least a set minimum percentage of the
+    total records. This minimum percentage is a modifiable parameter, but the default value is set to 10%.
+
+    ### Signs of High Risk
 
     - Any class that represents less than the pre-set minimum percentage threshold is marked as high risk, implying a
     potential class imbalance.
@@ -46,7 +49,7 @@ class ClassImbalance(ThresholdTest):
     - Fundamentally, if any class fails this test, it's highly likely that the dataset possesses imbalanced class
     distribution.
 
-    **Strengths**:
+    ### Strengths
 
     - The test can spot under-represented classes that could affect the efficiency of a machine learning model.
     - The calculation is straightforward and swift.
@@ -56,7 +59,7 @@ class ClassImbalance(ThresholdTest):
     - The test creates a visually insightful plot showing the classes and their corresponding proportions, enhancing
     interpretability and comprehension of the data.
 
-    **Limitations**:
+    ### Limitations
 
     - The test might struggle to perform well or provide vital insights for datasets with a high number of classes. In
     such cases, the imbalance could be inevitable due to the inherent class distribution.
@@ -66,7 +69,7 @@ class ClassImbalance(ThresholdTest):
     different classes, which might fluctuate based on specific applications or domains.
     - While it can identify imbalances in class distribution, it doesn't provide direct methods to address or correct
     these imbalances.
-    - The test is only applicable for classification opearations and unsuitable for regression or clustering tasks.
+    - The test is only applicable for classification operations and unsuitable for regression or clustering tasks.
     """
 
     # Changing the name test to avoid a name clash

validmind/tests/data_validation/DFGLSArch.py

@@ -17,32 +17,38 @@ logger = get_logger(__name__)
 @dataclass
 class DFGLSArch(Metric):
     """
-    Executes Dickey-Fuller GLS metric to determine order of integration and check stationarity in time series data.
+    Assesses stationarity in time series data using the Dickey-Fuller GLS test to determine the order of integration.
 
-    **Purpose**: The Dickey-Fuller GLS (DFGLS) Arch metric is utilized to determine the order of integration in time
-    series data. For machine learning models dealing with time series and forecasting, this metric evaluates the
-    existence of a unit root, thereby checking whether a time series is non-stationary. This analysis is a crucial
-    initial step when dealing with time series data.
+    ### Purpose
 
-    **Test Mechanism**: This code implements the Dickey-Fuller GLS unit root test on each attribute of the dataset.
-    This process involves iterating through every column of the dataset and applying the DFGLS test to assess the
-    presence of a unit root. The resulting information, including the test statistic ('stat'), the p-value ('pvalue'),
-    the quantity of lagged differences utilized in the regression ('usedlag'), and the number of observations ('nobs'),
-    is subsequently stored.
+    The Dickey-Fuller GLS (DFGLS) test is utilized to determine the order of integration in time series data. For
+    machine learning models dealing with time series and forecasting, this metric evaluates the existence of a unit
+    root, thereby checking whether a time series is non-stationary. This analysis is a crucial initial step when
+    dealing with time series data.
+
+    ### Test Mechanism
+
+    This code implements the Dickey-Fuller GLS unit root test on each attribute of the dataset. This process involves
+    iterating through every column of the dataset and applying the DFGLS test to assess the presence of a unit root.
+    The resulting information, including the test statistic ('stat'), the p-value ('pvalue'), the quantity of lagged
+    differences utilized in the regression ('usedlag'), and the number of observations ('nobs'), is subsequently stored.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A high p-value for the DFGLS test represents a high risk. Specifically, a p-value above a typical threshold of
     0.05 suggests that the time series data is quite likely to be non-stationary, thus presenting a high risk for
     generating unreliable forecasts.
 
-    **Strengths**:
+    ### Strengths
+
     - The Dickey-Fuller GLS test is a potent tool for checking the stationarity of time series data.
     - It helps to verify the assumptions of the models before the actual construction of the machine learning models
     proceeds.
     - The results produced by this metric offer a clear insight into whether the data is appropriate for specific
     machine learning models, especially those demanding the stationarity of time series data.
 
-    **Limitations**:
+    ### Limitations
+
     - Despite its benefits, the DFGLS test does present some drawbacks. It can potentially lead to inaccurate
     conclusions if the time series data incorporates a structural break.
     - If the time series tends to follow a trend while still being stationary, the test might misinterpret it,

validmind/tests/data_validation/DatasetDescription.py

@@ -25,42 +25,48 @@ class DatasetDescription(Metric):
     """
     Provides comprehensive analysis and statistical summaries of each field in a machine learning model's dataset.
 
-    **Purpose:**
+    ### Purpose
+
     The test depicted in the script is meant to run a comprehensive analysis on a Machine Learning model's datasets.
     The test or metric is implemented to obtain a complete summary of the fields in the dataset, including vital
     statistics of each field such as count, distinct values, missing values, histograms for numerical, categorical,
     boolean, and text fields. This summary gives a comprehensive overview of the dataset to better understand the
     characteristics of the data that the model is trained on or evaluates.
 
-    **Test Mechanism:**
+    ### Test Mechanism
+
     The DatasetDescription class accomplishes the purpose as follows: firstly, the test method "run" infers the data
-    type of each column in the dataset and stores the details (id, column type). For each field,
+    type of each column in the dataset and stores the details (id, column type). For each field, the
     "describe_dataset_field" method is invoked to collect statistical information about the field, including count,
     missing value count and its proportion to the total, unique value count, and its proportion to the total. Depending
     on the data type of a field, histograms are generated that reflect the distribution of data within the field.
-    Numerical fields use "get_numerical_histograms" method to calculate histogram distribution, whereas for
+    Numerical fields use the "get_numerical_histograms" method to calculate histogram distribution, whereas for
     categorical, boolean and text fields, a histogram is computed with frequencies of each unique value in the
     datasets. For unsupported types, an error is raised. Lastly, a summary table is built to aggregate all the
     statistical insights and histograms of the fields in a dataset.
 
-    **Signs of High Risk:**
-    - High ratio of missing values to total values in one or more fields which may impact quality of the predictions.
+    ### Signs of High Risk
+
+    - High ratio of missing values to total values in one or more fields which may impact the quality of the
+    predictions.
     - Unsupported data types in dataset fields.
     - Large number of unique values in the dataset's fields which might make it harder for the model to establish
     patterns.
     - Extreme skewness or irregular distribution of data as reflected in the histograms.
 
-    **Strengths:**
-    - Provides a detailed analysis of the dataset with versatile summaries like count, unique values, histograms etc.
+    ### Strengths
+
+    - Provides a detailed analysis of the dataset with versatile summaries like count, unique values, histograms, etc.
     - Flexibility in handling different types of data: numerical, categorical, boolean, and text.
     - Useful in detecting problems in the dataset like missing values, unsupported data types, irregular data
-    distribution etc.
+    distribution, etc.
     - The summary gives a comprehensive understanding of dataset features allowing developers to make informed
     decisions.
 
-    **Limitations:**
+    ### Limitations
+
     - The computation can be expensive from a resource standpoint, particularly for large datasets with numerous fields.
-    - The histograms use arbitrary number of bins which may not be the optimal number of bins for specific data
+    - The histograms use an arbitrary number of bins which may not be the optimal number of bins for specific data
     distribution.
     - Unsupported data types for columns will raise an error which may limit evaluating the dataset.
     - Fields with all null or missing values are not included in histogram computation.

validmind/tests/data_validation/DatasetSplit.py

@@ -10,26 +10,28 @@ class DatasetSplit(Metric):
     Evaluates and visualizes the distribution proportions among training, testing, and validation datasets of an ML
     model.
 
-    **Purpose:**
+    ### Purpose
+
     The DatasetSplit test is designed to evaluate and visualize the distribution of data among training, testing, and
     validation datasets, if available, within a given machine learning model. The main purpose is to assess whether the
     model's datasets are split appropriately, as an imbalanced split might affect the model's ability to learn from the
     data and generalize to unseen data.
 
-    **Test Mechanism:**
+    ### Test Mechanism
+
     The DatasetSplit test first calculates the total size of all available datasets in the model. Then, for each
     individual dataset, the methodology involves determining the size of the dataset and its proportion relative to the
     total size. The results are then conveniently summarized in a table that shows dataset names, sizes, and
     proportions. Absolute size and proportion of the total dataset size are displayed for each individual dataset.
 
-    **Signs of High Risk:**
+    ### Signs of High Risk
 
     - A very small training dataset, which may result in the model not learning enough from the data.
     - A very large training dataset and a small test dataset, which may lead to model overfitting and poor
     generalization to unseen data.
     - A small or non-existent validation dataset, which might complicate the model's performance assessment.
 
-    **Strengths:**
+    ### Strengths
 
     - The DatasetSplit test provides a clear, understandable visualization of dataset split proportions, which can
     highlight any potential imbalance in dataset splits quickly.
@@ -37,7 +39,7 @@ class DatasetSplit(Metric):
     - The metric is not tied to any specific data type and is applicable to tabular data, time series data, or text
     data.
 
-    **Limitations:**
+    ### Limitations
 
     - The DatasetSplit test does not provide any insight into the quality or diversity of the data within each split,
     just the size and proportion.