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

validmind/tests/data_validation/ANOVAOneWayTable.py

@@ -1,138 +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
-
-from dataclasses import dataclass
-
-import pandas as pd
-from scipy.stats import f_oneway
-
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
-
-
-@dataclass
-class ANOVAOneWayTable(Metric):
-    """
-    Applies one-way ANOVA (Analysis of Variance) to identify statistically significant numerical features in the
-    dataset.
-
-    **Purpose**: The ANOVA (Analysis of Variance) One-Way Table metric is utilized to determine whether the mean of
-    numerical variables differs across different groups identified by target or categorical variables. Its primary
-    purpose is to scrutinize the significant impact of categorical variables on numerical ones. This method proves
-    essential in identifying statistically significant features corresponding to the target variable present in the
-    dataset.
-
-    **Test Mechanism**: The testing mechanism involves the ANOVA F-test's performance on each numerical variable
-    against the target. If no specific features are mentioned, all numerical features are tested. A p-value is produced
-    for each test and compared against a certain threshold (default being 0.05 if not specified). If the p-value is
-    less than or equal to this threshold, the feature is marked as 'Pass', indicating significant mean difference
-    across the groups. Otherwise, it's marked as 'Fail'. The test produces a DataFrame that includes variable name, F
-    statistic value, p-value, threshold, and pass/fail status for every numerical variable.
-
-    **Signs of High Risk**:
-    - A large number of 'Fail' results in the ANOVA F-test could signify high risk or underperformance in the model.
-    This issue may arise when multiple numerical variables in the dataset don't exhibit any significant difference
-    across the target variable groups.
-    - Features with high p-values also indicate a high risk as they imply a greater chance of obtaining observed data
-    given that the null hypothesis is true.
-
-    **Strengths**:
-    - The ANOVA One Way Table is highly efficient in identifying statistically significant features by simultaneously
-    comparing group means.
-    - Its flexibility allows the testing of all numerical features in the dataset when no specific ones are mentioned.
-    - This metric provides a convenient method to measure the statistical significance of numerical variables and
-    assists in selecting those variables influencing the classifier's predictions considerably.
-
-    **Limitations**:
-    - This metric assumes that the data is normally distributed, which may not always be the case leading to erroneous
-    test results.
-    - The sensitivity of the F-test to variance changes may hinder this metric's effectiveness, especially for datasets
-    with high variance.
-    - The ANOVA One Way test does not specify which group means differ statistically from others; it strictly asserts
-    the existence of a difference.
-    - The metric fails to provide insights into variable interactions, and significant effects due to these
-    interactions could easily be overlooked.
-    """
-
-    name = "anova_one_way_table"
-    required_inputs = ["dataset"]
-    default_params = {"features": None, "p_threshold": 0.05}
-    tasks = ["classification"]
-    tags = [
-        "tabular_data",
-        "statistical_test",
-        "multiclass_classification",
-        "binary_classification",
-        "numerical_data",
-    ]
-
-    def run(self):
-        features = self.params["features"]
-        p_threshold = self.params["p_threshold"]
-
-        # Select all numerical features if none are specified
-        if features is None:
-            features = self.inputs.dataset.feature_columns_numeric
-
-        anova_results = self.anova_numerical_features(features, p_threshold)
-
-        return self.cache_results(
-            {
-                "anova_results": anova_results.to_dict(orient="records"),
-            }
-        )
-
-    def anova_numerical_features(self, features, p_threshold):
-        target_column = self.inputs.dataset.target_column
-        df = self.inputs.dataset.df
-
-        # Ensure the columns exist in the dataframe
-        for var in features:
-            if var not in df.columns:
-                raise ValueError(f"The column '{var}' does not exist in the dataframe.")
-        if target_column not in df.columns:
-            raise ValueError(
-                f"The target column '{target_column}' does not exist in the dataframe."
-            )
-
-        # Ensure the target variable is not included in num_vars
-        if target_column in features:
-            features.remove(target_column)
-
-        results = []
-
-        for var in features:
-            # Perform the ANOVA test
-            class_0 = df[df[target_column] == 0][var]
-            class_1 = df[df[target_column] == 1][var]
-
-            f, p = f_oneway(class_0, class_1)
-
-            # Add the result to the list of results
-            results.append(
-                [var, f, p, p_threshold, "Pass" if p <= p_threshold else "Fail"]
-            )
-
-        # Convert results to a DataFrame and return
-        results_df = pd.DataFrame(
-            results,
-            columns=["Variable", "F statistic", "p-value", "Threshold", "Pass/Fail"],
-        )
-
-        # Sort by p-value in ascending order
-        results_df = results_df.sort_values(by="p-value")
-
-        return results_df
-
-    def summary(self, metric_value):
-        anova_results_table = metric_value["anova_results"]
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=anova_results_table,
-                    metadata=ResultTableMetadata(
-                        title="ANOVA F-Test Results for Numerical Features"
-                    ),
-                )
-            ]
-        )

validmind/tests/data_validation/BivariateFeaturesBarPlots.py

@@ -1,142 +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
-
-from dataclasses import dataclass
-
-import matplotlib.colors as mcolors
-import matplotlib.pyplot as plt
-import numpy as np
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class BivariateFeaturesBarPlots(Metric):
-    """
-    Generates visual bar plots to analyze the relationship between paired features within categorical data in the model.
-
-    **Purpose**: The BivariateFeaturesBarPlots metric is intended to perform a visual analysis of categorical data
-    within the model. The goal is to assess and understand the specific relationships between various feature pairs,
-    while simultaneously highlighting the model's target variable. This form of bivariate plotting is immensely
-    beneficial in uncovering trends, correlations, patterns, or inconsistencies that may not be readily apparent within
-    raw tabular data.
-
-    **Test Mechanism**: These tests establish bar plots for each pair of features defined within the parameters. The
-    dataset is grouped by each feature pair and then calculates the mean of the target variable within each specific
-    grouping. Each group is represented via a bar in the plot, and the height of this bar aligns with the calculated
-    mean. The colors assigned to these bars are based on the categorical section to which they pertain: these colors
-    can either come from a colormap or generated anew if the total number of categories exceeds the current colormap's
-    scope.
-
-    **Signs of High Risk**:
-    - If any values are found missing or inconsistent within the feature pairs.
-    - If there exist large discrepancies or irregularities between the mean values of certain categories within feature
-    pairs.
-    - If the parameters for feature pairs have not been specified or if they were wrongly defined.
-
-    **Strengths**:
-    - The BivariateFeaturesBarPlots provides a clear, visual comprehension of the relationships between feature pairs
-    and the target variable.
-    - It allows an easy comparison between different categories within feature pairs.
-    - The metric can handle a diverse array of categorical data, enhancing its universal applicability.
-    - It is highly customizable due to its allowance for users to define feature pairs based on their specific
-    requirements.
-
-    **Limitations**:
-    - It can only be used with categorical data, limiting its usability with numerical or textual data.
-    - It relies on manual input for feature pairs, which could result in the overlooking of important feature pairs if
-    not chosen judiciously.
-    - The generated bar plots could become overly cluttered and difficult to decipher when dealing with feature pairs
-    with a large number of categories.
-    - This metric only provides a visual evaluation and fails to offer any numerical or statistical measures to
-    quantify the relationship between feature pairs.
-    """
-
-    name = "bivariate_features_bar_plots"
-    required_inputs = ["dataset"]
-    default_params = {"features_pairs": None}
-    tasks = ["classification"]
-    tags = [
-        "tabular_data",
-        "categorical_data",
-        "binary_classification",
-        "multiclass_classification",
-        "visualization",
-    ]
-
-    def run(self):
-        features_pairs = self.params["features_pairs"]
-
-        if features_pairs is None:
-            raise ValueError(
-                "The features_pairs parameter is required for this metric."
-            )
-
-        figures = self.plot_bivariate_bar(features_pairs)
-
-        return self.cache_results(figures=figures)
-
-    def plot_bivariate_bar(self, features_pairs):
-        status_var = self.inputs.dataset.target_column
-        figures = []
-        for x, hue in features_pairs.items():
-            df = self.inputs.dataset.df
-
-            means = df.groupby([x, hue])[status_var].mean().unstack().reset_index()
-            hue_categories = means.columns[1:]
-
-            n = len(hue_categories)
-            width = 1 / (n + 1)
-
-            plt.figure()
-
-            # Number of colors in the colormap
-            num_colors = len(plt.cm.get_cmap("tab10").colors)
-
-            if n <= num_colors:
-                # Use the colors from the colormap if there are enough
-                color_palette = {
-                    category: color
-                    for category, color in zip(
-                        hue_categories, plt.cm.get_cmap("tab10").colors
-                    )
-                }
-            else:
-                # Generate a larger set of colors if needed
-                hues = np.linspace(0, 1, n + 1)[
-                    :-1
-                ]  # exclude the last value which is equal to 1
-                color_palette = {
-                    category: mcolors.hsv_to_rgb(
-                        (h, 1, 1)
-                    )  # replace 1, 1 with desired saturation and value
-                    for category, h in zip(hue_categories, hues)
-                }
-
-            for i, hue_category in enumerate(hue_categories):
-                plt.bar(
-                    np.arange(len(means)) + i * width,
-                    means[hue_category],
-                    color=color_palette[hue_category],
-                    alpha=0.7,
-                    label=hue_category,
-                    width=width,
-                )
-
-            plt.title(x + " by " + hue)
-            plt.xlabel(x)
-            plt.ylabel("Default Ratio")
-            plt.xticks(ticks=np.arange(len(means)), labels=means[x], rotation=90)
-            plt.legend()
-            plt.show()
-
-            figures.append(
-                Figure(
-                    for_object=self, key=f"{self.key}:{x}_{hue}", figure=plt.figure()
-                )
-            )
-
-        plt.close("all")
-
-        return figures

validmind/tests/data_validation/BivariateHistograms.py

@@ -1,117 +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
-
-from dataclasses import dataclass
-
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class BivariateHistograms(Metric):
-    """
-    Generates bivariate histograms for paired features, aiding in visual inspection of categorical variables'
-    distributions and correlations.
-
-    **Purpose**: This metric, dubbed BivariateHistograms, is primarily used for visual data analysis via the inspection
-    of variable distribution, specifically categorical variables. Its main objective is to ascertain any potential
-    correlations between these variables and distributions within each defined target class. This is achieved by
-    offering an intuitive avenue into gaining insights into the characteristics of the data and any plausible patterns
-    therein.
-
-    **Test Mechanism**: The working mechanism of the BivariateHistograms module revolves around an input dataset and a
-    series of feature pairs. It uses seaborn's histogram plotting function and matplotlib techniques to create
-    bivariate histograms for each feature pair in the dataset. Two histograms, stratified by the target column status,
-    are produced for every pair of features. This enables the telling apart of different target statuses through color
-    differentiation. The module also offers optional functionality for restricting the data by a specific status
-    through the target_filter parameter.
-
-    **Signs of High Risk**:
-    - Irregular or unexpected distributions of data across the different categories.
-    - Highly skewed data distributions.
-    - Significant deviations from the perceived 'normal' or anticipated distributions.
-    - Large discrepancies in distribution patterns between various target statuses.
-
-    **Strengths**:
-    - Owing to its simplicity, the histogram-based approach is easy to implement and interpret which translates to
-    quick insights.
-    - The metrics provides a consolidated view of the distribution of data across different target conditions for each
-    variable pair, thereby assisting in highlighting potential correlations and patterns.
-    - It proves advantageous in spotting anomalies, comprehending interactions among features, and facilitating
-    exploratory data analysis.
-
-    **Limitations**:
-    - Its simplicity may be a drawback when it comes to spotting intricate or complex patterns in data.
-    - Overplotting might occur when working with larger datasets.
-    - The metric is only applicable to categorical data, and offers limited insights for numerical or continuous
-    variables.
-    - The interpretation of visual results hinges heavily on the expertise of the observer, possibly leading to
-    subjective analysis.
-    """
-
-    name = "bivariate_histograms"
-    required_inputs = ["dataset"]
-    default_params = {"features_pairs": None, "target_filter": None}
-    tasks = ["classification"]
-    tags = [
-        "tabular_data",
-        "categorical_data",
-        "binary_classification",
-        "multiclass_classification",
-        "visualization",
-    ]
-
-    def plot_bivariate_histogram(self, features_pairs, target_filter):
-        status_var = self.inputs.dataset.target_column
-        figures = []
-        palette = {0: (0.5, 0.5, 0.5, 0.8), 1: "tab:red"}
-
-        for x, y in features_pairs.items():
-            df = self.inputs.dataset.df
-            if target_filter is not None:
-                df = df[df[status_var] == target_filter]
-
-            fig, axes = plt.subplots(2, 1)
-
-            for ax, var in zip(axes, [x, y]):
-                for status, color in palette.items():
-                    subset = df[df[status_var] == status]
-                    sns.histplot(
-                        subset[var],
-                        ax=ax,
-                        color=color,
-                        edgecolor=None,
-                        kde=True,
-                        label=status_var if status else "Non-" + status_var,
-                    )
-
-                ax.set_title(f"Histogram of {var} by {status_var}")
-                ax.set_xlabel(var)
-                ax.legend()
-
-            plt.tight_layout()
-            plt.show()
-
-            figures.append(
-                Figure(for_object=self, key=f"{self.key}:{x}_{y}", figure=plt.figure())
-            )
-
-        plt.close("all")
-
-        return figures
-
-    def run(self):
-        features_pairs = self.params["features_pairs"]
-        target_filter = self.params["target_filter"]
-
-        if features_pairs is None:
-            raise ValueError(
-                "The features_pairs parameter is required for this metric."
-            )
-
-        figures = self.plot_bivariate_histogram(features_pairs, target_filter)
-
-        return self.cache_results(figures=figures)

validmind/tests/data_validation/HeatmapFeatureCorrelations.py

@@ -1,124 +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
-
-from dataclasses import dataclass
-
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-from validmind.vm_models import Figure, Metric
-
-
-@dataclass
-class HeatmapFeatureCorrelations(Metric):
-    """
-    Creates a heatmap to visually represent correlation patterns between pairs of numerical features in a dataset.
-
-    **Purpose:** The HeatmapFeatureCorrelations metric is utilized to evaluate the degree of interrelationships between
-    pairs of input features within a dataset. This metric allows us to visually comprehend the correlation patterns
-    through a heatmap, which can be essential in understanding which features may contribute most significantly to the
-    performance of the model. Features that have high intercorrelation can potentially reduce the model's ability to
-    learn, thus impacting the overall performance and stability of the machine learning model.
-
-    **Test Mechanism:** The metric executes the correlation test by computing the Pearson correlations for all pairs of
-    numerical features. It then generates a heatmap plot using seaborn, a Python data visualization library. The
-    colormap ranges from -1 to 1, indicating perfect negative correlation and perfect positive correlation
-    respectively. A 'declutter' option is provided which, if set to true, removes variable names and numerical
-    correlations from the plot to provide a more streamlined view. The size of feature names and correlation
-    coefficients can be controlled through 'fontsize' parameters.
-
-    **Signs of High Risk:**
-
-    - Indicators of potential risk include features with high absolute correlation values.
-    - A significant degree of multicollinearity might lead to instabilities in the trained model and can also result in
-    overfitting.
-    - The presence of multiple homogeneous blocks of high positive or negative correlation within the plot might
-    indicate redundant or irrelevant features included within the dataset.
-
-    **Strengths:**
-
-    - The strength of this metric lies in its ability to visually represent the extent and direction of correlation
-    between any two numeric features, which aids in the interpretation and understanding of complex data relationships.
-    - The heatmap provides an immediate and intuitively understandable representation, hence, it is extremely useful
-    for high-dimensional datasets where extracting meaningful relationships might be challenging.
-
-    **Limitations:**
-
-    - The central limitation might be that it can only calculate correlation between numeric features, making it
-    unsuitable for categorical variables unless they are already numerically encoded in a meaningful manner.
-    - It uses Pearson's correlation, which only measures linear relationships between features. It may perform poorly
-    in cases where the relationship is non-linear.
-    - Large feature sets might result in cluttered and difficult-to-read correlation heatmaps, especially when the
-    'declutter' option is set to false.
-    """
-
-    name = "heatmap_feature_correlations"
-    required_inputs = ["dataset"]
-    default_params = {"declutter": None, "fontsize": None, "num_features": None}
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "visualization", "correlation"]
-
-    def run(self):
-        features = self.params.get("features")
-        declutter = self.params.get("declutter", False)
-        fontsize = self.params.get("fontsize", 13)
-
-        # Filter DataFrame based on num_features
-        if features is None:
-            df = self.inputs.dataset.df
-        else:
-            df = self.inputs.dataset.df[features]
-
-        figure = self.visualize_correlations(df, declutter, fontsize)
-
-        return self.cache_results(figures=figure)
-
-    def visualize_correlations(self, df, declutter, fontsize):
-        # Compute Pearson correlations
-        correlations = df.corr(method="pearson")
-
-        # Create a figure and axes
-        fig, ax = plt.subplots()
-
-        # If declutter option is true, do not show correlation coefficients and variable names
-        if declutter:
-            sns.heatmap(
-                correlations,
-                cmap="coolwarm",
-                vmin=-1,
-                vmax=1,
-                ax=ax,
-                cbar_kws={"label": "Correlation"},
-            )
-            ax.set_xticklabels([])
-            ax.set_yticklabels([])
-            ax.set_xlabel(f"{df.shape[1]} Numerical Features", fontsize=fontsize)
-            ax.set_ylabel(f"{df.shape[1]} Numerical Features", fontsize=fontsize)
-        else:
-            # For the correlation numbers, you can use the 'annot_kws' argument
-            sns.heatmap(
-                correlations,
-                cmap="coolwarm",
-                vmin=-1,
-                vmax=1,
-                annot=True,
-                fmt=".2f",
-                ax=ax,
-                cbar_kws={"label": "Correlation"},
-                annot_kws={"size": fontsize},
-            )
-            plt.yticks(fontsize=fontsize)
-            plt.xticks(rotation=90, fontsize=fontsize)
-
-        # To set the fontsize of the color bar, you can iterate over its text elements and set their size
-        cbar = ax.collections[0].colorbar
-        cbar.ax.tick_params(labelsize=fontsize)
-        cbar.set_label("Correlation", size=fontsize)
-
-        # Show the plot
-        plt.tight_layout()
-        plt.close("all")
-
-        figure = Figure(for_object=self, key=self.key, figure=fig)
-        return [figure]

validmind/tests/data_validation/MissingValuesRisk.py

@@ -1,88 +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
-
-from dataclasses import dataclass
-
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
-
-
-@dataclass
-class MissingValuesRisk(Metric):
-    """
-    Assesses and quantifies the risk related to missing values in a dataset used for training an ML model.
-
-    **Purpose**: The Missing Values Risk metric is specifically designed to assess and quantify the risk associated
-    with missing values in the dataset used for machine learning model training. It measures two specific risks: the
-    percentage of total data that are missing, and the percentage of all variables (columns) that contain some missing
-    values.
-
-    **Test Mechanism**: Initially, the metric calculates the total number of data points in the dataset and the count
-    of missing values. It then inspects each variable (column) to determine how many contain at least one missing
-    datapoint. By methodically counting missing datapoints across the entire dataset and each variable (column), it
-    identifies the percentage of missing values in the entire dataset and the percentage of variables (columns) with
-    such values.
-
-    **Signs of High Risk**:
-
-    - Record high percentages in either of the risk measures could suggest a high risk.
-    - If the dataset indicates a high percentage of missing values, it might significantly undermine the model's
-    performance and credibility.
-    - If a significant portion of variables (columns) in the dataset are missing values, this could make the model
-    susceptible to bias and overfitting.
-
-    **Strengths**:
-
-    - The metric offers valuable insights into the readiness of a dataset for model training as missing values can
-    heavily destabilize both the model's performance and predictive capabilities.
-    - The metric's quantification of the risks caused by missing values allows for the use of targeted methods to
-    manage these values correctly- either through removal, imputation, or alternative strategies.
-    - The metric has the flexibility to be applied to both classification and regression assignments, maintaining its
-    utility across a wide range of models and scenarios.
-
-    **Limitations**:
-
-    - The metric primarily identifies and quantifies the risk associated with missing values without suggesting
-    specific mitigation strategies.
-    - The metric does not ascertain whether the missing values are random or associated with an underlying issue in the
-    stages of data collection or preprocessing.
-    - However, the identification of the presence and scale of missing data is the essential initial step towards
-    improving data quality.
-    """
-
-    name = "missing_values_risk"
-    required_inputs = ["dataset"]
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "data_quality", "risk_analysis"]
-
-    def run(self):
-        total_cells = self.inputs.dataset.df.size
-        total_missing = self.inputs.dataset.df.isnull().sum().sum()
-        total_columns = self.inputs.dataset.df.shape[1]
-        columns_with_missing = self.inputs.dataset.df.isnull().any().sum()
-
-        risk_measures = {
-            "Missing Values in the Dataset": round(
-                (total_missing / total_cells) * 100, 2
-            ),
-            "Variables with Missing Values": round(
-                (columns_with_missing / total_columns) * 100, 2
-            ),
-        }
-
-        return self.cache_results(risk_measures)
-
-    def summary(self, metric_value):
-        risk_measures_table = [
-            {"Risk Metric": measure, "Value (%)": value}
-            for measure, value in metric_value.items()
-        ]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=risk_measures_table,
-                    metadata=ResultTableMetadata(title="Missing Values Risk Measures"),
-                ),
-            ]
-        )

validmind/tests/model_validation/ModelMetadataComparison.py

@@ -1,59 +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 pandas as pd
-
-from validmind import tags, tasks
-from validmind.utils import get_model_info
-
-
-@tags("model_training", "metadata")
-@tasks("regression", "time_series_forecasting")
-def ModelMetadataComparison(models):
-    """
-    Compare metadata of different models and generate a summary table with the results.
-
-    **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.
-
-    **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.
-
-    **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.
-
-    **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**:
-    - 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.
-    """
-    column_labels = {
-        "architecture": "Modeling Technique",
-        "framework": "Modeling Framework",
-        "framework_version": "Framework Version",
-        "language": "Programming Language",
-    }
-
-    description = []
-
-    for model in models:
-        model_info = get_model_info(model)
-
-        # Rename columns based on provided labels
-        model_info_renamed = {
-            column_labels.get(k, k): v for k, v in model_info.items() if k != "params"
-        }
-
-        # Add model name or identifier if available
-        model_info_renamed = {"Model Name": model.input_id, **model_info_renamed}
-
-        description.append(model_info_renamed)
-
-    description_df = pd.DataFrame(description)
-
-    return description_df