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

validmind/tests/data_validation/WOEBinPlots.py

@@ -20,34 +20,41 @@ class WOEBinPlots(Metric):
     Generates visualizations of Weight of Evidence (WoE) and Information Value (IV) for understanding predictive power
     of categorical variables in a data set.
 
-    **Purpose**: This test is designed to visualize the Weight of Evidence (WoE) and Information Value (IV) for
-    categorical variables in a provided dataset. By showcasing the data distribution across different categories of
-    each feature, it aids in understanding each variable's predictive power in the context of a classification-based
-    machine learning model. Commonly used in credit scoring models, WoE and IV are robust statistical methods for
-    evaluating a variable's predictive power.
-
-    **Test Mechanism**: The test implementation follows defined steps. Initially, it selects non-numeric columns from
-    the dataset and changes them to string type, paving the way for accurate binning. It then performs an automated WoE
-    binning operation on these selected features, effectively categorizing the potential values of a variable into
-    distinct bins. After the binning process, the function generates two separate visualizations (a scatter chart for
-    WoE values and a bar chart for IV) for each variable. These visual presentations are formed according to the spread
-    of each metric across various categories of each feature.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    This test is designed to visualize the Weight of Evidence (WoE) and Information Value (IV) for categorical
+    variables in a provided dataset. By showcasing the data distribution across different categories of each feature,
+    it aids in understanding each variable's predictive power in the context of a classification-based machine learning
+    model. Commonly used in credit scoring models, WoE and IV are robust statistical methods for evaluating a
+    variable's predictive power.
+
+    ### Test Mechanism
+
+    The test implementation follows defined steps. Initially, it selects non-numeric columns from the dataset and
+    changes them to string type, paving the way for accurate binning. It then performs an automated WoE binning
+    operation on these selected features, effectively categorizing the potential values of a variable into distinct
+    bins. After the binning process, the function generates two separate visualizations (a scatter chart for WoE values
+    and a bar chart for IV) for each variable. These visual presentations are formed according to the spread of each
+    metric across various categories of each feature.
+
+    ### Signs of High Risk
+
     - Errors occurring during the binning process.
     - Challenges in converting non-numeric columns into string data type.
     - Misbalance in the distribution of WoE and IV, with certain bins overtaking others conspicuously. This could
     denote that the model is disproportionately dependent on certain variables or categories for predictions, an
     indication of potential risks to its robustness and generalizability.
 
-    **Strengths**:
+    ### Strengths
+
     - Provides a detailed visual representation of the relationship between feature categories and the target variable.
     This grants an intuitive understanding of each feature's contribution to the model.
     - Allows for easy identification of features with high impact, facilitating feature selection and enhancing
     comprehension of the model's decision logic.
     - WoE conversions are monotonic, upholding the rank ordering of the original data points, which simplifies analysis.
 
-    **Limitations**:
+    ### Limitations
+
     - The method is largely reliant on the binning process, and an inappropriate binning threshold or bin number choice
     might result in a misrepresentation of the variable's distribution.
     - While excellent for categorical data, the encoding of continuous variables into categorical can sometimes lead to

validmind/tests/data_validation/WOEBinTable.py

@@ -13,36 +13,41 @@ from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableM
 @dataclass
 class WOEBinTable(Metric):
     """
-    Calculates and assesses the Weight of Evidence (WoE) and Information Value (IV) of each feature in a ML model.
-
-    **Purpose**: The Weight of Evidence (WoE) and Information Value (IV) test is intended to evaluate the predictive
-    power of each feature in the machine learning model. The test generates binned groups of values from each feature
-    in a dataset, computes the WoE value and the IV value for each bin. These values provide insights on the
-    relationship between each feature and the target variable and their contribution towards the predictive output of
-    the model.
-
-    **Test Mechanism**: The metric leverages the `scorecardpy.woebin` method to perform WoE-based automatic binning on
-    the dataset. Depending on the parameter `breaks_adj`, the method adjusts the cut-off points for binning numeric
-    variables. The bins are then used to calculate the WoE and IV. The metric requires a dataset with the target
-    variable defined. The metric outputs a dataframe that comprises the bin boundaries, WoE, and IV values for each
-    feature.
-
-    **Signs of High Risk**:
-    - High IV values, which denote variables with too much predictive power which might lead to overfitting
-    - Errors during the binning process, which might be due to inappropriate data types or poorly defined bins
-
-    **Strengths**:
-    - The WoE and IV test is highly effective for feature selection in binary classification problems, as it quantifies
-    how much predictive information is packed within each feature regarding the binary outcome
-    - The WoE transformation creates a monotonic relationship between the target and independent variables
-
-    **Limitations**:
-    - Mainly designed for binary classification tasks, therefore it might not be applicable or reliable for multi-class
-    classification or regression tasks
-    - If the dataset has many features or the features are not binnable or they are non-numeric, this process might
-    encounter difficulties
-    - This metric doesn't help in identifying if the predictive factor being observed is a coincidence or a real
-    phenomenon due to data randomness
+    Assesses the Weight of Evidence (WoE) and Information Value (IV) of each feature to evaluate its predictive power
+    in a binary classification model.
+
+    ### Purpose
+
+    The Weight of Evidence (WoE) and Information Value (IV) test is designed to evaluate the predictive power of each
+    feature in a machine learning model. This test generates binned groups of values from each feature, computes the
+    WoE and IV for each bin, and provides insights into the relationship between each feature and the target variable,
+    illustrating their contribution to the model's predictive capabilities.
+
+    ### Test Mechanism
+
+    The test uses the `scorecardpy.woebin` method to perform automatic binning of the dataset based on WoE. The method
+    adjusts the cut-off points for binning numeric variables based on the parameter `breaks_adj`. The bins are then
+    used to calculate the WoE and IV values, effectively creating a dataframe that includes the bin boundaries, WoE,
+    and IV values for each feature. A target variable is required in the dataset to perform this analysis.
+
+    ### Signs of High Risk
+
+    - High IV values, indicating variables with excessive predictive power which might lead to overfitting.
+    - Errors during the binning process, potentially due to inappropriate data types or poorly defined bins.
+
+    ### Strengths
+
+    - Highly effective for feature selection in binary classification problems, as it quantifies the predictive
+    information within each feature concerning the binary outcome.
+    - The WoE transformation creates a monotonic relationship between the target and independent variables.
+
+    ### Limitations
+
+    - Primarily designed for binary classification tasks, making it less applicable or reliable for multi-class
+    classification or regression tasks.
+    - Potential difficulties if the dataset has many features, non-binnable features, or non-numeric features.
+    - The metric does not help in distinguishing whether the observed predictive factor is due to data randomness or a
+    true phenomenon.
     """
 
     name = "woe_bin_table"

validmind/tests/data_validation/ZivotAndrewsArch.py

@@ -17,36 +17,42 @@ logger = get_logger(__name__)
 @dataclass
 class ZivotAndrewsArch(Metric):
     """
-    Evaluates the order of integration and stationarity of time series data using Zivot-Andrews unit root test.
-
-    **Purpose**: The Zivot-Andrews Arch metric is used to evaluate the order of integration for a time series data in a
-    machine learning model. It's designed to test for stationarity, a crucial aspect in time series analysis where data
-    points are not dependent on time. Stationarity means that the statistical properties such as mean, variance and
-    autocorrelation are all constant over time.
-
-    **Test Mechanism**: The Zivot-Andrews unit root test is performed on each feature in the dataset using the
-    `ZivotAndrews` function from the `arch.unitroot` module. This function returns the Zivot-Andrews metric for each
-    feature, which includes the statistical value, p-value (probability value), the number of used lags, and the number
-    of observations. The p-value is later used to decide on the null hypothesis (the time series has a unit root and is
-    non-stationary) based on a chosen level of significance.
-
-    **Signs of High Risk**:
-    - A high p-value can suggest high risk. This might indicate that there's insufficient evidence to reject the null
-    hypothesis, which would mean the time series has a unit root and is therefore non-stationary.
+    Evaluates the order of integration and stationarity of time series data using the Zivot-Andrews unit root test.
+
+    ### Purpose
+
+    The Zivot-Andrews Arch metric is used to evaluate the order of integration for time series data in a machine
+    learning model. It's designed to test for stationarity, a crucial aspect of time series analysis, where data points
+    are independent of time. Stationarity means that the statistical properties such as mean, variance, and
+    autocorrelation are constant over time.
+
+    ### Test Mechanism
+
+    The Zivot-Andrews unit root test is performed on each feature in the dataset using the `ZivotAndrews` function from
+    the `arch.unitroot` module. This function returns several metrics for each feature, including the statistical
+    value, p-value (probability value), the number of lags used, and the number of observations. The p-value is used to
+    decide on the null hypothesis (the time series has a unit root and is non-stationary) based on a chosen level of
+    significance.
+
+    ### Signs of High Risk
+
+    - A high p-value suggests high risk, indicating insufficient evidence to reject the null hypothesis, implying that
+    the time series has a unit root and is non-stationary.
     - Non-stationary time series data can lead to misleading statistics and unreliable machine learning models.
 
-    **Strengths**:
-    - The Zivot-Andrews Arch metric dynamically tests for stationarity against structural breaks in time series data,
-    offering robust evaluation of stationarity in features.
-    - This metric is especially beneficial with financial, economic, or other time-series data where data observations
-    lack a consistent pattern and structural breaks may occur.
-
-    **Limitations**:
-    - The Zivot-Andrews Arch metric assumes that data is derived from a single-equation, autoregressive model. It may,
-    therefore, not be appropriate for multivariate time series data or data which does not align with the
-    autoregressive model assumption.
-    - It might not take into account unexpected shocks or changes in the series trend which can both have a significant
-    impact on the stationarity of the data.
+    ### Strengths
+
+    - Dynamically tests for stationarity against structural breaks in time series data, offering robust evaluation of
+    stationarity in features.
+    - Especially beneficial with financial, economic, or other time-series data where data observations lack a
+    consistent pattern and structural breaks may occur.
+
+    ### Limitations
+
+    - Assumes data is derived from a single-equation, autoregressive model, making it less appropriate for multivariate
+    time series data or data not aligning with this model.
+    - May not account for unexpected shocks or changes in the series trend, both of which can significantly impact data
+    stationarity.
     """
 
     name = "zivot_andrews"

validmind/tests/data_validation/nlp/CommonWords.py

@@ -19,33 +19,40 @@ from ....vm_models import Figure, Metric, VMDataset
 @dataclass
 class CommonWords(Metric):
     """
-    Identifies and visualizes the 40 most frequent non-stopwords in a specified text column within a dataset.
+    Assesses the most frequent non-stopwords in a text column for identifying prevalent language patterns.
 
-    **Purpose**: The CommonWords metric is used to identify and visualize the most prevalent words within a specified
-    text column of a dataset. This provides insights into the prevalent language patterns and vocabulary, especially
-    useful in Natural Language Processing (NLP) tasks such as text classification and text summarization.
+    ### Purpose
 
-    **Test Mechanism**: The test methodology involves splitting the specified text column's entries into words,
-    collating them into a corpus, and then counting the frequency of each word using the Counter. The forty most
-    frequently occurring non-stopwords are then visualized in a bar chart, where the x-axis represents the words, and
-    the y-axis indicates their frequency of occurrence.
+    The CommonWords metric is used to identify and visualize the most prevalent words within a specified text column of
+    a dataset. This provides insights into the prevalent language patterns and vocabulary, especially useful in Natural
+    Language Processing (NLP) tasks such as text classification and text summarization.
+
+    ### Test Mechanism
+
+    The test methodology involves splitting the specified text column's entries into words, collating them into a
+    corpus, and then counting the frequency of each word using the Counter. The forty most frequently occurring
+    non-stopwords are then visualized in a bar chart, where the x-axis represents the words, and the y-axis indicates
+    their frequency of occurrence.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A lack of distinct words within the list, or the most common words being stopwords.
     - Frequent occurrence of irrelevant or inappropriate words could point out a poorly curated or noisy dataset.
-    - An error returned due to the absence of a valid Dataset object indicates high risk as the metric cannot be
+    - An error returned due to the absence of a valid Dataset object, indicating high risk as the metric cannot be
     effectively implemented without it.
 
-    **Strengths**:
+    ### Strengths
+
     - The metric provides clear insights into the language features – specifically word frequency – of unstructured
     text data.
     - It can reveal prominent vocabulary and language patterns, which prove vital for feature extraction in NLP tasks.
     - The visualization helps in quickly capturing the patterns and understanding the data intuitively.
 
-    **Limitations**:
+    ### Limitations
+
     - The test disregards semantic or context-related information as it solely focuses on word frequency.
-    - It intentionally ignores stopwords which might carry necessary significance in certain scenarios.
-    - The applicability is limited to English language text data as English stopwords are used for filtering, hence
+    - It intentionally ignores stopwords, which might carry necessary significance in certain scenarios.
+    - The applicability is limited to English-language text data as English stopwords are used for filtering, hence
     cannot account for data in other languages.
     - The metric requires a valid Dataset object, indicating a dependency condition that limits its broader
     applicability.

validmind/tests/data_validation/nlp/Hashtags.py

@@ -9,8 +9,7 @@ Threshold based tests
 import re
 from dataclasses import dataclass
 
-import matplotlib.pyplot as plt
-import seaborn as sns
+import plotly.graph_objects as go
 
 from validmind.vm_models import Figure, ThresholdTest, VMDataset
 
@@ -20,37 +19,44 @@ class Hashtags(ThresholdTest):
     """
     Assesses hashtag frequency in a text column, highlighting usage trends and potential dataset bias or spam.
 
-    **Purpose**: The Hashtags test is designed to measure the frequency of hashtags used within a given text column in
-    a dataset. It is particularly useful for natural language processing tasks such as text classification and text
-    summarization. The goal is to identify common trends and patterns in the use of hashtags, which can serve as
-    critical indicators or features within a machine learning model.
+    ### Purpose
 
-    **Test Mechanism**: The test implements a regular expression (regex) to extract all hashtags from the specified
-    text column. For each hashtag found, it makes a tally of its occurrences. It then outputs a list of the top N
-    hashtags (default is 25, but customizable), sorted by their counts in descending order. The results are also
-    visualized in a bar plot, with frequency counts on the y-axis and the corresponding hashtags on the x-axis.
+    The Hashtags test is designed to measure the frequency of hashtags used within a given text column in a dataset. It
+    is particularly useful for natural language processing tasks such as text classification and text summarization.
+    The goal is to identify common trends and patterns in the use of hashtags, which can serve as critical indicators
+    or features within a machine learning model.
+
+    ### Test Mechanism
+
+    The test implements a regular expression (regex) to extract all hashtags from the specified text column. For each
+    hashtag found, it makes a tally of its occurrences. It then outputs a list of the top N hashtags (default is 25,
+    but customizable), sorted by their counts in descending order. The results are also visualized in a bar plot, with
+    frequency counts on the y-axis and the corresponding hashtags on the x-axis.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A low diversity in the usage of hashtags, as indicated by a few hashtags being used disproportionately more than
     others.
     - Repeated usage of one or few hashtags can be indicative of spam or a biased dataset.
     - If there are no or extremely few hashtags found in the dataset, it perhaps signifies that the text data does not
     contain structured social media data.
 
-    **Strengths**:
-    - It provides a concise visual representation of the frequency of hashtags, which can be critical for understanding
+    ### Strengths
+
+    - Provides a concise visual representation of the frequency of hashtags, which can be critical for understanding
     trends about a particular topic in text data.
-    - It is instrumental in tasks specifically related to social media text analytics, such as opinion analysis and
-    trend discovery.
-    - The test is adaptable, allowing the flexibility to determine the number of top hashtags to be analyzed.
+    - Instrumental in tasks specifically related to social media text analytics, such as opinion analysis and trend
+    discovery.
+    - Adaptable, allowing the flexibility to determine the number of top hashtags to be analyzed.
 
-    **Limitations**:
-    - The test assumes the presence of hashtags and therefore may not be applicable for text datasets that do not
-    contain hashtags (e.g., formal documents, scientific literature).
+    ### Limitations
+
+    - Assumes the presence of hashtags and therefore may not be applicable for text datasets that do not contain
+    hashtags (e.g., formal documents, scientific literature).
     - Language-specific limitations of hashtag formulations are not taken into account.
-    - It does not account for typographical errors, variations, or synonyms in hashtags.
-    - This test does not provide context or sentiment associated with the hashtags, so the information provided may
-    have limited utility on its own.
+    - Does not account for typographical errors, variations, or synonyms in hashtags.
+    - Does not provide context or sentiment associated with the hashtags, so the information provided may have limited
+    utility on its own.
     """
 
     name = "hashtags"
@@ -67,25 +73,23 @@ class Hashtags(ThresholdTest):
         text_column = self.inputs.dataset.text_column
 
         def find_hash(text):
-            line = re.findall(r"(?<=#)\w+", text)
-            return " ".join(line)
-
-        temp = (
-            self.inputs.dataset.df[text_column]
-            .apply(lambda x: find_hash(x))
-            .value_counts()[:][1 : self.params["top_hashtags"]]
-        )
-        temp = (
-            temp.to_frame()
-            .reset_index()
-            .rename(columns={"index": "Hashtag", text_column: "count"})
-        )
+            return re.findall(r"(?<=#)\w+", str(text))
+
+        # Extract hashtags from the text column and count occurrences
+        hashtags = self.inputs.dataset.df[text_column].apply(find_hash).explode()
+        temp = hashtags.value_counts().head(self.params["top_hashtags"])
+
+        print(f"temp: {temp}")
 
         figures = []
         if not temp.empty:
-            fig = plt.figure()
-            sns.barplot(x="Hashtag", y="count", data=temp)
-            plt.xticks(rotation=90)
+            fig = go.Figure(data=[go.Bar(x=temp.index, y=temp.values)])
+            fig.update_layout(
+                title="Top Hashtags",
+                xaxis_title="Hashtag",
+                yaxis_title="Count",
+                xaxis_tickangle=-45,
+            )
             figures.append(
                 Figure(
                     for_object=self,
@@ -93,7 +97,5 @@ class Hashtags(ThresholdTest):
                     figure=fig,
                 )
             )
-            # Do this if you want to prevent the figure from being displayed
-            plt.close("all")
 
         return self.cache_results([], passed=True, figures=figures)

validmind/tests/data_validation/nlp/LanguageDetection.py

@@ -17,24 +17,43 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def LanguageDetection(dataset):
     """
-    Detects the language of each text entry in a dataset and visualizes the distribution of languages
-    as a histogram.
+    Assesses the diversity of languages in a textual dataset by detecting and visualizing the distribution of languages.
 
-    This method checks for a specified text column in the dataset's dataframe, uses a language detection
-    library to determine the language of each text entry, and returns a histogram plot of the language
-    distribution.
+    ### Purpose
 
-    Args:
-        dataset (Dataset): A dataset object which must have a `df` attribute (a pandas DataFrame)
-            and a `text_column` attribute indicating the name of the column containing text. If the
-            `text_column` attribute is not set, a ValueError is raised.
+    The Language Detection test aims to identify and visualize the distribution of languages present within a textual
+    dataset. This test helps in understanding the diversity of languages in the data, which is crucial for developing
+    and validating multilingual models.
 
-    Returns:
-        plotly.graph_objs._figure.Figure: A Plotly histogram plot showing the distribution of detected
-        languages across the dataset's text entries.
+    ### Test Mechanism
 
-    Raises:
-        ValueError: If the `text_column` is not specified in the dataset object.
+    This test operates by:
+
+    - Checking if the dataset has a specified text column.
+    - Using a language detection library to determine the language of each text entry in the dataset.
+    - Generating a histogram plot of the language distribution, with language codes on the x-axis and their frequencies
+    on the y-axis.
+
+    If the text column is not specified, a ValueError is raised to ensure proper dataset configuration.
+
+    ### Signs of High Risk
+
+    - A high proportion of entries returning "Unknown" language codes.
+    - Detection of unexpectedly diverse or incorrect language codes, indicating potential data quality issues.
+    - Significant imbalance in language distribution, which might indicate potential biases in the dataset.
+
+    ### Strengths
+
+    - Provides a visual representation of language diversity within the dataset.
+    - Helps identify data quality issues related to incorrect or unknown language detection.
+    - Useful for ensuring that multilingual models have adequate and appropriate representation from various languages.
+
+    ### Limitations
+
+    - Dependency on the accuracy of the language detection library, which may not be perfect.
+    - Languages with similar structures or limited text length may be incorrectly classified.
+    - The test returns "Unknown" for entries where language detection fails, which might mask underlying issues with
+    certain languages or text formats.
     """
     # check text column
     if not dataset.text_column:

validmind/tests/data_validation/nlp/Mentions.py

@@ -20,31 +20,37 @@ class Mentions(ThresholdTest):
     """
     Calculates and visualizes frequencies of '@' prefixed mentions in a text-based dataset for NLP model analysis.
 
-    **Purpose**: This test, termed "Mentions", is designed to gauge the quality of data in a Natural Language
-    Processing (NLP) or text-focused Machine Learning model. The primary objective is to identify and calculate the
-    frequency of 'mentions' within a chosen text column of a dataset. A 'mention' in this context refers to individual
-    text elements that are prefixed by '@'. The output of this test reveals the most frequently mentioned entities or
-    usernames, which can be integral for applications such as social media analyses, customer sentiment analyses, and
-    so on.
-
-    **Test Mechanism**: The test first verifies the existence of a text column in the provided dataset. It then employs
-    a regular expression pattern to extract mentions from the text. Subsequently, the frequency of each unique mention
-    is calculated. The test selects the most frequent mentions based on default or user-defined parameters, the default
+    ### Purpose
+
+    The "Mentions" test is designed to gauge the quality of data in a Natural Language Processing (NLP) or text-focused
+    Machine Learning model. The primary objective is to identify and calculate the frequency of 'mentions' within a
+    chosen text column of a dataset. A 'mention' in this context refers to individual text elements that are prefixed
+    by '@'. The output of this test reveals the most frequently mentioned entities or usernames, which can be integral
+    for applications such as social media analyses or customer sentiment analyses.
+
+    ### Test Mechanism
+
+    The test first verifies the existence of a text column in the provided dataset. It then employs a regular
+    expression pattern to extract mentions from the text. Subsequently, the frequency of each unique mention is
+    calculated. The test selects the most frequent mentions based on default or user-defined parameters, the default
     being the top 25, for representation. This process of thresholding forms the core of the test. A treemap plot
     visualizes the test results, where the size of each rectangle corresponds to the frequency of a particular mention.
 
-    **Signs of High Risk**:
+    ### Signs of High Risk
+
     - The lack of a valid text column in the dataset, which would result in the failure of the test execution.
     - The absence of any mentions within the text data, indicating that there might not be any text associated with
-    '@'. This situation could point towards sparse or poor-quality data, thereby hampering the model's generalization
-    or learning capabilities.
+    '@'. This situation could point toward sparse or poor-quality data, thereby hampering the model's generalization or
+    learning capabilities.
+
+    ### Strengths
 
-    **Strengths**:
     - The test is specifically optimized for text-based datasets which gives it distinct power in the context of NLP.
     - It enables quick identification and visually appealing representation of the predominant elements or mentions.
     - It can provide crucial insights about the most frequently mentioned entities or usernames.
 
-    **Limitations**:
+    ### Limitations
+
     - The test only recognizes mentions that are prefixed by '@', hence useful textual aspects not preceded by '@'
     might be ignored.
     - This test isn't suited for datasets devoid of textual data.

validmind/tests/data_validation/nlp/PolarityAndSubjectivity.py

@@ -14,18 +14,41 @@ from validmind import tags, tasks
 @tasks("nlp")
 def PolarityAndSubjectivity(dataset):
     """
-    Analyzes the polarity and subjectivity of text data within a dataset.
+    Analyzes the polarity and subjectivity of text data within a given dataset to visualize the sentiment distribution.
 
-    This method processes a dataset containing textual data to compute the polarity and
-    subjectivity scores using TextBlob, and returns a Plotly scatter plot visualizing
-    these scores.
+    ### Purpose
 
-    Args:
-        dataset (Dataset): A dataset object which must have a `df` attribute (a pandas DataFrame)
-            and a `text_column` attribute indicating the name of the column containing text.
+    The Polarity and Subjectivity test is designed to evaluate the sentiment expressed in textual data. By analyzing
+    these aspects, it helps to identify the emotional tone and subjectivity of the dataset, which could be crucial in
+    understanding customer feedback, social media sentiments, or other text-related data.
 
-    Returns:
-        plotly.graph_objs._figure.Figure: A Plotly scatter plot of polarity vs subjectivity.
+    ### Test Mechanism
+
+    This test uses TextBlob to compute the polarity and subjectivity scores of textual data in a given dataset. The
+    mechanism includes:
+
+    - Iterating through each text entry in the specified column of the dataset.
+    - Applying the TextBlob library to compute the polarity (ranging from -1 for negative sentiment to +1 for positive
+    sentiment) and subjectivity (ranging from 0 for objective to 1 for subjective) for each entry.
+    - Creating a scatter plot using Plotly to visualize the relationship between polarity and subjectivity.
+
+    ### Signs of High Risk
+
+    - High concentration of negative polarity values indicating prevalent negative sentiments.
+    - High subjectivity scores suggesting the text data is largely opinion-based rather than factual.
+    - Disproportionate clusters of extreme scores (e.g., many points near -1 or +1 polarity).
+
+    ### Strengths
+
+    - Quantifies sentiment and subjectivity which can provide actionable insights.
+    - Visualizes sentiment distribution, aiding in easy interpretation.
+    - Utilizes well-established TextBlob library for sentiment analysis.
+
+    ### Limitations
+
+    - Polarity and subjectivity calculations may oversimplify nuanced text sentiments.
+    - Reliance on TextBlob which may not be accurate for all domains or contexts.
+    - Visualization could become cluttered with very large datasets, making interpretation difficult.
     """
 
     # Function to calculate sentiment and subjectivity

validmind/tests/data_validation/nlp/Punctuations.py

@@ -20,34 +20,38 @@ class Punctuations(Metric):
     """
     Analyzes and visualizes the frequency distribution of punctuation usage in a given text dataset.
 
-    **1. Purpose:** The Punctuations Metric's primary purpose is to analyze the frequency of punctuation usage within a
-    given text dataset. This is often used in Natural Language Processing tasks, such as text classification and text
+    ### Purpose
+
+    The Punctuations Metric's primary purpose is to analyze the frequency of punctuation usage within a given text
+    dataset. This is often used in Natural Language Processing tasks, such as text classification and text
     summarization.
 
-    **2. Test Mechanism:** The test begins by verifying that the input "dataset" is of the type VMDataset. Following
-    that, a corpus is created from the dataset by splitting its text on spaces. Each unique punctuation character in
-    the text corpus is then tallied. Then, the frequency distribution of each punctuation symbol is visualized as a bar
-    graph, with these results being stored as Figures and associated with the main Punctuations object.
+    ### Test Mechanism
+
+    The test begins by verifying that the input "dataset" is of the type VMDataset. Following that, a corpus is created
+    from the dataset by splitting its text on spaces. Each unique punctuation character in the text corpus is then
+    tallied. The frequency distribution of each punctuation symbol is visualized as a bar graph, with these results
+    being stored as Figures and associated with the main Punctuations object.
 
-    **3. Signs of High Risk:**
+    ### Signs of High Risk
 
-    - High risk can be indicated by the excessive or unusual frequency of specific punctuation marks, potentially
-    denoting dubious quality, data corruption, or skewed data.
+    - Excessive or unusual frequency of specific punctuation marks, potentially denoting dubious quality, data
+    corruption, or skewed data.
 
-    **4. Strengths:**
+    ### Strengths
 
-    - The Punctuations Metric provides valuable insights into the distribution of punctuation usage in a text dataset.
-    - This insight can be important in validating the quality, consistency, and nature of the data.
-    - It can provide hints about the style or tonality of the text corpus. For example, frequent usage of exclamation
-    marks may suggest a more informal and emotional context.
+    - Provides valuable insights into the distribution of punctuation usage in a text dataset.
+    - Important in validating the quality, consistency, and nature of the data.
+    - Can provide hints about the style or tonality of the text corpus, such as informal and emotional context
+    indicated by frequent exclamation marks.
 
-    **5. Limitations:**
+    ### Limitations
 
-    - The metric focuses solely on punctuation usage and can miss other important textual characteristics.
-    - It's important not to make general cultural or tonality assumptions based solely on punctuation distribution,
-    since these can vary greatly across different languages and contexts.
-    - The metric may be less effective with languages that use non-standard or different punctuation.
-    - The visualization may lack interpretability when there are many unique punctuation marks in the dataset.
+    - Focuses solely on punctuation usage, potentially missing other important textual characteristics.
+    - General cultural or tonality assumptions based on punctuation distribution can be misguiding, as these vary
+    across different languages and contexts.
+    - Less effective with languages that use non-standard or different punctuation.
+    - Visualization may lack interpretability when there are many unique punctuation marks in the dataset.
     """
 
     name = "punctuations"