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

validmind/tests/model_validation/ClusterSizeDistribution.py

@@ -13,40 +13,44 @@ from validmind.vm_models import Figure, Metric
 @dataclass
 class ClusterSizeDistribution(Metric):
     """
-    Compares and visualizes the distribution of cluster sizes in model predictions and actual data for assessing
-    clustering model performance.
-
-    **Purpose:** The purpose of the `ClusterSizeDistribution` metric is to assess the performance of clustering models.
-    It does this by comparing the distribution of cluster sizes in the predictions made by the model and the actual
-    data. Observing the cluster distribution helps gain insights into whether the model's output aligns well with the
-    actual dataset distribution.
-
-    **Test Mechanism:** The testing mechanism for `ClusterSizeDistribution` involves first running the clustering model
-    on the training dataset, storing predictions, and comparing these predictions with the actual output. The actual
-    and predicted outputs are then converted into pandas dataframes, which conveniently enables the use of pandas
-    built-in functions to derive cluster size distributions. Two histograms are constructed from this data: one for the
-    actual distribution and one for the predicted distribution. These histograms are then plotted side-by-side for
-    visual comparison.
-
-    **Signs of High Risk:**
-    * Discrepancies between the actual cluster size distribution and the predicted cluster size distribution may
-    indicate high risk.
-    * An irregular distribution of data across clusters in the predicted outcomes points towards an inaccurate
-    prediction model.
-    * A high number of outlier clusters could indicate that the model has trouble correctly grouping data.
-
-    **Strengths:**
-    * `ClusterSizeDistribution` provides a visual and intuitive way to compare the performance of the clustering model
-    against the actual data.
-    * This metric can effectively reveal where the model might be over- or underestimating cluster sizes.
-    * It works well with any clustering models, making it a versatile comparison tool.
-
-    **Limitations:**
-    * The metric assumes that the actual cluster distribution is optimal, which may not always be the case.
-    * It relies heavily on visual comparison, which might be subjective and may not provide a precise numerical measure
-    of model performance.
-    * The metric might not fully capture other important aspects of clustering such as cluster density, distances
-    between clusters, and the shape of clusters.
+    Assesses the performance of clustering models by comparing the distribution of cluster sizes in model predictions
+    with the actual data.
+
+    ### Purpose
+
+    The Cluster Size Distribution test aims to assess the performance of clustering models by comparing the
+    distribution of cluster sizes in the model's predictions with the actual data. This comparison helps determine if
+    the clustering model's output aligns well with the true cluster distribution, providing insights into the model's
+    accuracy and performance.
+
+    ### Test Mechanism
+
+    The test mechanism involves the following steps:
+    - Run the clustering model on the provided dataset to obtain predictions.
+    - Convert both the actual and predicted outputs into pandas dataframes.
+    - Use pandas built-in functions to derive the cluster size distributions from these dataframes.
+    - Construct two histograms: one for the actual cluster size distribution and one for the predicted distribution.
+    - Plot the histograms side-by-side for visual comparison.
+
+    ### Signs of High Risk
+
+    - Discrepancies between the actual cluster size distribution and the predicted cluster size distribution.
+    - Irregular distribution of data across clusters in the predicted outcomes.
+    - High number of outlier clusters suggesting the model struggles to correctly group data.
+
+    ### Strengths
+
+    - Provides a visual and intuitive way to compare the clustering model's performance against actual data.
+    - Effectively reveals where the model may be over- or underestimating cluster sizes.
+    - Versatile as it works well with any clustering model.
+
+    ### Limitations
+
+    - Assumes that the actual cluster distribution is optimal, which may not always be the case.
+    - Relies heavily on visual comparison, which could be subjective and may not offer a precise numerical measure of
+    performance.
+    - May not fully capture other important aspects of clustering, such as cluster density, distances between clusters,
+    and the shape of clusters.
     """
 
     name = "cluster_size_distribution"

validmind/tests/model_validation/ContextualRecall.py

@@ -13,29 +13,54 @@ from validmind import tags, tasks
 @tasks("text_classification", "text_summarization")
 def ContextualRecall(dataset, model):
     """
-    Evaluates a Natural Language Generation model's ability to generate contextually relevant and factually correct text, visualizing the results through histograms and bar charts, alongside compiling a comprehensive table of descriptive statistics for contextual recall scores.
+    Evaluates a Natural Language Generation model's ability to generate contextually relevant and factually correct
+    text, visualizing the results through histograms and bar charts, alongside compiling a comprehensive table of
+    descriptive statistics for contextual recall scores.
 
-    **Purpose:**
-    The Contextual Recall metric is used to evaluate the ability of a natural language generation (NLG) model to generate text that appropriately reflects the given context or prompt. It measures the model's capability to remember and reproduce the main context in its resulting output. This metric is critical in natural language processing tasks, as the coherency and contextuality of the generated text are essential.
+    ### Purpose
 
-    **Test Mechanism:**
-    The function starts by extracting the true and predicted values from the provided dataset and model. It then tokenizes the reference and candidate texts into discernible words or tokens using NLTK. The token overlap between the reference and candidate texts is identified, and the Contextual Recall score is computed by dividing the number of overlapping tokens by the total number of tokens in the reference text. Scores are calculated for each test dataset instance, resulting in an array of scores. These scores are visualized using a histogram and a bar chart to show score variations across different rows. Additionally, a table of descriptive statistics (mean, median, standard deviation, minimum, and maximum) is compiled for the contextual recall scores, providing a comprehensive summary of the model's performance.
+    The Contextual Recall metric is used to evaluate the ability of a natural language generation (NLG) model to
+    generate text that appropriately reflects the given context or prompt. It measures the model's capability to
+    remember and reproduce the main context in its resulting output. This metric is critical in natural language
+    processing tasks, as the coherency and contextuality of the generated text are essential.
 
-    **Signs of High Risk:**
-    - Low contextual recall scores could indicate that the model is not effectively reflecting the original context in its output, leading to incoherent or contextually misaligned text.
+    ### Test Mechanism
+
+    The function starts by extracting the true and predicted values from the provided dataset and model. It then
+    tokenizes the reference and candidate texts into discernible words or tokens using NLTK. The token overlap between
+    the reference and candidate texts is identified, and the Contextual Recall score is computed by dividing the number
+    of overlapping tokens by the total number of tokens in the reference text. Scores are calculated for each test
+    dataset instance, resulting in an array of scores. These scores are visualized using a histogram and a bar chart to
+    show score variations across different rows. Additionally, a table of descriptive statistics (mean, median,
+    standard deviation, minimum, and maximum) is compiled for the contextual recall scores, providing a comprehensive
+    summary of the model's performance.
+
+    ### Signs of High Risk
+
+    - Low contextual recall scores could indicate that the model is not effectively reflecting the original context in
+    its output, leading to incoherent or contextually misaligned text.
     - A consistent trend of low recall scores could suggest underperformance of the model.
 
-    **Strengths:**
-    - Provides a quantifiable measure of a model's adherence to the context and factual elements of the generated narrative.
-    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of contextual recall scores.
-    - Descriptive statistics offer a concise summary of the model's performance in generating contextually relevant texts.
+    ### Strengths
 
-    **Limitations:**
-    - The focus on word overlap could result in high scores for texts that use many common words, even when these texts lack coherence or meaningful context.
+    - Provides a quantifiable measure of a model's adherence to the context and factual elements of the generated
+    narrative.
+    - Visual representations (histograms and bar charts) make it easier to interpret the distribution and trends of
+    contextual recall scores.
+    - Descriptive statistics offer a concise summary of the model's performance in generating contextually relevant
+    texts.
+
+    ### Limitations
+
+    - The focus on word overlap could result in high scores for texts that use many common words, even when these texts
+    lack coherence or meaningful context.
     - This metric does not consider the order of words, which could lead to overestimated scores for scrambled outputs.
     - Models that effectively use infrequent words might be undervalued, as these words might not overlap as often.
     """
 
+    # download nltk data
+    nltk.download("punkt_tab", quiet=True)
+
     y_true = dataset.y
     y_pred = dataset.y_pred(model)
 

validmind/tests/model_validation/FeaturesAUC.py

@@ -19,24 +19,43 @@ logger = get_logger(__name__)
 @dataclass
 class FeaturesAUC(Metric):
     """
-    Evaluates the discriminatory power of each individual feature within a binary classification model by calculating the Area Under the Curve (AUC) for each feature separately.
+    Evaluates the discriminatory power of each individual feature within a binary classification model by calculating
+    the Area Under the Curve (AUC) for each feature separately.
 
-    **Purpose**: The central objective of this metric is to quantify how well each feature on its own can differentiate between the two classes in a binary classification problem. It serves as a univariate analysis tool that can help in pre-modeling feature selection or post-modeling interpretation.
+    ### Purpose
 
-    **Test Mechanism**: For each feature, the metric treats the feature values as raw scores to compute the AUC against the actual binary outcomes. It provides an AUC value for each feature, offering a simple yet powerful indication of each feature's univariate classification strength.
+    The central objective of this metric is to quantify how well each feature on its own can differentiate between the
+    two classes in a binary classification problem. It serves as a univariate analysis tool that can help in
+    pre-modeling feature selection or post-modeling interpretation.
 
-    **Signs of High Risk**:
-    - A feature with a low AUC score may not be contributing significantly to the differentiation between the two classes, which could be a concern if it is expected to be predictive.
-    - Conversely, a surprisingly high AUC for a feature not believed to be informative may suggest data leakage or other issues with the data.
+    ### Test Mechanism
 
-    **Strengths**:
-    - By isolating each feature, it highlights the individual contribution of features to the classification task without the influence of other variables.
-    - Useful for both initial feature evaluation and for providing insights into the model's reliance on individual features after model training.
+    For each feature, the metric treats the feature values as raw scores to compute the AUC against the actual binary
+    outcomes. It provides an AUC value for each feature, offering a simple yet powerful indication of each feature's
+    univariate classification strength.
 
-    **Limitations**:
-    - Does not reflect the combined effects of features or any interaction between them, which can be critical in certain models.
-    - The AUC values are calculated without considering the model's use of the features, which could lead to different interpretations of feature importance when considering the model holistically.
-    - This metric is applicable only to binary classification tasks and cannot be directly extended to multiclass classification or regression without modifications.
+    ### Signs of High Risk
+
+    - A feature with a low AUC score may not be contributing significantly to the differentiation between the two
+    classes, which could be a concern if it is expected to be predictive.
+    - Conversely, a surprisingly high AUC for a feature not believed to be informative may suggest data leakage or
+    other issues with the data.
+
+    ### Strengths
+
+    - By isolating each feature, it highlights the individual contribution of features to the classification task
+    without the influence of other variables.
+    - Useful for both initial feature evaluation and for providing insights into the model's reliance on individual
+    features after model training.
+
+    ### Limitations
+
+    - Does not reflect the combined effects of features or any interaction between them, which can be critical in
+    certain models.
+    - The AUC values are calculated without considering the model's use of the features, which could lead to different
+    interpretations of feature importance when considering the model holistically.
+    - This metric is applicable only to binary classification tasks and cannot be directly extended to multiclass
+    classification or regression without modifications.
     """
 
     name = "features_auc"

validmind/tests/model_validation/MeteorScore.py

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

validmind/tests/model_validation/ModelMetadata.py

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

validmind/tests/model_validation/ModelPredictionResiduals.py

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