validmind 2.5.25__py3-none-any.whl → 2.6.8__py3-none-any.whl

validmind/tests/data_validation/IQROutliersTable.py

@@ -2,15 +2,23 @@
 # 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 import tags, tasks
+from validmind.vm_models import VMDataset
 
-import pandas as pd
 
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+def compute_outliers(series, threshold=1.5):
+    Q1 = series.quantile(0.25)
+    Q3 = series.quantile(0.75)
+    IQR = Q3 - Q1
+    lower_bound = Q1 - threshold * IQR
+    upper_bound = Q3 + threshold * IQR
 
+    return series[(series < lower_bound) | (series > upper_bound)]
 
-@dataclass
-class IQROutliersTable(Metric):
+
+@tags("tabular_data", "numerical_data")
+@tasks("classification", "regression")
+def IQROutliersTable(dataset: VMDataset, threshold: float = 1.5):
     """
     Determines and summarizes outliers in numerical features using the Interquartile Range method.
 
@@ -53,80 +61,32 @@ class IQROutliersTable(Metric):
     - Default thresholds may not be optimal for data with heavy pre-processing, manipulation, or inherently high
     kurtosis (heavy tails).
     """
-
-    name = "iqr_outliers_table"
-    required_inputs = ["dataset"]
-    default_params = {"threshold": 1.5}
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "numerical_data"]
-
-    def run(self):
-
-        # Select numerical features
-        features = self.inputs.dataset.feature_columns_numeric
-
-        # Select non-binary features
-        features = [
-            feature
-            for feature in features
-            if len(self.inputs.dataset.df[feature].unique()) > 2
-        ]
-
-        threshold = self.params["threshold"]
-
-        df = self.inputs.dataset.df
-
-        outliers_summary_table = self.detect_and_analyze_outliers(
-            df, features, threshold
+    df = dataset.df
+
+    outliers_table = []
+
+    for col in dataset.feature_columns_numeric:
+        # Skip binary features
+        if len(df[col].unique()) <= 2:
+            continue
+
+        outliers = compute_outliers(df[col], threshold)
+        if outliers.empty:
+            continue
+
+        outliers_table.append(
+            {
+                "Variable": col,
+                "Total Count of Outliers": outliers.count(),
+                "Mean Value of Variable": df[col].mean(),
+                "Minimum Outlier Value": outliers.min(),
+                "Outlier Value at 25th Percentile": outliers.quantile(0.25),
+                "Outlier Value at 50th Percentile": outliers.median(),
+                "Outlier Value at 75th Percentile": outliers.quantile(0.75),
+                "Maximum Outlier Value": outliers.max(),
+            }
         )
 
-        return self.cache_results(
-            {"outliers_summary_table": outliers_summary_table.to_dict(orient="records")}
-        )
-
-    @staticmethod
-    def compute_outliers(series, threshold=1.5):
-        Q1 = series.quantile(0.25)
-        Q3 = series.quantile(0.75)
-        IQR = Q3 - Q1
-        lower_bound = Q1 - threshold * IQR
-        upper_bound = Q3 + threshold * IQR
-        return series[(series < lower_bound) | (series > upper_bound)]
-
-    def detect_and_analyze_outliers(self, df, features, threshold=1.5):
-
-        outliers_summary = []
-        for feature in features:
-            outliers_series = self.compute_outliers(df[feature], threshold)
-            if not outliers_series.empty:
-                outliers_summary.append(
-                    {
-                        "Variable": feature,
-                        "Total Count of Outliers": outliers_series.count(),
-                        "Mean Value of Variable": df[feature].mean(),
-                        "Minimum Outlier Value": outliers_series.min(),
-                        "Outlier Value at 25th Percentile": outliers_series.quantile(
-                            0.25
-                        ),
-                        "Outlier Value at 50th Percentile": outliers_series.median(),
-                        "Outlier Value at 75th Percentile": outliers_series.quantile(
-                            0.75
-                        ),
-                        "Maximum Outlier Value": outliers_series.max(),
-                    }
-                )
-        outliers_summary_table = pd.DataFrame(outliers_summary)
-        return outliers_summary_table
-
-    def summary(self, metric_value):
-        outliers_summary_table = pd.DataFrame(metric_value["outliers_summary_table"])
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=outliers_summary_table,
-                    metadata=ResultTableMetadata(
-                        title="Summary of Outliers Detected by IQR Method"
-                    ),
-                ),
-            ]
-        )
+    return {
+        "Summary of Outliers Detected by IQR Method": outliers_table,
+    }

validmind/tests/data_validation/IsolationForestOutliers.py

@@ -3,17 +3,23 @@
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
 import itertools
-from dataclasses import dataclass
 
 import matplotlib.pyplot as plt
 import seaborn as sns
 from sklearn.ensemble import IsolationForest
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset
 
 
-@dataclass
-class IsolationForestOutliers(Metric):
+@tags("tabular_data", "anomaly_detection")
+@tasks("classification")
+def IsolationForestOutliers(
+    dataset: VMDataset,
+    random_state: int = 0,
+    contamination: float = 0.1,
+    feature_columns: list = None,
+):
     """
     Detects outliers in a dataset using the Isolation Forest algorithm and visualizes results through scatter plots.
 
@@ -55,64 +61,36 @@ class IsolationForestOutliers(Metric):
     - Potential failure in detecting collective anomalies if they behave similarly to normal data
     - Potential lack of precision in identifying which features contribute most to the anomalous behavior
     """
-
-    name = "isolation_forest"
-    default_params = {
-        "random_state": 0,
-        "contamination": 0.1,
-        "features_columns": None,
-    }
-    tasks = ["classification"]
-    tags = ["tabular_data", "anomaly_detection"]
-
-    required_inputs = ["dataset"]
-
-    def run(self):
-        if self.params["features_columns"] is None:
-            features_list = self.inputs.dataset.feature_columns_numeric
-        else:
-            features_list = self.params["features_columns"]
-
-        # Check if all elements from features_list are present in the feature columns
-        all_present = all(
-            elem in self.inputs.dataset.feature_columns for elem in features_list
+    if feature_columns and not all(elem in dataset.columns for elem in feature_columns):
+        raise ValueError(
+            "The list of feature columns provided do not match with training dataset feature columns"
         )
-        if not all_present:
-            raise ValueError(
-                "The list of feature columns provided do not match with "
-                + "training dataset feature columns"
-            )
-
-        dataset = self.inputs.dataset.df[features_list]
-
-        # Training with isolation forest algorithm
-        clf = IsolationForest(
-            random_state=self.params["random_state"],
-            contamination=self.params["contamination"],
+
+    feature_columns = feature_columns or dataset.feature_columns_numeric
+
+    df = dataset.df[feature_columns]
+
+    clf = IsolationForest(
+        random_state=random_state,
+        contamination=contamination,
+    )
+    clf.fit(df)
+    y_pred = clf.predict(df)
+
+    figures = []
+
+    for feature1, feature2 in itertools.combinations(feature_columns, 2):
+        fig = plt.figure()
+        ax = sns.scatterplot(
+            data=df, x=feature1, y=feature2, hue=y_pred, palette="bright"
         )
-        clf.fit(dataset)
-        y_pred = clf.predict(dataset)
-
-        test_figures = []
-        combination_pairs = list(itertools.combinations(features_list, 2))
-        for feature1, feature2 in combination_pairs:
-            fig = plt.figure()
-            ax = sns.scatterplot(
-                data=dataset, x=feature1, y=feature2, hue=y_pred, palette="bright"
-            )
-            handles, labels = ax.get_legend_handles_labels()
-            labels = list(map(lambda x: x.replace("-1", "Outliers"), labels))
-            labels = list(map(lambda x: x.replace("1", "Inliers"), labels))
-            ax.legend(handles, labels)
-            # Do this if you want to prevent the figure from being displayed
-            plt.close("all")
-
-            test_figures.append(
-                Figure(
-                    for_object=self,
-                    key=f"{self.name}:{feature1}_{feature2}",
-                    figure=fig,
-                )
-            )
-
-        return self.cache_results(figures=test_figures)
+        handles, labels = ax.get_legend_handles_labels()
+        labels = list(map(lambda x: x.replace("-1", "Outliers"), labels))
+        labels = list(map(lambda x: x.replace("1", "Inliers"), labels))
+        ax.legend(handles, labels)
+
+        figures.append(fig)
+
+        plt.close()
+
+    return tuple(figures)

validmind/tests/data_validation/KPSS.py

@@ -2,19 +2,20 @@
 # 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 statsmodels.tsa.stattools import kpss
 
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
 from validmind.logging import get_logger
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+from validmind.vm_models import VMDataset
 
 logger = get_logger(__name__)
 
 
-@dataclass
-class KPSS(Metric):
+@tags("time_series_data", "stationarity", "unit_root_test", "statsmodels")
+@tasks("data_validation")
+def KPSS(dataset: VMDataset):
     """
     Assesses the stationarity of time-series data in a machine learning model using the KPSS unit root test.
 
@@ -53,81 +54,32 @@ class KPSS(Metric):
     - The reliability of the test is contingent on the number of lags selected, which introduces potential bias in the
     measurement.
     """
+    df = dataset.df.dropna()
 
-    name = "kpss"
-    required_inputs = ["dataset"]
-    tasks = ["regression"]
-    tags = [
-        "time_series_data",
-        "forecasting",
-        "stationarity",
-        "unit_root_test",
-        "statsmodels",
-    ]
-
-    def run(self):
-        """
-        Calculates KPSS for each of the dataset features
-        """
-        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()
-
-        # Convert to numeric and handle non-numeric data
-        dataset = dataset.apply(pd.to_numeric, errors="coerce")
-
-        # Initialize a list to store KPSS results
-        kpss_values = []
-
-        for col in dataset.columns:
-            try:
-                kpss_stat, pvalue, usedlag, critical_values = kpss(dataset[col].values)
-                kpss_values.append(
-                    {
-                        "Variable": col,
-                        "stat": kpss_stat,
-                        "pvalue": pvalue,
-                        "usedlag": usedlag,
-                        "critical_values": critical_values,
-                    }
-                )
-            except Exception as e:
-                logger.error(f"Error processing column '{col}': {e}")
-                kpss_values.append(
-                    {
-                        "Variable": col,
-                        "stat": None,
-                        "pvalue": None,
-                        "usedlag": None,
-                        "critical_values": None,
-                        "error": str(e),
-                    }
-                )
-
-        return self.cache_results({"kpss_results": kpss_values})
-
-    def summary(self, metric_value):
-        """
-        Build a table for summarizing the KPSS results
-        """
-        kpss_results = metric_value["kpss_results"]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=kpss_results,
-                    metadata=ResultTableMetadata(title="KPSS Test Results"),
-                )
-            ]
+    if not isinstance(df.index, (pd.DatetimeIndex, pd.PeriodIndex)):
+        raise SkipTestError(
+            "Dataset index must be a datetime or period index for time series analysis."
         )
+
+    df = df.apply(pd.to_numeric, errors="coerce")
+
+    kpss_table = []
+
+    for col in dataset.columns:
+        kpss_stat, pvalue, usedlag, critical_values = kpss(df[col].values)
+        kpss_table.append(
+            {
+                "Variable": col,
+                "stat": kpss_stat,
+                "pvalue": pvalue,
+                "usedlag": usedlag,
+                "critical_values": critical_values,
+            }
+        )
+
+    if not kpss_table:
+        raise SkipTestError(f"No KPSS results found for dataset: {dataset.input_id}")
+
+    return {
+        "KPSS Test Results": kpss_table,
+    }

validmind/tests/data_validation/LaggedCorrelationHeatmap.py

@@ -6,13 +6,16 @@ import numpy as np
 import pandas as pd
 import plotly.figure_factory as ff
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset
 
 # Define the 'coolwarm' color scale manually
 COOLWARM = [[0, "rgb(95,5,255)"], [0.5, "rgb(255,255,255)"], [1, "rgb(255,5,0)"]]
 
 
-class LaggedCorrelationHeatmap(Metric):
+@tags("time_series_data", "visualization")
+@tasks("regression")
+def LaggedCorrelationHeatmap(dataset: VMDataset, num_lags: int = 10):
     """
     Assesses and visualizes correlation between target variable and lagged independent variables in a time-series
     dataset.
@@ -55,98 +58,47 @@ class LaggedCorrelationHeatmap(Metric):
     to interpret, while too few might overlook delayed effects.
     - This metric does not take into account any causal relationships, but merely demonstrates correlation.
     """
-
-    name = "lagged_correlation_heatmap"
-    required_inputs = ["dataset"]
-    tasks = ["regression"]
-    tags = ["time_series_data", "visualization"]
-
-    def _compute_correlations(self, df, target_col, independent_vars, num_lags):
-        correlations = np.zeros((len(independent_vars), num_lags + 1))
-
-        for i, ind_var_col in enumerate(independent_vars):
-            for lag in range(num_lags + 1):
-                temp_df = pd.DataFrame(
-                    {
-                        target_col: df[target_col],
-                        f"{ind_var_col}_lag{lag}": df[ind_var_col].shift(lag),
-                    }
-                )
-
-                temp_df = temp_df.dropna()
-
-                corr = temp_df[target_col].corr(temp_df[f"{ind_var_col}_lag{lag}"])
-
-                correlations[i, lag] = corr
-
-        return correlations
-
-    def _plot_heatmap(self, correlations, independent_vars, target_col, num_lags):
-        correlation_df = pd.DataFrame(
-            correlations,
-            columns=[f"{i}" for i in range(num_lags + 1)],
-            index=independent_vars,
-        )
-
-        # Create heatmap using Plotly
-        fig = ff.create_annotated_heatmap(
-            z=correlation_df.values,
-            x=list(correlation_df.columns),
-            y=list(correlation_df.index),
-            colorscale=COOLWARM,
-            annotation_text=correlation_df.round(2).values,
-            showscale=True,
-        )
-
-        fig.update_layout(
-            title={
-                "text": f"Correlations between {target_col} and Lags of Features",
-                "y": 0.95,
-                "x": 0.5,
-                "xanchor": "center",
-                "yanchor": "top",
-            },
-            font=dict(size=14),
-            xaxis_title="Lags",
-        )
-
-        return fig
-
-    def run(self):
-        if isinstance(self.inputs.dataset.target_column, list):
-            target_col = self.inputs.dataset.target_column[
-                0
-            ]  # take the first item from the list
-        else:
-            target_col = self.inputs.dataset.target_column
-
-        independent_vars = list(self.inputs.dataset.feature_columns)
-        num_lags = self.params.get("num_lags", 10)
-
-        if isinstance(target_col, list) and len(target_col) == 1:
-            target_col = target_col[0]
-
-        if not isinstance(target_col, str):
-            raise ValueError(
-                "The 'target_col' must be a single string or a list containing a single string"
-            )
-
-        df = self.inputs.dataset.df
-
-        correlations = self._compute_correlations(
-            df, target_col, independent_vars, num_lags
-        )
-        fig = self._plot_heatmap(correlations, independent_vars, target_col, num_lags)
-
-        figures = []
-        figures.append(
-            Figure(
-                for_object=self,
-                key=self.key,
-                figure=fig,
+    correlations = np.zeros((len(dataset.feature_columns), num_lags + 1))
+
+    for i, ind_var_col in enumerate(dataset.feature_columns):
+        for lag in range(num_lags + 1):
+            temp_df = pd.DataFrame(
+                {
+                    dataset.target_column: dataset.df[dataset.target_column],
+                    f"{ind_var_col}_lag{lag}": dataset.df[ind_var_col].shift(lag),
+                }
+            ).dropna()
+
+            corr = temp_df[dataset.target_column].corr(
+                temp_df[f"{ind_var_col}_lag{lag}"]
             )
-        )
 
-        return self.cache_results(
-            figures=figures,
-        )
+            correlations[i, lag] = corr
+
+    correlation_df = pd.DataFrame(
+        correlations,
+        columns=[f"{i}" for i in range(num_lags + 1)],
+        index=dataset.feature_columns,
+    )
+
+    fig = ff.create_annotated_heatmap(
+        z=correlation_df.values,
+        x=list(correlation_df.columns),
+        y=list(correlation_df.index),
+        colorscale=COOLWARM,
+        annotation_text=correlation_df.round(2).values,
+        showscale=True,
+    )
+    fig.update_layout(
+        title={
+            "text": f"Correlations between {dataset.target_column} and Lags of Features",
+            "y": 0.95,
+            "x": 0.5,
+            "xanchor": "center",
+            "yanchor": "top",
+        },
+        font=dict(size=14),
+        xaxis_title="Lags",
+    )
+
+    return fig

validmind/tests/data_validation/MissingValues.py

@@ -2,20 +2,13 @@
 # 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 typing import List
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset
 
-from validmind.vm_models import (
-    ResultSummary,
-    ResultTable,
-    ResultTableMetadata,
-    ThresholdTest,
-    ThresholdTestResult,
-)
 
-
-@dataclass
-class MissingValues(ThresholdTest):
+@tags("tabular_data", "data_quality")
+@tasks("classification", "regression")
+def MissingValues(dataset: VMDataset, min_threshold: int = 1):
     """
     Evaluates dataset quality by ensuring missing value ratio across all features does not exceed a set threshold.
 
@@ -53,49 +46,15 @@ class MissingValues(ThresholdTest):
     - Does not account for data encoded as values like "-999" or "None," which might not technically classify as
     missing but could bear similar implications.
     """
-
-    name = "missing"
-    required_inputs = ["dataset"]
-    default_params = {"min_threshold": 1}
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "data_quality"]
-
-    def summary(self, results: List[ThresholdTestResult], all_passed: bool):
-        """
-        The missing values test returns results like these:
-        [{"values": {"n_missing": 0, "p_missing": 0.0}, "column": "Exited", "passed": true}]
-        """
-        results_table = [
-            {
-                "Column": result.column,
-                "Number of Missing Values": result.values["n_missing"],
-                "Percentage of Missing Values (%)": result.values["p_missing"] * 100,
-                "Pass/Fail": "Pass" if result.passed else "Fail",
-            }
-            for result in results
-        ]
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=results_table,
-                    metadata=ResultTableMetadata(
-                        title="Missing Values Results for Dataset"
-                    ),
-                )
-            ]
-        )
-
-    def run(self):
-        rows = self.inputs.dataset.df.shape[0]
-
-        missing = self.inputs.dataset.df.isna().sum()
-        results = [
-            ThresholdTestResult(
-                column=col,
-                passed=missing[col] < self.params["min_threshold"],
-                values={"n_missing": missing[col], "p_missing": missing[col] / rows},
-            )
-            for col in missing.index
-        ]
-
-        return self.cache_results(results, passed=all([r.passed for r in results]))
+    df = dataset.df
+    missing = df.isna().sum()
+
+    return [
+        {
+            "Column": col,
+            "Number of Missing Values": missing[col],
+            "Percentage of Missing Values (%)": missing[col] / df.shape[0] * 100,
+            "Pass/Fail": "Pass" if missing[col] < min_threshold else "Fail",
+        }
+        for col in missing.index
+    ], all(missing[col] < min_threshold for col in missing.index)