validmind 2.2.6__py3-none-any.whl → 2.3.3__py3-none-any.whl

validmind/tests/__init__.py

@@ -30,7 +30,9 @@ from ..utils import (
     test_id_to_name,
 )
 from ..vm_models import TestContext, TestInput
-from .decorator import metric, tags, tasks
+from .__types__ import TestID
+from .decorator import tags, tasks
+from .decorator import test as test_decorator
 from .test_providers import LocalTestProvider, TestProvider
 
 logger = get_logger(__name__)
@@ -84,7 +86,6 @@ def _pretty_list_tests(tests, truncate=True):
         {
             "ID": test_id,
             "Name": test_id_to_name(test_id),
-            "Test Type": __test_classes[test_id].test_type,
             "Description": _test_description(__test_classes[test_id], truncate),
             "Required Inputs": __test_classes[test_id].required_inputs,
             "Params": __test_classes[test_id].default_params or {},
@@ -340,7 +341,7 @@ def load_test(test_id: str, reload=False):
         # if its a function, we decorate it and then load the class
         # TODO: simplify this as we move towards all functional metrics
         # "_" is used here so it doesn't conflict with other test ids
-        metric("_")(test)
+        test_decorator("_")(test)
         test = __custom_tests["_"]
 
     test.test_id = f"{test_id}:{result_id}" if result_id else test_id
@@ -348,7 +349,7 @@ def load_test(test_id: str, reload=False):
     return test
 
 
-def describe_test(test_id: str = None, raw: bool = False, show: bool = True):
+def describe_test(test_id: TestID = None, raw: bool = False, show: bool = True):
     """Get or show details about the test
 
     This function can be used to see test details including the test name, description,
@@ -365,7 +366,6 @@ def describe_test(test_id: str = None, raw: bool = False, show: bool = True):
     details = {
         "ID": test_id,
         "Name": test_id_to_name(test_id),
-        "Test Type": test.test_type,
         "Required Inputs": test.required_inputs,
         "Params": test.default_params or {},
         "Description": inspect.getdoc(test).strip() or "",
@@ -407,7 +407,7 @@ def describe_test(test_id: str = None, raw: bool = False, show: bool = True):
 
 
 def run_test(
-    test_id: str = None,
+    test_id: TestID = None,
     name: str = None,
     unit_metrics: list = None,
     params: dict = None,
@@ -451,7 +451,7 @@ def run_test(
 
     if unit_metrics:
         metric_id_name = "".join(word[0].upper() + word[1:] for word in name.split())
-        test_id = f"validmind.composite_metric.{metric_id_name}"
+        test_id = f"validmind.composite_test.{metric_id_name}"
 
         error, TestClass = load_composite_metric(
             unit_metrics=unit_metrics, metric_name=metric_id_name

validmind/tests/__types__.py

@@ -0,0 +1,170 @@
+# 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
+
+"""Literal types for test IDs.
+
+This module is auto-generated by running `make generate-test-id-types`.
+Should not be modified manually.
+"""
+
+from typing import Literal
+
+TestID = Literal[
+    "validmind.prompt_validation.Bias",
+    "validmind.prompt_validation.Clarity",
+    "validmind.prompt_validation.Specificity",
+    "validmind.prompt_validation.Robustness",
+    "validmind.prompt_validation.NegativeInstruction",
+    "validmind.prompt_validation.Conciseness",
+    "validmind.prompt_validation.Delimitation",
+    "validmind.model_validation.BertScore",
+    "validmind.model_validation.RegardScore",
+    "validmind.model_validation.BleuScore",
+    "validmind.model_validation.RegressionResidualsPlot",
+    "validmind.model_validation.FeaturesAUC",
+    "validmind.model_validation.ContextualRecall",
+    "validmind.model_validation.MeteorScore",
+    "validmind.model_validation.RougeScore",
+    "validmind.model_validation.ModelMetadata",
+    "validmind.model_validation.ClusterSizeDistribution",
+    "validmind.model_validation.TokenDisparity",
+    "validmind.model_validation.ToxicityScore",
+    "validmind.model_validation.embeddings.CosineSimilarityComparison",
+    "validmind.model_validation.embeddings.EmbeddingsVisualization2D",
+    "validmind.model_validation.embeddings.StabilityAnalysisRandomNoise",
+    "validmind.model_validation.embeddings.TSNEComponentsPairwisePlots",
+    "validmind.model_validation.embeddings.CosineSimilarityDistribution",
+    "validmind.model_validation.embeddings.PCAComponentsPairwisePlots",
+    "validmind.model_validation.embeddings.CosineSimilarityHeatmap",
+    "validmind.model_validation.embeddings.StabilityAnalysisTranslation",
+    "validmind.model_validation.embeddings.EuclideanDistanceComparison",
+    "validmind.model_validation.embeddings.ClusterDistribution",
+    "validmind.model_validation.embeddings.EuclideanDistanceHeatmap",
+    "validmind.model_validation.embeddings.StabilityAnalysis",
+    "validmind.model_validation.embeddings.StabilityAnalysisKeyword",
+    "validmind.model_validation.embeddings.StabilityAnalysisSynonyms",
+    "validmind.model_validation.embeddings.DescriptiveAnalytics",
+    "validmind.model_validation.ragas.ContextEntityRecall",
+    "validmind.model_validation.ragas.Faithfulness",
+    "validmind.model_validation.ragas.AspectCritique",
+    "validmind.model_validation.ragas.AnswerSimilarity",
+    "validmind.model_validation.ragas.AnswerCorrectness",
+    "validmind.model_validation.ragas.ContextRecall",
+    "validmind.model_validation.ragas.ContextRelevancy",
+    "validmind.model_validation.ragas.ContextPrecision",
+    "validmind.model_validation.ragas.AnswerRelevance",
+    "validmind.model_validation.sklearn.RegressionModelsPerformanceComparison",
+    "validmind.model_validation.sklearn.AdjustedMutualInformation",
+    "validmind.model_validation.sklearn.SilhouettePlot",
+    "validmind.model_validation.sklearn.RobustnessDiagnosis",
+    "validmind.model_validation.sklearn.AdjustedRandIndex",
+    "validmind.model_validation.sklearn.SHAPGlobalImportance",
+    "validmind.model_validation.sklearn.ConfusionMatrix",
+    "validmind.model_validation.sklearn.HomogeneityScore",
+    "validmind.model_validation.sklearn.CompletenessScore",
+    "validmind.model_validation.sklearn.OverfitDiagnosis",
+    "validmind.model_validation.sklearn.ClusterPerformanceMetrics",
+    "validmind.model_validation.sklearn.PermutationFeatureImportance",
+    "validmind.model_validation.sklearn.FowlkesMallowsScore",
+    "validmind.model_validation.sklearn.MinimumROCAUCScore",
+    "validmind.model_validation.sklearn.ClusterCosineSimilarity",
+    "validmind.model_validation.sklearn.PrecisionRecallCurve",
+    "validmind.model_validation.sklearn.ClassifierPerformance",
+    "validmind.model_validation.sklearn.VMeasure",
+    "validmind.model_validation.sklearn.MinimumF1Score",
+    "validmind.model_validation.sklearn.ROCCurve",
+    "validmind.model_validation.sklearn.RegressionR2Square",
+    "validmind.model_validation.sklearn.RegressionErrors",
+    "validmind.model_validation.sklearn.ClusterPerformance",
+    "validmind.model_validation.sklearn.TrainingTestDegradation",
+    "validmind.model_validation.sklearn.HyperParametersTuning",
+    "validmind.model_validation.sklearn.KMeansClustersOptimization",
+    "validmind.model_validation.sklearn.ModelsPerformanceComparison",
+    "validmind.model_validation.sklearn.WeakspotsDiagnosis",
+    "validmind.model_validation.sklearn.PopulationStabilityIndex",
+    "validmind.model_validation.sklearn.MinimumAccuracy",
+    "validmind.model_validation.statsmodels.RegressionModelsCoeffs",
+    "validmind.model_validation.statsmodels.BoxPierce",
+    "validmind.model_validation.statsmodels.RegressionCoeffsPlot",
+    "validmind.model_validation.statsmodels.RegressionModelSensitivityPlot",
+    "validmind.model_validation.statsmodels.RegressionModelForecastPlotLevels",
+    "validmind.model_validation.statsmodels.ScorecardHistogram",
+    "validmind.model_validation.statsmodels.LJungBox",
+    "validmind.model_validation.statsmodels.JarqueBera",
+    "validmind.model_validation.statsmodels.KolmogorovSmirnov",
+    "validmind.model_validation.statsmodels.ShapiroWilk",
+    "validmind.model_validation.statsmodels.CumulativePredictionProbabilities",
+    "validmind.model_validation.statsmodels.RegressionFeatureSignificance",
+    "validmind.model_validation.statsmodels.RegressionModelSummary",
+    "validmind.model_validation.statsmodels.Lilliefors",
+    "validmind.model_validation.statsmodels.RunsTest",
+    "validmind.model_validation.statsmodels.RegressionPermutationFeatureImportance",
+    "validmind.model_validation.statsmodels.PredictionProbabilitiesHistogram",
+    "validmind.model_validation.statsmodels.AutoARIMA",
+    "validmind.model_validation.statsmodels.GINITable",
+    "validmind.model_validation.statsmodels.RegressionModelForecastPlot",
+    "validmind.model_validation.statsmodels.DurbinWatsonTest",
+    "validmind.data_validation.MissingValuesRisk",
+    "validmind.data_validation.IQROutliersTable",
+    "validmind.data_validation.BivariateFeaturesBarPlots",
+    "validmind.data_validation.Skewness",
+    "validmind.data_validation.Duplicates",
+    "validmind.data_validation.MissingValuesBarPlot",
+    "validmind.data_validation.DatasetDescription",
+    "validmind.data_validation.ZivotAndrewsArch",
+    "validmind.data_validation.ScatterPlot",
+    "validmind.data_validation.TimeSeriesOutliers",
+    "validmind.data_validation.TabularCategoricalBarPlots",
+    "validmind.data_validation.AutoStationarity",
+    "validmind.data_validation.DescriptiveStatistics",
+    "validmind.data_validation.ANOVAOneWayTable",
+    "validmind.data_validation.TargetRateBarPlots",
+    "validmind.data_validation.PearsonCorrelationMatrix",
+    "validmind.data_validation.FeatureTargetCorrelationPlot",
+    "validmind.data_validation.TabularNumericalHistograms",
+    "validmind.data_validation.IsolationForestOutliers",
+    "validmind.data_validation.ChiSquaredFeaturesTable",
+    "validmind.data_validation.HighCardinality",
+    "validmind.data_validation.MissingValues",
+    "validmind.data_validation.PhillipsPerronArch",
+    "validmind.data_validation.RollingStatsPlot",
+    "validmind.data_validation.TabularDescriptionTables",
+    "validmind.data_validation.AutoMA",
+    "validmind.data_validation.UniqueRows",
+    "validmind.data_validation.TooManyZeroValues",
+    "validmind.data_validation.HighPearsonCorrelation",
+    "validmind.data_validation.ACFandPACFPlot",
+    "validmind.data_validation.BivariateHistograms",
+    "validmind.data_validation.WOEBinTable",
+    "validmind.data_validation.HeatmapFeatureCorrelations",
+    "validmind.data_validation.TimeSeriesFrequency",
+    "validmind.data_validation.DatasetSplit",
+    "validmind.data_validation.SpreadPlot",
+    "validmind.data_validation.TimeSeriesLinePlot",
+    "validmind.data_validation.KPSS",
+    "validmind.data_validation.AutoSeasonality",
+    "validmind.data_validation.BivariateScatterPlots",
+    "validmind.data_validation.EngleGrangerCoint",
+    "validmind.data_validation.TimeSeriesMissingValues",
+    "validmind.data_validation.TimeSeriesHistogram",
+    "validmind.data_validation.LaggedCorrelationHeatmap",
+    "validmind.data_validation.SeasonalDecompose",
+    "validmind.data_validation.WOEBinPlots",
+    "validmind.data_validation.ClassImbalance",
+    "validmind.data_validation.IQROutliersBarPlot",
+    "validmind.data_validation.DFGLSArch",
+    "validmind.data_validation.AutoAR",
+    "validmind.data_validation.TabularDateTimeHistograms",
+    "validmind.data_validation.ADF",
+    "validmind.data_validation.nlp.Toxicity",
+    "validmind.data_validation.nlp.PolarityAndSubjectivity",
+    "validmind.data_validation.nlp.Punctuations",
+    "validmind.data_validation.nlp.Sentiment",
+    "validmind.data_validation.nlp.CommonWords",
+    "validmind.data_validation.nlp.Hashtags",
+    "validmind.data_validation.nlp.LanguageDetection",
+    "validmind.data_validation.nlp.Mentions",
+    "validmind.data_validation.nlp.TextDescription",
+    "validmind.data_validation.nlp.StopWords",
+]

validmind/tests/data_validation/ACFandPACFPlot.py

@@ -2,9 +2,9 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-import matplotlib.pyplot as plt
 import pandas as pd
-from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
+import plotly.graph_objects as go
+from statsmodels.tsa.stattools import acf, pacf
 
 from validmind.vm_models import Figure, Metric
 
@@ -77,37 +77,46 @@ class ACFandPACFPlot(Metric):
         for col in df.columns:
             series = df[col]
 
-            # Create subplots
-            fig, (ax1, ax2) = plt.subplots(1, 2)
-            width, _ = fig.get_size_inches()
-            fig.set_size_inches(width, 5)
-
-            plot_acf(series, ax=ax1)
-            plot_pacf(series, ax=ax2)
-
-            # Get the current y-axis limits
-            ymin, ymax = ax1.get_ylim()
-            # Set new limits - adding a bit of space
-            ax1.set_ylim([ymin, ymax + 0.05 * (ymax - ymin)])
+            # Calculate the maximum number of lags based on the size of the dataset
+            max_lags = min(40, len(series) // 2 - 1)
+
+            # Calculate ACF and PACF values
+            acf_values = acf(series, nlags=max_lags)
+            pacf_values = pacf(series, nlags=max_lags)
+
+            # Create ACF plot using Plotly
+            acf_fig = go.Figure()
+            acf_fig.add_trace(go.Bar(x=list(range(len(acf_values))), y=acf_values))
+            acf_fig.update_layout(
+                title=f"ACF for {col}",
+                xaxis_title="Lag",
+                yaxis_title="ACF",
+                font=dict(size=18),
+            )
 
-            ymin, ymax = ax2.get_ylim()
-            ax2.set_ylim([ymin, ymax + 0.05 * (ymax - ymin)])
+            # Create PACF plot using Plotly
+            pacf_fig = go.Figure()
+            pacf_fig.add_trace(go.Bar(x=list(range(len(pacf_values))), y=pacf_values))
+            pacf_fig.update_layout(
+                title=f"PACF for {col}",
+                xaxis_title="Lag",
+                yaxis_title="PACF",
+                font=dict(size=18),
+            )
 
-            ax1.tick_params(axis="both", labelsize=18)
-            ax2.tick_params(axis="both", labelsize=18)
-            ax1.set_title(f"ACF for {col}", weight="bold", fontsize=20)
-            ax2.set_title(f"PACF for {col}", weight="bold", fontsize=20)
-            ax1.set_xlabel("Lag", fontsize=18)
-            ax2.set_xlabel("Lag", fontsize=18)
             figures.append(
                 Figure(
                     for_object=self,
-                    key=f"{self.key}:{col}",
-                    figure=fig,
+                    key=f"{self.key}:{col}_acf",
+                    figure=acf_fig,
+                )
+            )
+            figures.append(
+                Figure(
+                    for_object=self,
+                    key=f"{self.key}:{col}_pacf",
+                    figure=pacf_fig,
                 )
             )
-
-            # Do this if you want to prevent the figure from being displayed
-            plt.close("all")
 
         return self.cache_results(figures=figures)

validmind/tests/{model_validation/statsmodels → data_validation}/ADF.py

@@ -2,12 +2,18 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-from pandas import DataFrame
+from dataclasses import dataclass
+
+import pandas as pd
 from statsmodels.tsa.stattools import adfuller
 
+from validmind.logging import get_logger
 from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
 
+logger = get_logger(__name__)
+
 
+@dataclass
 class ADF(Metric):
     """
     Assesses the stationarity of a time series dataset using the Augmented Dickey-Fuller (ADF) test.
@@ -53,7 +59,7 @@ class ADF(Metric):
     }
 
     def summary(self, metric_value: dict):
-        table = DataFrame.from_dict(metric_value, orient="index")
+        table = pd.DataFrame.from_dict(metric_value, orient="index")
         table = table.reset_index()
         table.columns = [
             "Feature",
@@ -83,18 +89,41 @@ class ADF(Metric):
         """
         dataset = self.inputs.dataset.df
 
+        # Check if the dataset is a time series
+        if not isinstance(dataset.index, (pd.DatetimeIndex, pd.PeriodIndex)):
+            raise ValueError(
+                "Dataset index must be a datetime or period index for time series analysis."
+            )
+
+        # Preprocessing: Drop rows with any NaN values
+        if dataset.isnull().values.any():
+            logger.warning(
+                "Dataset contains missing values. Rows with NaNs will be dropped."
+            )
+            dataset = dataset.dropna()
+
         adf_values = {}
         for col in dataset.columns:
-            adf, pvalue, usedlag, nobs, critical_values, icbest = adfuller(
-                dataset[col].values
-            )
-            adf_values[col] = {
-                "stat": adf,
-                "pvalue": pvalue,
-                "usedlag": usedlag,
-                "nobs": nobs,
-                "critical_values": critical_values,
-                "icbest": icbest,
-            }
+            try:
+                adf_result = adfuller(dataset[col].values)
+                adf_values[col] = {
+                    "ADF Statistic": adf_result[0],
+                    "P-Value": adf_result[1],
+                    "Used Lag": adf_result[2],
+                    "Number of Observations": adf_result[3],
+                    "Critical Values": adf_result[4],
+                    "IC Best": adf_result[5],
+                }
+            except Exception as e:
+                logger.error(f"Error processing column '{col}': {e}")
+                adf_values[col] = {
+                    "ADF Statistic": None,
+                    "P-Value": None,
+                    "Used Lag": None,
+                    "Number of Observations": None,
+                    "Critical Values": None,
+                    "IC Best": None,
+                    "Error": str(e),
+                }
 
         return self.cache_results(adf_values)

validmind/tests/data_validation/BivariateScatterPlots.py

@@ -2,10 +2,10 @@
 # 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 matplotlib.pyplot as plt
-import seaborn as sns
+import plotly.express as px
 
 from validmind.vm_models import Figure, Metric
 
@@ -23,7 +23,7 @@ class BivariateScatterPlots(Metric):
     biases and irregularities in the data.
 
     **Test Mechanism**: This metric operates by creating a scatter plot for each pair of the selected features in the
-    dataset. If the parameters "features_pairs" are not specified, an error will be thrown. The metric offers
+    dataset. If the parameters "selected_columns" are not specified, an error will be thrown. The metric offers
     flexibility by allowing the user to filter on a specific target class - specified by the "target_filter" parameter
     - for more granified insights. Each scatterplot is then color-coded based on the category of the target variable
     for better visual differentiation. The seaborn scatterplot library is used for generating the plots.
@@ -53,7 +53,7 @@ class BivariateScatterPlots(Metric):
 
     name = "bivariate_scatter_plots"
     required_inputs = ["dataset"]
-    default_params = {"features_pairs": None, "target_filter": None}
+    default_params = {"selected_columns": None}
     metadata = {
         "task_types": ["classification"],
         "tags": [
@@ -65,52 +65,49 @@ class BivariateScatterPlots(Metric):
         ],
     }
 
-    def plot_bivariate_scatter(self, features_pairs, target_filter):
-        status_var = self.inputs.dataset.target_column
+    def plot_bivariate_scatter(self, columns):
         figures = []
-        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]
-
-            plt.figure()
-
-            # Scatterplot using seaborn, with color variation based on 'status_var'
-            # Create color mapping with rgba values, last value is alpha (transparency)
-            palette = {0: (0.8, 0.8, 0.8, 0.8), 1: "tab:red"}
-            plot = sns.scatterplot(
-                data=df, x=x, y=y, hue=status_var, palette=palette, alpha=1
+        df = self.inputs.dataset.df
+
+        # Generate all pairs of columns
+        features_pairs = list(itertools.combinations(columns, 2))
+
+        for x, y in features_pairs:
+            fig = px.scatter(
+                df,
+                x=x,
+                y=y,
+                title=f"{x} and {y}",
+                labels={x: x, y: y},
+                opacity=0.7,
+                color_discrete_sequence=["blue"],  # Use the same color for all points
             )
-
-            # Change legend labels
-            legend_labels = [
-                "Category 1" if t.get_text() == "1" else "Category 2"
-                for t in plot.legend_.texts[1:]
-            ]
-            plot.legend_.texts[1:] = legend_labels
-
-            plt.title(x + " and " + y)
-            plt.xlabel(x)
-            plt.ylabel(y)
-            plt.show()
+            fig.update_traces(marker=dict(color="blue"))
 
             figures.append(
-                Figure(for_object=self, key=f"{self.key}:{x}_{y}", figure=plt.figure())
+                Figure(for_object=self, key=f"{self.key}:{x}_{y}", figure=fig)
             )
 
-        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."
-            )
+        selected_columns = self.params["selected_columns"]
+
+        if selected_columns is None:
+            # Use all columns if selected_columns is not provided
+            selected_columns = self.inputs.dataset.df.columns.tolist()
+        else:
+            # Check if all selected columns exist in the dataframe
+            missing_columns = [
+                col
+                for col in selected_columns
+                if col not in self.inputs.dataset.df.columns
+            ]
+            if missing_columns:
+                raise ValueError(
+                    f"The following selected columns are not in the dataframe: {missing_columns}"
+                )
 
-        figures = self.plot_bivariate_scatter(features_pairs, target_filter)
+        figures = self.plot_bivariate_scatter(selected_columns)
 
         return self.cache_results(figures=figures)

validmind/tests/{model_validation/statsmodels → data_validation}/DFGLSArch.py

@@ -4,9 +4,14 @@
 
 from dataclasses import dataclass
 
+import pandas as pd
 from arch.unitroot import DFGLS
+from numpy.linalg import LinAlgError
 
-from validmind.vm_models import Metric
+from validmind.logging import get_logger
+from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+
+logger = get_logger(__name__)
 
 
 @dataclass
@@ -59,14 +64,65 @@ class DFGLSArch(Metric):
         """
         dataset = self.inputs.dataset.df
 
-        dfgls_values = {}
+        # Check if the dataset is a time series
+        if not isinstance(dataset.index, (pd.DatetimeIndex, pd.PeriodIndex)):
+            raise ValueError(
+                "Dataset index must be a datetime or period index for time series analysis."
+            )
+
+        # Preprocessing: Drop rows with any NaN values
+        if dataset.isnull().values.any():
+            logger.warning(
+                "Dataset contains missing values. Rows with NaNs will be dropped."
+            )
+            dataset = dataset.dropna()
+
+        # Convert to numeric and handle non-numeric data
+        dataset = dataset.apply(pd.to_numeric, errors="coerce")
+
+        # Initialize a list to store DFGLS results
+        dfgls_values = []
+
         for col in dataset.columns:
-            dfgls_out = DFGLS(dataset[col].values)
-            dfgls_values[col] = {
-                "stat": dfgls_out.stat,
-                "pvalue": dfgls_out.pvalue,
-                "usedlag": dfgls_out.lags,
-                "nobs": dfgls_out.nobs,
-            }
-
-        return self.cache_results(dfgls_values)
+            try:
+                dfgls_out = DFGLS(dataset[col].values)
+                dfgls_values.append(
+                    {
+                        "Variable": col,
+                        "stat": dfgls_out.stat,
+                        "pvalue": dfgls_out.pvalue,
+                        "usedlag": dfgls_out.lags,
+                        "nobs": dfgls_out.nobs,
+                    }
+                )
+            except LinAlgError as e:
+                logger.error(
+                    f"SVD did not converge while processing column '{col}'. This could be due to numerical instability or multicollinearity. Error details: {e}"
+                )
+                dfgls_values.append(
+                    {
+                        "Variable": col,
+                        "stat": None,
+                        "pvalue": None,
+                        "usedlag": None,
+                        "nobs": None,
+                        "error": str(e),
+                    }
+                )
+
+        return self.cache_results({"dfgls_results": dfgls_values})
+
+    def summary(self, metric_value):
+        """
+        Build a table for summarizing the DFGLS results
+        """
+        dfgls_results = metric_value["dfgls_results"]
+
+        return ResultSummary(
+            results=[
+                ResultTable(
+                    data=dfgls_results,
+                    metadata=ResultTableMetadata(title="DFGLS Test Results"),
+                )
+            ]
+        )

validmind/tests/data_validation/HeatmapFeatureCorrelations.py

@@ -62,7 +62,7 @@ class HeatmapFeatureCorrelations(Metric):
     }
 
     def run(self):
-        features = self.params["features"]
+        features = self.params.get("features")
         declutter = self.params.get("declutter", False)
         fontsize = self.params.get("fontsize", 13)
 

validmind/tests/data_validation/HighPearsonCorrelation.py

@@ -65,9 +65,18 @@ class HighPearsonCorrelation(ThresholdTest):
     }
 
     def summary(self, results: List[ThresholdTestResult], all_passed: bool):
-        """
-        The high pearson correlation test returns results like these:
-        [{"values": {"correlations": [{"column": "NumOfProducts", "correlation": -0.3044645622389459}]}, "column": "Balance", "passed": false}]
+        """The high pearson correlation test returns results like these:
+        [
+            {
+                "values": {
+                    "correlations": [
+                        {"column": "NumOfProducts", "correlation": -0.3044645622389459}
+                    ]
+                },
+                "column": "Balance",
+                "passed": false,
+            }
+        ]
         """
         results_table = [
             {

validmind/tests/data_validation/IsolationForestOutliers.py

@@ -64,7 +64,7 @@ class IsolationForestOutliers(Metric):
 
     def run(self):
         if self.params["features_columns"] is None:
-            features_list = self.inputs.dataset.feature_columns
+            features_list = self.inputs.dataset.feature_columns_numeric
         else:
             features_list = self.params["features_columns"]
 
@@ -78,7 +78,7 @@ class IsolationForestOutliers(Metric):
                 + "training dataset feature columns"
             )
 
-        dataset = self.inputs.dataset.df
+        dataset = self.inputs.dataset.df[features_list]
 
         # Training with isolation forest algorithm
         clf = IsolationForest(