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

validmind/tests/data_validation/TimeSeriesDescription.py

@@ -11,31 +11,38 @@ from validmind import tags, tasks
 @tasks("regression")
 def TimeSeriesDescription(dataset):
     """
-    Generates a detailed analysis for the provided time series dataset.
+    Generates a detailed analysis for the provided time series dataset, summarizing key statistics to identify trends,
+    patterns, and data quality issues.
 
-    **Purpose**: The purpose of the TimeSeriesDescription function is to analyze an individual time series
-    by providing a summary of key statistics. This helps in understanding trends, patterns, and data quality issues
-    within the time series.
+    ### Purpose
 
-    **Test Mechanism**: The function extracts the time series data and provides a summary of key statistics.
-    The dataset is expected to have a datetime index. The function checks this and raises an error if the index is
-    not in datetime format. For each variable (column) in the dataset, appropriate statistics including start date,
-    end date, frequency, number of missing values, count, min, and max values are calculated.
+    The TimeSeriesDescription function aims to analyze an individual time series by providing a summary of key
+    statistics. This helps in understanding trends, patterns, and data quality issues within the time series.
+
+    ### Test Mechanism
+
+    The function extracts the time series data and provides a summary of key statistics. The dataset is expected to
+    have a datetime index. The function checks this and raises an error if the index is not in datetime format. For
+    each variable (column) in the dataset, appropriate statistics including start date, end date, frequency, number of
+    missing values, count, min, and max values are calculated.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - If the index of the dataset is not in datetime format, it could lead to errors in time-series analysis.
     - Inconsistent or missing data within the dataset might affect the analysis of trends and patterns.
 
-    **Strengths**:
-    - This function provides a comprehensive summary of key statistics for each variable, helping to identify data quality
-      issues such as missing values.
-    - The function helps in understanding the distribution and range of the data by including min and max values.
+    ### Strengths
+
+    - Provides a comprehensive summary of key statistics for each variable, helping to identify data quality issues
+    such as missing values.
+    - Helps in understanding the distribution and range of the data by including min and max values.
+
+    ### Limitations
 
-    **Limitations**:
-    - This function assumes that the dataset is provided as a DataFrameDataset object with a .df attribute to access
-      the pandas DataFrame.
-    - It only analyzes datasets with a datetime index and will raise an error for other types of indices.
-    - The function does not handle large datasets efficiently, and performance may degrade with very large datasets.
+    - Assumes that the dataset is provided as a DataFrameDataset object with a .df attribute to access the pandas
+    DataFrame.
+    - Only analyzes datasets with a datetime index and will raise an error for other types of indices.
+    - Does not handle large datasets efficiently; performance may degrade with very large datasets.
     """
 
     summary = []

validmind/tests/data_validation/TimeSeriesDescriptiveStatistics.py

@@ -12,30 +12,36 @@ from validmind import tags, tasks
 @tasks("regression")
 def TimeSeriesDescriptiveStatistics(dataset):
     """
-    Generates a detailed table of descriptive statistics for the provided time series dataset.
+    Evaluates the descriptive statistics of a time series dataset to identify trends, patterns, and data quality issues.
 
-    **Purpose**: The purpose of the TimeSeriesDescriptiveStatistics function is to analyze an individual time series
-    by providing a summary of key descriptive statistics. This helps in understanding trends, patterns, and data quality issues
-    within the time series.
+    ### Purpose
 
-    **Test Mechanism**: The function extracts the time series data and provides a summary of key descriptive statistics.
-    The dataset is expected to have a datetime index. The function checks this and raises an error if the index is
-    not in datetime format. For each variable (column) in the dataset, appropriate statistics including start date,
-    end date, min, mean, max, skewness, kurtosis, and count are calculated.
+    The purpose of the TimeSeriesDescriptiveStatistics function is to analyze an individual time series by providing a
+    summary of key descriptive statistics. This analysis helps in understanding trends, patterns, and data quality
+    issues within the time series dataset.
+
+    ### Test Mechanism
+
+    The function extracts the time series data and provides a summary of key descriptive statistics. The dataset is
+    expected to have a datetime index, and the function will check this and raise an error if the index is not in a
+    datetime format. For each variable (column) in the dataset, appropriate statistics, including start date, end date,
+    min, mean, max, skewness, kurtosis, and count, are calculated.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - If the index of the dataset is not in datetime format, it could lead to errors in time-series analysis.
     - Inconsistent or missing data within the dataset might affect the analysis of trends and patterns.
 
-    **Strengths**:
-    - This function provides a comprehensive summary of key descriptive statistics for each variable, helping to identify data quality
-      issues and understand the distribution of the data.
+    ### Strengths
+
+    - Provides a comprehensive summary of key descriptive statistics for each variable.
+    - Helps identify data quality issues and understand the distribution of the data.
+
+    ### Limitations
 
-    **Limitations**:
-    - This function assumes that the dataset is provided as a DataFrameDataset object with a .df attribute to access
-      the pandas DataFrame.
-    - It only analyzes datasets with a datetime index and will raise an error for other types of indices.
-    - The function does not handle large datasets efficiently, and performance may degrade with very large datasets.
+    - Assumes the dataset is provided as a DataFrameDataset object with a .df attribute to access the pandas DataFrame.
+    - Only analyzes datasets with a datetime index and will raise an error for other types of indices.
+    - Does not handle large datasets efficiently, and performance may degrade with very large datasets.
     """
 
     summary = []

validmind/tests/data_validation/TimeSeriesFrequency.py

@@ -22,34 +22,41 @@ class TimeSeriesFrequency(ThresholdTest):
     """
     Evaluates consistency of time series data frequency and generates a frequency plot.
 
-    **Purpose**: The purpose of the TimeSeriesFrequency test is to evaluate the consistency in the frequency of data
-    points in a time-series dataset. This test inspects the intervals or duration between each data point to determine
-    if a fixed pattern (such as daily, weekly, or monthly) exists. The identification of such patterns is crucial to
-    time-series analysis as any irregularities could lead to erroneous results and hinder the model's capacity for
-    identifying trends and patterns.
-
-    **Test Mechanism**: Initially, the test checks if the dataframe index is in datetime format. Subsequently, it
-    utilizes pandas' `infer_freq` method to identify the frequency of each data series within the dataframe. The
-    `infer_freq` method attempts to establish the frequency of a time series and returns both the frequency string and
-    a dictionary relating these strings to their respective labels. The test compares the frequencies of all datasets.
-    If they share a common frequency, the test passes, but it fails if they do not. Additionally, Plotly is used to
-    create a frequency plot, offering a visual depiction of the time differences between consecutive entries in the
-    dataframe index.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    The purpose of the TimeSeriesFrequency test is to evaluate the consistency in the frequency of data points in a
+    time-series dataset. This test inspects the intervals or duration between each data point to determine if a fixed
+    pattern (such as daily, weekly, or monthly) exists. The identification of such patterns is crucial to time-series
+    analysis as any irregularities could lead to erroneous results and hinder the model's capacity for identifying
+    trends and patterns.
+
+    ### Test Mechanism
+
+    Initially, the test checks if the dataframe index is in datetime format. Subsequently, it utilizes pandas'
+    `infer_freq` method to identify the frequency of each data series within the dataframe. The `infer_freq` method
+    attempts to establish the frequency of a time series and returns both the frequency string and a dictionary
+    relating these strings to their respective labels. The test compares the frequencies of all datasets. If they share
+    a common frequency, the test passes, but it fails if they do not. Additionally, Plotly is used to create a
+    frequency plot, offering a visual depiction of the time differences between consecutive entries in the dataframe
+    index.
+
+    ### Signs of High Risk
+
     - The test fails, indicating multiple unique frequencies within the dataset. This failure could suggest irregular
     intervals between observations, potentially interrupting pattern recognition or trend analysis.
     - The presence of missing or null frequencies could be an indication of inconsistencies in data or gaps within the
     data collection process.
 
-    **Strengths**:
+    ### Strengths
+
     - This test uses a systematic approach to checking the consistency of data frequency within a time-series dataset.
     - It increases the model's reliability by asserting the consistency of observations over time, an essential factor
     in time-series analysis.
     - The test generates a visual plot, providing an intuitive representation of the dataset's frequency distribution,
     which caters to visual learners and aids in interpretation and explanation.
 
-    **Limitations**:
+    ### Limitations
+
     - This test is only applicable to time-series datasets and hence not suitable for other types of datasets.
     - The `infer_freq` method might not always correctly infer frequency when faced with missing or irregular data
     points.

validmind/tests/data_validation/TimeSeriesHistogram.py

@@ -13,39 +13,40 @@ def TimeSeriesHistogram(dataset, nbins=30):
     """
     Visualizes distribution of time-series data using histograms and Kernel Density Estimation (KDE) lines.
 
-    **Purpose**: The purpose of this metric is to perform a histogram analysis on time-series data. It primarily
-    assesses the distribution of values within a dataset over a period of time, typically used for regression tasks.
-    The types of data that this metric can be applicable to are diverse, ranging from internet traffic and stock prices
-    to weather data. This analysis provides valuable insights into the probability distribution, skewness, and peakness
-    (kurtosis) underlying the data.
-
-    **Test Mechanism**: This test operates on a specific column within the dataset that is required to have a datetime
-    type index. It goes through each column in the given dataset, creating a histogram with Plotly's histplot
-    function. In cases where the dataset includes more than one time-series (i.e., more than one column with a datetime
-    type index), a distinct histogram is plotted for each series. Additionally, a kernel density estimate (KDE) line is
-    drawn for each histogram, providing a visualization of the data's underlying probability distribution. The x and
-    y-axis labels are purposely hidden to concentrate solely on the data distribution.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    The TimeSeriesHistogram test aims to perform a histogram analysis on time-series data to assess the distribution of
+    values within a dataset over time. This test is useful for regression tasks and can be applied to various types of
+    data, such as internet traffic, stock prices, and weather data, providing insights into the probability
+    distribution, skewness, and kurtosis of the dataset.
+
+    ### Test Mechanism
+
+    This test operates on a specific column within the dataset that must have a datetime type index. For each column in
+    the dataset, a histogram is created using Plotly's histplot function. If the dataset includes more than one
+    time-series, a distinct histogram is plotted for each series. Additionally, a Kernel Density Estimate (KDE) line is
+    drawn for each histogram, visualizing the data's underlying probability distribution. The x and y-axis labels are
+    hidden to focus solely on the data distribution.
+
+    ### Signs of High Risk
+
     - The dataset lacks a column with a datetime type index.
     - The specified columns do not exist within the dataset.
-    - The data distribution within the histogram demonstrates high degrees of skewness or kurtosis, which could bias
-    the model.
-    - Outliers that differ significantly from the primary data distribution are present.
-
-    **Strengths**:
-    - It serves as a visual diagnostic tool, offering an ideal starting point for understanding the overall behavior
-    and distribution trends within the dataset.
-    - It is effective for both single and multiple time-series data analysis.
-    - The Kernel Density Estimation (KDE) line provides a smooth estimate of the overall trend in data distribution.
-
-    **Limitations**:
-    - The metric only presents a high-level view of data distribution and does not offer specific numeric measures such
-    as skewness or kurtosis.
-    - The histogram does not display precise data values; due to the data grouping into bins, some detail is inevitably
-    lost, marking a trade-off between precision and general overview.
-    - The histogram cannot handle non-numeric data columns.
-    - The histogram's shape may be sensitive to the number of bins used.
+    - High skewness or kurtosis in the data distribution, indicating potential bias.
+    - Presence of significant outliers in the data distribution.
+
+    ### Strengths
+
+    - Serves as a visual diagnostic tool for understanding data behavior and distribution trends.
+    - Effective for analyzing both single and multiple time-series data.
+    - KDE line provides a smooth estimate of the overall trend in data distribution.
+
+    ### Limitations
+
+    - Provides a high-level view without specific numeric measures such as skewness or kurtosis.
+    - The histogram loses some detail due to binning of data values.
+    - Cannot handle non-numeric data columns.
+    - Histogram shape may be sensitive to the number of bins used.
     """
 
     df = dataset.df
@@ -62,7 +63,7 @@ def TimeSeriesHistogram(dataset, nbins=30):
         )
         fig.update_layout(
             title={
-                "text": f"Histogram for {col}",
+                "text": f"{col}",
                 "y": 0.9,
                 "x": 0.5,
                 "xanchor": "center",

validmind/tests/data_validation/TimeSeriesLinePlot.py

@@ -12,22 +12,28 @@ class TimeSeriesLinePlot(Metric):
     """
     Generates and analyses time-series data through line plots revealing trends, patterns, anomalies over time.
 
-    **Purpose**: The TimeSeriesLinePlot metric is designed to generate and analyze time series data through the
-    creation of line plots. This assists in the initial inspection of the data by providing a visual representation of
-    patterns, trends, seasonality, irregularity, and anomalies that may be present in the dataset over a period of time.
+    ### Purpose
 
-    **Test Mechanism**: The mechanism for this Python class involves extracting the column names from the provided
-    dataset and subsequently generates line plots for each column using the Plotly Python library. For every column in
-    the dataset, a time-series line plot is created where the values are plotted against the dataset's datetime index.
-    It is important to note that indexes that are not of datetime type will result in a ValueError.
+    The TimeSeriesLinePlot metric is designed to generate and analyze time series data through the creation of line
+    plots. This assists in the initial inspection of the data by providing a visual representation of patterns, trends,
+    seasonality, irregularity, and anomalies that may be present in the dataset over a period of time.
+
+    ### Test Mechanism
+
+    The mechanism for this Python class involves extracting the column names from the provided dataset and subsequently
+    generating line plots for each column using the Plotly Python library. For every column in the dataset, a
+    time-series line plot is created where the values are plotted against the dataset's datetime index. It is important
+    to note that indexes that are not of datetime type will result in a ValueError.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - Presence of time-series data that does not have datetime indices.
     - Provided columns do not exist in the provided dataset.
     - The detection of anomalous patterns or irregularities in the time-series plots, indicating potential high model
     instability or probable predictive error.
 
-    **Strengths**:
+    ### Strengths
+
     - The visual representation of complex time series data, which simplifies understanding and helps in recognizing
     temporal trends, patterns, and anomalies.
     - The adaptability of the metric, which allows it to effectively work with multiple time series within the same
@@ -35,7 +41,8 @@ class TimeSeriesLinePlot(Metric):
     - Enables the identification of anomalies and irregular patterns through visual inspection, assisting in spotting
     potential data or model performance problems.
 
-    **Limitations**:
+    ### Limitations
+
     - The effectiveness of the metric is heavily reliant on the quality and patterns of the provided time series data.
     - Exclusively a visual tool, it lacks the capability to provide quantitative measurements, making it less effective
     for comparing and ranking multiple models or when specific numerical diagnostics are needed.

validmind/tests/data_validation/TimeSeriesMissingValues.py

@@ -23,37 +23,42 @@ class TimeSeriesMissingValues(ThresholdTest):
     """
     Validates time-series data quality by confirming the count of missing values is below a certain threshold.
 
-    **Purpose**:
+    ### Purpose
+
     This test is designed to validate the quality of a historical time-series dataset by verifying that the number of
     missing values is below a specified threshold. As time-series models greatly depend on the continuity and
     temporality of data points, missing values could compromise the model's performance. Consequently, this test aims
     to ensure data quality and readiness for the machine learning model, safeguarding its predictive capacity.
 
-    **Test Mechanism**:
-    The test method commences by validating if the dataset has a datetime index, if not, an error is raised. It
+    ### Test Mechanism
+
+    The test method commences by validating if the dataset has a datetime index; if not, an error is raised. It
     establishes a lower limit threshold for missing values and performs a missing values check on each column of the
     dataset. An object for the test result is created stating whether the number of missing values is within the
     specified threshold. Additionally, the test calculates the percentage of missing values alongside the raw count.
 
-    To aid in data visualization, the test generates two plots - a bar plot and a heatmap, to better illustrate the
-    distribution and quantity of missing values per variable. The test results, a count of missing values, the
-    percentage of missing values, and a pass/fail status are returned in a results table.
+    To aid in data visualization, the test generates two plots - a bar plot and a heatmap - to better illustrate the
+    distribution and quantity of missing values per variable. The test results, including a count of missing values,
+    the percentage of missing values, and a pass/fail status, are returned in a results table.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - The number of missing values in any column of the dataset surpasses the threshold, marking a failure and a
     high-risk scenario. The reasons could range from incomplete data collection, faulty sensors to data preprocessing
     errors.
     - A continuous visual 'streak' in the heatmap may indicate a systematic error during data collection, pointing
     towards another potential risk source.
 
-    **Strengths**:
-    - Effectively identifies missing values which could adversely affect the model's performance.
+    ### Strengths
+
+    - Effectively identifies missing values which could adversely affect the model’s performance.
     - Applicable and customizable through the threshold parameter across different data sets.
     - Goes beyond raw numbers by calculating the percentage of missing values, offering a more relative understanding
     of data scarcity.
     - Includes a robust visualization mechanism for easy and fast understanding of data quality.
 
-    **Limitations**:
+    ### Limitations
+
     - Although it identifies missing values, the test does not provide solutions to handle them.
     - The test demands that the dataset should have a datetime index, hence limiting its use only to time series
     analysis.

validmind/tests/data_validation/TimeSeriesOutliers.py

@@ -20,43 +20,47 @@ from validmind.vm_models import (
 @dataclass
 class TimeSeriesOutliers(ThresholdTest):
     """
-    Identifies and visualizes outliers in time-series data using z-score method.
-
-    **Purpose**: This test is designed to identify outliers in time-series data using the z-score method. It's vital
-    for ensuring data quality before modeling, as outliers can skew predictive models and significantly impact their
-    overall performance.
-
-    **Test Mechanism**: The test processes a given dataset which must have datetime indexing, checks if a
-    'zscore_threshold' parameter has been supplied, and identifies columns with numeric data types. After finding
-    numeric columns, the implementer then applies the z-score method to each numeric column, identifying outliers based
-    on the threshold provided. Each outlier is listed together with their variable name, z-score, timestamp and
-    relative threshold in a dictionary and converted to a DataFrame for convenient output. Additionally, it produces
-    visual plots for each time series illustrating outliers in the context of the broader dataset. The
-    'zscore_threshold' parameter sets the limit beyond which a data point will be labeled as an outlier. The default
-    threshold is set at 3, indicating that any data point that falls 3 standard deviations away from the mean will be
-    marked as an outlier.
-
-    **Signs of High Risk**:
-    - If many or substantial outliers are present within a dataset, this may be an indicator of high risk as it
-    suggests that the dataset contains significant anomalies.
-    - This could potentially affect the performance of the machine learning models, if not properly addressed.
-    - Data points with z-scores higher than the set threshold would be flagged as outliers and could be considered as
-    high risk.
-
-    **Strengths**:
+    Identifies and visualizes outliers in time-series data using the z-score method.
+
+    ### Purpose
+
+    This test is designed to identify outliers in time-series data using the z-score method. It's vital for ensuring
+    data quality before modeling, as outliers can skew predictive models and significantly impact their overall
+    performance.
+
+    ### Test Mechanism
+
+    The test processes a given dataset which must have datetime indexing, checks if a 'zscore_threshold' parameter has
+    been supplied, and identifies columns with numeric data types. After finding numeric columns, the implementer then
+    applies the z-score method to each numeric column, identifying outliers based on the threshold provided. Each
+    outlier is listed together with their variable name, z-score, timestamp, and relative threshold in a dictionary and
+    converted to a DataFrame for convenient output. Additionally, it produces visual plots for each time series
+    illustrating outliers in the context of the broader dataset. The 'zscore_threshold' parameter sets the limit beyond
+    which a data point will be labeled as an outlier. The default threshold is set at 3, indicating that any data point
+    that falls 3 standard deviations away from the mean will be marked as an outlier.
+
+    ### Signs of High Risk
+
+    - Many or substantial outliers are present within the dataset, indicating significant anomalies.
+    - Data points with z-scores higher than the set threshold.
+    - Potential impact on the performance of machine learning models if outliers are not properly addressed.
+
+    ### Strengths
+
     - The z-score method is a popular and robust method for identifying outliers in a dataset.
-    - Time series maintenance is simplified through requiring a datetime index.
-    - Outliers are identified for each numeric feature individually.
-    - Provides an elaborate report which shows variables, date, z-score and whether the test passed or failed.
-    - Offers visual inspection for detected outliers in the respective time-series through plots.
+    - Simplifies time series maintenance by requiring a datetime index.
+    - Identifies outliers for each numeric feature individually.
+    - Provides an elaborate report showing variables, dates, z-scores, and pass/fail tests.
+    - Offers visual inspection for detected outliers through plots.
+
+    ### Limitations
 
-    **Limitations**:
-    - This test only identifies outliers in numeric columns, and won't identify outliers in categorical variables.
+    - The test only identifies outliers in numeric columns, not in categorical variables.
     - The utility and accuracy of z-scores can be limited if the data doesn't follow a normal distribution.
     - The method relies on a subjective z-score threshold for deciding what constitutes an outlier, which might not
-    always be suitable depending on the dataset and the use case.
+    always be suitable depending on the dataset and use case.
     - It does not address possible ways to handle identified outliers in the data.
-    - The necessity for a datetime index could limit the extent of its application.
+    - The requirement for a datetime index could limit its application.
     """
 
     name = "time_series_outliers"
@@ -215,7 +219,7 @@ class TimeSeriesOutliers(ThresholdTest):
                 )
 
             fig.update_layout(
-                title=f"Time Series with Outliers for {col}",
+                title=f"Outliers for {col}",
                 xaxis_title="Date",
                 yaxis_title=col,
             )

validmind/tests/data_validation/TooManyZeroValues.py

@@ -23,27 +23,31 @@ class TooManyZeroValues(ThresholdTest):
     Identifies numerical columns in a dataset that contain an excessive number of zero values, defined by a threshold
     percentage.
 
-    **Purpose**:
+    ### Purpose
+
     The 'TooManyZeroValues' test is utilized to identify numerical columns in the dataset that may present a quantity
     of zero values considered excessive. The aim is to detect situations where these may implicate data sparsity or a
     lack of variation, limiting their effectiveness within a machine learning model. The definition of 'too many' is
     quantified as a percentage of total values, with a default set to 3%.
 
-    **Test Mechanism**:
+    ### Test Mechanism
+
     This test is conducted by looping through each column in the dataset and categorizing those that pertain to
     numerical data. On identifying a numerical column, the function computes the total quantity of zero values and
     their ratio to the total row count. Should the proportion exceed a pre-set threshold parameter, set by default at
-    0.03 or 3%, the column is considered to have failed the test. The results for each column are summarised and
+    0.03 or 3%, the column is considered to have failed the test. The results for each column are summarized and
     reported, indicating the count and percentage of zero values for each numerical column, alongside a status
     indicating whether the column has passed or failed the test.
 
-    **Signs of High Risk**:
-    - Indicators evidencing a high risk connected with this test would include numerical columns showing a high ratio
-    of zero values when compared to the total count of rows (exceeding a pre-determined threshold).
+    ### Signs of High Risk
+
+    - Numerical columns showing a high ratio of zero values when compared to the total count of rows (exceeding the
+    predetermined threshold).
     - Columns characterized by zero values across the board suggest a complete lack of data variation, signifying high
     risk.
 
-    **Strengths**:
+    ### Strengths
+
     - Assists in highlighting columns featuring an excess of zero values that could otherwise go unnoticed within a
     large dataset.
     - Provides the flexibility to alter the threshold that determines when the quantity of zero values becomes 'too
@@ -53,12 +57,13 @@ class TooManyZeroValues(ThresholdTest):
     - Targets specifically numerical data, thereby avoiding inappropriate application to non-numerical columns and
     mitigating the risk of false test failures.
 
-    **Limitations**:
-    - Is exclusively designed to check for zero values, and doesn’t assesses the potential impact of other values that
-    could affect the dataset, such as extremely high or low figures, missing values or outliers.
+    ### Limitations
+
+    - Is exclusively designed to check for zero values and doesn’t assess the potential impact of other values that
+    could affect the dataset, such as extremely high or low figures, missing values, or outliers.
     - Lacks the ability to detect a repetitive pattern of zeros, which could be significant in time-series or
     longitudinal data.
-    - Zero values can actually be meaningful in some contexts, therefore tagging them as 'too many' could potentially
+    - Zero values can actually be meaningful in some contexts; therefore, tagging them as 'too many' could potentially
     misinterpret the data to some extent.
     - This test does not take into consideration the context of the dataset, and fails to recognize that within certain
     columns, a high number of zero values could be quite normal and not necessarily an indicator of poor data quality.

validmind/tests/data_validation/UniqueRows.py

@@ -19,31 +19,36 @@ class UniqueRows(ThresholdTest):
     """
     Verifies the diversity of the dataset by ensuring that the count of unique rows exceeds a prescribed threshold.
 
-    **Purpose**:
+    ### Purpose
+
     The UniqueRows test is designed to gauge the quality of the data supplied to the machine learning model by
     verifying that the count of distinct rows in the dataset exceeds a specific threshold, thereby ensuring a varied
     collection of data. Diversity in data is essential for training an unbiased and robust model that excels when faced
     with novel data.
 
-    **Test Mechanism**:
+    ### Test Mechanism
+
     The testing process starts with calculating the total number of rows in the dataset. Subsequently, the count of
     unique rows is determined for each column in the dataset. If the percentage of unique rows (calculated as the ratio
     of unique rows to the overall row count) is less than the prescribed minimum percentage threshold given as a
-    function parameter, the test is passed. The results are cached and a final pass or fail verdict is given based on
+    function parameter, the test passes. The results are cached and a final pass or fail verdict is given based on
     whether all columns have successfully passed the test.
 
-    **Signs of High Risk**:
+    ### Signs of High Risk
+
     - A lack of diversity in data columns, demonstrated by a count of unique rows that falls short of the preset
     minimum percentage threshold, is indicative of high risk.
     - This lack of variety in the data signals potential issues with data quality, possibly leading to overfitting in
     the model and issues with generalization, thus posing a significant risk.
 
-    **Strengths**:
+    ### Strengths
+
     - The UniqueRows test is efficient in evaluating the data's diversity across each information column in the dataset.
     - This test provides a quick, systematic method to assess data quality based on uniqueness, which can be pivotal in
     developing effective and unbiased machine learning models.
 
-    **Limitations**:
+    ### Limitations
+
     - A limitation of the UniqueRows test is its assumption that the data's quality is directly proportionate to its
     uniqueness, which may not always hold true. There might be contexts where certain non-unique rows are essential and
     should not be overlooked.