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

validmind/tests/data_validation/nlp/Sentiment.py

@@ -17,16 +17,35 @@ def Sentiment(dataset):
     """
     Analyzes the sentiment of text data within a dataset using the VADER sentiment analysis tool.
 
-    This method initializes the VADER SentimentIntensityAnalyzer and applies it to each text entry
-    in the specified column of the dataset's dataframe. It returns a KDE plot visualizing the distribution
-    of sentiment scores across the dataset.
+    ### 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 Sentiment test evaluates the overall sentiment of text data within a dataset. By analyzing sentiment scores, it
+    aims to ensure that the model is interpreting text data accurately and is not biased towards a particular sentiment.
 
-    Returns:
-        matplotlib.figure.Figure: A KDE plot visualizing the distribution of sentiment scores.
+    ### Test Mechanism
+
+    This test uses the VADER (Valence Aware Dictionary and sEntiment Reasoner) SentimentIntensityAnalyzer. It processes
+    each text entry in a specified column of the dataset to calculate the compound sentiment score, which represents
+    the overall sentiment polarity. The distribution of these sentiment scores is then visualized using a KDE (Kernel
+    Density Estimation) plot, highlighting any skewness or concentration in sentiment.
+
+    ### Signs of High Risk
+
+    - Extreme polarity in sentiment scores, indicating potential bias.
+    - Unusual concentration of sentiment scores in a specific range.
+    - Significant deviation from expected sentiment distribution for the given text data.
+
+    ### Strengths
+
+    - Provides a clear visual representation of sentiment distribution.
+    - Uses a well-established sentiment analysis tool (VADER).
+    - Can handle a wide range of text data, making it flexible for various applications.
+
+    ### Limitations
+
+    - May not capture nuanced or context-specific sentiments.
+    - Relies heavily on the accuracy of the VADER sentiment analysis tool.
+    - Visualization alone may not provide comprehensive insights into underlying causes of sentiment distribution.
     """
     nltk.download("vader_lexicon", quiet=True)
     # Initialize VADER

validmind/tests/data_validation/nlp/StopWords.py

@@ -30,40 +30,47 @@ class StopWords(ThresholdTest):
     """
     Evaluates and visualizes the frequency of English stop words in a text dataset against a defined threshold.
 
-    **Purpose**: The StopWords threshold test is a tool designed for assessing the quality of text data in an ML model.
-    It focuses on the identification and analysis of "stop words" in a given dataset. Stop words are frequent, common,
-    yet semantically insignificant words (for example: "the", "and", "is") in a language. This test evaluates the
+    ### Purpose
+
+    The StopWords threshold test is a tool designed for assessing the quality of text data in an ML model. It focuses
+    on the identification and analysis of "stop words" in a given dataset. Stop words are frequent, common, yet
+    semantically insignificant words (for example: "the", "and", "is") in a language. This test evaluates the
     proportion of stop words to the total word count in the dataset, in essence, scrutinizing the frequency of stop
     word usage. The core objective is to highlight the prevalent stop words based on their usage frequency, which can
     be instrumental in cleaning the data from noise and improving ML model performance.
 
-    **Test Mechanism**: The StopWords test initiates on receiving an input of a 'VMDataset' object. Absence of such an
-    object will trigger an error. The methodology involves inspection of the text column of the VMDataset to create a
-    'corpus' (a collection of written texts). Leveraging the Natural Language Toolkit's (NLTK) stop word repository,
-    the test screens the corpus for any stop words and documents their frequency. It further calculates the percentage
-    usage of each stop word compared to the total word count in the corpus. This percentage is evaluated against a
-    predefined 'min_percent_threshold'. If this threshold is breached, the test returns a failed output. Top prevailing
-    stop words along with their usage percentages are returned, facilitated by a bar chart visualization of these stop
-    words and their frequency.
+    ### Test Mechanism
+
+    The StopWords test initiates on receiving an input of a 'VMDataset' object. Absence of such an object will trigger
+    an error. The methodology involves inspection of the text column of the VMDataset to create a 'corpus' (a
+    collection of written texts). Leveraging the Natural Language Toolkit's (NLTK) stop word repository, the test
+    screens the corpus for any stop words and documents their frequency. It further calculates the percentage usage of
+    each stop word compared to the total word count in the corpus. This percentage is evaluated against a predefined
+    'min_percent_threshold'. If this threshold is breached, the test returns a failed output. Top prevailing stop words
+    along with their usage percentages are returned, facilitated by a bar chart visualization of these stop words and
+    their frequency.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A percentage of any stop words exceeding the predefined 'min_percent_threshold'.
     - High frequency of stop words in the dataset which may adversely affect the application's analytical performance
     due to noise creation.
 
-    **Strengths**:
+    ### Strengths
+
     - The ability to scrutinize and quantify the usage of stop words.
-    - Provides insights into potential noise in the text data due to stop words. This can directly aid in enhancing
-    model training efficiency.
-    - The test includes a bar chart visualization feature to easily interpret and action upon the stop words frequency
+    - Provides insights into potential noise in the text data due to stop words.
+    - Directly aids in enhancing model training efficiency.
+    - Includes a bar chart visualization feature to easily interpret and action upon the stop words frequency
     information.
 
-    **Limitations**:
+    ### Limitations
+
     - The test only supports English stop words, making it less effective with datasets of other languages.
     - The 'min_percent_threshold' parameter may require fine-tuning for different datasets, impacting the overall
     effectiveness of the test.
-    - Contextual use of the stop words within the dataset is not considered which may lead to overlooking their
-    significance in certain contexts.
+    - Contextual use of the stop words within the dataset is not considered, potentially overlooking their significance
+    in certain contexts.
     - The test focuses specifically on the frequency of stop words, not providing direct measures of model performance
     or predictive accuracy.
     """

validmind/tests/data_validation/nlp/TextDescription.py

@@ -17,46 +17,47 @@ from ....vm_models import Figure, Metric, VMDataset
 @dataclass
 class TextDescription(Metric):
     """
-    Performs comprehensive textual analysis on a dataset using NLTK, evaluating various parameters and generating
+    Conducts comprehensive textual analysis on a dataset using NLTK to evaluate various parameters and generate
     visualizations.
 
-    **Purpose**: This test uses the TextDescription metric to conduct a comprehensive textual analysis of a given
-    dataset. Various parameters such as total words, total sentences, average sentence length, total paragraphs, total
-    unique words, most common words, total punctuations, and lexical diversity are evaluated. This metric aids in
-    comprehending the nature of the text and evaluating the potential challenges that machine learning algorithms
-    deployed for textual analysis, language processing, or summarization might face.
-
-    **Test Mechanism**: The test works by parsing the given dataset and utilizes the NLTK (Natural Language Toolkit)
-    library for tokenizing the text into words, sentences, and paragraphs. Subsequently, it processes the text further
-    by eliminating stopwords declared in 'unwanted_tokens' and punctuations. Next, it determines parameters like the
-    total count of words, sentences, paragraphs, punctuations alongside the average sentence length and lexical
-    diversity. Lastly, the result from these calculations is condensed and scatter plots for certain variable
-    combinations (e.g. Total Words vs Total Sentences, Total Words vs Total Unique Words) are produced, providing a
-    visual representation of the text's structure.
-
-    **Signs of High Risk**:
-    - Anomalies or an increase in complexity within the lexical diversity results.
+    ### Purpose
+
+    The TextDescription test aims to conduct a thorough textual analysis of a dataset using the NLTK (Natural Language
+    Toolkit) library. It evaluates various metrics such as total words, total sentences, average sentence length, total
+    paragraphs, total unique words, most common words, total punctuations, and lexical diversity. The goal is to
+    understand the nature of the text and anticipate challenges machine learning models might face in text processing,
+    language understanding, or summarization tasks.
+
+    ### Test Mechanism
+
+    The test works by:
+
+    - Parsing the dataset and tokenizing the text into words, sentences, and paragraphs using NLTK.
+    - Removing stopwords and unwanted tokens.
+    - Calculating parameters like total words, total sentences, average sentence length, total paragraphs, total unique
+    words, total punctuations, and lexical diversity.
+    - Generating scatter plots to visualize correlations between various metrics (e.g., Total Words vs Total Sentences).
+
+    ### Signs of High Risk
+
+    - Anomalies or increased complexity in lexical diversity.
     - Longer sentences and paragraphs.
     - High uniqueness of words.
-    - Presence of a significant amount of unwanted tokens.
+    - Large number of unwanted tokens.
     - Missing or erroneous visualizations.
-     These signs suggest potential risk in text processing ML models, indicating that the ability of the model to
-    absorb and process text could be compromised.
-
-    **Strengths**:
-    - An essential pre-processing tool, specifically for textual analysis in machine learning model data.
-    - Provides a comprehensive breakdown of a text dataset, which aids in understanding both structural and vocabulary
-    complexity.
-    - Generates visualizations of correlations between chosen variables to further comprehend the text's structure and
-    complexity.
-
-    **Limitations**:
-    - Heavy reliance on the NLTK library, restricting its use to only the languages that NLTK supports.
-    - Limited customization capacity as the undesirable tokens and stop words are predefined.
-    - Lacks the ability to consider semantics or grammatical complexities, which could be crucial aspects in language
-    processing.
-    - Assumes that the document is well-structured (includes sentences and paragraphs); therefore, unstructured or
-    poorly formatted text may distort the results.
+
+    ### Strengths
+
+    - Essential for pre-processing text data in machine learning models.
+    - Provides a comprehensive breakdown of text data, aiding in understanding its complexity.
+    - Generates visualizations to help comprehend text structure and complexity.
+
+    ### Limitations
+
+    - Highly dependent on the NLTK library, limiting the test to supported languages.
+    - Limited customization for removing undesirable tokens and stop words.
+    - Does not consider semantic or grammatical complexities.
+    - Assumes well-structured documents, which may result in inaccuracies with poorly formatted text.
     """
 
     name = "text_description"
@@ -83,7 +84,6 @@ class TextDescription(Metric):
     tags = ["nlp", "text_data", "visualization"]
 
     def general_text_metrics(self, df, text_column):
-        nltk.download("punkt", quiet=True)
         results = []
 
         for text in df[text_column]:
@@ -174,6 +174,9 @@ class TextDescription(Metric):
         if not isinstance(self.inputs.dataset, VMDataset):
             raise ValueError("TextDescription requires a validmind Dataset object")
 
+        # download nltk data
+        nltk.download("punkt_tab", quiet=True)
+
         df_text_description = self.text_description_table(
             self.inputs.dataset.df, self.params
         )

validmind/tests/data_validation/nlp/Toxicity.py

@@ -13,18 +13,41 @@ from validmind import tags, tasks
 @tasks("nlp")
 def Toxicity(dataset):
     """
-    Analyzes the toxicity of text data within a dataset using a pre-trained toxicity model.
+    Assesses the toxicity of text data within a dataset to visualize the distribution of toxicity scores.
 
-    This method loads a toxicity evaluation model and applies it to each text entry
-    in the specified column of the dataset's dataframe. It returns a KDE plot visualizing the distribution
-    of toxicity scores across the dataset.
+    ### 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 Toxicity test aims to evaluate the level of toxic content present in a text dataset by leveraging a pre-trained
+    toxicity model. It helps in identifying potentially harmful or offensive language that may negatively impact users
+    or stakeholders.
 
-    Returns:
-        matplotlib.figure.Figure: A KDE plot visualizing the distribution of toxicity scores.
+    ### Test Mechanism
+
+    This test uses a pre-trained toxicity evaluation model and applies it to each text entry in the specified column of
+    a dataset’s dataframe. The procedure involves:
+
+    - Loading a pre-trained toxicity model.
+    - Extracting the text from the specified column in the dataset.
+    - Computing toxicity scores for each text entry.
+    - Generating a KDE (Kernel Density Estimate) plot to visualize the distribution of these toxicity scores.
+
+    ### Signs of High Risk
+
+    - High concentration of high toxicity scores in the KDE plot.
+    - A significant proportion of text entries with toxicity scores above a predefined threshold.
+    - Wide distribution of toxicity scores, indicating inconsistency in content quality.
+
+    ### Strengths
+
+    - Provides a visual representation of toxicity distribution, making it easier to identify outliers.
+    - Uses a robust pre-trained model for toxicity evaluation.
+    - Can process large text datasets efficiently.
+
+    ### Limitations
+
+    - Depends on the accuracy and bias of the pre-trained toxicity model.
+    - Does not provide context-specific insights, which may be necessary for nuanced understanding.
+    - May not capture all forms of subtle or indirect toxic language.
     """
     toxicity = evaluate.load("toxicity")
     input_text = dataset.df[dataset.text_column]

validmind/tests/decorator.py

@@ -9,6 +9,7 @@
 
 import inspect
 import os
+from typing import Any, Dict, List, Tuple, Union
 from uuid import uuid4
 
 import pandas as pd
@@ -22,6 +23,8 @@ from validmind.vm_models import (
     ResultSummary,
     ResultTable,
     ResultTableMetadata,
+    VMDataset,
+    VMModel,
 )
 from validmind.vm_models.figure import (
     Figure,
@@ -36,30 +39,42 @@ from ._store import test_store
 logger = get_logger(__name__)
 
 
-def _inspect_signature(test_func: callable):
-    input_keys = ["dataset", "datasets", "model", "models"]
+_input_type_map = {
+    "dataset": VMDataset,
+    "datasets": List[VMDataset],
+    "model": VMModel,
+    "models": List[VMModel],
+}
+
 
+def _inspect_signature(test_func: callable):
     inputs = {}
     params = {}
 
     for name, arg in inspect.signature(test_func).parameters.items():
-        if name in input_keys:
-            target_dict = inputs
+        if name in _input_type_map:
+            inputs[name] = {
+                "type": _input_type_map[name],
+            }
         else:
-            target_dict = params
-
-        target_dict[name] = {
-            "type": arg.annotation,
-            "default": (
-                arg.default if arg.default is not inspect.Parameter.empty else None
-            ),
-        }
+            params[name] = {
+                "type": arg.annotation,
+                "default": (
+                    arg.default if arg.default is not inspect.Parameter.empty else None
+                ),
+            }
 
     return inputs, params
 
 
 def _build_result(  # noqa: C901
-    results, test_id, description, output_template, inputs, generate_description=True
+    results: Union[Any, Tuple[Any, ...]],
+    test_id: str,
+    inputs: List[str],
+    params: Dict[str, Any],
+    description: str = None,
+    output_template: str = None,
+    generate_description: bool = True,
 ):
     ref_id = str(uuid4())
     figure_metadata = {
@@ -70,14 +85,17 @@ def _build_result(  # noqa: C901
 
     tables = []
     figures = []
+    scalars = []
 
-    def process_item(item):
+    def process_result_item(item):
         # TOOD: build out a more robust/extensible system for this
         # TODO: custom type handlers would be really cool
 
-        # unit metrics (scalar values) - show in a simple table for now
-        if isinstance(item, int) or isinstance(item, float) or isinstance(item, str):
-            tables.append(ResultTable(data=[{test_id.split(".")[-1]: item}]))
+        # unit metrics (scalar values) - for now only one per test
+        if isinstance(item, int) or isinstance(item, float):
+            if scalars:
+                raise ValueError("Only one unit metric may be returned per test.")
+            scalars.append(item)
 
         # plots
         elif isinstance(item, Figure):
@@ -114,46 +132,66 @@ def _build_result(  # noqa: C901
     # if the results are a tuple, process each item as a separate result
     if isinstance(results, tuple):
         for item in results:
-            process_item(item)
+            process_result_item(item)
     else:
-        process_item(results)
+        process_result_item(results)
 
-    result_summary = ResultSummary(results=tables)
+    metric_inputs = [
+        sub_i.input_id if hasattr(sub_i, "input_id") else sub_i
+        for i in inputs
+        for sub_i in (i if isinstance(i, list) else [i])
+    ]
 
     return MetricResultWrapper(
         result_id=test_id,
-        metric=MetricResult(
-            key=test_id,
-            ref_id=ref_id,
-            value="Empty",
-            summary=result_summary,
+        scalar=scalars[0] if scalars else None,
+        metric=(
+            MetricResult(
+                key=test_id,
+                ref_id=ref_id,
+                value="Empty",
+                summary=ResultSummary(results=tables),
+            )
+            if tables or figures  # if tables or figures than its a traditional metric
+            else None
         ),
         figures=figures,
-        result_metadata=[
-            get_description_metadata(
-                test_id=test_id,
-                default_description=description,
-                summary=result_summary.serialize(),
-                figures=figures,
-                should_generate=generate_description,
-            )
-        ],
-        inputs=inputs,
+        result_metadata=(
+            [
+                get_description_metadata(
+                    test_id=test_id,
+                    default_description=description,
+                    summary=ResultSummary(results=tables).serialize(),
+                    figures=figures,
+                    should_generate=generate_description,
+                )
+            ]
+            if tables or figures
+            else None
+        ),
+        inputs=metric_inputs,
+        params=params,
         output_template=output_template,
     )
 
 
-def _get_run_method(func, inputs, params):
+def _get_run_method(func, func_inputs, func_params):
     def run(self: Metric):
-        input_kwargs = {}
-        for k in inputs.keys():
+        input_kwargs = {}  # map function inputs (`dataset` etc) to actual objects
+        input_ids = []  # store input_ids used so they can be logged
+        for key in func_inputs.keys():
             try:
-                input_kwargs[k] = getattr(self.inputs, k)
+                input_kwargs[key] = getattr(self.inputs, key)
+                if isinstance(input_kwargs[key], list):
+                    input_ids.extend([i.input_id for i in input_kwargs[key]])
+                else:
+                    input_ids.append(input_kwargs[key].input_id)
             except AttributeError:
-                raise MissingRequiredTestInputError(f"Missing required input: {k}.")
+                raise MissingRequiredTestInputError(f"Missing required input: {key}.")
 
         param_kwargs = {
-            k: self.params.get(k, params[k]["default"]) for k in params.keys()
+            key: self.params.get(key, func_params[key]["default"])
+            for key in func_params.keys()
         }
 
         raw_results = func(**input_kwargs, **param_kwargs)
@@ -162,8 +200,9 @@ def _get_run_method(func, inputs, params):
             results=raw_results,
             test_id=self.test_id,
             description=inspect.getdoc(self),
+            inputs=input_ids,
+            params=param_kwargs,
             output_template=self.output_template,
-            inputs=self.get_accessed_inputs(),
             generate_description=self.generate_description,
         )
 

validmind/tests/model_validation/BertScore.py

@@ -13,39 +13,48 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def BertScore(dataset, model):
     """
-    Evaluates the quality of machine-generated text using BERTScore metrics and visualizes the results through histograms
-    and bar charts, alongside compiling a comprehensive table of descriptive statistics for each BERTScore metric.
-
-    **Purpose:**
-    This function is designed to assess the quality of text generated by machine learning models using BERTScore metrics.
-    BERTScore evaluates text generation models' performance by calculating precision, recall, and F1 score based on BERT
-    contextual embeddings.
-
-    **Test Mechanism:**
-    The function starts by extracting the true and predicted values from the provided dataset and model. It then initializes
-    the BERTScore evaluator. For each pair of true and predicted texts, the function calculates the BERTScore metrics and
-    compiles them into a dataframe. Histograms and bar charts are generated for each BERTScore metric (Precision, Recall,
-    and F1 Score) to visualize their distribution. Additionally, a table of descriptive statistics (mean, median, standard
-    deviation, minimum, and maximum) is compiled for each metric, providing a comprehensive summary of the model's performance.
-
-    **Signs of High Risk:**
-    - Consistently low scores across BERTScore metrics could indicate poor quality in the generated text, suggesting that the model
-      fails to capture the essential content of the reference texts.
+    Assesses the quality of machine-generated text using BERTScore metrics and visualizes results through histograms
+    and bar charts, alongside compiling a comprehensive table of descriptive statistics.
+
+    ### Purpose
+
+    This function is designed to assess the quality of text generated by machine learning models using BERTScore
+    metrics. BERTScore evaluates text generation models' performance by calculating precision, recall, and F1 score
+    based on BERT contextual embeddings.
+
+    ### Test Mechanism
+
+    The function starts by extracting the true and predicted values from the provided dataset and model. It then
+    initializes the BERTScore evaluator. For each pair of true and predicted texts, the function calculates the
+    BERTScore metrics and compiles them into a dataframe. Histograms and bar charts are generated for each BERTScore
+    metric (Precision, Recall, and F1 Score) to visualize their distribution. Additionally, a table of descriptive
+    statistics (mean, median, standard deviation, minimum, and maximum) is compiled for each metric, providing a
+    comprehensive summary of the model's performance.
+
+    ### Signs of High Risk
+
+    - Consistently low scores across BERTScore metrics could indicate poor quality in the generated text, suggesting
+    that the model fails to capture the essential content of the reference texts.
     - Low precision scores might suggest that the generated text contains a lot of redundant or irrelevant information.
     - Low recall scores may indicate that important information from the reference text is being omitted.
-    - An imbalanced performance between precision and recall, reflected by a low F1 Score, could signal issues in the model's ability
-      to balance informativeness and conciseness.
+    - An imbalanced performance between precision and recall, reflected by a low F1 Score, could signal issues in the
+    model's ability to balance informativeness and conciseness.
 
-    **Strengths:**
-    - Provides a multifaceted evaluation of text quality through different BERTScore metrics, offering a detailed view of model performance.
-    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of the scores.
+    ### Strengths
+
+    - Provides a multifaceted evaluation of text quality through different BERTScore metrics, offering a detailed view
+    of model performance.
+    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of the
+    scores.
     - Descriptive statistics offer a concise summary of the model's strengths and weaknesses in generating text.
 
-    **Limitations:**
-    - BERTScore relies on the contextual embeddings from BERT models, which may not fully capture all nuances of text similarity.
+    ### Limitations
+
+    - BERTScore relies on the contextual embeddings from BERT models, which may not fully capture all nuances of text
+    similarity.
     - The evaluation relies on the availability of high-quality reference texts, which may not always be obtainable.
-    - While useful for comparison, BERTScore metrics alone do not provide a complete assessment of a model's performance and should be
-      supplemented with other metrics and qualitative analysis.
+    - While useful for comparison, BERTScore metrics alone do not provide a complete assessment of a model's
+    performance and should be supplemented with other metrics and qualitative analysis.
     """
 
     # Extract true and predicted values

validmind/tests/model_validation/BleuScore.py

@@ -16,39 +16,45 @@ def BleuScore(dataset, model):
     Evaluates the quality of machine-generated text using BLEU metrics and visualizes the results through histograms
     and bar charts, alongside compiling a comprehensive table of descriptive statistics for BLEU scores.
 
-    **Purpose:**
+    ### Purpose
+
     This function is designed to assess the quality of text generated by machine learning models using the BLEU metric.
     BLEU, which stands for Bilingual Evaluation Understudy, is a metric used to evaluate the overlap of n-grams between
     the machine-generated text and reference texts. This evaluation is crucial for tasks such as text summarization,
     machine translation, and text generation, where the goal is to produce text that accurately reflects the content
     and meaning of human-crafted references.
 
-    **Test Mechanism:**
-    The function starts by extracting the true and predicted values from the provided dataset and model. It then initializes
-    the BLEU evaluator. For each pair of true and predicted texts, the function calculates the BLEU scores and compiles them
-    into a dataframe. Histograms and bar charts are generated for the BLEU scores to visualize their distribution. Additionally,
-    a table of descriptive statistics (mean, median, standard deviation, minimum, and maximum) is compiled for the BLEU scores,
-    providing a comprehensive summary of the model's performance.
+    ### Test Mechanism
+
+    The function starts by extracting the true and predicted values from the provided dataset and model. It then
+    initializes the BLEU evaluator. For each pair of true and predicted texts, the function calculates the BLEU scores
+    and compiles them into a dataframe. Histograms and bar charts are generated for the BLEU scores to visualize their
+    distribution. Additionally, a table of descriptive statistics (mean, median, standard deviation, minimum, and
+    maximum) is compiled for the BLEU scores, providing a comprehensive summary of the model's performance.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk:**
-    - Consistently low BLEU scores could indicate poor quality in the generated text, suggesting that the model fails to capture
-      the essential content of the reference texts.
+    - Consistently low BLEU scores could indicate poor quality in the generated text, suggesting that the model fails
+    to capture the essential content of the reference texts.
     - Low precision scores might suggest that the generated text contains a lot of redundant or irrelevant information.
     - Low recall scores may indicate that important information from the reference text is being omitted.
-    - An imbalanced performance between precision and recall, reflected by a low BLEU score, could signal issues in the model's
-      ability to balance informativeness and conciseness.
+    - An imbalanced performance between precision and recall, reflected by a low BLEU score, could signal issues in the
+    model's ability to balance informativeness and conciseness.
+
+    ### Strengths
 
-    **Strengths:**
     - Provides a straightforward and widely-used evaluation of text quality through BLEU scores.
-    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of the scores.
+    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of the
+    scores.
     - Descriptive statistics offer a concise summary of the model's strengths and weaknesses in generating text.
 
-    **Limitations:**
-    - BLEU metrics primarily focus on n-gram overlap and may not fully capture semantic coherence, fluency, or grammatical quality
-      of the text.
+    ### Limitations
+
+    - BLEU metrics primarily focus on n-gram overlap and may not fully capture semantic coherence, fluency, or
+    grammatical quality of the text.
     - The evaluation relies on the availability of high-quality reference texts, which may not always be obtainable.
-    - While useful for comparison, BLEU scores alone do not provide a complete assessment of a model's performance and should be
-      supplemented with other metrics and qualitative analysis.
+    - While useful for comparison, BLEU scores alone do not provide a complete assessment of a model's performance and
+    should be supplemented with other metrics and qualitative analysis.
     """
 
     # Extract true and predicted values