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

validmind/tests/data_validation/AutoAR.py

@@ -6,13 +6,16 @@ import pandas as pd
 from statsmodels.tsa.ar_model import AutoReg
 from statsmodels.tsa.stattools import adfuller
 
+from validmind import tags, tasks
 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__)
 
 
-class AutoAR(Metric):
+@tags("time_series_data", "statsmodels", "forecasting", "statistical_test")
+@tasks("regression")
+def AutoAR(dataset: VMDataset, max_ar_order: int = 3):
     """
     Automatically identifies the optimal Autoregressive (AR) order for a time series using BIC and AIC criteria.
 
@@ -56,98 +59,58 @@ class AutoAR(Metric):
     - AIC and BIC may not always agree on the selection of the best model. This potentially requires the user to juggle
     interpretational choices.
     """
-
-    type = "dataset"
-    name = "auto_ar"
-    required_inputs = ["dataset"]
-    default_params = {"max_ar_order": 3}
-    tasks = ["regression"]
-    tags = ["time_series_data", "statsmodels", "forecasting", "statistical_test"]
-
-    def run(self):
-        if "max_ar_order" not in self.params:
-            raise ValueError("max_ar_order must be provided in params")
-
-        max_ar_order = int(self.params["max_ar_order"])
-
-        df = self.inputs.dataset.df
-
-        # Create empty DataFrames to store the results
-        summary_ar_analysis = pd.DataFrame()
-        best_ar_order = pd.DataFrame()
-
-        for col in df.columns:
-            series = df[col].dropna()
-
-            # Check for stationarity using the Augmented Dickey-Fuller test
-            adf_test = adfuller(series)
-            if adf_test[1] > 0.05:
-                logger.warning(
-                    f"Warning: {col} is not stationary. Results may be inaccurate."
+    df = dataset.df
+
+    summary_ar_analysis = pd.DataFrame()
+    best_ar_order = pd.DataFrame()
+
+    for col in df.columns:
+        series = df[col].dropna()
+
+        # Check for stationarity using the Augmented Dickey-Fuller test
+        adf_test = adfuller(series)
+        if adf_test[1] > 0.05:
+            logger.warning(
+                f"Warning: {col} is not stationary. Results may be inaccurate."
+            )
+
+        for ar_order in range(0, max_ar_order + 1):
+            try:
+                model = AutoReg(series, lags=ar_order, old_names=False)
+                model_fit = model.fit()
+
+                # Append the result of each AR order directly into the DataFrame
+                summary_ar_analysis = pd.concat(
+                    [
+                        summary_ar_analysis,
+                        pd.DataFrame(
+                            [
+                                {
+                                    "Variable": col,
+                                    "AR Order": ar_order,
+                                    "BIC": model_fit.bic,
+                                    "AIC": model_fit.aic,
+                                }
+                            ]
+                        ),
+                    ],
+                    ignore_index=True,
                 )
-
-            for ar_order in range(0, max_ar_order + 1):
-                try:
-                    model = AutoReg(series, lags=ar_order, old_names=False)
-                    model_fit = model.fit()
-
-                    # Append the result of each AR order directly into the DataFrame
-                    summary_ar_analysis = pd.concat(
-                        [
-                            summary_ar_analysis,
-                            pd.DataFrame(
-                                [
-                                    {
-                                        "Variable": col,
-                                        "AR Order": ar_order,
-                                        "BIC": model_fit.bic,
-                                        "AIC": model_fit.aic,
-                                    }
-                                ]
-                            ),
-                        ],
-                        ignore_index=True,
-                    )
-                except Exception as e:
-                    logger.error(f"Error fitting AR({ar_order}) model for {col}: {e}")
-
-            # Find the best AR Order for this variable based on the minimum BIC
-            variable_summary = summary_ar_analysis[
-                summary_ar_analysis["Variable"] == col
-            ]
-            best_bic_row = variable_summary[
-                variable_summary["BIC"] == variable_summary["BIC"].min()
-            ]
-            best_ar_order = pd.concat([best_ar_order, best_bic_row])
-
-        # Convert the 'AR Order' column to integer
-        summary_ar_analysis["AR Order"] = summary_ar_analysis["AR Order"].astype(int)
-        best_ar_order["AR Order"] = best_ar_order["AR Order"].astype(int)
-
-        return self.cache_results(
-            {
-                "auto_ar_analysis": summary_ar_analysis.to_dict(orient="records"),
-                "best_ar_order": best_ar_order.to_dict(orient="records"),
-            }
-        )
-
-    def summary(self, metric_value):
-        """
-        Build one table for summarizing the auto AR results
-        and another for the best AR Order results
-        """
-        summary_ar_analysis = metric_value["auto_ar_analysis"]
-        best_ar_order = metric_value["best_ar_order"]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=summary_ar_analysis,
-                    metadata=ResultTableMetadata(title="Auto AR Analysis Results"),
-                ),
-                ResultTable(
-                    data=best_ar_order,
-                    metadata=ResultTableMetadata(title="Best AR Order Results"),
-                ),
-            ]
-        )
+            except Exception as e:
+                logger.error(f"Error fitting AR({ar_order}) model for {col}: {e}")
+
+        # Find the best AR Order for this variable based on the minimum BIC
+        variable_summary = summary_ar_analysis[summary_ar_analysis["Variable"] == col]
+        best_bic_row = variable_summary[
+            variable_summary["BIC"] == variable_summary["BIC"].min()
+        ]
+        best_ar_order = pd.concat([best_ar_order, best_bic_row])
+
+    # Convert the 'AR Order' column to integer
+    summary_ar_analysis["AR Order"] = summary_ar_analysis["AR Order"].astype(int)
+    best_ar_order["AR Order"] = best_ar_order["AR Order"].astype(int)
+
+    return {
+        "Auto AR Analysis Results": summary_ar_analysis,
+        "Best AR Order Results": best_ar_order,
+    }

validmind/tests/data_validation/AutoMA.py

@@ -6,13 +6,16 @@ import pandas as pd
 from statsmodels.tsa.arima.model import ARIMA
 from statsmodels.tsa.stattools import adfuller
 
+from validmind import tags, tasks
 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__)
 
 
-class AutoMA(Metric):
+@tags("time_series_data", "statsmodels", "forecasting", "statistical_test")
+@tasks("regression")
+def AutoMA(dataset: VMDataset, max_ma_order: int = 3):
     """
     Automatically selects the optimal Moving Average (MA) order for each variable in a time series dataset based on
     minimal BIC and AIC values.
@@ -59,98 +62,58 @@ class AutoMA(Metric):
     - The computation time increases with the rise in `max_ma_order`, hence, the metric may become computationally
     costly for larger values.
     """
-
-    type = "dataset"
-    name = "auto_ma"
-    required_inputs = ["dataset"]
-    default_params = {"max_ma_order": 3}
-    tasks = ["regression"]
-    tags = ["time_series_data", "statsmodels", "forecasting", "statistical_test"]
-
-    def run(self):
-        if "max_ma_order" not in self.params:
-            raise ValueError("max_ma_order must be provided in params")
-
-        max_ma_order = int(self.params["max_ma_order"])
-
-        df = self.inputs.dataset.df
-
-        # Create empty DataFrames to store the results
-        summary_ma_analysis = pd.DataFrame()
-        best_ma_order = pd.DataFrame()
-
-        for col in df.columns:
-            series = df[col].dropna()
-
-            # Check for stationarity using the Augmented Dickey-Fuller test
-            adf_test = adfuller(series)
-            if adf_test[1] > 0.05:
-                logger.warning(
-                    f"Warning: {col} is not stationary. Results may be inaccurate."
+    df = dataset.df
+
+    summary_ma_analysis = pd.DataFrame()
+    best_ma_order = pd.DataFrame()
+
+    for col in df.columns:
+        series = df[col].dropna()
+
+        # Check for stationarity using the Augmented Dickey-Fuller test
+        adf_test = adfuller(series)
+        if adf_test[1] > 0.05:
+            logger.warning(
+                f"Warning: {col} is not stationary. Results may be inaccurate."
+            )
+
+        for ma_order in range(0, max_ma_order + 1):
+            try:
+                model = ARIMA(series, order=(0, 0, ma_order))
+                model_fit = model.fit()
+
+                # Append the result of each MA order directly into the DataFrame
+                summary_ma_analysis = pd.concat(
+                    [
+                        summary_ma_analysis,
+                        pd.DataFrame(
+                            [
+                                {
+                                    "Variable": col,
+                                    "MA Order": ma_order,
+                                    "BIC": model_fit.bic,
+                                    "AIC": model_fit.aic,
+                                }
+                            ]
+                        ),
+                    ],
+                    ignore_index=True,
                 )
-
-            for ma_order in range(0, max_ma_order + 1):
-                try:
-                    model = ARIMA(series, order=(0, 0, ma_order))
-                    model_fit = model.fit()
-
-                    # Append the result of each MA order directly into the DataFrame
-                    summary_ma_analysis = pd.concat(
-                        [
-                            summary_ma_analysis,
-                            pd.DataFrame(
-                                [
-                                    {
-                                        "Variable": col,
-                                        "MA Order": ma_order,
-                                        "BIC": model_fit.bic,
-                                        "AIC": model_fit.aic,
-                                    }
-                                ]
-                            ),
-                        ],
-                        ignore_index=True,
-                    )
-                except Exception as e:
-                    logger.error(f"Error fitting MA({ma_order}) model for {col}: {e}")
-
-            # Find the best MA Order for this variable based on the minimum BIC
-            variable_summary = summary_ma_analysis[
-                summary_ma_analysis["Variable"] == col
-            ]
-            best_bic_row = variable_summary[
-                variable_summary["BIC"] == variable_summary["BIC"].min()
-            ]
-            best_ma_order = pd.concat([best_ma_order, best_bic_row])
-
-        # Convert the 'MA Order' column to integer
-        summary_ma_analysis["MA Order"] = summary_ma_analysis["MA Order"].astype(int)
-        best_ma_order["MA Order"] = best_ma_order["MA Order"].astype(int)
-
-        return self.cache_results(
-            {
-                "auto_ma_analysis": summary_ma_analysis.to_dict(orient="records"),
-                "best_ma_order": best_ma_order.to_dict(orient="records"),
-            }
-        )
-
-    def summary(self, metric_value):
-        """
-        Build one table for summarizing the auto MA results
-        and another for the best MA Order results
-        """
-        summary_ma_analysis = metric_value["auto_ma_analysis"]
-        best_ma_order = metric_value["best_ma_order"]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=summary_ma_analysis,
-                    metadata=ResultTableMetadata(title="Auto MA Analysis Results"),
-                ),
-                ResultTable(
-                    data=best_ma_order,
-                    metadata=ResultTableMetadata(title="Best MA Order Results"),
-                ),
-            ]
-        )
+            except Exception as e:
+                logger.error(f"Error fitting MA({ma_order}) model for {col}: {e}")
+
+        # Find the best MA Order for this variable based on the minimum BIC
+        variable_summary = summary_ma_analysis[summary_ma_analysis["Variable"] == col]
+        best_bic_row = variable_summary[
+            variable_summary["BIC"] == variable_summary["BIC"].min()
+        ]
+        best_ma_order = pd.concat([best_ma_order, best_bic_row])
+
+    # Convert the 'MA Order' column to integer
+    summary_ma_analysis["MA Order"] = summary_ma_analysis["MA Order"].astype(int)
+    best_ma_order["MA Order"] = best_ma_order["MA Order"].astype(int)
+
+    return {
+        "Auto MA Analysis Results": summary_ma_analysis,
+        "Best MA Order Results": best_ma_order,
+    }

validmind/tests/data_validation/AutoStationarity.py

@@ -6,10 +6,13 @@ import numpy as np
 import pandas as pd
 from statsmodels.tsa.stattools import adfuller
 
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset
 
 
-class AutoStationarity(Metric):
+@tags("time_series_data", "statsmodels", "forecasting", "statistical_test")
+@tasks("regression")
+def AutoStationarity(dataset: VMDataset, max_order: int = 5, threshold: float = 0.05):
     """
     Automates Augmented Dickey-Fuller test to assess stationarity across multiple time series in a DataFrame.
 
@@ -54,65 +57,62 @@ class AutoStationarity(Metric):
     - There's also a risk of over-differencing if the maximum order is set too high, which could induce unnecessary
     cycles.
     """
+    df = dataset.df.dropna()
 
-    type = "dataset"
-    name = "auto_stationarity"
-    required_inputs = ["dataset"]
-    default_params = {"max_order": 5, "threshold": 0.05}
-    tasks = ["regression"]
-    tags = [
-        "time_series_data",
-        "statsmodels",
-        "forecasting",
-        "statistical_test",
-        "stationarity",
-    ]
-
-    def run(self):
-        if "max_order" not in self.params:
-            raise ValueError("max_order must be provided in params")
-        max_order = self.params["max_order"]
-
-        if "threshold" not in self.params:
-            raise ValueError("threshold must be provided in params")
-        threshold = self.params["threshold"]
-
-        df = self.inputs.dataset.df.dropna()
-
-        # Create an empty DataFrame to store the results
-        summary_stationarity = pd.DataFrame()
-        best_integration_order = pd.DataFrame()  # New DataFrame
-
-        # Loop over each column in the input DataFrame and perform stationarity tests
-        for col in df.columns:
-            is_stationary = False
-            order = 0
-
-            while not is_stationary and order <= max_order:
-                series = df[col]
-
-                if order == 0:
-                    adf_result = adfuller(series)
-                else:
-                    adf_result = adfuller(np.diff(series, n=order - 1))
-
-                adf_pvalue = adf_result[1]
-                adf_pass_fail = adf_pvalue < threshold
-                adf_decision = "Stationary" if adf_pass_fail else "Non-stationary"
-
-                # Append the result of each test directly into the DataFrame
-                summary_stationarity = pd.concat(
+    summary_stationarity = pd.DataFrame()
+    best_integration_order = pd.DataFrame()
+
+    # Loop over each column in the input DataFrame and perform stationarity tests
+    for col in df.columns:
+        is_stationary = False
+        order = 0
+
+        while not is_stationary and order <= max_order:
+            series = df[col]
+
+            if order == 0:
+                adf_result = adfuller(series)
+            else:
+                adf_result = adfuller(np.diff(series, n=order))
+
+            adf_pvalue = adf_result[1]
+            adf_pass_fail = adf_pvalue < threshold
+            adf_decision = "Stationary" if adf_pass_fail else "Non-stationary"
+
+            # Append the result of each test directly into the DataFrame
+            summary_stationarity = pd.concat(
+                [
+                    summary_stationarity,
+                    pd.DataFrame(
+                        [
+                            {
+                                "Variable": col,
+                                "Integration Order": order,
+                                "Test": "ADF",
+                                "p-value": adf_pvalue,
+                                "Threshold": threshold,
+                                "Pass/Fail": "Pass" if adf_pass_fail else "Fail",
+                                "Decision": adf_decision,
+                            }
+                        ]
+                    ),
+                ],
+                ignore_index=True,
+            )
+
+            if adf_pass_fail:
+                is_stationary = True
+                best_integration_order = pd.concat(
                     [
-                        summary_stationarity,
+                        best_integration_order,
                         pd.DataFrame(
                             [
                                 {
                                     "Variable": col,
-                                    "Integration Order": order,
+                                    "Best Integration Order": order,
                                     "Test": "ADF",
                                     "p-value": adf_pvalue,
                                     "Threshold": threshold,
-                                    "Pass/Fail": "Pass" if adf_pass_fail else "Fail",
                                     "Decision": adf_decision,
                                 }
                             ]
@@ -121,65 +121,17 @@ class AutoStationarity(Metric):
                     ignore_index=True,
                 )
 
-                if adf_pass_fail:
-                    is_stationary = True
-                    best_integration_order = pd.concat(
-                        [
-                            best_integration_order,
-                            pd.DataFrame(
-                                [
-                                    {
-                                        "Variable": col,
-                                        "Best Integration Order": order,
-                                        "Test": "ADF",
-                                        "p-value": adf_pvalue,
-                                        "Threshold": threshold,
-                                        "Decision": adf_decision,
-                                    }
-                                ]
-                            ),
-                        ],
-                        ignore_index=True,
-                    )
-
-                order += 1
-
-        # Convert the 'Integration Order' and 'Best Integration Order' column to integer
-        summary_stationarity["Integration Order"] = summary_stationarity[
-            "Integration Order"
-        ].astype(int)
-        best_integration_order["Best Integration Order"] = best_integration_order[
-            "Best Integration Order"
-        ].astype(int)
-
-        return self.cache_results(
-            {
-                "stationarity_analysis": summary_stationarity.to_dict(orient="records"),
-                "best_integration_order": best_integration_order.to_dict(
-                    orient="records"
-                ),
-            }
-        )
-
-    def summary(self, metric_value):
-        """
-        Build one table for summarizing the stationarity results
-        and another for the best integration order results
-        """
-        summary_stationarity = metric_value["stationarity_analysis"]
-        best_integration_order = metric_value["best_integration_order"]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=summary_stationarity,
-                    metadata=ResultTableMetadata(title="Stationarity Analysis Results"),
-                ),
-                ResultTable(
-                    data=best_integration_order,
-                    metadata=ResultTableMetadata(
-                        title="Best Integration Order Results"
-                    ),
-                ),
-            ]
-        )
+            order += 1
+
+    # Convert the 'Integration Order' and 'Best Integration Order' column to integer
+    summary_stationarity["Integration Order"] = summary_stationarity[
+        "Integration Order"
+    ].astype(int)
+    best_integration_order["Best Integration Order"] = best_integration_order[
+        "Best Integration Order"
+    ].astype(int)
+
+    return {
+        "Stationarity Analysis Results": summary_stationarity,
+        "Best Integration Order Results": best_integration_order,
+    }