validmind 2.1.0__py3-none-any.whl → 2.2.2__py3-none-any.whl

validmind/tests/model_validation/RegardHistogram.py

@@ -1,148 +0,0 @@
-# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
-# See the LICENSE file in the root of this repository for details.
-# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
-
-import itertools
-from dataclasses import dataclass
-
-import evaluate
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class RegardHistogram(Metric):
-    """
-    **Purpose:**
-    The `RegardHistogram` metric offers a histogram-based visualization of regard scores across different text
-    samples. As an evolution from the line plot representation, the histogram provides a distributional perspective
-    on how often certain regard scores (positive, negative, neutral, or other) are perceived or generated by the model.
-
-    **Test Mechanism:**
-    This metric extracts the necessary data from the model's test dataset: the input text, the true regard (target text),
-    and the model's predicted regard. After ensuring data consistency, the `evaluate.load("regard")` tool computes the
-    regard scores. Histograms are then created for each category of regard against input, target, and predicted texts.
-    These histograms illustrate the frequency distribution of scores within each category, shedding light on commonalities
-    or outliers in the model's performance.
-
-    **Signs of High Risk:**
-    Any 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. For instance, a lack of neutral scores in the model's
-    predictions, despite a balanced distribution in the target data, might signal an issue.
-
-    **Strengths:**
-    Histogram representations give a quick, intuitive snapshot of score distributions. The immediate visual contrast
-    between the model's predictions and target data is useful for stakeholders and researchers aiming to gauge
-    model reliability in regard to sentiment assessments.
-
-    **Limitations:**
-    The efficacy of `RegardHistogram` hinges upon the precision of underlying tools like `evaluate.load("regard")`, which
-    might have their biases or inaccuracies. The metric portrays regard in set categories, but sentiments in real-world scenarios
-    can be more nuanced. Assumptions made, like the expectation of consistent regard across texts, may not always hold, given that
-    sentiments can be subjective. While histograms showcase distributions, they may not capture the intricate contexts behind
-    texts, possibly leading to oversimplifications or misinterpretations.
-    """
-
-    name = "regard_histogram"
-    required_inputs = ["model", "dataset"]
-    metadata = {
-        "task_types": ["text_classification", "text_summarization"],
-        "tags": ["regard_histogram"],
-    }
-
-    def _get_datasets(self):
-        if not hasattr(self, "model"):
-            raise AttributeError("The 'model' attribute is missing.")
-
-        y_true = list(itertools.chain.from_iterable(self.inputs.dataset.y))
-        y_pred = self.inputs.dataset.y_pred(self.inputs.model)
-
-        if not len(y_true) == len(y_pred):
-            raise ValueError(
-                "Inconsistent lengths among true summaries and predicted summaries."
-            )
-
-        return y_true, y_pred
-
-    def regard_histogram(self):
-        regard_tool = evaluate.load("regard")
-        y_true, y_pred = self._get_datasets()
-
-        dataframes = {
-            "Target Text": y_true,
-            "Predicted Summaries": y_pred,
-        }
-
-        total_text_columns = len(dataframes)
-        total_rows = total_text_columns * 2
-
-        categories_order = ["positive", "negative", "neutral", "other"]
-        category_colors = {
-            "negative": "#d9534f",
-            "neutral": "#5bc0de",
-            "other": "#f0ad4e",
-            "positive": "#5cb85c",
-        }
-
-        fig = make_subplots(
-            rows=total_rows,
-            cols=2,
-            subplot_titles=[
-                f"{col_name} {cat}"
-                for col_name in dataframes
-                for cat in categories_order
-            ],
-            shared_xaxes=True,
-            vertical_spacing=0.1,
-        )
-
-        row_offset = 0
-
-        for column_name, column_data in dataframes.items():
-            results = regard_tool.compute(data=column_data)["regard"]
-            regard_dicts = [
-                dict((x["label"], x["score"]) for x in sublist) for sublist in results
-            ]
-
-            for idx, category in enumerate(categories_order, start=1):
-                row, col = ((idx - 1) // 2 + 1 + row_offset, (idx - 1) % 2 + 1)
-                fig.add_trace(
-                    go.Histogram(
-                        name=f"{category} ({column_name})",
-                        x=[res_dict[category] for res_dict in regard_dicts],
-                        marker_color=category_colors[category],
-                        showlegend=False,  # Disable the legend
-                    ),
-                    row=row,
-                    col=col,
-                )
-            row_offset += 2  # Move to the next pair of rows for the next text column
-
-        subplot_height = 350
-        total_height = (
-            total_rows * subplot_height + 200
-        )  # 200 for padding, titles, etc.
-
-        fig.update_layout(
-            title_text="Regard Score Histogram Distribution", height=total_height
-        )
-
-        # Specify x and y titles only for the first subplot
-        fig.update_xaxes(title_text="Index", showticklabels=True, row=1, col=1)
-        fig.update_yaxes(title_text="Score", showticklabels=True, row=1, col=1)
-
-        # Show tick labels on all subplots
-        for row in range(total_rows):
-            for col in range(2):  # since you have 2 columns
-                fig.update_xaxes(showticklabels=True, row=row + 1, col=col + 1)
-                fig.update_yaxes(showticklabels=True, row=row + 1, col=col + 1)
-
-        return fig
-
-    def run(self):
-        fig = self.regard_histogram()
-        return self.cache_results(
-            figures=[Figure(for_object=self, key=self.key, figure=fig)]
-        )

validmind/tests/model_validation/RougeMetrics.py

@@ -1,147 +0,0 @@
-# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
-# See the LICENSE file in the root of this repository for details.
-# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
-
-import itertools
-from dataclasses import dataclass
-
-import pandas as pd
-import plotly.graph_objects as go
-from rouge import Rouge
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class RougeMetrics(Metric):
-    """
-    Evaluates the quality of machine-generated text using various ROUGE metrics, and visualizes the results.
-
-    **Purpose**: The ROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a metric employed to assess the
-    quality of machine-generated text. This evaluation technique is mainly used in natural language processing tasks,
-    such as text summarization, machine translation, and text generation. Its goal is to measure how well the
-    machine-generated text reflects the key information and concepts in the human-crafted reference text.
-
-    **Test Mechanism**:
-
-    1. **Comparison Procedure**: The testing mechanism involves comparing machine-generated content with a reference
-    human-constructed text.
-
-    2. **Integral Metrics**:
-       - **ROUGE-N (N-gram Overlap)**: This evaluates the overlap of n-grams (sequences of n words) between the
-    generated and reference texts. The common n-values are 1 (unigrams), 2 (bigrams), and 3 (trigrams). Each metric
-    calculates precision, recall, and F1-score.
-
-       - **ROUGE-L (Longest Common Subsequence)**: This identifies the longest shared word sequence in both the machine
-    and reference texts, thus evaluating the capability of the generated text to mirror key phrases.
-
-       - **ROUGE-S (Skip-bigram)**: This measures the concurrence of skip-bigrams — word pairings that appear within a
-    predefined word window in the text. This metric maintains sensitivity to word order while allowing for sporadic
-    word omissions.
-
-    3. **Visual Representation**: Precision, recall, and F1-score for all the metrics are visually charted, which makes
-    the results easier to comprehend.
-
-    **Signs of High Risk**:
-
-    - Low scores across the suite of ROUGE metrics
-    - Low precision might indicate redundant information in machine-produced text
-    - Low recall may suggest the omission of important information from the reference text
-    - Low F1 score could indicate an imbalanced performance between precision and recall
-    - Persistent low scores could signal inherent flaws in the model
-
-    **Strengths**:
-
-    - Offers a multifaceted perspective on text quality using various evaluation metrics
-    - Adapts to synonyms and rewording, thanks to n-gram-based evaluation
-    - Encourages the retention of key word sequences using the longest common subsequence method
-    - Visual representation of precision, recall, and F1-scores enhances understandability of model performance
-
-    **Limitations**:
-
-    - May fail to fully address the semantic coherence, fluency, or grammatical quality of the generated text
-    - Tends to evaluate isolated phrases or n-grams rather than comprehensive sentences
-    - May prove challenging when reference texts are difficult or impractical to obtain due to its reliance on
-    comparisons with human-made references.
-    """
-
-    name = "rouge_metric"
-    required_inputs = ["model", "dataset"]
-    default_params = {
-        "rouge_metrics": ["rouge-1", "rouge-2", "rouge-l"],
-    }
-
-    def run(self):
-        r_metrics = self.params["rouge_metrics"]
-        if r_metrics is None:
-            raise ValueError("rouge_metrics must be provided in params")
-
-        if not (
-            set(self.default_params.get("rouge_metrics")).intersection(r_metrics)
-            == set(r_metrics)
-        ):
-            raise ValueError(
-                f"Invalid metrics from {self.default_params.get('rouge_metrics')}"
-            )
-
-        y_true = list(itertools.chain.from_iterable(self.inputs.dataset.y))
-        y_pred = self.inputs.dataset.y_pred(self.inputs.model)
-
-        rouge = Rouge(metrics=r_metrics)
-
-        score_list = []
-        for y_t, y_p in zip(y_true, y_pred):
-            scores = rouge.get_scores(y_p, y_t, avg=True)
-            score_list.append(scores)
-
-        metrics_df = pd.DataFrame(score_list)
-        figures = []
-
-        for m in metrics_df.columns:
-            df_scores = pd.DataFrame(metrics_df[m].tolist())
-            # Visualization part
-            fig = go.Figure()
-
-            # Adding the line plots for precision, recall, and F1-score with lines and markers
-            fig.add_trace(
-                go.Scatter(
-                    x=df_scores.index,
-                    y=df_scores["p"],
-                    mode="lines+markers",
-                    name="Precision",
-                )
-            )
-            fig.add_trace(
-                go.Scatter(
-                    x=df_scores.index,
-                    y=df_scores["r"],
-                    mode="lines+markers",
-                    name="Recall",
-                )
-            )
-            fig.add_trace(
-                go.Scatter(
-                    x=df_scores.index,
-                    y=df_scores["f"],
-                    mode="lines+markers",
-                    name="F1 Score",
-                )
-            )
-
-            fig.update_layout(
-                title=f"ROUGE Scores for {m}",
-                xaxis_title="Row Index",
-                yaxis_title="Score",
-            )
-
-            # Ensure a unique key for each metric
-            k = f"{m.replace('-', '')}_{len(figures)}"
-            figures.append(
-                Figure(
-                    for_object=self,
-                    key=k,
-                    figure=fig,
-                )
-            )
-
-        return self.cache_results(figures=figures)

validmind/tests/model_validation/RougeMetricsAggregate.py

@@ -1,133 +0,0 @@
-# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
-# See the LICENSE file in the root of this repository for details.
-# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
-
-import itertools
-from dataclasses import dataclass
-
-import pandas as pd
-import plotly.graph_objects as go
-from rouge import Rouge
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class RougeMetricsAggregate(Metric):
-    """
-    Evaluates the average quality of machine-generated text using various ROUGE metrics and visualizes the aggregated results.
-
-    **Purpose**: The ROUGE, or Recall-Oriented Understudy for Gisting Evaluation, remains a cornerstone for assessing
-    machine-generated text quality. Predominantly used in tasks such as text summarization, machine translation,
-    and text generation, the emphasis of ROUGE is to gauge the reflection of pivotal information and core concepts
-    from human references in machine-produced content.
-
-    **Test Mechanism**:
-
-    1. **Comparison Procedure**: The evaluation requires contrasting machine-rendered text against a human-made reference.
-
-    2. **Integral Metrics**:
-       - **ROUGE-N (N-gram Overlap)**: Assesses the commonality of n-grams between both sets of texts. Regularly,
-       metrics consider 1 (unigrams), 2 (bigrams), and 3 (trigrams), rendering precision, recall, and F1-score.
-
-       - **ROUGE-L (Longest Common Subsequence)**: Discerns the lengthiest mutually inclusive word chain in both
-       texts, ascertaining the machine text's efficacy in capturing essential phrases.
-
-       - **ROUGE-S (Skip-bigram)**: Quantifies the concurrence of skip-bigrams. This metric cherishes word order
-       but tolerates occasional omissions.
-
-    3. **Visual Representation**: The aggregate approach underscores the visualization of average scores across
-    precision, recall, and F1-score, enhancing result interpretation.
-
-    **Signs of High Risk**:
-
-    - Diminished average scores across ROUGE metrics
-    - Depressed precision may highlight verbosity in machine text
-    - Lacking recall might hint at missed critical details from the reference
-    - A dwindling F1 score might spotlight a disjointed precision-recall performance
-    - Consistently low averages could reveal deep-rooted model inadequacies
-
-    **Strengths**:
-
-    - Provides a holistic view of text quality via diverse metrics
-    - Gracefully handles paraphrasing owing to n-gram evaluations
-    - Promotes the capture of crucial word chains through the longest common subsequence
-    - Aggregate visual insights bolster comprehension of overall model behavior
-
-    **Limitations**:
-
-    - Might overlook nuances like semantic integrity, fluency, or syntactic correctness
-    - Focuses more on discrete phrases or n-grams over holistic sentences
-    - Reliance on human references can be limiting when they're hard to source or infeasible.
-    """
-
-    name = "rouge_metrics_aggregate"
-    required_inputs = ["model", "dataset"]
-    default_params = {
-        "rouge_metrics": ["rouge-1", "rouge-2", "rouge-l"],
-    }
-
-    def run(self):
-        r_metrics = self.params["rouge_metrics"]
-        if r_metrics is None:
-            raise ValueError("rouge_metrics must be provided in params")
-
-        if not (
-            set(self.default_params.get("rouge_metrics")).intersection(r_metrics)
-            == set(r_metrics)
-        ):
-            raise ValueError(
-                f"Invalid metrics from {self.default_params.get('rouge_metrics')}"
-            )
-
-        y_true = list(itertools.chain.from_iterable(self.inputs.dataset.y))
-        y_pred = self.inputs.dataset.y_pred(self.inputs.model)
-
-        rouge = Rouge(metrics=r_metrics)
-
-        score_list = []
-        for y_t, y_p in zip(y_true, y_pred):
-            scores = rouge.get_scores(y_p, y_t, avg=True)
-            score_list.append(scores)
-
-        metrics_df = pd.DataFrame(score_list)
-        figures = []
-
-        colors = {"Precision": "blue", "Recall": "green", "F1 Score": "red"}
-        mapping = {"p": "Precision", "r": "Recall", "f": "F1 Score"}
-
-        for m in metrics_df.columns:
-            df_scores = pd.DataFrame(metrics_df[m].tolist())
-            avg_scores = df_scores.mean()
-
-            # Visualization part
-            fig = go.Figure()
-
-            # Adding the bar plots for average scores with specified colors
-            for metric_short, metric_full in mapping.items():
-                fig.add_trace(
-                    go.Bar(
-                        x=[metric_full],
-                        y=[avg_scores[metric_short]],
-                        name=metric_full,
-                        marker_color=colors[metric_full],
-                        showlegend=False,
-                    )
-                )
-
-            fig.update_layout(
-                title=f"Average ROUGE Scores for {m}",
-                xaxis_title="Metric",
-                yaxis_title="Average Score",
-            )
-
-            k = m.replace("-", "")
-            figures.append(
-                Figure(
-                    for_object=self,
-                    key=k,
-                    figure=fig,
-                )
-            )
-
-        return self.cache_results(figures=figures)

validmind/tests/model_validation/SelfCheckNLIScore.py

@@ -1,112 +0,0 @@
-# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
-# See the LICENSE file in the root of this repository for details.
-# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
-
-import itertools
-from dataclasses import dataclass
-
-import pandas as pd
-import plotly.graph_objects as go
-import torch
-from selfcheckgpt.modeling_selfcheck import SelfCheckNLI
-from tqdm import tqdm
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class SelfCheckNLIScore(Metric):
-    """
-    Evaluates text generation models' performance by quantifying the level of hallucination in generated texts compared to reference texts.
-
-    **Purpose**: The HallucinationScore metric is designed to assess the factual accuracy and reliability of text generated by models, focusing on the detection and quantification of hallucinations—instances where generated content deviates from factual or expected outputs. By comparing generated texts against reference texts, this metric highlights discrepancies indicative of hallucinations, offering insights into the model's ability to produce contextually and factually coherent content.
-
-    **Test Mechanism**: To compute the HallucinationScore, the metric employs a comparison between the generated texts (model predictions) and the provided reference texts (true values). Using the SelfCheckNLI model, it evaluates each generated text's level of factual congruence with the reference, assigning a hallucination score based on the semantic coherence and factual accuracy. The scores for each text instance are then visualized in a line plot, allowing for the examination of hallucination trends across the dataset.
-
-    **Signs of High Risk**:
-    - High hallucination scores across a significant portion of the dataset, indicating a prevalence of factually inaccurate or irrelevant content generation.
-    - Patterns of consistent hallucination in specific contexts or subjects, suggesting gaps in the model's understanding or knowledge.
-    - Sharp fluctuations in hallucination scores, which may reveal inconsistencies in the model's performance or sensitivity to certain types of input.
-
-    **Strengths**:
-    - Directly addresses the critical aspect of factual accuracy in generated text, beyond mere linguistic or stylistic coherence.
-    - Provides a granular, instance-by-instance analysis of model performance, allowing for targeted improvements and diagnostics.
-    - Facilitates a deeper understanding of a model's capabilities and limitations in producing reliable and accurate content.
-
-    **Limitations**:
-    - Reliance on the SelfCheckNLI model means the accuracy and effectiveness of the HallucinationScore are contingent upon the performance and suitability of the underlying NLI model.
-    - May not fully capture the subtleties of certain factual inaccuracies or the contextual relevance of reference texts, especially in complex or nuanced domains.
-    - Potentially resource-intensive, given the computational demands of running advanced NLI models for large datasets.
-    """
-
-    name = "self_check_nli_score"
-    required_inputs = ["model", "dataset"]
-
-    def run(self):
-        # Assuming the dataset is structured with generated sentences and reference samples
-        y_true = list(itertools.chain.from_iterable(self.inputs.dataset.y))
-        y_pred = self.inputs.dataset.y_pred(self.inputs.model)
-
-        hallucination_scores = self.compute_hallucination_scores(y_pred, y_true)
-
-        # Visualization of scores
-        figures = self.visualize_scores(hallucination_scores)
-
-        return self.cache_results(figures=figures)
-
-    def compute_hallucination_scores(self, predictions, references):
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        selfcheck_nli = SelfCheckNLI(device=device)
-        hallucination_scores = []
-
-        print("Starting hallucination score computation...")
-
-        for index, (sentences, samples) in enumerate(
-            tqdm(zip(predictions, references), total=len(predictions))
-        ):
-            sent_scores_nli = selfcheck_nli.predict(
-                sentences=sentences, sampled_passages=samples
-            )
-
-            # Compute the mean of the hallucination scores for this row
-            average_score = sent_scores_nli.mean()
-            hallucination_scores.append(average_score)
-
-            # Print a progress update for each row
-            print(
-                f"Row {index + 1}/{len(predictions)}: Average hallucination score: {average_score}"
-            )
-
-        print("Completed hallucination score computation.")
-
-        return hallucination_scores
-
-    def visualize_scores(self, scores):
-        scores_df = pd.DataFrame(scores, columns=["Hallucination Score"])
-
-        fig = go.Figure()
-        fig.add_trace(
-            go.Scatter(
-                x=scores_df.index,
-                y=scores_df["Hallucination Score"],
-                mode="lines+markers",
-                name="Hallucination Score",
-            )
-        )
-
-        fig.update_layout(
-            title="Hallucination Scores Across Text Instances",
-            xaxis_title="Text Instance Index",
-            yaxis_title="Hallucination Score",
-        )
-
-        # Wrapping the plotly figure for compatibility with your framework might be needed
-        figures = [
-            Figure(
-                for_object=self,
-                key=self.key,
-                figure=fig,
-            )
-        ]
-
-        return figures

validmind/tests/model_validation/ToxicityHistogram.py

@@ -1,136 +0,0 @@
-# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
-# See the LICENSE file in the root of this repository for details.
-# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
-
-import itertools
-from dataclasses import dataclass
-
-import evaluate
-import pandas as pd
-import plotly.graph_objects as go
-import plotly.subplots as sp
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class ToxicityHistogram(Metric):
-    """
-    **Purpose:**
-    The ToxicityHistogram metric visualizes and analyzes the toxicity scores of various texts. Through histograms, it
-    provides insights into the distribution and nature of toxicity present in the evaluated text segments.
-
-    **Test Mechanism:**
-    Texts are fetched from specified columns and their toxicity scores are computed using a preloaded `toxicity`
-    evaluation tool. Each text data column is visualized with its own histogram, culminating in a multi-panel
-    visualization.
-
-    **Signs of High Risk:**
-    High toxicity concentrations in the histogram, especially on the upper scale, signify a higher presence of toxic
-    content in the respective text segment. If predicted summaries show significantly differing patterns from input or
-    target texts, it could indicate issues with the model's output.
-
-    **Strengths:**
-    The metric offers a lucid representation of toxicity distributions, facilitating the swift identification of
-    concerning patterns. It's instrumental for gauging potential pitfalls of generated content, particularly in the
-    realm of predicted summaries.
-
-    **Limitations:**
-    The ToxicityHistogram's efficacy hinges on the accuracy of the `toxicity` tool it employs. While histograms depict
-    distribution patterns, they omit details about which specific text portions or tokens result in high toxicity
-    scores. Therefore, for a comprehensive understanding, more in-depth analysis might be requisite.
-    """
-
-    name = "toxicity_histogram"
-    required_inputs = ["model"]
-    metadata = {
-        "task_types": [
-            "text_classification",
-            "text_summarization",
-        ],
-        "tags": ["toxicity_histogram"],
-    }
-
-    def _get_datasets(self):
-        # Check model attributes
-        if not hasattr(self, "model"):
-            raise AttributeError("The 'model' attribute is missing.")
-
-        y_true = list(itertools.chain.from_iterable(self.inputs.dataset.y))
-        y_pred = self.inputs.dataset.y_pred(self.inputs.model)
-        input_text = self.inputs.dataset.df[self.inputs.dataset.text_column]
-
-        # Ensure consistency in lengths
-        if not len(y_true) == len(y_pred) == len(input_text):
-            raise ValueError(
-                "Inconsistent lengths among input text, true summaries, and predicted summaries."
-            )
-
-        return input_text, y_true, y_pred
-
-    def toxicity_histograms(self, df):
-        """
-        Compute toxicity scores for texts and then plot histograms for all columns of df.
-
-        Parameters:
-        - df (pd.DataFrame): The dataframe containing texts.
-        """
-
-        # Extract necessary parameters
-        toxicity = evaluate.load("toxicity")
-
-        # Get all columns of df
-        text_columns = df.columns.tolist()
-
-        # Determine the number of rows required based on the number of text columns
-        num_rows = (len(text_columns) + 1) // 2  # +1 to handle odd number of columns
-
-        # Create a subplot layout
-        fig = sp.make_subplots(rows=num_rows, cols=2, subplot_titles=text_columns)
-
-        subplot_height = 350  # Height of each subplot
-        total_height = num_rows * subplot_height + 200  # 200 for padding, titles, etc.
-
-        for idx, col in enumerate(text_columns, start=1):
-            row = (idx - 1) // 2 + 1
-            col_idx = (idx - 1) % 2 + 1  # to place subplots in two columns
-
-            # Get list of texts from dataframe
-            texts = df[col].tolist()
-
-            # Compute toxicity for texts
-            toxicity_scores = toxicity.compute(predictions=texts)["toxicity"]
-
-            # Add traces to the corresponding subplot without legend
-            fig.add_trace(
-                go.Histogram(x=toxicity_scores, showlegend=False), row=row, col=col_idx
-            )
-
-            # Update xaxes and yaxes titles only for the first subplot
-            if idx == 1:
-                fig.update_xaxes(title_text="Toxicity Score", row=row, col=col_idx)
-                fig.update_yaxes(title_text="Frequency", row=row, col=col_idx)
-
-        # Update layout
-        fig.update_layout(
-            title_text="Histograms of Toxicity Scores", height=total_height
-        )
-
-        return fig
-
-    def run(self):
-        input_text, y_true, y_pred = self._get_datasets()
-
-        df = pd.DataFrame(
-            {
-                "Input Text": input_text,
-                "Target Text": y_true,
-                "Predicted Summaries": y_pred,
-            }
-        )
-
-        fig = self.toxicity_histograms(df)
-
-        return self.cache_results(
-            figures=[Figure(for_object=self, key=self.key, figure=fig)]
-        )