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

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

validmind/tests/model_validation/ToxicityScore.py

@@ -13,31 +13,40 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def ToxicityScore(dataset, model):
     """
-    Computes and visualizes the toxicity score for input text, true text, and predicted text, assessing content quality and potential risk.
+    Assesses the toxicity levels of texts generated by NLP models to identify and mitigate harmful or offensive content.
 
-    **Purpose:**
-    The ToxicityScore metric is designed to evaluate the toxicity levels of texts generated by models. This is crucial for
-    identifying and mitigating harmful or offensive content in machine-generated texts.
+    ### Purpose
 
-    **Test Mechanism:**
-    The function starts by extracting the input, true, and predicted values from the provided dataset and model. The toxicity score is
-    computed for each text using a preloaded `toxicity` evaluation tool. The scores are compiled into dataframes, and histograms
-    and bar charts are generated to visualize the distribution of toxicity scores. Additionally, a table of descriptive statistics
-    (mean, median, standard deviation, minimum, and maximum) is compiled for the toxicity scores, providing a comprehensive
-    summary of the model's performance.
+    The ToxicityScore metric is designed to evaluate the toxicity levels of texts generated by models. This is crucial
+    for identifying and mitigating harmful or offensive content in machine-generated texts.
+
+    ### Test Mechanism
+
+    The function starts by extracting the input, true, and predicted values from the provided dataset and model. The
+    toxicity score is computed for each text using a preloaded `toxicity` evaluation tool. The scores are compiled into
+    dataframes, and histograms and bar charts are generated to visualize the distribution of toxicity scores.
+    Additionally, a table of descriptive statistics (mean, median, standard deviation, minimum, and maximum) is
+    compiled for the toxicity scores, providing a comprehensive summary of the model's performance.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk:**
     - Drastic spikes in toxicity scores indicate potentially toxic content within the associated text segment.
-    - Persistent high toxicity scores across multiple texts may suggest systemic issues in the model's text generation process.
+    - Persistent high toxicity scores across multiple texts may suggest systemic issues in the model's text generation
+    process.
 
-    **Strengths:**
-    - Provides a clear evaluation of toxicity levels in generated texts, helping to ensure content safety and appropriateness.
-    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of toxicity scores.
+    ### Strengths
+
+    - Provides a clear evaluation of toxicity levels in generated texts, helping to ensure content safety and
+    appropriateness.
+    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of
+    toxicity scores.
     - Descriptive statistics offer a concise summary of the model's performance in generating non-toxic texts.
 
-    **Limitations:**
+    ### Limitations
+
     - The accuracy of the toxicity scores is contingent upon the underlying `toxicity` tool.
-    - The scores provide a broad overview but do not specify which portions or tokens of the text are responsible for high toxicity.
+    - The scores provide a broad overview but do not specify which portions or tokens of the text are responsible for
+    high toxicity.
     - Supplementary, in-depth analysis might be needed for granular insights.
     """
 

validmind/tests/model_validation/embeddings/ClusterDistribution.py

@@ -12,38 +12,42 @@ class ClusterDistribution(Metric):
     """
     Assesses the distribution of text embeddings across clusters produced by a model using KMeans clustering.
 
-    **Purpose:** The purpose of this metric is to analyze the distribution of the clusters produced by a text embedding
-    model. By dividing the text embeddings into different clusters, we can understand how the model is grouping or
-    categorizing the text data. This aids in visualizing the organization and segregation of the data and thus gives an
+    ### Purpose
+
+    The purpose of this metric is to analyze the distribution of the clusters produced by a text embedding model. By
+    dividing the text embeddings into different clusters, we can understand how the model is grouping or categorizing
+    the text data. This aids in visualizing the organization and segregation of the data, thereby giving an
     understanding of how the model is processing the data.
 
-    **Test Mechanism:** The metric applies the KMeans clustering algorithm on the predictions made by the model on the
-    testing dataset and divides the text embeddings into a pre-defined number of clusters. By default, this number is
-    set to 5 but can be customized as per requirements. The output of this test is a histogram plot that shows the
-    distribution of embeddings across these clusters.
+    ### Test Mechanism
+
+    The metric applies the KMeans clustering algorithm on the predictions made by the model on the testing dataset and
+    divides the text embeddings into a pre-defined number of clusters. By default, this number is set to 5 but can be
+    customized as per requirements. The output of this test is a histogram plot that shows the distribution of
+    embeddings across these clusters.
 
-    **Signs of High Risk:**
+    ### Signs of High Risk
 
-    - If the embeddings are skewed towards one or two clusters, that would indicate that the model is not effectively
+    - If the embeddings are skewed towards one or two clusters, it indicates that the model is not effectively
     differentiating the various categories in the text data.
     - Uniform distribution of the embeddings across the clusters might show a lack of proper categorization.
 
-    **Strengths:**
+    ### Strengths
 
-    - Great tool to visualize the text data categorization by the model. It provides a way to assess if the model is
-    distinguishing the categories effectively or not.
-    - It is flexible with the number of clusters (classes), so can be used on various types of data regardless of the
-    number of categories.
+    - Great tool to visualize the text data categorization by the model.
+    - Provides a way to assess if the model is distinguishing the categories effectively or not.
+    - Flexible with the number of clusters, so it can be used on various types of data regardless of the number of
+    categories.
 
-    **Limitations:**
+    ### Limitations
 
-    - The success or failure of this test is based on visual interpretation, which might not be enough for making solid
+    - Success or failure of this test is based on visual interpretation, which might not be enough for making solid
     conclusions or determining the exact points of failure.
-    - It assumes that the division of text embeddings across clusters should ideally be homogeneous, which might not
+    - Assumes that the division of text embeddings across clusters should ideally be homogeneous, which might not
     always be the case depending on the nature of the text data.
-    - It only applies to text embedding models, reducing its utility across various ML models.
-    - This test uses the KMeans clustering algorithm, which assumes that clusters are convex and isotropic. Thus, this
-    test may not work as intended if the true clusters in the data are not of this shape.
+    - Only applies to text embedding models, reducing its utility across various ML models.
+    - Uses the KMeans clustering algorithm, which assumes that clusters are convex and isotropic, and may not work as
+    intended if the true clusters in the data are not of this shape.
     """
 
     name = "Text Embeddings Cluster Distribution"

validmind/tests/model_validation/embeddings/CosineSimilarityComparison.py

@@ -16,45 +16,48 @@ from validmind import tags, tasks
 @tasks("text_qa", "text_generation", "text_summarization")
 def CosineSimilarityComparison(dataset, models):
     """
-    Computes pairwise cosine similarities between model embeddings and visualizes the results through bar charts,
-    alongside compiling a comprehensive table of descriptive statistics for each model pair.
+    Assesses the similarity between embeddings generated by different models using Cosine Similarity, providing both
+    statistical and visual insights.
 
-    **Purpose:**
-    This function is designed to analyze and compare the embeddings produced by different models using Cosine Similarity.
-    Cosine Similarity, a measure calculating the cosine of the angle between two vectors, is widely used to determine
-    the alignment or similarity between vectors in high-dimensional spaces, such as text embeddings. This analysis helps
-    to understand how similar or different the models' predictions are in terms of embedding generation.
+    ### Purpose
 
-    **Test Mechanism:**
-    The function begins by computing the embeddings for each model using the provided dataset. It then calculates the
-    cosine similarity for every possible pair of models, generating a similarity matrix. Each element of this matrix
-    represents the cosine similarity between two model embeddings. The function flattens this matrix and uses it to
-    create a bar chart for each model pair, visualizing their similarity distribution. Additionally, it compiles a table
-    with descriptive statistics (mean, median, standard deviation, minimum, and maximum) for the similarities of each
-    pair, including a reference to the compared models.
+    The Cosine Similarity Comparison test aims to analyze and compare the embeddings produced by different models using
+    Cosine Similarity. Cosine Similarity is a measure that calculates the cosine of the angle between two vectors,
+    widely used to determine the alignment or similarity between high-dimensional vectors, such as text embeddings.
+    This analysis helps understand how similar or different the models' predictions are in terms of embedding
+    generation.
 
-    **Signs of High Risk:**
+    ### Test Mechanism
+
+    The function starts by computing the embeddings for each model using the provided dataset. It then calculates the
+    cosine similarity for every possible pair of models, generating a similarity matrix wherein each element represents
+    the cosine similarity between two model embeddings. This matrix is flattened to create a bar chart for each model
+    pair, visualizing their similarity distribution. Additionally, a table with descriptive statistics (mean, median,
+    standard deviation, minimum, and maximum) for the similarities of each pair is compiled, referencing the compared
+    models.
+
+    ### Signs of High Risk
 
     - A high concentration of cosine similarity values close to 1 could suggest that the models are producing very
-      similar embeddings, which could be a sign of redundancy or lack of diversity in model training or design.
-    - Conversely, very low similarity values near -1 indicate strong dissimilarity, potentially highlighting models
-      that are too divergent, possibly focusing on very different features of the data.
+    similar embeddings, indicating redundancy or lack of diversity in model training or design.
+    - Very low similarity values near -1 highlight strong dissimilarity, suggesting models that are too divergent and
+    possibly focusing on very different features of the data.
 
-    **Strengths:**
+    ### Strengths
 
     - Enables detailed comparisons between multiple models' embedding strategies through visual and statistical means.
-    - Helps identify which models produce similar or dissimilar embeddings, useful for tasks requiring model diversity.
+    - Identifies models producing similar or dissimilar embeddings, useful for tasks requiring model diversity.
     - Provides quantitative and visual feedback on the degree of similarity, enhancing interpretability of model
-      behavior in embedding spaces.
+    behavior in embedding spaces.
 
-    **Limitations:**
+    ### Limitations
 
-    - The analysis is confined to the comparison of embeddings and does not assess the overall performance of the models
-      in terms of their primary tasks (e.g., classification, regression).
+    - The analysis is confined to the comparison of embeddings and does not assess the overall performance of the
+    models in terms of their primary tasks (e.g., classification, regression).
     - Assumes that the models are suitable for generating comparable embeddings, which might not always be the case,
-      especially across different types of models.
-    - Interpretation of results is heavily dependent on the understanding of Cosine Similarity and the nature of high-dimensional
-      embedding spaces.
+    especially across different types of models.
+    - Interpretation of results is heavily dependent on the understanding of Cosine Similarity and the nature of
+    high-dimensional embedding spaces.
     """
 
     figures = []