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

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

validmind/tests/model_validation/TimeSeriesPredictionWithCI.py

@@ -14,28 +14,45 @@ from validmind import tags, tasks
 @tasks("regression", "time_series_forecasting")
 def TimeSeriesPredictionWithCI(dataset, model, confidence=0.95):
     """
-    Plot actual vs predicted values for a time series with confidence intervals and compute breaches.
+    Assesses predictive accuracy and uncertainty in time series models, highlighting breaches beyond confidence
+    intervals.
 
-    **Purpose**: The purpose of this function is to visualize the actual versus predicted values for time series data, including confidence intervals, and to compute and report the number of breaches beyond these intervals.
+    ### Purpose
 
-    **Test Mechanism**: The function calculates the standard deviation of prediction errors, determines the confidence intervals, and counts the number of actual values that fall outside these intervals (breaches). It then generates a plot with the actual values, predicted values, and confidence intervals, and returns a DataFrame summarizing the breach information.
+    The purpose of the Time Series Prediction with Confidence Intervals (CI) test is to visualize the actual versus
+    predicted values for time series data, including confidence intervals, and to compute and report the number of
+    breaches beyond these intervals. This helps in evaluating the reliability and accuracy of the model's predictions.
 
-    **Signs of High Risk**:
-    - A high number of breaches indicates that the model's predictions are not reliable within the specified confidence level.
-    - Significant deviations between actual and predicted values may highlight model inadequacies or issues with data quality.
+    ### Test Mechanism
+
+    The function performs the following steps:
+
+    - Calculates the standard deviation of prediction errors.
+    - Determines the confidence intervals using a specified confidence level, typically 95%.
+    - Counts the number of actual values that fall outside the confidence intervals, referred to as breaches.
+    - Generates a plot visualizing the actual values, predicted values, and confidence intervals.
+    - Returns a DataFrame summarizing the breach information, including the total breaches, upper breaches, and lower
+    breaches.
+
+    ### Signs of High Risk
+
+    - A high number of breaches indicates that the model's predictions are not reliable within the specified confidence
+    level.
+    - Significant deviations between actual and predicted values may highlight model inadequacies or issues with data
+    quality.
+
+    ### Strengths
 
-    **Strengths**:
     - Provides a visual representation of prediction accuracy and the uncertainty around predictions.
     - Includes a statistical measure of prediction reliability through confidence intervals.
     - Computes and reports breaches, offering a quantitative assessment of prediction performance.
 
-    **Limitations**:
+    ### Limitations
+
     - Assumes that the dataset is provided as a DataFrameDataset object with a datetime index.
     - Requires that `dataset.y_pred(model)` returns the predicted values for the model.
     - The calculation of confidence intervals assumes normally distributed errors, which may not hold for all datasets.
     """
-    dataset_name = dataset.input_id
-    model_name = model.input_id
     time_index = dataset.df.index  # Assuming the index of the dataset is datetime
 
     # Get actual and predicted values
@@ -77,7 +94,7 @@ def TimeSeriesPredictionWithCI(dataset, model, confidence=0.95):
             x=time_index,
             y=y_true,
             mode="lines",
-            name="Actual Values",
+            name="Actual",
             line=dict(color="blue"),
         )
     )
@@ -88,7 +105,7 @@ def TimeSeriesPredictionWithCI(dataset, model, confidence=0.95):
             x=time_index,
             y=y_pred,
             mode="lines",
-            name=f"Predicted by {model_name}",
+            name="Predicted",
             line=dict(color="red"),
         )
     )
@@ -121,10 +138,9 @@ def TimeSeriesPredictionWithCI(dataset, model, confidence=0.95):
 
     # Update layout
     fig.update_layout(
-        title=f"Time Series Actual vs Predicted Values for {dataset_name} and {model_name}",
+        title="Actual vs Predicted",
         xaxis_title="Time",
         yaxis_title="Values",
-        legend_title="Legend",
         template="plotly_white",
     )
 

validmind/tests/model_validation/TimeSeriesPredictionsPlot.py

@@ -2,7 +2,6 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-import plotly.express as px
 import plotly.graph_objects as go
 
 from validmind import tags, tasks
@@ -10,66 +9,64 @@ from validmind import tags, tasks
 
 @tags("model_predictions", "visualization")
 @tasks("regression", "time_series_forecasting")
-def TimeSeriesPredictionsPlot(datasets, models):
+def TimeSeriesPredictionsPlot(dataset, model):
     """
-    Plot actual vs predicted values for time series data and generate a visual comparison for each model.
+    Plot actual vs predicted values for time series data and generate a visual comparison for the model.
 
-    **Purpose**: The purpose of this function is to visualize the actual versus predicted values for time series data across different models.
+    ### Purpose
 
-    **Test Mechanism**: The function iterates through each dataset-model pair, plots the actual values from the dataset, and overlays the predicted values from each model using Plotly for interactive visualization.
+    The purpose of this function is to visualize the actual versus predicted values for time
+    series data for a single model.
+
+    ### Test Mechanism
+
+    The function plots the actual values from the dataset and overlays the predicted
+    values from the model using Plotly for interactive visualization.
 
-    **Signs of High Risk**:
     - Large discrepancies between actual and predicted values indicate poor model performance.
     - Systematic deviations in predicted values can highlight model bias or issues with data patterns.
 
-    **Strengths**:
+    ### Strengths
+
     - Provides a clear visual comparison of model predictions against actual values.
     - Uses Plotly for interactive and visually appealing plots.
-    - Can handle multiple models and datasets, displaying them with distinct colors.
 
-    **Limitations**:
+    ### Limitations
+
     - Assumes that the dataset is provided as a DataFrameDataset object with a datetime index.
     - Requires that `dataset.y_pred(model)` returns the predicted values for the model.
-    - Visualization might become cluttered with a large number of models or datasets.
     """
     fig = go.Figure()
 
-    # Use Plotly's color sequence for different model predictions
-    colors = px.colors.qualitative.Plotly
-
-    # Plot actual values from the first dataset
-    dataset = datasets[0]
+    # Plot actual values from the dataset
     time_index = dataset.df.index  # Assuming the index of the dataset is datetime
     fig.add_trace(
         go.Scatter(
             x=time_index,
             y=dataset.y,
             mode="lines",
-            name="Actual Values",
+            name="Actual",
             line=dict(color="blue"),
         )
     )
 
-    # Plot predicted values for each dataset-model pair
-    for idx, (dataset, model) in enumerate(zip(datasets, models)):
-        model_name = model.input_id
-        y_pred = dataset.y_pred(model)
-        fig.add_trace(
-            go.Scatter(
-                x=time_index,
-                y=y_pred,
-                mode="lines",
-                name=f"Predicted by {model_name}",
-                line=dict(color=colors[idx % len(colors)]),
-            )
+    # Plot predicted values for the model
+    y_pred = dataset.y_pred(model)
+    fig.add_trace(
+        go.Scatter(
+            x=time_index,
+            y=y_pred,
+            mode="lines",
+            name="Predicted",
+            line=dict(color="orange"),  # Using a distinct color for the prediction
         )
+    )
 
     # Update layout
     fig.update_layout(
-        title="Time Series Actual vs Predicted Values",
+        title="Actual vs Predicted",
         xaxis_title="Time",
         yaxis_title="Values",
-        legend_title="Legend",
         template="plotly_white",
     )
 

validmind/tests/model_validation/TimeSeriesR2SquareBySegments.py

@@ -12,75 +12,80 @@ from validmind import tags, tasks
 
 @tags("model_performance", "sklearn")
 @tasks("regression", "time_series_forecasting")
-def TimeSeriesR2SquareBySegments(datasets, models, segments=None):
+def TimeSeriesR2SquareBySegments(dataset, model, segments=None):
     """
-    Plot R-Squared values for each model over specified time segments and generate a bar chart
-    with the results.
+    Evaluates the R-Squared values of regression models over specified time segments in time series data to assess
+    segment-wise model performance.
 
-    **Purpose**: The purpose of this function is to plot the R-Squared values for different models applied to various segments of the time series data.
+    ### Purpose
 
-    **Parameters**:
-    - datasets: List of datasets to evaluate.
-    - models: List of models to evaluate.
-    - segments: Dictionary with 'start_date' and 'end_date' keys containing lists of start and end dates for each segments. If None, the time series will be segmented into two halves.
+    The TimeSeriesR2SquareBySegments test aims to evaluate the R-Squared values for several regression models across
+    different segments of time series data. This helps in determining how well the models explain the variability in
+    the data within each specific time segment.
 
-    **Test Mechanism**: The function iterates through each dataset-model pair, calculates the R-Squared values for specified time segments, and generates a bar chart with these results.
+    ### Test Mechanism
+    - Provides a visual representation of model performance across different time segments.
+    - Allows for identification of segments where the model performs poorly.
+    - Calculating the R-Squared values for each segment.
+    - Generating a bar chart to visually represent the R-Squared values across different models and segments.
 
-    **Signs of High Risk**:
-    - If the R-Squared values are significantly low for certain segments, it could indicate that the model is not explaining much of the variability in the dataset for those segments.
+    ### Signs of High Risk
 
-    **Strengths**:
-    - Provides a visual representation of model performance across different time segments.
-    - Allows for identification of segments where models perform poorly.
+    - Significantly low R-Squared values for certain time segments, indicating poor model performance in those periods.
+    - Large variability in R-Squared values across different segments for the same model, suggesting inconsistent
+    performance.
+
+    ### Strengths
+
+    - Provides a visual representation of how well models perform over different time periods.
+    - Helps identify time segments where models may need improvement or retraining.
+    - Facilitates comparison between multiple models in a straightforward manner.
+
+    ### Limitations
 
-    **Limitations**:
-    - Assumes that the dataset is provided as a DataFrameDataset object with `y`, `y_pred`, and `feature_columns` attributes.
-    - Requires that `dataset.y_pred(model)` returns the predicted values for the model.
-    - Assumes that `y_true` and `y_pred` are pandas Series with datetime indices.
+    - Assumes datasets are provided as DataFrameDataset objects with the attributes `y`, `y_pred`, and
+    `feature_columns`.
+    - Requires that `dataset.y_pred(model)` returns predicted values for the model.
+    - Assumes that both `y_true` and `y_pred` are pandas Series with datetime indices, which may not always be the case.
+    - May not account for more nuanced temporal dependencies within the segments.
     """
     results_list = []
 
-    for dataset, model in zip(datasets, models):
-        dataset_name = dataset.input_id
-        model_name = model.input_id
-
-        y_true = dataset.y
-        y_pred = dataset.y_pred(model)
-
-        # Ensure y_true and y_pred are pandas Series with the same index
-        if not isinstance(y_true, pd.Series):
-            y_true = pd.Series(y_true, index=dataset.df.index)
-        if not isinstance(y_pred, pd.Series):
-            y_pred = pd.Series(y_pred, index=dataset.df.index)
-
-        index = dataset.df.index
-
-        if segments is None:
-            mid_point = len(index) // 2
-            segments = {
-                "start_date": [index.min(), index[mid_point]],
-                "end_date": [index[mid_point - 1], index.max()],
-            }
-
-        for segment_index, (start_date, end_date) in enumerate(
-            zip(segments["start_date"], segments["end_date"])
-        ):
-            mask = (index >= start_date) & (index <= end_date)
-            y_true_segment = y_true.loc[mask]
-            y_pred_segment = y_pred.loc[mask]
-
-            if len(y_true_segment) > 0 and len(y_pred_segment) > 0:
-                r2s = metrics.r2_score(y_true_segment, y_pred_segment)
-                results_list.append(
-                    {
-                        "Model": model_name,
-                        "Dataset": dataset_name,
-                        "Segments": f"Segment {segment_index + 1}",
-                        "Start Date": start_date,
-                        "End Date": end_date,
-                        "R-Squared": r2s,
-                    }
-                )
+    y_true = dataset.y
+    y_pred = dataset.y_pred(model)
+
+    # Ensure y_true and y_pred are pandas Series with the same index
+    if not isinstance(y_true, pd.Series):
+        y_true = pd.Series(y_true, index=dataset.df.index)
+    if not isinstance(y_pred, pd.Series):
+        y_pred = pd.Series(y_pred, index=dataset.df.index)
+
+    index = dataset.df.index
+
+    if segments is None:
+        mid_point = len(index) // 2
+        segments = {
+            "start_date": [index.min(), index[mid_point]],
+            "end_date": [index[mid_point - 1], index.max()],
+        }
+
+    for segment_index, (start_date, end_date) in enumerate(
+        zip(segments["start_date"], segments["end_date"])
+    ):
+        mask = (index >= start_date) & (index <= end_date)
+        y_true_segment = y_true.loc[mask]
+        y_pred_segment = y_pred.loc[mask]
+
+        if len(y_true_segment) > 0 and len(y_pred_segment) > 0:
+            r2s = metrics.r2_score(y_true_segment, y_pred_segment)
+            results_list.append(
+                {
+                    "Segments": f"Segment {segment_index + 1}",
+                    "Start Date": start_date,
+                    "End Date": end_date,
+                    "R-Squared": r2s,
+                }
+            )
 
     # Convert results list to a DataFrame
     results_df = pd.DataFrame(results_list)
@@ -90,13 +95,13 @@ def TimeSeriesR2SquareBySegments(datasets, models, segments=None):
         results_df,
         x="Segments",
         y="R-Squared",
-        color="Model",
+        # color="Model",
         barmode="group",
-        title="R-Squared Comparison by Segment and Model",
+        title="R-Squared by Segment",
         labels={
             "R-Squared": "R-Squared Value",
-            "Segment": "Time Segment",
-            "Model": "Model",
+            "Segments": "Time Segment",
+            # "Model": "Model",
         },
     )
 

validmind/tests/model_validation/TokenDisparity.py

@@ -12,33 +12,41 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def TokenDisparity(dataset, model):
     """
-    Evaluates the token disparity between reference and generated texts, visualizing the results through histograms
-    and bar charts, alongside compiling a comprehensive table of descriptive statistics for token counts.
-
-    **Purpose:**
-    This function is designed to assess the token disparity between reference and generated texts. Token disparity is
-    important for understanding how closely the length and token usage of generated texts match the reference texts.
-
-    **Test Mechanism:**
-    The function starts by extracting the true and predicted values from the provided dataset and model. It then calculates
-    the number of tokens in each reference and generated text. Histograms and bar charts are generated for the token counts
-    of both reference and generated texts to visualize their distribution. Additionally, a table of descriptive statistics
-    (mean, median, standard deviation, minimum, and maximum) is compiled for the token counts, providing a comprehensive
-    summary of the model's performance.
-
-    **Signs of High Risk:**
-    - Significant disparity in token counts between reference and generated texts could indicate issues with text generation
-      quality, such as verbosity or lack of detail.
+    Evaluates the token disparity between reference and generated texts, visualizing the results through histograms and
+    bar charts, alongside compiling a comprehensive table of descriptive statistics for token counts.
+
+    ### Purpose
+
+    The Token Disparity test aims to assess the difference in the number of tokens between reference texts and texts
+    generated by the model. Understanding token disparity is essential for evaluating how well the generated content
+    matches the expected length and richness of the reference texts.
+
+    ### Test Mechanism
+
+    The test extracts true and predicted values from the dataset and model. It computes the number of tokens in each
+    reference and generated text. The results are visualized using histograms and bar charts to display the
+    distribution of token counts. Additionally, a table of descriptive statistics, including the mean, median, standard
+    deviation, minimum, and maximum token counts, is compiled to provide a detailed summary of token usage.
+
+    ### Signs of High Risk
+
+    - Significant disparity in token counts between reference and generated texts could indicate issues with text
+    generation quality, such as verbosity or lack of detail.
     - Consistently low token counts in generated texts compared to references might suggest that the model is producing
-      incomplete or overly concise outputs.
+    incomplete or overly concise outputs.
+
+    ### Strengths
 
-    **Strengths:**
     - Provides a simple yet effective evaluation of text length and token usage.
-    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of token counts.
-    - Descriptive statistics offer a concise summary of the model's performance in generating texts of appropriate length.
+    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of
+    token counts.
+    - Descriptive statistics offer a concise summary of the model's performance in generating texts of appropriate
+    length.
+
+    ### Limitations
 
-    **Limitations:**
-    - Token counts alone do not provide a complete assessment of text quality and should be supplemented with other metrics and qualitative analysis.
+    - Token counts alone do not provide a complete assessment of text quality and should be supplemented with other
+    metrics and qualitative analysis.
     """
 
     # Extract true and predicted values