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

validmind/tests/data_validation/ChiSquaredFeaturesTable.py

@@ -2,140 +2,101 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-from dataclasses import dataclass
 
 import pandas as pd
 from scipy.stats import chi2_contingency
 
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
 
 
-@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
+    features = dataset.feature_columns_categorical
 
-        return self.cache_results(
-            {
-                "chi_squared_results": chi_squared_results.to_dict(orient="records"),
-            }
-        )
+    if not features:
+        raise SkipTestError("No categorical features found in dataset")
+
+    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.

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"