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

validmind/tests/data_validation/TooManyZeroValues.py

@@ -2,23 +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.tests import tags, tasks
+from validmind.vm_models import VMDataset
 
-from ydata_profiling.config import Settings
-from ydata_profiling.model.typeset import ProfilingTypeSet
 
-from validmind.vm_models import (
-    ResultSummary,
-    ResultTable,
-    ResultTableMetadata,
-    ThresholdTest,
-    ThresholdTestResult,
-)
-
-
-@dataclass
-class TooManyZeroValues(ThresholdTest):
+@tags("tabular_data")
+@tasks("regression", "classification")
+def TooManyZeroValues(dataset: VMDataset, max_percent_threshold: float = 0.03):
     """
     Identifies numerical columns in a dataset that contain an excessive number of zero values, defined by a threshold
     percentage.
@@ -70,65 +60,26 @@ class TooManyZeroValues(ThresholdTest):
     - Cannot evaluate non-numerical or categorical columns, which might bring with them different types of concerns or
     issues.
     """
+    df = dataset.df
+
+    table = []
+
+    for col in dataset.feature_columns_numeric:
+        value_counts = df[col].value_counts()
 
-    name = "zeros"
-    required_inputs = ["dataset"]
-    default_params = {"max_percent_threshold": 0.03}
+        if 0 not in value_counts.index:
+            continue
 
-    tasks = ["regression", "classification"]
-    tags = ["tabular_data"]
+        n_zeros = value_counts[0]
+        p_zeros = n_zeros / df.shape[0]
 
-    def summary(self, results: List[ThresholdTestResult], all_passed: bool):
-        """
-        The zeros test returns results like these:
-        [{"values": {"n_zeros": 10000, "p_zeros": 1.0}, "column": "Exited", "passed": true}]
-        """
-        results_table = [
+        table.append(
             {
-                "Column": result.column,
-                "Number of Zero Values": result.values["n_zeros"],
-                "Percentage of Zero Values (%)": result.values["p_zeros"] * 100,
-                "Pass/Fail": "Pass" if result.passed else "Fail",
+                "Column": col,
+                "Number of Zero Values": n_zeros,
+                "Percentage of Zero Values (%)": p_zeros * 100,
+                "Pass/Fail": "Pass" if p_zeros < max_percent_threshold else "Fail",
             }
-            for result in results
-        ]
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=results_table,
-                    metadata=ResultTableMetadata(title="Zeros Results for Dataset"),
-                )
-            ]
         )
 
-    def run(self):
-        rows = self.inputs.dataset.df.shape[0]
-        typeset = ProfilingTypeSet(Settings())
-        dataset_types = typeset.infer_type(self.inputs.dataset.df)
-        results = []
-
-        for col in self.inputs.dataset.df.columns:
-            # Only calculate zeros for numerical columns
-            if str(dataset_types[col]) != "Numeric":
-                continue
-
-            value_counts = self.inputs.dataset.df[col].value_counts()
-
-            if 0 not in value_counts.index:
-                continue
-
-            n_zeros = value_counts[0]
-            p_zeros = n_zeros / rows
-
-            results.append(
-                ThresholdTestResult(
-                    column=col,
-                    passed=p_zeros < self.params["max_percent_threshold"],
-                    values={
-                        "n_zeros": n_zeros,
-                        "p_zeros": p_zeros,
-                    },
-                )
-            )
-
-        return self.cache_results(results, passed=all([r.passed for r in results]))
+    return table, all(row["Pass/Fail"] == "Pass" for row in table)

validmind/tests/data_validation/UniqueRows.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 UniqueRows(ThresholdTest):
+@tags("tabular_data")
+@tasks("regression", "classification")
+def UniqueRows(dataset: VMDataset, min_percent_threshold: float = 1):
     """
     Verifies the diversity of the dataset by ensuring that the count of unique rows exceeds a prescribed threshold.
 
@@ -57,53 +50,21 @@ class UniqueRows(ThresholdTest):
     - This test may not be suitable or useful for categorical variables, where the count of unique categories is
     inherently limited.
     """
-
-    name = "unique"
-    required_inputs = ["dataset"]
-    default_params = {"min_percent_threshold": 1}
-
-    tasks = ["regression", "classification"]
-    tags = ["tabular_data"]
-
-    def summary(self, results: List[ThresholdTestResult], all_passed: bool):
-        """
-        The unique rows test returns results like these:
-        [{"values": {"n_unique": 10000, "p_unique": 1.0}, "column": "Exited", "passed": true}]
-        """
-        results_table = [
-            {
-                "Column": result.column,
-                "Number of Unique Values": result.values["n_unique"],
-                "Percentage of Unique Values (%)": result.values["p_unique"] * 100,
-                "Pass/Fail": "Pass" if result.passed else "Fail",
-            }
-            for result in results
-        ]
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=results_table,
-                    metadata=ResultTableMetadata(
-                        title="Unique Rows Results for Dataset"
-                    ),
-                )
-            ]
-        )
-
-    def run(self):
-        rows = self.inputs.dataset.df.shape[0]
-
-        unique_rows = self.inputs.dataset.df.nunique()
-        results = [
-            ThresholdTestResult(
-                column=col,
-                passed=(unique_rows[col] / rows) < self.params["min_percent_threshold"],
-                values={
-                    "n_unique": unique_rows[col],
-                    "p_unique": unique_rows[col] / rows,
-                },
-            )
-            for col in unique_rows.index
-        ]
-
-        return self.cache_results(results, passed=all([r.passed for r in results]))
+    df = dataset.df
+
+    rows = df.shape[0]
+    unique_rows = df.nunique()
+
+    table = [
+        {
+            "Column": col,
+            "Number of Unique Values": unique_rows[col],
+            "Percentage of Unique Values (%)": unique_rows[col] / rows * 100,
+            "Pass/Fail": (
+                "Pass" if unique_rows[col] / rows >= min_percent_threshold else "Fail"
+            ),
+        }
+        for col in unique_rows.index
+    ]
+
+    return table, all(row["Pass/Fail"] == "Pass" for row in table)

validmind/tests/data_validation/WOEBinPlots.py

@@ -2,8 +2,6 @@
 # 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 numpy as np
 import pandas as pd
 import plotly.express as px
@@ -11,11 +9,22 @@ import plotly.graph_objects as go
 import scorecardpy as sc
 from plotly.subplots import make_subplots
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
+from validmind.logging import get_logger
+from validmind.vm_models import VMDataset
+
+logger = get_logger(__name__)
 
 
-@dataclass
-class WOEBinPlots(Metric):
+@tags("tabular_data", "visualization", "categorical_data")
+@tasks("classification")
+def WOEBinPlots(
+    dataset: VMDataset,
+    breaks_adj: list = None,
+    fig_height: int = 600,
+    fig_width: int = 500,
+):
     """
     Generates visualizations of Weight of Evidence (WoE) and Information Value (IV) for understanding predictive power
     of categorical variables in a data set.
@@ -63,107 +72,72 @@ class WOEBinPlots(Metric):
     - The method requires a sufficient number of events per bin to generate a reliable information value and weight of
     evidence.
     """
-
-    name = "woe_bin_plots"
-    required_inputs = ["dataset"]
-    default_params = {"breaks_adj": None, "fig_height": 600, "fig_width": 500}
-    tasks = ["classification"]
-    tags = ["tabular_data", "visualization", "categorical_data"]
-
-    def run(self):
-        df = self.inputs.dataset.df
-        target_column = self.inputs.dataset.target_column
-        fig_height = self.params["fig_height"]
-        fig_width = self.params["fig_width"]
-        breaks_adj = self.params["breaks_adj"]
-
-        woe_iv_df = self.binning_data(df, target_column, breaks_adj)
-        return self.plot_woe_iv_distribution(woe_iv_df, fig_height, fig_width)
-
-    def binning_data(self, df, y, breaks_adj=None):
-        """
-        This function performs automatic binning using WoE.
-        df: A pandas dataframe
-        y: The target variable in quotes, e.g. 'target'
-        """
-
-        non_numeric_cols = df.select_dtypes(exclude=["int64", "float64"]).columns
-        df[non_numeric_cols] = df[non_numeric_cols].astype(str)
-
-        try:
-            bins = sc.woebin(df, y, breaks_list=breaks_adj)
-        except Exception as e:
-            print("Error during binning: ")
-            print(e)
-        else:
-            bins_df = pd.concat(bins.values(), keys=bins.keys())
-            bins_df.reset_index(inplace=True)
-            bins_df.drop(columns=["variable"], inplace=True)
-            bins_df.rename(
-                columns={"level_0": "variable", "level_1": "bin_number"}, inplace=True
-            )
-
-            return bins_df
-
-    def plot_woe_iv_distribution(self, woe_iv_df, fig_height, fig_width):
-        variables = woe_iv_df["variable"].unique()
-
-        figures = []
-        for variable in variables:
-            variable_df = woe_iv_df[woe_iv_df["variable"] == variable]
-
-            fig = make_subplots(rows=1, cols=2)
-
-            fig.add_trace(
-                go.Bar(
-                    x=variable_df["bin"],
-                    y=variable_df["bin_iv"],
-                    marker_color=px.colors.qualitative.Plotly[
-                        : len(variable_df["bin"])
-                    ],
-                    hovertemplate="<b>%{x}</b><br>" + "IV: %{y}<extra></extra>",
-                ),
-                row=1,
-                col=1,
-            )
-            fig.update_xaxes(
-                ticktext=variable_df["bin"].tolist(),
-                tickvals=np.arange(len(variable_df["bin"])),
-                row=1,
-                col=1,
-            )
-
-            fig.add_trace(
-                go.Scatter(
-                    x=variable_df["bin"],
-                    y=variable_df["woe"],
-                    mode="lines+markers",
-                    marker=dict(symbol="circle", size=6),
-                    hovertemplate="<b>%{x}</b><br>" + "WoE: %{y}<extra></extra>",
-                ),
-                row=1,
-                col=2,
-            )
-            fig.update_xaxes(
-                ticktext=variable_df["bin"].tolist(),
-                tickvals=np.arange(len(variable_df["bin"])),
-                row=1,
-                col=2,
-            )
-
-            fig.update_layout(
-                title=f"IV and WoE for {variable}",
-                height=fig_height,
-                width=fig_width,
-                showlegend=False,
-            )
-
-            figures.append(
-                Figure(
-                    for_object=self,
-                    key=f"{self.key}:{variable}",
-                    figure=fig,
-                )
-            )
-
-        return self.cache_results(figures=figures)
+    df = dataset.df
+
+    non_numeric_cols = df.select_dtypes(exclude=["int64", "float64"]).columns
+    df[non_numeric_cols] = df[non_numeric_cols].astype(str)
+
+    try:
+        bins = sc.woebin(df, dataset.target_column, breaks_list=breaks_adj)
+    except Exception as e:
+        raise SkipTestError(f"Error performing binning: {e}") from e
+
+    woe_iv_df = (
+        pd.concat(bins.values(), keys=bins.keys())
+        .reset_index()
+        .drop(columns=["variable"])
+        .rename(columns={"level_0": "variable", "level_1": "bin_number"})
+    )
+
+    figures = []
+
+    for variable in woe_iv_df["variable"].unique():
+        variable_df = woe_iv_df[woe_iv_df["variable"] == variable]
+
+        fig = make_subplots(rows=1, cols=2)
+
+        fig.add_trace(
+            go.Bar(
+                x=variable_df["bin"],
+                y=variable_df["bin_iv"],
+                marker_color=px.colors.qualitative.Plotly[: len(variable_df["bin"])],
+                hovertemplate="<b>%{x}</b><br>" + "IV: %{y}<extra></extra>",
+            ),
+            row=1,
+            col=1,
+        )
+        fig.update_xaxes(
+            ticktext=variable_df["bin"].tolist(),
+            tickvals=np.arange(len(variable_df["bin"])),
+            row=1,
+            col=1,
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=variable_df["bin"],
+                y=variable_df["woe"],
+                mode="lines+markers",
+                marker=dict(symbol="circle", size=6),
+                hovertemplate="<b>%{x}</b><br>" + "WoE: %{y}<extra></extra>",
+            ),
+            row=1,
+            col=2,
+        )
+        fig.update_xaxes(
+            ticktext=variable_df["bin"].tolist(),
+            tickvals=np.arange(len(variable_df["bin"])),
+            row=1,
+            col=2,
+        )
+
+        fig.update_layout(
+            title=f"IV and WoE for {variable}",
+            height=fig_height,
+            width=fig_width,
+            showlegend=False,
+        )
+
+        figures.append(fig)
+
+    return tuple(figures)

validmind/tests/data_validation/WOEBinTable.py

@@ -2,16 +2,17 @@
 # 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
 import scorecardpy as sc
 
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
+from validmind.vm_models import VMDataset
 
 
-@dataclass
-class WOEBinTable(Metric):
+@tags("tabular_data", "categorical_data")
+@tasks("classification")
+def WOEBinTable(dataset: VMDataset, breaks_adj: list = None):
     """
     Assesses the Weight of Evidence (WoE) and Information Value (IV) of each feature to evaluate its predictive power
     in a binary classification model.
@@ -26,9 +27,10 @@ class WOEBinTable(Metric):
     ### Test Mechanism
 
     The test uses the `scorecardpy.woebin` method to perform automatic binning of the dataset based on WoE. The method
-    adjusts the cut-off points for binning numeric variables based on the parameter `breaks_adj`. The bins are then
-    used to calculate the WoE and IV values, effectively creating a dataframe that includes the bin boundaries, WoE,
-    and IV values for each feature. A target variable is required in the dataset to perform this analysis.
+    accepts a list of break points for binning numeric variables through the parameter `breaks_adj`. If no breaks are
+    provided, it uses default binning. The bins are then used to calculate the WoE and IV values, effectively creating
+    a dataframe that includes the bin boundaries, WoE, and IV values for each feature. A target variable is required
+    in the dataset to perform this analysis.
 
     ### Signs of High Risk
 
@@ -49,65 +51,22 @@ class WOEBinTable(Metric):
     - The metric does not help in distinguishing whether the observed predictive factor is due to data randomness or a
     true phenomenon.
     """
-
-    name = "woe_bin_table"
-    required_inputs = ["dataset"]
-    default_params = {"breaks_adj": None}
-    tasks = ["classification"]
-    tags = ["tabular_data", "categorical_data"]
-
-    def run(self):
-        target_column = self.inputs.dataset.target_column
-        breaks_adj = self.params["breaks_adj"]
-
-        df = self.inputs.dataset.df
-        print(
-            f"Running with breaks_adj: {breaks_adj}"
-        )  # print the breaks_adj being used
-        bins_df = self.binning_data(df, target_column, breaks_adj)
-
-        return self.cache_results(
-            {
-                "woe_iv": bins_df.to_dict(orient="records"),
-            }
-        )
-
-    def binning_data(self, df, y, breaks_adj=None):
-        """
-        This function performs automatic binning using WoE.
-        df: A pandas dataframe
-        y: The target variable in quotes, e.g. 'target'
-        """
-        non_numeric_cols = df.select_dtypes(exclude=["int64", "float64"]).columns
-        df[non_numeric_cols] = df[non_numeric_cols].astype(str)
-
-        try:
-            print(
-                f"Performing binning with breaks_adj: {breaks_adj}"
-            )  # print the breaks_adj being used
-            bins = sc.woebin(df, y, breaks_list=breaks_adj)
-        except Exception as e:
-            print("Error during binning: ")
-            print(e)
-        else:
-            bins_df = pd.concat(bins.values(), keys=bins.keys())
-            bins_df.reset_index(inplace=True)
-            bins_df.drop(columns=["variable"], inplace=True)
-            bins_df.rename(columns={"level_0": "variable"}, inplace=True)
-
-            bins_df["bin_number"] = bins_df.groupby("variable").cumcount()
-
-            return bins_df
-
-    def summary(self, metric_value):
-        summary_woe_iv_table = metric_value["woe_iv"]
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=summary_woe_iv_table,
-                    metadata=ResultTableMetadata(
-                        title="Weight of Evidence (WoE) and Information Value (IV)"
-                    ),
-                )
-            ]
+    df = dataset.df
+
+    non_numeric_cols = df.select_dtypes(exclude=["int64", "float64"]).columns
+    df[non_numeric_cols] = df[non_numeric_cols].astype(str)
+
+    try:
+        bins = sc.woebin(df, dataset.target_column, breaks_list=breaks_adj)
+    except Exception as e:
+        raise SkipTestError(f"Error during binning: {e}")
+
+    return {
+        "Weight of Evidence (WoE) and Information Value (IV)": (
+            pd.concat(bins.values(), keys=bins.keys())
+            .reset_index()
+            .drop(columns=["variable"])
+            .rename(columns={"level_0": "variable"})
+            .assign(bin_number=lambda x: x.groupby("variable").cumcount())
         )
+    }

validmind/tests/data_validation/ZivotAndrewsArch.py

@@ -2,20 +2,21 @@
 # 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 arch.unitroot import ZivotAndrews
 from numpy.linalg import LinAlgError
 
+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 ZivotAndrewsArch(Metric):
+@tags("time_series_data", "stationarity", "unit_root_test")
+@tasks("regression")
+def ZivotAndrewsArch(dataset: VMDataset):
     """
     Evaluates the order of integration and stationarity of time series data using the Zivot-Andrews unit root test.
 
@@ -54,75 +55,32 @@ class ZivotAndrewsArch(Metric):
     - May not account for unexpected shocks or changes in the series trend, both of which can significantly impact data
     stationarity.
     """
+    df = dataset.df
+    if not isinstance(df.index, (pd.DatetimeIndex, pd.PeriodIndex)):
+        raise SkipTestError(
+            "Dataset index must be a datetime or period index for time series analysis."
+        )
 
-    name = "zivot_andrews"
-    required_inputs = ["dataset"]
-    tasks = ["regression"]
-    tags = ["time_series_data", "stationarity", "unit_root_test"]
-
-    def run(self):
-        """
-        Calculates Zivot-Andrews metric 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 Zivot-Andrews results
-        za_values = []
-
-        for col in dataset.columns:
-            try:
-                za = ZivotAndrews(dataset[col].values)
-                za_values.append(
-                    {
-                        "Variable": col,
-                        "stat": za.stat,
-                        "pvalue": za.pvalue,
-                        "usedlag": za.lags,
-                        "nobs": za.nobs,
-                    }
-                )
-            except (LinAlgError, ValueError) as e:
-                logger.error(f"Error while processing column '{col}'. Details: {e}")
-                za_values.append(
-                    {
-                        "Variable": col,
-                        "stat": None,
-                        "pvalue": None,
-                        "usedlag": None,
-                        "nobs": None,
-                        "error": str(e),
-                    }
-                )
-
-        return self.cache_results({"zivot_andrews_results": za_values})
-
-    def summary(self, metric_value):
-        """
-        Build a table for summarizing the Zivot-Andrews results
-        """
-        za_results = metric_value["zivot_andrews_results"]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=za_results,
-                    metadata=ResultTableMetadata(title="Zivot-Andrews Test Results"),
-                )
-            ]
+    df = df.dropna()
+    df = df.apply(pd.to_numeric, errors="coerce")
+
+    za_values = []
+
+    for col in df.columns:
+        try:
+            za = ZivotAndrews(df[col].values)
+        except (LinAlgError, ValueError) as e:
+            logger.error(f"Error while processing column '{col}': {e}")
+            continue
+
+        za_values.append(
+            {
+                "Variable": col,
+                "stat": za.stat,
+                "pvalue": za.pvalue,
+                "usedlag": za.lags,
+                "nobs": za.nobs,
+            }
         )
+
+    return {"Zivot-Andrews Test Results": za_values}