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

validmind/tests/data_validation/MissingValuesBarPlot.py

@@ -2,15 +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 plotly.graph_objects as go
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset
 
 
-@dataclass
-class MissingValuesBarPlot(Metric):
+@tags("tabular_data", "data_quality", "visualization")
+@tasks("classification", "regression")
+def MissingValuesBarPlot(
+    dataset: VMDataset, threshold: int = 80, fig_height: int = 600
+):
     """
     Assesses the percentage and distribution of missing values in the dataset via a bar plot, with emphasis on
     identifying high-risk columns based on a user-defined threshold.
@@ -55,90 +57,62 @@ class MissingValuesBarPlot(Metric):
     - The metric does not consider possible impacts of the missing data on the model's accuracy or precision.
     - Interpretation of the findings and the next steps might require an expert understanding of the field.
     """
-
-    name = "missing_values_bar_plot"
-    required_inputs = ["dataset"]
-    default_params = {"threshold": 80, "fig_height": 600}
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "data_quality", "visualization"]
-
-    def run(self):
-        threshold = self.params["threshold"]
-        fig_height = self.params["fig_height"]
-
-        figure = self.visualize_missing_values(threshold, fig_height)
-
-        return self.cache_results(figures=figure)
-
-    def visualize_missing_values(self, threshold, fig_height):
-        # Calculate the percentage of missing values in each column
-        missing_percentages = (
-            self.inputs.dataset.df.isnull().sum() / len(self.inputs.dataset.df)
-        ) * 100
-
-        # Only keep entries where missing_percentage > 0
-        missing_percentages = missing_percentages[missing_percentages > 0]
-
-        # Sort missing value percentages in ascending order
-        missing_percentages_sorted = missing_percentages.sort_values(ascending=True)
-
-        # Create lists to store the x and y values for each bar
-        y_below_threshold = []
-        x_below_threshold = []
-        y_above_threshold = []
-        x_above_threshold = []
-
-        # Iterate through the missing percentages and separate values based on the threshold
-        for index, value in missing_percentages_sorted.items():
-            if value < threshold:
-                y_below_threshold.append(index)
-                x_below_threshold.append(value)
-            else:
-                y_above_threshold.append(index)
-                x_above_threshold.append(value)
-
-        # Create bar traces for values below and above threshold
-        trace_below_threshold = go.Bar(
-            y=y_below_threshold,
-            x=x_below_threshold,
-            marker_color="grey",
-            name="Below Threshold",
-            orientation="h",
-            hovertemplate="Column: %{y}<br>Missing Value Percentage: %{x:.2f}%",
-        )
-
-        trace_above_threshold = go.Bar(
-            y=y_above_threshold,
-            x=x_above_threshold,
-            marker_color="lightcoral",
-            name="Above Threshold",
-            orientation="h",
-            hovertemplate="Column: %{y}<br>Missing Value Percentage: %{x:.2f}%",
-        )
-
-        # Draw a red line at the specified threshold
-        threshold_line = go.Scatter(
-            y=missing_percentages_sorted.index,
-            x=[threshold] * len(missing_percentages_sorted.index),
-            mode="lines",
-            name="Threshold: {}%".format(threshold),
-            line=dict(color="red", dash="dash"),
-        )
-
-        # Create a layout
-        layout = go.Layout(
+    # Calculate the percentage of missing values in each column
+    missing_percentages = (dataset.df.isnull().sum() / len(dataset.df)) * 100
+    # Only keep entries where missing_percentage > 0
+    missing_percentages = missing_percentages[missing_percentages > 0]
+    # Sort missing value percentages in ascending order
+    missing_percentages_sorted = missing_percentages.sort_values(ascending=True)
+
+    # Create lists to store the x and y values for each bar
+    y_below_threshold = []
+    x_below_threshold = []
+    y_above_threshold = []
+    x_above_threshold = []
+
+    # Iterate through the missing percentages and separate values based on the threshold
+    for index, value in missing_percentages_sorted.items():
+        if value < threshold:
+            y_below_threshold.append(index)
+            x_below_threshold.append(value)
+        else:
+            y_above_threshold.append(index)
+            x_above_threshold.append(value)
+
+    # Create bar traces for values below and above threshold
+    trace_below_threshold = go.Bar(
+        y=y_below_threshold,
+        x=x_below_threshold,
+        marker_color="grey",
+        name="Below Threshold",
+        orientation="h",
+        hovertemplate="Column: %{y}<br>Missing Value Percentage: %{x:.2f}%",
+    )
+    trace_above_threshold = go.Bar(
+        y=y_above_threshold,
+        x=x_above_threshold,
+        marker_color="lightcoral",
+        name="Above Threshold",
+        orientation="h",
+        hovertemplate="Column: %{y}<br>Missing Value Percentage: %{x:.2f}%",
+    )
+
+    # Draw a red line at the specified threshold
+    threshold_line = go.Scatter(
+        y=missing_percentages_sorted.index,
+        x=[threshold] * len(missing_percentages_sorted.index),
+        mode="lines",
+        name="Threshold: {}%".format(threshold),
+        line=dict(color="red", dash="dash"),
+    )
+
+    return go.Figure(
+        data=[trace_below_threshold, trace_above_threshold, threshold_line],
+        layout=go.Layout(
             title="Missing Values",
             yaxis=dict(title="Columns"),
             xaxis=dict(title="Missing Value Percentage (%)", range=[0, 100]),
             barmode="stack",
             height=fig_height,
-        )
-
-        # Create a Figure object
-        fig = go.Figure(
-            data=[trace_below_threshold, trace_above_threshold, threshold_line],
-            layout=layout,
-        )
-
-        figure = Figure(for_object=self, key=self.key, figure=fig)
-        return [figure]
+        ),
+    )

validmind/tests/data_validation/PhillipsPerronArch.py

@@ -2,20 +2,22 @@
 # 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
 from arch.unitroot import PhillipsPerron
 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 PhillipsPerronArch(Metric):
+@tags("time_series_data", "forecasting", "statistical_test", "unit_root_test")
+@tasks("regression")
+def PhillipsPerronArch(dataset: VMDataset):
     """
     Assesses the stationarity of time series data in each feature of the ML model using the Phillips-Perron test.
 
@@ -55,80 +57,55 @@ class PhillipsPerronArch(Metric):
     - Non-stationary time series must be converted to stationary series through differencing, potentially leading to
     loss of important data points.
     """
+    df = dataset.df.dropna()
 
-    name = "phillips_perron"
-    required_inputs = ["dataset"]
-    tasks = ["regression"]
-    tags = [
-        "time_series_data",
-        "forecasting",
-        "statistical_test",
-        "unit_root_test",
-    ]
-
-    def run(self):
-        """
-        Calculates PP 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 Phillips-Perron results
-        pp_values = []
-
-        for col in dataset.columns:
-            try:
-                pp = PhillipsPerron(dataset[col].values)
-                pp_values.append(
-                    {
-                        "Variable": col,
-                        "stat": pp.stat,
-                        "pvalue": pp.pvalue,
-                        "usedlag": pp.lags,
-                        "nobs": pp.nobs,
-                    }
-                )
-            except LinAlgError as e:
-                logger.error(f"Error processing column '{col}': {e}")
-                pp_values.append(
-                    {
-                        "Variable": col,
-                        "stat": None,
-                        "pvalue": None,
-                        "usedlag": None,
-                        "nobs": None,
-                        "error": str(e),
-                    }
-                )
-
-        return self.cache_results({"phillips_perron_results": pp_values})
-
-    def summary(self, metric_value):
-        """
-        Build a table for summarizing the Phillips-Perron results
-        """
-        pp_results = metric_value["phillips_perron_results"]
+    if not isinstance(df.index, (pd.DatetimeIndex, pd.PeriodIndex)):
+        raise ValueError(
+            "Dataset index must be a datetime or period index for time series analysis."
+        )
 
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=pp_results,
-                    metadata=ResultTableMetadata(title="Phillips-Perron Test Results"),
+    # Filter numeric columns first
+    numeric_columns = df.select_dtypes(include=np.number).columns
+    if not any(col in numeric_columns for col in dataset.feature_columns):
+        raise SkipTestError("No numeric columns found for Phillips-Perron test.")
+
+    pp_table = []
+
+    for col in dataset.feature_columns:
+        # Skip non-numeric columns
+        if col not in numeric_columns:
+            logger.warning(f"Skipping non-numeric column: {col}")
+            continue
+
+        try:
+            # Drop any NaN values for this column
+            series = df[col].dropna()
+            if len(series) == 0:
+                logger.warning(
+                    f"Skipping column '{col}': No valid data after dropping NaN values"
                 )
-            ]
-        )
+                continue
+
+            pp = PhillipsPerron(series.values)
+            pp_table.append(
+                {
+                    "Variable": col,
+                    "stat": pp.stat,
+                    "pvalue": pp.pvalue,
+                    "usedlag": pp.lags,
+                    "nobs": pp.nobs,
+                }
+            )
+        except LinAlgError as e:
+            logger.error(f"Error processing column '{col}': {e}")
+            continue
+        except Exception as e:
+            logger.error(f"Unexpected error processing column '{col}': {e}")
+            continue
+
+    if not pp_table:
+        raise SkipTestError("No valid columns found for Phillips-Perron test.")
+
+    return {
+        "Phillips-Perron Test Results": pp_table,
+    }

validmind/tests/data_validation/RollingStatsPlot.py

@@ -5,10 +5,44 @@
 import matplotlib.pyplot as plt
 import pandas as pd
 
-from validmind.vm_models import Figure, Metric
-
-
-class RollingStatsPlot(Metric):
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
+from validmind.vm_models import VMDataset
+
+
+def plot_rolling_statistics(df, col, window_size):
+    rolling_mean = df[col].rolling(window=window_size).mean()
+    rolling_std = df[col].rolling(window=window_size).std()
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
+
+    ax1.plot(rolling_mean)
+    ax1.set_title(
+        f"Rolling Mean for {col}",
+        fontsize=20,
+        weight="bold",
+    )
+    ax1.set_ylabel("")
+    ax1.tick_params(axis="both", labelsize=18)
+    ax1.legend()
+
+    ax2.plot(rolling_std, label="Rolling Standard Deviation", color="orange")
+    ax2.set_title(
+        f"Rolling STD for {col}",
+        fontsize=20,
+        weight="bold",
+    )
+    ax2.set_xlabel("")
+    ax2.set_ylabel("")
+    ax2.tick_params(axis="both", labelsize=18)
+    ax2.legend()
+
+    return fig
+
+
+@tags("time_series_data", "visualization", "stationarity")
+@tasks("regression")
+def RollingStatsPlot(dataset: VMDataset, window_size: int = 12):
     """
     Evaluates the stationarity of time series data by plotting its rolling mean and standard deviation over a specified
     window.
@@ -58,81 +92,16 @@ class RollingStatsPlot(Metric):
     such as through statistical tests. Therefore, the interpretation is subjective and depends heavily on modeler
     discretion.
     """
-
-    name = "rolling_stats_plot"
-    required_inputs = ["dataset"]
-    default_params = {"window_size": 12}
-    tasks = ["regression"]
-    tags = ["time_series_data", "visualization", "stationarity"]
-
-    def plot_rolling_statistics(self, col, window_size=12):
-        """
-        Plot rolling mean and rolling standard deviation in different subplots for a given series.
-        :param series: Pandas Series with time-series data
-        :param window_size: Window size for the rolling calculations
-        :param ax1: Axis object for the rolling mean plot
-        :param ax2: Axis object for the rolling standard deviation plot
-        """
-        rolling_mean = (
-            self.inputs.dataset.df[col].rolling(window=int(window_size)).mean()
-        )
-        rolling_std = self.inputs.dataset.df[col].rolling(window=int(window_size)).std()
-
-        # Create a new figure and axis objects
-        fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
-
-        ax1.plot(rolling_mean)
-
-        ax1.set_title(
-            f"Rolling Mean for {col}",
-            fontsize=20,
-            weight="bold",
-        )
-        ax1.set_ylabel("")
-        ax1.tick_params(axis="both", labelsize=18)
-        ax1.legend()
-
-        ax2.plot(rolling_std, label="Rolling Standard Deviation", color="orange")
-        ax2.set_title(
-            f"Rolling STD for {col}",
-            fontsize=20,
-            weight="bold",
-        )
-        ax2.set_xlabel("")
-        ax2.set_ylabel("")
-        ax2.tick_params(axis="both", labelsize=18)
-        ax2.legend()
-
-        return fig
-
-    def run(self):
-        if "window_size" not in self.params:
-            raise ValueError("Window size must be provided in params")
-
-        # Check if index is datetime
-        if not pd.api.types.is_datetime64_any_dtype(self.inputs.dataset.df.index):
-            raise ValueError("Index must be a datetime type")
-
-        window_size = self.params["window_size"]
-        df = self.inputs.dataset.df.dropna()
-
-        if not set(df.columns).issubset(set(df.columns)):
-            raise ValueError("Provided 'columns' must exist in the dataset")
-
-        figures = []
-
-        for col in df.columns:
-            fig = self.plot_rolling_statistics(col, window_size=window_size)
-
-            figures.append(
-                Figure(
-                    for_object=self,
-                    key=f"{self.key}:{col}",
-                    figure=fig,
-                )
+    if not pd.api.types.is_datetime64_any_dtype(dataset.df.index):
+        raise SkipTestError("Index must be a datetime type")
+
+    return tuple(
+        [
+            plot_rolling_statistics(
+                df=dataset.df.dropna(),
+                col=col,
+                window_size=window_size,
             )
-
-            # Do this if you want to prevent the figure from being displayed
-            plt.close("all")
-
-        return self.cache_results(figures=figures)
+            for col in dataset.feature_columns
+        ]
+    )