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

validmind/tests/data_validation/SeasonalDecompose.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
 
-import warnings
-
 import numpy as np
 import pandas as pd
 import plotly.graph_objects as go
@@ -11,13 +9,17 @@ from plotly.subplots import make_subplots
 from scipy import stats
 from statsmodels.tsa.seasonal import seasonal_decompose
 
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
 from validmind.logging import get_logger
-from validmind.vm_models import Figure, Metric
+from validmind.vm_models import VMDataset
 
 logger = get_logger(__name__)
 
 
-class SeasonalDecompose(Metric):
+@tags("time_series_data", "seasonality", "statsmodels")
+@tasks("regression")
+def SeasonalDecompose(dataset: VMDataset, seasonal_model: str = "additive"):
     """
     Assesses patterns and seasonality in a time series dataset by decomposing its features into foundational components.
 
@@ -59,183 +61,99 @@ class SeasonalDecompose(Metric):
     - **Unreliability with Noisy Datasets**: Produces unreliable results when used with datasets that contain heavy
     noise.
     """
-
-    name = "seasonal_decompose"
-    required_inputs = ["dataset"]
-    default_params = {"seasonal_model": "additive"}
-    tasks = ["regression"]
-    tags = ["time_series_data", "seasonality", "statsmodels"]
-
-    def store_seasonal_decompose(self, column, sd_one_column):
-        """
-        Stores the seasonal decomposition results in the test context so they
-        can be re-used by other tests. Note we store one `sd` at a time for every
-        column in the dataset.
-        """
-        sd_all_columns = self.context.get_context_data("seasonal_decompose") or dict()
-        sd_all_columns[column] = sd_one_column
-        self.context.set_context_data("seasonal_decompose", sd_all_columns)
-
-    def serialize_seasonal_decompose(self, sd):
-        """
-        Serializes the seasonal decomposition results for one column into a
-        JSON serializable format that can be sent to the API.
-        """
-        results = {
-            "observed": sd.observed,
-            "trend": sd.trend,
-            "seasonal": sd.seasonal,
-            "resid": sd.resid,
-        }
-
-        # Convert pandas Series to DataFrames, reset their indices, and convert the dates to strings
-        dfs = [
-            pd.DataFrame(series)
-            .pipe(
-                lambda x: (
-                    x.reset_index()
-                    if not isinstance(x.index, pd.DatetimeIndex)
-                    else x.reset_index().rename(columns={x.index.name: "Date"})
-                )
-            )
-            .assign(
-                Date=lambda x: (
-                    x["Date"].astype(str)
-                    if "Date" in x.columns
-                    else x.index.astype(str)
-                )
-            )
-            for series in results.values()
-        ]
-
-        # Merge DataFrames on the 'Date' column
-        merged_df = dfs[0]
-        for df in dfs[1:]:
-            merged_df = merged_df.merge(df, on="Date")
-        # Convert the merged DataFrame into a list of dictionaries
-        return merged_df.to_dict("records")
-
-    def run(self):
-        # Parse input parameters
-        if "seasonal_model" not in self.params:
-            raise ValueError("seasonal_model must be provided in params")
-        seasonal_model = self.params["seasonal_model"]
-
-        df = self.inputs.dataset.df
-
-        results = {}
-        figures = []
-
-        for col in df.columns:
-            series = df[col].dropna()
-
-            # Check for non-finite values and handle them
-            if not series[np.isfinite(series)].empty:
-                inferred_freq = pd.infer_freq(series.index)
-
-                if inferred_freq is not None:
-
-                    # Only take finite values to seasonal_decompose
-                    sd = seasonal_decompose(
-                        series[np.isfinite(series)], model=seasonal_model
-                    )
-                    self.store_seasonal_decompose(col, sd)
-
-                    results[col] = self.serialize_seasonal_decompose(sd)
-
-                    # Create subplots using Plotly
-                    fig = make_subplots(
-                        rows=3,
-                        cols=2,
-                        subplot_titles=(
-                            "Observed",
-                            "Trend",
-                            "Seasonal",
-                            "Residuals",
-                            "Histogram and KDE of Residuals",
-                            "Normal Q-Q Plot of Residuals",
-                        ),
-                        vertical_spacing=0.1,
-                    )
-
-                    # Observed
-                    fig.add_trace(
-                        go.Scatter(x=sd.observed.index, y=sd.observed, name="Observed"),
-                        row=1,
-                        col=1,
-                    )
-
-                    # Trend
-                    fig.add_trace(
-                        go.Scatter(x=sd.trend.index, y=sd.trend, name="Trend"),
-                        row=1,
-                        col=2,
-                    )
-
-                    # Seasonal
-                    fig.add_trace(
-                        go.Scatter(x=sd.seasonal.index, y=sd.seasonal, name="Seasonal"),
-                        row=2,
-                        col=1,
-                    )
-
-                    # Residuals
-                    fig.add_trace(
-                        go.Scatter(x=sd.resid.index, y=sd.resid, name="Residuals"),
-                        row=2,
-                        col=2,
-                    )
-
-                    # Histogram with KDE
-                    residuals = sd.resid.dropna()
-                    fig.add_trace(
-                        go.Histogram(x=residuals, nbinsx=100, name="Residuals"),
-                        row=3,
-                        col=1,
-                    )
-
-                    # Normal Q-Q plot
-                    qq = stats.probplot(residuals, plot=None)
-                    qq_line_slope, qq_line_intercept = stats.linregress(
-                        qq[0][0], qq[0][1]
-                    )[:2]
-                    qq_line = qq_line_slope * np.array(qq[0][0]) + qq_line_intercept
-
-                    fig.add_trace(
-                        go.Scatter(
-                            x=qq[0][0], y=qq[0][1], mode="markers", name="QQ plot"
-                        ),
-                        row=3,
-                        col=2,
-                    )
-                    fig.add_trace(
-                        go.Scatter(
-                            x=qq[0][0],
-                            y=qq_line,
-                            mode="lines",
-                            name="QQ line",
-                        ),
-                        row=3,
-                        col=2,
-                    )
-
-                    fig.update_layout(
-                        height=1000,
-                        title_text=f"Seasonal Decomposition for {col}",
-                        showlegend=False,
-                    )
-
-                    figures.append(
-                        Figure(
-                            for_object=self,
-                            key=f"{self.key}:{col}",
-                            figure=fig,
-                        )
-                    )
-                else:
-                    warnings.warn(
-                        f"No frequency could be inferred for variable '{col}'. "
-                        "Skipping seasonal decomposition and plots for this variable."
-                    )
-
-        return self.cache_results(results, figures=figures)
+    df = dataset.df
+
+    figures = []
+
+    for col in df.columns:
+        series = df[col].dropna()
+
+        if series[np.isfinite(series)].empty:
+            logger.warning(f"No finite values found for {col}, skipping")
+            continue
+
+        inferred_freq = pd.infer_freq(series.index)
+        if inferred_freq is None:
+            logger.warning(f"No frequency found for {col}, skipping")
+            continue
+
+        sd = seasonal_decompose(series[np.isfinite(series)], model=seasonal_model)
+
+        # Create subplots using Plotly
+        fig = make_subplots(
+            rows=3,
+            cols=2,
+            subplot_titles=(
+                "Observed",
+                "Trend",
+                "Seasonal",
+                "Residuals",
+                "Histogram and KDE of Residuals",
+                "Normal Q-Q Plot of Residuals",
+            ),
+            vertical_spacing=0.1,
+        )
+
+        # Observed
+        fig.add_trace(
+            go.Scatter(x=sd.observed.index, y=sd.observed, name="Observed"),
+            row=1,
+            col=1,
+        )
+        # Trend
+        fig.add_trace(
+            go.Scatter(x=sd.trend.index, y=sd.trend, name="Trend"),
+            row=1,
+            col=2,
+        )
+        # Seasonal
+        fig.add_trace(
+            go.Scatter(x=sd.seasonal.index, y=sd.seasonal, name="Seasonal"),
+            row=2,
+            col=1,
+        )
+        # Residuals
+        fig.add_trace(
+            go.Scatter(x=sd.resid.index, y=sd.resid, name="Residuals"),
+            row=2,
+            col=2,
+        )
+        # Histogram with KDE
+        residuals = sd.resid.dropna()
+        fig.add_trace(
+            go.Histogram(x=residuals, nbinsx=100, name="Residuals"),
+            row=3,
+            col=1,
+        )
+        # Normal Q-Q plot
+        qq = stats.probplot(residuals, plot=None)
+        qq_line_slope, qq_line_intercept = stats.linregress(qq[0][0], qq[0][1])[:2]
+        qq_line = qq_line_slope * np.array(qq[0][0]) + qq_line_intercept
+        fig.add_trace(
+            go.Scatter(x=qq[0][0], y=qq[0][1], mode="markers", name="QQ plot"),
+            row=3,
+            col=2,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=qq[0][0],
+                y=qq_line,
+                mode="lines",
+                name="QQ line",
+            ),
+            row=3,
+            col=2,
+        )
+
+        fig.update_layout(
+            height=1000,
+            title_text=f"Seasonal Decomposition for {col}",
+            showlegend=False,
+        )
+
+        figures.append(fig)
+
+    if not figures:
+        raise SkipTestError("No valid features found for seasonal decomposition")
+
+    return tuple(figures)

validmind/tests/data_validation/Skewness.py

@@ -2,23 +2,15 @@
 # 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 ydata_profiling.config import Settings
 from ydata_profiling.model.typeset import ProfilingTypeSet
 
-from validmind.vm_models import (
-    ResultSummary,
-    ResultTable,
-    ResultTableMetadata,
-    ThresholdTest,
-    ThresholdTestResult,
-)
+from validmind import tags, tasks
 
 
-@dataclass
-class Skewness(ThresholdTest):
+@tags("data_quality", "tabular_data")
+@tasks("classification", "regression")
+def Skewness(dataset, max_threshold=1):
     """
     Evaluates the skewness of numerical data in a dataset to check against a defined threshold, aiming to ensure data
     quality and optimize model performance.
@@ -57,59 +49,30 @@ class Skewness(ThresholdTest):
     - Subjective threshold for risk grading, requiring expert input and recurrent iterations for refinement.
     """
 
-    name = "skewness"
-    required_inputs = ["dataset"]
-    default_params = {"max_threshold": 1}
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "data_quality"]
-
-    def summary(self, results: List[ThresholdTestResult], all_passed: bool):
-        """
-        The skewness test returns results like these:
-        [{"values": {"skewness": 1.0}, "column": "NumOfProducts", "passed": false}]
-        """
-        results_table = [
+    typeset = ProfilingTypeSet(Settings())
+    dataset_types = typeset.infer_type(dataset.df)
+
+    skewness = dataset.df.skew(numeric_only=True)
+
+    results_table = []
+    passed = True
+
+    for col in skewness.index:
+        if str(dataset_types[col]) != "Numeric":
+            continue
+
+        col_skewness = skewness[col]
+        col_passed = abs(col_skewness) < max_threshold
+        passed = passed and col_passed
+
+        results_table.append(
             {
-                "Column": result.column,
-                "Skewness": result.values["skewness"],
-                "Pass/Fail": "Pass" if result.passed else "Fail",
+                "Column": col,
+                "Skewness": col_skewness,
+                "Pass/Fail": "Pass" if col_passed else "Fail",
             }
-            for result in results
-        ]
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=results_table,
-                    metadata=ResultTableMetadata(title="Skewness Results for Dataset"),
-                )
-            ]
         )
 
-    def run(self):
-        typeset = ProfilingTypeSet(Settings())
-        dataset_types = typeset.infer_type(self.inputs.dataset.df)
-
-        skewness = self.inputs.dataset.df.skew(numeric_only=True)
-
-        results = []
-        passed = []
-
-        for col in skewness.index:
-            # Only calculate skewness for numerical columns
-            if str(dataset_types[col]) != "Numeric":
-                continue
-
-            col_skewness = skewness[col]
-            col_pass = abs(col_skewness) < self.params["max_threshold"]
-            passed.append(col_pass)
-            results.append(
-                ThresholdTestResult(
-                    column=col,
-                    passed=col_pass,
-                    values={
-                        "skewness": col_skewness,
-                    },
-                )
-            )
-
-        return self.cache_results(results, passed=all(passed))
+    return {
+        "Skewness Results for Dataset": results_table,
+    }, passed

validmind/tests/data_validation/SpreadPlot.py

@@ -3,12 +3,17 @@
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
 import matplotlib.pyplot as plt
+import pandas as pd
 import seaborn as sns
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
+from validmind.vm_models import VMDataset
 
 
-class SpreadPlot(Metric):
+@tags("time_series_data", "visualization")
+@tasks("regression")
+def SpreadPlot(dataset: VMDataset):
     """
     Assesses potential correlations between pairs of time series variables through visualization to enhance
     understanding of their relationships.
@@ -51,66 +56,38 @@ class SpreadPlot(Metric):
     plots.
     - Might not completely capture intricate non-linear relationships between the variables.
     """
+    # Validate that the index is datetime
+    if not isinstance(dataset.df.index, pd.DatetimeIndex):
+        raise SkipTestError("Index must be a datetime type for time series analysis")
 
-    name = "spread_plot"
-    required_inputs = ["dataset"]
-    tasks = ["regression"]
-    tags = ["time_series_data", "visualization"]
+    df = dataset.df.dropna()
 
-    @staticmethod
-    def plot_spread(series1, series2, ax=None):
-        """
-        Plot the spread between two time series variables.
-        :param series1: Pandas Series with time-series data for the first variable
-        :param series2: Pandas Series with time-series data for the second variable
-        :param ax: Axis object for the spread plot
-        """
-        spread = series1 - series2
+    # Get all unique pairs of feature columns
+    feature_pairs = [
+        (dataset.feature_columns[i], dataset.feature_columns[j])
+        for i in range(len(dataset.feature_columns))
+        for j in range(i + 1, len(dataset.feature_columns))
+    ]
 
-        if ax is None:
-            _, ax = plt.subplots()
+    figures = []
 
-        sns.lineplot(data=spread, ax=ax)
+    for var1, var2 in feature_pairs:
+        fig, ax = plt.subplots()
+        fig.suptitle(
+            f"Spread between {var1} and {var2}",
+            fontsize=20,
+            weight="bold",
+            y=0.95,
+        )
 
-        return ax
+        sns.lineplot(
+            data=df[var1] - df[var2],
+            ax=ax,
+        )
 
-    def run(self):
-        df = self.inputs.dataset.df.dropna()
+        ax.set_xlabel("")
+        ax.tick_params(axis="both", labelsize=18)
 
-        figures = []
-        columns = df.columns
-        num_vars = len(columns)
+        figures.append(fig)
 
-        for i in range(num_vars):
-            for j in range(i + 1, num_vars):
-                var1 = columns[i]
-                var2 = columns[j]
-
-                series1 = df[var1]
-                series2 = df[var2]
-
-                fig, ax = plt.subplots()
-                fig.suptitle(
-                    f"Spread between {var1} and {var2}",
-                    fontsize=20,
-                    weight="bold",
-                    y=0.95,
-                )
-
-                self.plot_spread(series1, series2, ax=ax)
-
-                ax.set_xlabel("")
-                ax.tick_params(axis="both", labelsize=18)
-
-                # Do this if you want to prevent the figure from being displayed
-                plt.close("all")
-
-                figures.append(
-                    Figure(
-                        for_object=self,
-                        key=f"{self.key}:{var1}_{var2}",
-                        figure=fig,
-                    )
-                )
-
-        return self.cache_results(figures=figures)
+    return tuple(figures)

validmind/tests/data_validation/TabularCategoricalBarPlots.py

@@ -2,13 +2,16 @@
 # 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
 import plotly.graph_objs as go
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
+from validmind.vm_models import VMDataset
 
 
-class TabularCategoricalBarPlots(Metric):
+@tags("tabular_data", "visualization")
+@tasks("classification", "regression")
+def TabularCategoricalBarPlots(dataset: VMDataset):
     """
     Generates and visualizes bar plots for each category in categorical features to evaluate the dataset's composition.
 
@@ -46,67 +49,45 @@ class TabularCategoricalBarPlots(Metric):
     - Offers no insights into the model's performance or precision, but rather provides a descriptive analysis of the
     input.
     """
-
-    name = "tabular_categorical_bar_plots"
-    required_inputs = ["dataset"]
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "visualization"]
-
-    def run(self):
-        df = self.inputs.dataset.df
-
-        # Extract categorical columns from the dataset
-        categorical_columns = df.select_dtypes(
-            include=[object, pd.Categorical]
-        ).columns.tolist()
-
-        if len(categorical_columns) == 0:
-            raise ValueError("No categorical columns found in the dataset")
-
-        # Define a color sequence for the categories
-        color_sequence = [
-            "#636EFA",
-            "#EF553B",
-            "#00CC96",
-            "#AB63FA",
-            "#FFA15A",
-            "#19D3F3",
-            "#FF6692",
-            "#B6E880",
-            "#FF97FF",
-            "#FECB52",
-        ]
-
-        figures = []
-        for col in categorical_columns:
-            counts = df[col].value_counts()
-
-            fig = go.Figure()
-            fig.add_trace(
-                go.Bar(
-                    x=counts.index,
-                    y=counts.values,
-                    name=col,
-                    marker_color=color_sequence[: len(counts)],
-                )
-            )  # add colored bar plot trace
-            fig.update_layout(
-                title_text=f"{col}",  # title of plot
-                xaxis_title_text="",  # xaxis label
-                yaxis_title_text="",  # yaxis label
-                autosize=False,
-                width=500,
-                height=500,
-                margin=dict(l=50, r=50, b=100, t=100, pad=4),
-            )
-            figures.append(
-                Figure(
-                    for_object=self,
-                    key=f"{self.key}:{col}",
-                    figure=fig,
-                )
+    if not dataset.feature_columns_categorical:
+        raise SkipTestError("No categorical columns found in the dataset")
+
+    color_sequence = [
+        "#636EFA",
+        "#EF553B",
+        "#00CC96",
+        "#AB63FA",
+        "#FFA15A",
+        "#19D3F3",
+        "#FF6692",
+        "#B6E880",
+        "#FF97FF",
+        "#FECB52",
+    ]
+
+    figures = []
+
+    for col in dataset.feature_columns_categorical:
+        counts = dataset.df[col].value_counts()
+
+        fig = go.Figure()
+        fig.add_trace(
+            go.Bar(
+                x=counts.index,
+                y=counts.values,
+                name=col,
+                marker_color=color_sequence[: len(counts)],
             )
-
-        return self.cache_results(
-            figures=figures,
         )
+        fig.update_layout(
+            title_text=f"{col}",
+            xaxis_title_text="",
+            yaxis_title_text="",
+            autosize=False,
+            width=500,
+            height=500,
+            margin=dict(l=50, r=50, b=100, t=100, pad=4),
+        )
+        figures.append(fig)
+
+    return tuple(figures)