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

validmind/tests/model_validation/MeteorScore.py

@@ -13,39 +13,52 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def MeteorScore(dataset, model):
     """
-    Computes and visualizes the METEOR score for each text generation instance, assessing translation quality.
-
-    **Purpose:**
-    METEOR (Metric for Evaluation of Translation with Explicit ORdering) is designed to evaluate the quality of machine translations
-    by comparing them against reference translations. It emphasizes both the accuracy and fluency of translations, incorporating
-    precision, recall, and word order into its assessment.
-
-    **Test Mechanism:**
-    The function starts by extracting the true and predicted values from the provided dataset and model. The METEOR score is computed
-    for each pair of machine-generated translation (prediction) and its corresponding human-produced reference. This is done by
-    considering unigram matches between the translations, including matches based on surface forms, stemmed forms, and synonyms.
-    The score is a combination of unigram precision and recall, adjusted for word order through a fragmentation penalty. Scores are
-    compiled into a dataframe, and histograms and bar charts are generated to visualize the distribution of METEOR scores. Additionally,
-    a table of descriptive statistics (mean, median, standard deviation, minimum, and maximum) is compiled for the METEOR scores,
-    providing a comprehensive summary of the model's performance.
-
-    **Signs of High Risk:**
-    - Lower METEOR scores can indicate a lack of alignment between the machine-generated translations and their human-produced references,
-      highlighting potential deficiencies in both the accuracy and fluency of translations.
-    - Significant discrepancies in word order or an excessive fragmentation penalty could signal issues with how the translation model processes
-      and reconstructs sentence structures, potentially compromising the natural flow of translated text.
-    - Persistent underperformance across a variety of text types or linguistic contexts might suggest a broader inability of the model to adapt to the
-      nuances of different languages or dialects, pointing towards gaps in its training or inherent limitations.
-
-    **Strengths:**
-    - Incorporates a balanced consideration of precision and recall, weighted towards recall to reflect the importance of content coverage in translations.
-    - Directly accounts for word order, offering a nuanced evaluation of translation fluency beyond simple lexical matching.
-    - Adapts to various forms of lexical similarity, including synonyms and stemmed forms, allowing for flexible matching.
-
-    **Limitations:**
-    - While comprehensive, the complexity of METEOR's calculation can make it computationally intensive, especially for large datasets.
-    - The use of external resources for synonym and stemming matching may introduce variability based on the resources' quality and relevance to the specific
-      translation task.
+    Assesses the quality of machine-generated translations by comparing them to human-produced references using the
+    METEOR score, which evaluates precision, recall, and word order.
+
+    ### Purpose
+
+    The METEOR (Metric for Evaluation of Translation with Explicit ORdering) score is designed to evaluate the quality
+    of machine translations by comparing them against reference translations. It emphasizes both the accuracy and
+    fluency of translations, incorporating precision, recall, and word order into its assessment.
+
+    ### Test Mechanism
+
+    The function starts by extracting the true and predicted values from the provided dataset and model. The METEOR
+    score is computed for each pair of machine-generated translation (prediction) and its corresponding human-produced
+    reference. This is done by considering unigram matches between the translations, including matches based on surface
+    forms, stemmed forms, and synonyms. The score is a combination of unigram precision and recall, adjusted for word
+    order through a fragmentation penalty. Scores are compiled into a dataframe, and histograms and bar charts are
+    generated to visualize the distribution of METEOR scores. Additionally, a table of descriptive statistics (mean,
+    median, standard deviation, minimum, and maximum) is compiled for the METEOR scores, providing a comprehensive
+    summary of the model's performance.
+
+    ### Signs of High Risk
+
+    - Lower METEOR scores can indicate a lack of alignment between the machine-generated translations and their
+    human-produced references, highlighting potential deficiencies in both the accuracy and fluency of translations.
+    - Significant discrepancies in word order or an excessive fragmentation penalty could signal issues with how the
+    translation model processes and reconstructs sentence structures, potentially compromising the natural flow of
+    translated text.
+    - Persistent underperformance across a variety of text types or linguistic contexts might suggest a broader
+    inability of the model to adapt to the nuances of different languages or dialects, pointing towards gaps in its
+    training or inherent limitations.
+
+    ### Strengths
+
+    - Incorporates a balanced consideration of precision and recall, weighted towards recall to reflect the importance
+    of content coverage in translations.
+    - Directly accounts for word order, offering a nuanced evaluation of translation fluency beyond simple lexical
+    matching.
+    - Adapts to various forms of lexical similarity, including synonyms and stemmed forms, allowing for flexible
+    matching.
+
+    ### Limitations
+
+    - While comprehensive, the complexity of METEOR's calculation can make it computationally intensive, especially for
+    large datasets.
+    - The use of external resources for synonym and stemming matching may introduce variability based on the resources'
+    quality and relevance to the specific translation task.
     """
 
     # Extract true and predicted values

validmind/tests/model_validation/ModelMetadata.py

@@ -2,66 +2,36 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-from dataclasses import dataclass
-
 import pandas as pd
 
+from validmind import tags, tasks
 from validmind.utils import get_model_info
-from validmind.vm_models import Metric, ResultSummary, ResultTable
 
 
-@dataclass
-class ModelMetadata(Metric):
+@tags("model_training", "metadata")
+@tasks("regression", "time_series_forecasting")
+def ModelMetadata(model):
     """
-    Extracts and summarizes critical metadata from a machine learning model instance for comprehensive analysis.
-
-    **Purpose:**
-    This test is designed to collect and summarize important metadata related to a particular machine learning model.
-    Such metadata includes the model's architecture (modeling technique), the version and type of modeling framework
-    used, and the programming language the model is written in.
-
-    **Test Mechanism:**
-    The mechanism of this test consists of extracting information from the model instance. It tries to extract the
-    model information such as the modeling technique used, the modeling framework version, and the programming
-    language. It decorates this information into a data frame and returns a summary of the results.
+    Compare metadata of different models and generate a summary table with the results.
 
-    **Signs of High Risk:**
+    **Purpose**: The purpose of this function is to compare the metadata of different models, including information about their architecture, framework, framework version, and programming language.
 
-    - High risk could be determined by a lack of documentation or inscrutable metadata for the model.
-    - Unidentifiable language, outdated or unsupported versions of modeling frameworks, or undisclosed model
-    architectures reflect risky situations, as they could hinder future reproducibility, support, and debugging of the
-    model.
+    **Test Mechanism**: The function retrieves the metadata for each model using `get_model_info`, renames columns according to a predefined set of labels, and compiles this information into a summary table.
 
-    **Strengths:**
+    **Signs of High Risk**:
+    - Inconsistent or missing metadata across models can indicate potential issues in model documentation or management.
+    - Significant differences in framework versions or programming languages might pose challenges in model integration and deployment.
 
-    - The strengths of this test lie in the increased transparency and understanding it brings regarding the model's
-    setup.
-    - Knowing the model's architecture, the specific modeling framework version used, and the language involved,
-    provides multiple benefits: supports better error understanding and debugging, facilitates model reuse, aids
-    compliance of software policies, and assists in planning for model obsolescence due to evolving or discontinuing
-    software and dependencies.
+    **Strengths**:
+    - Provides a clear comparison of essential model metadata.
+    - Standardizes metadata labels for easier interpretation and comparison.
+    - Helps identify potential compatibility or consistency issues across models.
 
-    **Limitations:**
-
-    - Notably, this test is largely dependent on the compliance and correctness of information provided by the model or
-    the model developer.
-    - If the model's built-in methods for describing its architecture, framework or language are incorrect or lack
-    necessary information, this test will hold limitations.
-    - Moreover, it is not designed to directly evaluate the performance or accuracy of the model, rather it provides
-    supplementary information which aids in comprehensive analysis.
+    **Limitations**:
+    - Assumes that the `get_model_info` function returns all necessary metadata fields.
+    - Relies on the correctness and completeness of the metadata provided by each model.
+    - Does not include detailed parameter information, focusing instead on high-level metadata.
     """
-
-    name = "model_metadata"
-    required_inputs = ["model"]
-    tasks = [
-        "classification",
-        "regression",
-        "text_classification",
-        "text_summarization",
-    ]
-
-    tags = ["model_metadata"]
-
     column_labels = {
         "architecture": "Modeling Technique",
         "framework": "Modeling Framework",
@@ -69,22 +39,20 @@ class ModelMetadata(Metric):
         "language": "Programming Language",
     }
 
-    def summary(self, metric_value):
-        df = pd.DataFrame(metric_value.items(), columns=["Attribute", "Value"])
-        # Don't serialize the params attribute
-        df = df[df["Attribute"] != "params"]
-        df["Attribute"] = df["Attribute"].map(self.column_labels)
-
-        return ResultSummary(
-            results=[
-                ResultTable(data=df.to_dict(orient="records")),
-            ]
-        )
-
-    def run(self):
+    def extract_and_rename_metadata(model):
         """
-        Extracts model metadata from a model object instance
+        Extracts metadata for a single model and renames columns based on predefined labels.
         """
-        model_info = get_model_info(self.inputs.model)
+        model_info = get_model_info(model)
+        renamed_info = {
+            column_labels.get(k, k): v for k, v in model_info.items() if k != "params"
+        }
+        return renamed_info
+
+    # Collect metadata for all models
+    metadata_list = [extract_and_rename_metadata(model)]
+
+    # Create a DataFrame from the collected metadata
+    metadata_df = pd.DataFrame(metadata_list)
 
-        return self.cache_results(model_info)
+    return metadata_df

validmind/tests/model_validation/ModelPredictionResiduals.py

@@ -12,92 +12,94 @@ from validmind import tags, tasks
 @tags("regression")
 @tasks("residual_analysis", "visualization")
 def ModelPredictionResiduals(
-    datasets, models, nbins=100, p_value_threshold=0.05, start_date=None, end_date=None
+    dataset, model, nbins=100, p_value_threshold=0.05, start_date=None, end_date=None
 ):
     """
-    Plot the residuals and histograms for each model, and generate a summary table
-    with the Kolmogorov-Smirnov normality test results.
+    Assesses normality and behavior of residuals in regression models through visualization and statistical tests.
 
-    **Purpose**: The purpose of this function is to visualize the residuals of model predictions and
-    assess the normality of residuals using the Kolmogorov-Smirnov test.
+    ### Purpose
 
-    **Test Mechanism**: The function iterates through each dataset-model pair, calculates residuals, and generates
-    two figures for each model: one for the time series of residuals and one for the histogram of residuals.
+    The Model Prediction Residuals test aims to visualize the residuals of model predictions and assess their normality
+    using the Kolmogorov-Smirnov (KS) test. It helps to identify potential issues related to model assumptions and
+    effectiveness.
+
+    ### Test Mechanism
+
+    The function calculates residuals and generates
+    two figures: one for the time series of residuals and one for the histogram of residuals.
     It also calculates the KS test for normality and summarizes the results in a table.
 
-    **Signs of High Risk**:
-    - If the residuals are not normally distributed, it could indicate issues with model assumptions.
-    - High skewness or kurtosis in the residuals may indicate model misspecification.
+    ### Signs of High Risk
+
+    - Residuals are not normally distributed, indicating potential issues with model assumptions.
+    - High skewness or kurtosis in the residuals, which may suggest model misspecification.
 
-    **Strengths**:
-    - Provides a clear visualization of residuals over time and their distribution.
+    ### Strengths
+
+    - Provides clear visualizations of residuals over time and their distribution.
     - Includes statistical tests to assess the normality of residuals.
+    - Helps in identifying potential model misspecifications and assumption violations.
+
+    ### Limitations
 
-    **Limitations**:
-    - Assumes that the dataset is provided as a DataFrameDataset object with a .df attribute to access
-      the pandas DataFrame.
-    - Only generates plots for datasets with a datetime index, and will raise an error for other types of indices.
+    - Assumes that the dataset is provided as a DataFrameDataset object with a .df attribute to access the pandas
+    DataFrame.
+    - Only generates plots for datasets with a datetime index, resulting in errors for other types of indices.
     """
 
+    df = dataset.df.copy()
+
+    # Filter DataFrame by date range if specified
+    if start_date:
+        df = df[df.index >= pd.to_datetime(start_date)]
+    if end_date:
+        df = df[df.index <= pd.to_datetime(end_date)]
+
+    y_true = dataset.y
+    y_pred = dataset.y_pred(model)
+    residuals = y_true - y_pred
+
     figures = []
-    summary = []
-
-    for dataset, model in zip(datasets, models):
-        df = dataset.df.copy()
-
-        # Filter DataFrame by date range if specified
-        if start_date:
-            df = df[df.index >= pd.to_datetime(start_date)]
-        if end_date:
-            df = df[df.index <= pd.to_datetime(end_date)]
-
-        y_true = dataset.y
-        y_pred = dataset.y_pred(model)
-        residuals = y_true - y_pred
-
-        # Plot residuals
-        residuals_fig = go.Figure()
-        residuals_fig.add_trace(
-            go.Scatter(x=df.index, y=residuals, mode="lines", name="Residuals")
-        )
-        residuals_fig.update_layout(
-            title=f"Residuals for {model.input_id}",
-            xaxis_title="Date",
-            yaxis_title="Residuals",
-            font=dict(size=16),
-            showlegend=False,
-        )
-        figures.append(residuals_fig)
-
-        # Plot histogram of residuals
-        hist_fig = go.Figure()
-        hist_fig.add_trace(go.Histogram(x=residuals, nbinsx=nbins, name="Residuals"))
-        hist_fig.update_layout(
-            title=f"Histogram of Residuals for {model.input_id}",
-            xaxis_title="Residuals",
-            yaxis_title="Frequency",
-            font=dict(size=16),
-            showlegend=False,
-        )
-        figures.append(hist_fig)
-
-        # Perform KS normality test
-        ks_stat, p_value = kstest(
-            residuals, "norm", args=(residuals.mean(), residuals.std())
-        )
-        ks_normality = "Normal" if p_value > p_value_threshold else "Not Normal"
-
-        summary.append(
-            {
-                "Model": model.input_id,
-                "KS Statistic": ks_stat,
-                "p-value": p_value,
-                "KS Normality": ks_normality,
-                "p-value Threshold": p_value_threshold,
-            }
-        )
+
+    # Plot residuals
+    residuals_fig = go.Figure()
+    residuals_fig.add_trace(
+        go.Scatter(x=df.index, y=residuals, mode="markers", name="Residuals")
+    )
+    residuals_fig.update_layout(
+        title="Residuals",
+        yaxis_title="Residuals",
+        font=dict(size=16),
+        showlegend=False,
+    )
+    figures.append(residuals_fig)
+
+    # Plot histogram of residuals
+    hist_fig = go.Figure()
+    hist_fig.add_trace(go.Histogram(x=residuals, nbinsx=nbins, name="Residuals"))
+    hist_fig.update_layout(
+        title="Histogram of Residuals",
+        xaxis_title="Residuals",
+        yaxis_title="Frequency",
+        font=dict(size=16),
+        showlegend=False,
+    )
+    figures.append(hist_fig)
+
+    # Perform KS normality test
+    ks_stat, p_value = kstest(
+        residuals, "norm", args=(residuals.mean(), residuals.std())
+    )
+    ks_normality = "Normal" if p_value > p_value_threshold else "Not Normal"
+
+    summary = {
+        "KS Statistic": ks_stat,
+        "p-value": p_value,
+        "KS Normality": ks_normality,
+        "p-value Threshold": p_value_threshold,
+    }
 
     # Create a summary DataFrame for the KS normality test results
-    summary_df = pd.DataFrame(summary)
+    summary_df = pd.DataFrame([summary])
 
     return (summary_df, *figures)

validmind/tests/model_validation/RegardScore.py

@@ -13,26 +13,42 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def RegardScore(dataset, model):
     """
-    Computes and visualizes the regard score for each text instance, assessing sentiment and potential biases.
+    Assesses the sentiment and potential biases in text generated by NLP models by computing and visualizing regard
+    scores.
 
-    **Purpose:**
-    The `RegardScore` metric is designed to evaluate the regard levels (positive, negative, neutral, or other) of texts generated by models. This helps in understanding the sentiment and biases in the generated content.
+    ### Purpose
 
-    **Test Mechanism:**
-    The function starts by extracting the true and predicted values from the provided dataset and model. The regard scores are computed for each text using a preloaded `regard` evaluation tool. The scores are compiled into dataframes, and histograms and bar charts are generated to visualize the distribution of regard scores. Additionally, a table of descriptive statistics (mean, median, standard deviation, minimum, and maximum) is compiled for the regard scores, providing a comprehensive summary of the model's performance.
+    The `RegardScore` test aims to evaluate the levels of regard (positive, negative, neutral, or other) in texts
+    generated by NLP models. It helps in understanding the sentiment and bias present in the generated content.
 
-    **Signs of High Risk:**
-    - Noticeable skewness in the histogram, especially when comparing the predicted regard scores with the target regard scores, could indicate biases or inconsistencies in the model.
-    - Lack of neutral scores in the model's predictions, despite a balanced distribution in the target data, might signal an issue.
+    ### Test Mechanism
 
-    **Strengths:**
-    - Provides a clear evaluation of regard levels in generated texts, helping to ensure content appropriateness.
-    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of regard scores.
-    - Descriptive statistics offer a concise summary of the model's performance in generating texts with balanced sentiments.
+    This test extracts the true and predicted values from the provided dataset and model. It then computes the regard
+    scores for each text instance using a preloaded `regard` evaluation tool. The scores are compiled into dataframes,
+    and visualizations such as histograms and bar charts are generated to display the distribution of regard scores.
+    Additionally, descriptive statistics (mean, median, standard deviation, minimum, and maximum) are calculated for
+    the regard scores, providing a comprehensive overview of the model's performance.
+
+    ### Signs of High Risk
+
+    - Noticeable skewness in the histogram, especially when comparing the predicted regard scores with the target
+    regard scores, can indicate biases or inconsistencies in the model.
+    - Lack of neutral scores in the model's predictions, despite a balanced distribution in the target data, might
+    signal an issue.
+
+    ### Strengths
+
+    - Provides a clear evaluation of regard levels in generated texts, aiding in ensuring content appropriateness.
+    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of
+    regard scores.
+    - Descriptive statistics offer a concise summary of the model's performance in generating texts with balanced
+    sentiments.
+
+    ### Limitations
 
-    **Limitations:**
     - The accuracy of the regard scores is contingent upon the underlying `regard` tool.
-    - The scores provide a broad overview but do not specify which portions or tokens of the text are responsible for high regard.
+    - The scores provide a broad overview but do not specify which portions or tokens of the text are responsible for
+    high regard.
     - Supplementary, in-depth analysis might be needed for granular insights.
     """
 

validmind/tests/model_validation/RegressionResidualsPlot.py

@@ -16,19 +16,22 @@ class RegressionResidualsPlot(Metric):
     """
     Evaluates regression model performance using residual distribution and actual vs. predicted plots.
 
-    **Purpose:**
+    ### Purpose
+
     The `RegressionResidualsPlot` metric aims to evaluate the performance of regression models. By generating and
     analyzing two plots – a distribution of residuals and a scatter plot of actual versus predicted values – this tool
     helps to visually appraise how well the model predicts and the nature of errors it makes.
 
-    **Test Mechanism:**
+    ### Test Mechanism
+
     The process begins by extracting the true output values (`y_true`) and the model's predicted values (`y_pred`).
     Residuals are computed by subtracting predicted from true values. These residuals are then visualized using a
     histogram to display their distribution. Additionally, a scatter plot is derived to compare true values against
     predicted values, together with a "Perfect Fit" line, which represents an ideal match (predicted values equal
     actual values), facilitating the assessment of the model's predictive accuracy.
 
-    **Signs of High Risk:**
+    ### Signs of High Risk
+
     - Residuals showing a non-normal distribution, especially those with frequent extreme values.
     - Significant deviations of predicted values from actual values in the scatter plot.
     - Sparse density of data points near the "Perfect Fit" line in the scatter plot, indicating poor prediction
@@ -36,13 +39,15 @@ class RegressionResidualsPlot(Metric):
     - Visible patterns or trends in the residuals plot, suggesting the model's failure to capture the underlying data
     structure adequately.
 
-    **Strengths:**
+    ### Strengths
+
     - Provides a direct, visually intuitive assessment of a regression model’s accuracy and handling of data.
     - Visual plots can highlight issues of underfitting or overfitting.
     - Can reveal systematic deviations or trends that purely numerical metrics might miss.
     - Applicable across various regression model types.
 
-    **Limitations:**
+    ### Limitations
+
     - Relies on visual interpretation, which can be subjective and less precise than numerical evaluations.
     - May be difficult to interpret in cases with multi-dimensional outputs due to the plots’ two-dimensional nature.
     - Overlapping data points in the residuals plot can complicate interpretation efforts.

validmind/tests/model_validation/RougeScore.py

@@ -13,44 +13,50 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def RougeScore(dataset, model, metric="rouge-1"):
     """
-    Evaluates the quality of machine-generated text using ROUGE metrics and visualizes the results through histograms
-    and bar charts, alongside compiling a comprehensive table of descriptive statistics for each ROUGE metric.
-
-    **Purpose:**
-    This function is designed to assess the quality of text generated by machine learning models using various ROUGE metrics.
-    ROUGE, which stands for Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics used to evaluate the
-    overlap of n-grams, word sequences, and word pairs 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 ROUGE
-    evaluator with the specified metric (e.g., ROUGE-1). For each pair of true and predicted texts, the function calculates the ROUGE
-    scores and compiles them into a dataframe. Histograms and bar charts are generated for each ROUGE 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 ROUGE 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 ROUGE metrics and visualizes the results to provide
+    comprehensive performance insights.
+
+    ### Purpose
+
+    The ROUGE Score test is designed to evaluate the quality of text generated by machine learning models using various
+    ROUGE metrics. ROUGE, which stands for Recall-Oriented Understudy for Gisting Evaluation, measures the overlap of
+    n-grams, word sequences, and word pairs between machine-generated text and reference texts. This evaluation is
+    crucial for tasks like 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 test extracts the true and predicted values from the provided dataset and model. It initializes the ROUGE
+    evaluator with the specified metric (e.g., ROUGE-1). For each pair of true and predicted texts, it calculates the
+    ROUGE scores and compiles them into a dataframe. Histograms and bar charts are generated for each ROUGE 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 ROUGE 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:**
+    ### Strengths
 
-    - Provides a multifaceted evaluation of text quality through different ROUGE 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.
+    - Provides a multifaceted evaluation of text quality through different ROUGE 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:**
+    ### Limitations
 
-    - ROUGE metrics primarily focus on n-gram overlap and may not fully capture semantic coherence, fluency, or grammatical quality of the text.
+    - ROUGE 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, ROUGE 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, ROUGE 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