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

validmind/tests/{model_validation/statsmodels → data_validation}/ShapiroWilk.py

@@ -2,38 +2,48 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
+import pandas as pd
 from scipy import stats
 
-from validmind.vm_models import Metric
+from validmind import tags, tasks
 
 
-class ShapiroWilk(Metric):
+@tasks("classification", "regression")
+@tags("tabular_data", "data_distribution", "statistical_test")
+def ShapiroWilk(dataset):
     """
     Evaluates feature-wise normality of training data using the Shapiro-Wilk test.
 
-    **Purpose**: The Shapiro-Wilk test is utilized to investigate whether a particular dataset conforms to the standard
-    normal distribution. This analysis is crucial in machine learning modeling because the normality of the data can
+    ### Purpose
+
+    The Shapiro-Wilk test is utilized to investigate whether a particular dataset conforms to the standard normal
+    distribution. This analysis is crucial in machine learning modeling because the normality of the data can
     profoundly impact the performance of the model. This metric is especially useful in evaluating various features of
     the dataset in both classification and regression tasks.
 
-    **Test Mechanism**: The Shapiro-Wilk test is conducted on each feature column of the training dataset to determine
-    if the data contained fall within the normal distribution. The test presents a statistic and a p-value, with the
-    p-value serving to validate or repudiate the null hypothesis, which is that the tested data is normally distributed.
+    ### Test Mechanism
+
+    The Shapiro-Wilk test is conducted on each feature column of the training dataset to determine if the data
+    contained fall within the normal distribution. The test presents a statistic and a p-value, with the p-value
+    serving to validate or repudiate the null hypothesis, which is that the tested data is normally distributed.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A p-value that falls below 0.05 signifies a high risk as it discards the null hypothesis, indicating that the
     data does not adhere to the normal distribution.
     - For machine learning models built on the presumption of data normality, such an outcome could result in subpar
     performance or incorrect predictions.
 
-    **Strengths**:
+    ### Strengths
+
     - The Shapiro-Wilk test is esteemed for its level of accuracy, thereby making it particularly well-suited to
     datasets of small to moderate sizes.
     - It proves its versatility through its efficient functioning in both classification and regression tasks.
     - By separately testing each feature column, the Shapiro-Wilk test can raise an alarm if a specific feature does
     not comply with the normality.
 
-    **Limitations**:
+    ### Limitations
+
     - The Shapiro-Wilk test's sensitivity can be a disadvantage as it often rejects the null hypothesis (i.e., data is
     normally distributed), even for minor deviations, especially in large datasets. This may lead to unwarranted 'false
     alarms' of high risk by deeming the data as not normally distributed even if it approximates normal distribution.
@@ -42,23 +52,18 @@ class ShapiroWilk(Metric):
     - Lastly, the Shapiro-Wilk test is not optimally suited for processing data with pronounced skewness or kurtosis.
     """
 
-    name = "shapiro_wilk"
-    required_inputs = ["dataset"]
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "data_distribution", "statistical_test"]
-
-    def run(self):
-        """
-        Calculates Shapiro-Wilk test for each of the dataset features.
-        """
-        x_train = self.inputs.dataset.df[self.inputs.dataset.feature_columns_numeric]
-        sw_values = {}
-        for col in x_train.columns:
-            sw_stat, sw_pvalue = stats.shapiro(x_train[col].values)
-
-            sw_values[col] = {
-                "stat": sw_stat,
-                "pvalue": sw_pvalue,
-            }
-
-        return self.cache_results(sw_values)
+    df = dataset.df[dataset.feature_columns_numeric]
+
+    sw_values = {}
+    for col in df.columns:
+        sw_stat, sw_pvalue = stats.shapiro(df[col].values)
+        sw_values[col] = {
+            "stat": sw_stat,
+            "pvalue": sw_pvalue,
+        }
+
+    sw_df = pd.DataFrame.from_dict(sw_values, orient="index")
+    sw_df.reset_index(inplace=True)
+    sw_df.columns = ["column", "stat", "pvalue"]
+
+    return sw_df

validmind/tests/data_validation/Skewness.py

@@ -20,43 +20,41 @@ from validmind.vm_models import (
 @dataclass
 class Skewness(ThresholdTest):
     """
-    Evaluates the skewness of numerical data in a machine learning model and checks if it falls below a set maximum
-    threshold.
-
-    **Purpose**: The purpose of the Skewness test is to measure the asymmetry in the distribution of data within a
-    predictive machine learning model. Specifically, it evaluates the divergence of said distribution from a normal
-    distribution. In understanding the level of skewness, we can potentially identify issues with data quality, an
-    essential component for optimizing the performance of traditional machine learning models in both classification
-    and regression settings.
-
-    **Test Mechanism**: This test calculates skewness of numerical columns in a dataset, which is extracted from the
-    DataFrame, specifically focusing on numerical data types. The skewness value is then contrasted against a
-    predetermined maximum threshold, set by default to 1. The skewness value under review is deemed to have passed the
-    test only if it is less than this maximum threshold; otherwise, the test is considered 'fail'. Subsequently, the
-    test results of each column, together with the skewness value and column name, are cached.
-
-    **Signs of High Risk**:
-
-    - The presence of substantial skewness levels that significantly exceed the maximum threshold is an indication of
-    skewed data distribution and subsequently high model risk.
-    - Persistent skewness in data could signify that the foundational assumptions of the machine learning model may not
-    be applicable, potentially leading to subpar model performance, erroneous predictions, or biased inferences.
-
-    **Strengths**:
-
-    - Fast and efficient identification of unequal data
-    - distributions within a machine learning model is enabled by the skewness test.
-    - The maximum threshold parameter can be adjusted to meet the user's specific needs, enhancing the test's
-    versatility.
-
-    **Limitations**:
-
-    - The test only evaluates numeric columns, which means that data in non-numeric columns could still include bias or
-    problematic skewness that this test does not capture.
-    - The test inherently assumes that the data should follow a normal distribution, an expectation which may not
-    always be met in real-world data.
-    - The risk grading is largely dependent on a subjective threshold, which may result in excessive strictness or
-    leniency depending upon selection. This factor might require expert input and recurrent iterations for refinement.
+    Evaluates the skewness of numerical data in a dataset to check against a defined threshold, aiming to ensure data
+    quality and optimize model performance.
+
+    ### Purpose
+
+    The purpose of the Skewness test is to measure the asymmetry in the distribution of data within a predictive
+    machine learning model. Specifically, it evaluates the divergence of said distribution from a normal distribution.
+    Understanding the level of skewness helps identify data quality issues, which are crucial for optimizing the
+    performance of traditional machine learning models in both classification and regression settings.
+
+    ### Test Mechanism
+
+    This test calculates the skewness of numerical columns in the dataset, focusing specifically on numerical data
+    types. The calculated skewness value is then compared against a predetermined maximum threshold, which is set by
+    default to 1. If the skewness value is less than this maximum threshold, the test passes; otherwise, it fails. The
+    test results, along with the skewness values and column names, are then recorded for further analysis.
+
+    ### Signs of High Risk
+
+    - Substantial skewness levels that significantly exceed the maximum threshold.
+    - Persistent skewness in the data, indicating potential issues with the foundational assumptions of the machine
+    learning model.
+    - Subpar model performance, erroneous predictions, or biased inferences due to skewed data distributions.
+
+    ### Strengths
+
+    - Fast and efficient identification of unequal data distributions within a machine learning model.
+    - Adjustable maximum threshold parameter, allowing for customization based on user needs.
+    - Provides a clear quantitative measure to mitigate model risks related to data skewness.
+
+    ### Limitations
+
+    - Only evaluates numeric columns, potentially missing skewness or bias in non-numeric data.
+    - Assumes that data should follow a normal distribution, which may not always be applicable to real-world data.
+    - Subjective threshold for risk grading, requiring expert input and recurrent iterations for refinement.
     """
 
     name = "skewness"

validmind/tests/data_validation/SpreadPlot.py

@@ -10,46 +10,46 @@ from validmind.vm_models import Figure, Metric
 
 class SpreadPlot(Metric):
     """
-    Visualizes the spread relationship between pairs of time-series variables in a dataset, thereby aiding in
-    identification of potential correlations.
+    Assesses potential correlations between pairs of time series variables through visualization to enhance
+    understanding of their relationships.
 
-    **Purpose**:
-    The SpreadPlot metric is intended to graphically illustrate and analyse the relationships between pairs of time
-    series variables within a given dataset. This facilitated understanding helps in identifying and assessing
-    potential time series correlations, like cointegration, between the variables.
+    ### Purpose
 
-    **Test Mechanism**:
-    The SpreadPlot metric operates by computing and representing the spread between each pair of time series variables
-    in the dataset. In particular, the difference between two variables is calculated and presented as a line graph.
-    This method is iterated for each unique pair of variables in the dataset.
+    The SpreadPlot test aims to graphically illustrate and analyze the relationships between pairs of time series
+    variables within a given dataset. This facilitated understanding helps in identifying and assessing potential time
+    series correlations, such as cointegration, between the variables.
 
-    **Signs of High Risk**:
-    Potential indicators of high risk related to the SpreadPlot metric might include:
+    ### Test Mechanism
 
-    - Large fluctuations in the spread over a given timespan
-    - Unexpected patterns or trends that may signal a potential risk in the underlying correlations between the
-    variables
+    The SpreadPlot test computes and represents the spread between each pair of time series variables in the dataset.
+    Specifically, the difference between two variables is calculated and presented as a line graph. This process is
+    iterated for each unique pair of variables in the dataset, allowing for comprehensive visualization of their
+    relationships.
+
+    ### Signs of High Risk
+
+    - Large fluctuations in the spread over a given timespan.
+    - Unexpected patterns or trends that may signal potential risks in the underlying correlations between the
+    variables.
     - Presence of significant missing data or extreme outlier values, which could potentially skew the spread and
-    indicate high risk
-
-    **Strengths**:
-    The SpreadPlot metric provides several key advantages:
-
-    - It allows for thorough visual examination and interpretation of the correlations between time-series pairs
-    - It aids in revealing complex relationships like cointegration
-    - It enhances interpretability by visualising the relationships, thereby helping in spotting outliers and trends
-    - It is capable of handling numerous variable pairs from the dataset through a versatile and adaptable process
-
-    **Limitations**:
-    Despite its advantages, the SpreadPlot metric does have certain drawbacks:
-
-    - It primarily serves as a visualisation tool and does not offer quantitative measurements or statistics to
-    objectively determine relationships
-    - It heavily relies on the quality and granularity of the data - missing data or outliers can notably disturb the
-    interpretation of the relationships
-    - It can become inefficient or difficult to interpret with a high number of variables due to the profuse number of
-    plots
-    - It might not completely capture intricate non-linear relationships between the variables
+    indicate high risk.
+
+    ### Strengths
+
+    - Allows for thorough visual examination and interpretation of the correlations between time-series pairs.
+    - Aids in revealing complex relationships like cointegration.
+    - Enhances interpretability by visualizing the relationships, thereby helping in spotting outliers and trends.
+    - Capable of handling numerous variable pairs from the dataset through a versatile and adaptable process.
+
+    ### Limitations
+
+    - Primarily serves as a visualization tool and does not offer quantitative measurements or statistics to
+    objectively determine relationships.
+    - Heavily relies on the quality and granularity of the data—missing data or outliers can notably disturb the
+    interpretation of relationships.
+    - Can become inefficient or difficult to interpret with a high number of variables due to the profuse number of
+    plots.
+    - Might not completely capture intricate non-linear relationships between the variables.
     """
 
     name = "spread_plot"

validmind/tests/data_validation/TabularCategoricalBarPlots.py

@@ -10,17 +10,21 @@ from validmind.vm_models import Figure, Metric
 
 class TabularCategoricalBarPlots(Metric):
     """
-    Generates and visualizes bar plots for each category in categorical features to evaluate dataset's composition.
+    Generates and visualizes bar plots for each category in categorical features to evaluate the dataset's composition.
 
-    **Purpose**: The purpose of this metric is to visually analyze categorical data using bar plots. It is intended to
-    evaluate the dataset's composition by displaying the counts of each category in each categorical feature.
+    ### Purpose
 
-    **Test Mechanism**: The provided dataset is first checked to determine if it contains any categorical variables. If
-    no categorical columns are found, the tool raises a ValueError. For each categorical variable in the dataset, a
-    separate bar plot is generated. The number of occurrences for each category is calculated and displayed on the
-    plot. If a dataset contains multiple categorical columns, multiple bar plots are produced.
+    The purpose of this metric is to visually analyze categorical data using bar plots. It is intended to evaluate the
+    dataset's composition by displaying the counts of each category in each categorical feature.
 
-    **Signs of High Risk**:
+    ### Test Mechanism
+
+    The provided dataset is first checked to determine if it contains any categorical variables. If no categorical
+    columns are found, the tool raises a ValueError. For each categorical variable in the dataset, a separate bar plot
+    is generated. The number of occurrences for each category is calculated and displayed on the plot. If a dataset
+    contains multiple categorical columns, multiple bar plots are produced.
+
+    ### Signs of High Risk
 
     - High risk could occur if the categorical variables exhibit an extreme imbalance, with categories having very few
     instances possibly being underrepresented in the model, which could affect the model's performance and its ability
@@ -28,17 +32,19 @@ class TabularCategoricalBarPlots(Metric):
     - Another sign of risk is if there are too many categories in a single variable, which could lead to overfitting
     and make the model complex.
 
-    **Strengths**: This metric provides a visual and intuitively understandable representation of categorical data,
-    which aids in the analysis of variable distributions. By presenting model inputs in this way, we can easily
-    identify imbalances or rare categories that could affect the model's performance.
+    ### Strengths
+
+    - Provides a visual and intuitively understandable representation of categorical data.
+    - Aids in the analysis of variable distributions.
+    - Helps in easily identifying imbalances or rare categories that could affect the model's performance.
 
-    **Limitations**:
+    ### Limitations
 
-    - This method only works with categorical data, meaning it won't apply to numerical variables.
-    - In addition, the method does not provide any informative value when there are too many categories, as the bar
-    chart could become cluttered and hard to interpret.
-    - It offers no insights into the model's performance or precision, but rather provides a descriptive analysis of
-    the input.
+    - This method only works with categorical data and won't apply to numerical variables.
+    - It does not provide informative value when there are too many categories, as the bar chart could become cluttered
+    and hard to interpret.
+    - Offers no insights into the model's performance or precision, but rather provides a descriptive analysis of the
+    input.
     """
 
     name = "tabular_categorical_bar_plots"

validmind/tests/data_validation/TabularDateTimeHistograms.py

@@ -10,26 +10,33 @@ from validmind.vm_models import Figure, Metric
 
 class TabularDateTimeHistograms(Metric):
     """
-    Generates histograms to provide graphical insight into the distribution of time intervals in model's datetime data.
+    Generates histograms to provide graphical insight into the distribution of time intervals in a model's datetime
+    data.
 
-    **Purpose**: The `TabularDateTimeHistograms` metric is designed to provide graphical insight into the distribution
-    of time intervals in a machine learning model's datetime data. By plotting histograms of differences between
-    consecutive date entries in all datetime variables, it enables an examination of the underlying pattern of time
-    series data and identification of anomalies.
+    ### Purpose
 
-    **Test Mechanism**: This test operates by first identifying all datetime columns and extracting them from the
-    dataset. For each datetime column, it next computes the differences (in days) between consecutive dates, excluding
-    zero values, and visualizes these differences in a histogram. The seaborn library's histplot function is used to
-    generate histograms, which are labeled appropriately and provide a graphical representation of the frequency of
-    different day intervals in the dataset.
+    The `TabularDateTimeHistograms` metric is designed to provide graphical insight into the distribution of time
+    intervals in a machine learning model's datetime data. By plotting histograms of differences between consecutive
+    date entries in all datetime variables, it enables an examination of the underlying pattern of time series data and
+    identification of anomalies.
+
+    ### Test Mechanism
+
+    This test operates by first identifying all datetime columns and extracting them from the dataset. For each
+    datetime column, it next computes the differences (in days) between consecutive dates, excluding zero values, and
+    visualizes these differences in a histogram. The Plotly library's histogram function is used to generate
+    histograms, which are labeled appropriately and provide a graphical representation of the frequency of different
+    day intervals in the dataset.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - If no datetime columns are detected in the dataset, this would lead to a ValueError. Hence, the absence of
     datetime columns signifies a high risk.
     - A severely skewed or irregular distribution depicted in the histogram may indicate possible complications with
     the data, such as faulty timestamps or abnormalities.
 
-    **Strengths**:
+    ### Strengths
+
     - The metric offers a visual overview of time interval frequencies within the dataset, supporting the recognition
     of inherent patterns.
     - Histogram plots can aid in the detection of potential outliers and data anomalies, contributing to an assessment
@@ -37,7 +44,8 @@ class TabularDateTimeHistograms(Metric):
     - The metric is versatile, compatible with a range of task types, including classification and regression, and can
     work with multiple datetime variables if present.
 
-    **Limitations**:
+    ### Limitations
+
     - A major weakness of this metric is its dependence on the visual examination of data, as it does not provide a
     measurable evaluation of the model.
     - The metric might overlook complex or multi-dimensional trends in the data.

validmind/tests/data_validation/TabularDescriptionTables.py

@@ -13,14 +13,17 @@ def TabularDescriptionTables(dataset):
     """
     Summarizes key descriptive statistics for numerical, categorical, and datetime variables in a dataset.
 
-    **Purpose**: The main purpose of this metric is to gather and present the descriptive statistics of numerical,
-    categorical, and datetime variables present in a dataset. The attributes it measures include the count, mean,
-    minimum and maximum values, percentage of missing values, data types of fields, and unique values for categorical
-    fields, among others.
+    ### Purpose
 
-    **Test Mechanism**: The test first segregates the variables in the dataset according to their data types
-    (numerical, categorical, or datetime). Then, it compiles summary statistics for each type of variable. The
-    specifics of these statistics vary depending on the type of variable:
+    The main purpose of this metric is to gather and present the descriptive statistics of numerical, categorical, and
+    datetime variables present in a dataset. The attributes it measures include the count, mean, minimum and maximum
+    values, percentage of missing values, data types of fields, and unique values for categorical fields, among others.
+
+    ### Test Mechanism
+
+    The test first segregates the variables in the dataset according to their data types (numerical, categorical, or
+    datetime). Then, it compiles summary statistics for each type of variable. The specifics of these statistics vary
+    depending on the type of variable:
 
     - For numerical variables, the metric extracts descriptors like count, mean, minimum and maximum values, count of
     missing values, and data types.
@@ -29,14 +32,16 @@ def TabularDescriptionTables(dataset):
     - For datetime variables, it counts the number of unique values, identifies the earliest and latest dates, counts
     missing values, and identifies data types.
 
-    **Signs of High Risk**:
+    ### Signs of High Risk
+
     - Masses of missing values in the descriptive statistics results could hint at high risk or failure, indicating
     potential data collection, integrity, and quality issues.
     - Detection of inappropriate distributions for numerical variables, like having negative values for variables that
     are always supposed to be positive.
     - Identifying inappropriate data types, like a continuous variable being encoded as a categorical type.
 
-    **Strengths**:
+    ### Strengths
+
     - Provides a comprehensive overview of the dataset.
     - Gives a snapshot into the essence of the numerical, categorical, and datetime fields.
     - Identifies potential data quality issues such as missing values or inconsistencies crucial for building credible
@@ -44,7 +49,8 @@ def TabularDescriptionTables(dataset):
     - The metadata, including the data type and missing value information, are vital for anyone including data
     scientists dealing with the dataset before the modeling process.
 
-    **Limitations**:
+    ### Limitations
+
     - It does not perform any deeper statistical analysis or tests on the data.
     - It does not handle issues such as outliers, or relationships between variables.
     - It offers no insights into potential correlations or possible interactions between variables.
@@ -57,15 +63,44 @@ def TabularDescriptionTables(dataset):
     categorical_fields = get_categorical_columns(dataset)
     datetime_fields = get_datetime_columns(dataset)
 
-    summary_stats_numerical = get_summary_statistics_numerical(
-        dataset, numerical_fields
+    summary_stats_numerical = (
+        get_summary_statistics_numerical(dataset, numerical_fields)
+        if numerical_fields
+        else pd.DataFrame()
+    )
+    summary_stats_categorical = (
+        get_summary_statistics_categorical(dataset, categorical_fields)
+        if categorical_fields
+        else pd.DataFrame()
+    )
+    summary_stats_datetime = (
+        get_summary_statistics_datetime(dataset, datetime_fields)
+        if datetime_fields
+        else pd.DataFrame()
+    )
+
+    # Replace empty DataFrames with None
+    summary_stats_numerical = (
+        summary_stats_numerical if not summary_stats_numerical.empty else None
     )
-    summary_stats_categorical = get_summary_statistics_categorical(
-        dataset, categorical_fields
+    summary_stats_categorical = (
+        summary_stats_categorical if not summary_stats_categorical.empty else None
+    )
+    summary_stats_datetime = (
+        summary_stats_datetime if not summary_stats_datetime.empty else None
     )
-    summary_stats_datetime = get_summary_statistics_datetime(dataset, datetime_fields)
 
-    return (summary_stats_numerical, summary_stats_categorical, summary_stats_datetime)
+    # Return a tuple with only non-None values (tables with data)
+    return tuple(
+        filter(
+            lambda x: x is not None,
+            (
+                summary_stats_numerical,
+                summary_stats_categorical,
+                summary_stats_datetime,
+            ),
+        )
+    )
 
 
 def get_summary_statistics_numerical(dataset, numerical_fields):

validmind/tests/data_validation/TabularNumericalHistograms.py

@@ -13,39 +13,42 @@ class TabularNumericalHistograms(Metric):
     Generates histograms for each numerical feature in a dataset to provide visual insights into data distribution and
     detect potential issues.
 
-    **Purpose**: The purpose of this test is to provide visual analysis of numerical data through the generation of
-    histograms for each numerical feature in the dataset. Histograms aid in the exploratory analysis of data, offering
-    insight into the distribution of the data, skewness, presence of outliers, and central tendencies. It helps in
-    understanding if the inputs to the model are normally distributed which is a common assumption in many machine
-    learning algorithms.
+    ### Purpose
 
-    **Test Mechanism**: This test scans the provided dataset and extracts all the numerical columns. For each numerical
-    column, it constructs a histogram using plotly, with 50 bins. The deployment of histograms offers a robust visual
-    aid, ensuring unruffled identification and understanding of numerical data distribution patterns.
+    The purpose of this test is to provide visual analysis of numerical data through the generation of histograms for
+    each numerical feature in the dataset. Histograms aid in the exploratory analysis of data, offering insight into
+    the distribution of the data, skewness, presence of outliers, and central tendencies. It helps in understanding if
+    the inputs to the model are normally distributed, which is a common assumption in many machine learning algorithms.
 
-    **Signs of High Risk**:
+    ### Test Mechanism
+
+    This test scans the provided dataset and extracts all the numerical columns. For each numerical column, it
+    constructs a histogram using plotly, with 50 bins. The deployment of histograms offers a robust visual aid,
+    ensuring unruffled identification and understanding of numerical data distribution patterns.
+
+    ### Signs of High Risk
 
     - A high degree of skewness
     - Unexpected data distributions
     - Existence of extreme outliers in the histograms
+
     These may indicate issues with the data that the model is receiving. If data for a numerical feature is expected to
-    follow a certain distribution (like normal distribution) but does not, it could lead to sub-par performance by the
-    model. As such these instances should be treated as high-risk indicators.
+    follow a certain distribution (like a normal distribution) but does not, it could lead to sub-par performance by
+    the model. As such these instances should be treated as high-risk indicators.
 
-    **Strengths**:
+    ### Strengths
 
-    - This test provides a simple, easy-to-interpret visualization of how data for each numerical attribute is
-    distributed.
-    - It can help detect skewed values and outliers, that could potentially harm the AI model's performance.
-    - It can be applied to large datasets and multiple numerical variables conveniently.
+    - Provides a simple, easy-to-interpret visualization of how data for each numerical attribute is distributed.
+    - Helps detect skewed values and outliers that could potentially harm the AI model's performance.
+    - Can be applied to large datasets and multiple numerical variables conveniently.
 
-    **Limitations**:
+    ### Limitations
 
-    - This test only works with numerical data, thus ignoring non-numerical or categorical data.
-    - It does not analyze relationships between different features, only the individual feature distributions.
-    - It is a univariate analysis, and may miss patterns or anomalies that only appear when considering multiple
-    variables together.
-    - It does not provide any insight into how these features affect the output of the model; it is purely an input
+    - Only works with numerical data, thus ignoring non-numerical or categorical data.
+    - Does not analyze relationships between different features, only the individual feature distributions.
+    - Is a univariate analysis and may miss patterns or anomalies that only appear when considering multiple variables
+    together.
+    - Does not provide any insight into how these features affect the output of the model; it is purely an input
     analysis tool.
     """
 

validmind/tests/data_validation/TargetRateBarPlots.py

@@ -13,29 +13,36 @@ class TargetRateBarPlots(Metric):
     Generates bar plots visualizing the default rates of categorical features for a classification machine learning
     model.
 
-    **Purpose**: This test, implemented as a metric, is designed to provide an intuitive, graphical summary of the
-    decision-making patterns exhibited by a categorical classification machine learning model. The model's performance
-    is evaluated using bar plots depicting the ratio of target rates—meaning the proportion of positive classes—for
-    different categorical inputs. This allows for an easy, at-a-glance understanding of the model's accuracy.
-
-    **Test Mechanism**: The test involves creating a pair of bar plots for each categorical feature in the dataset. The
-    first plot depicts the frequency of each category in the dataset, with each category visually distinguished by its
-    unique color. The second plot shows the mean target rate of each category (sourced from the "default_column").
-    Plotly, a Python library, is used to generate these plots, with distinct plots created for each feature. If no
-    specific columns are selected, the test will generate plots for each categorical column in the dataset.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    This test, implemented as a metric, is designed to provide an intuitive, graphical summary of the decision-making
+    patterns exhibited by a categorical classification machine learning model. The model's performance is evaluated
+    using bar plots depicting the ratio of target rates—meaning the proportion of positive classes—for different
+    categorical inputs. This allows for an easy, at-a-glance understanding of the model's accuracy.
+
+    ### Test Mechanism
+
+    The test involves creating a pair of bar plots for each categorical feature in the dataset. The first plot depicts
+    the frequency of each category in the dataset, with each category visually distinguished by its unique color. The
+    second plot shows the mean target rate of each category (sourced from the "default_column"). Plotly, a Python
+    library, is used to generate these plots, with distinct plots created for each feature. If no specific columns are
+    selected, the test will generate plots for each categorical column in the dataset.
+
+    ### Signs of High Risk
+
     - Inconsistent or non-binary values in the "default_column" could complicate or render impossible the calculation
     of average target rates.
     - Particularly low or high target rates for a specific category might suggest that the model is misclassifying
     instances of that category.
 
-    **Strengths**:
+    ### Strengths
+
     - This test offers a visually interpretable breakdown of the model's decisions, providing an easy way to spot
     irregularities, inconsistencies, or patterns.
     - Its flexibility allows for the inspection of one or multiple columns, as needed.
 
-    **Limitations**:
+    ### Limitations
+
     - The test is less useful when dealing with numeric or continuous data, as it's designed specifically for
     categorical features.
     - If the model in question is dealing with a multi-class problem rather than binary classification, the test's