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

validmind/tests/data_validation/TabularDateTimeHistograms.py

@@ -5,10 +5,14 @@
 import pandas as pd
 import plotly.graph_objects 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 TabularDateTimeHistograms(Metric):
+@tags("time_series_data", "visualization")
+@tasks("classification", "regression")
+def TabularDateTimeHistograms(dataset: VMDataset):
     """
     Generates histograms to provide graphical insight into the distribution of time intervals in a model's datetime
     data.
@@ -52,46 +56,20 @@ class TabularDateTimeHistograms(Metric):
     - The test is only applicable to datasets containing datetime columns and will fail if such columns are unavailable.
     - The interpretation of the histograms relies heavily on the domain expertise and experience of the reviewer.
     """
-
-    name = "tabular_datetime_histograms"
-    required_inputs = ["dataset"]
-
-    tasks = ["classification", "regression"]
-    tags = ["time_series_data", "visualization"]
-
-    def run(self):
-        df = self.inputs.dataset.df
-
-        # Check if the index is a datetime type
-        if not isinstance(df.index, (pd.DatetimeIndex, pd.PeriodIndex)):
-            raise ValueError("Index must be a datetime type")
-
-        figures = []
-
-        # Calculate the difference between consecutive dates in the index
-        date_diffs = df.index.to_series().sort_values().diff().dt.days.dropna()
-
-        # Filter out 0 values
-        date_diffs = date_diffs[date_diffs != 0]
-
-        # Create a histogram using Plotly
-        fig = go.Figure()
-        fig.add_trace(go.Histogram(x=date_diffs, nbinsx=30))
-        fig.update_layout(
-            title="Index",
-            xaxis_title="Days Between Consecutive Dates",
-            yaxis_title="Frequency",
-            font=dict(size=18),
-        )
-
-        figures.append(
-            Figure(
-                for_object=self,
-                key=f"{self.key}:index",
-                figure=fig,
-            )
-        )
-
-        return self.cache_results(
-            figures=figures,
-        )
+    df = dataset.df
+    if not isinstance(df.index, (pd.DatetimeIndex, pd.PeriodIndex)):
+        raise SkipTestError("Index must be a datetime type")
+
+    date_diffs = df.index.to_series().sort_values().diff().dt.days.dropna()
+    date_diffs = date_diffs[date_diffs != 0]
+
+    fig = go.Figure()
+    fig.add_trace(go.Histogram(x=date_diffs, nbinsx=30))
+    fig.update_layout(
+        title="Index",
+        xaxis_title="Days Between Consecutive Dates",
+        yaxis_title="Frequency",
+        font=dict(size=18),
+    )
+
+    return fig

validmind/tests/data_validation/TabularNumericalHistograms.py

@@ -2,13 +2,15 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-import numpy as np
 import plotly.graph_objs as go
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset
 
 
-class TabularNumericalHistograms(Metric):
+@tags("tabular_data", "visualization")
+@tasks("classification", "regression")
+def TabularNumericalHistograms(dataset: VMDataset):
     """
     Generates histograms for each numerical feature in a dataset to provide visual insights into data distribution and
     detect potential issues.
@@ -51,47 +53,26 @@ class TabularNumericalHistograms(Metric):
     - Does not provide any insight into how these features affect the output of the model; it is purely an input
     analysis tool.
     """
-
-    name = "tabular_numerical_histograms"
-    required_inputs = ["dataset"]
-
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "visualization"]
-
-    def run(self):
-        df = self.inputs.dataset.df
-
-        # Extract numerical columns from the dataset
-        numerical_columns = df.select_dtypes(include=[np.number]).columns.tolist()
-
-        if len(numerical_columns) == 0:
-            raise ValueError("No numerical columns found in the dataset")
-
-        figures = []
-        for col in numerical_columns:
-            fig = go.Figure()
-            fig.add_trace(
-                go.Histogram(x=df[col], nbinsx=50, name=col)
-            )  # add histogram trace
-            fig.update_layout(
-                title_text=f"{col}",  # title of plot
-                xaxis_title_text="",  # xaxis label
-                yaxis_title_text="",  # yaxis label
-                bargap=0.2,  # gap between bars of adjacent location coordinates
-                bargroupgap=0.1,  # gap between bars of the same location coordinates
-                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,
-                )
-            )
-
-        return self.cache_results(
-            figures=figures,
+    if len(dataset.feature_columns_numeric) == 0:
+        raise ValueError("No numerical columns found in the dataset")
+
+    df = dataset.df
+    figures = []
+
+    for col in dataset.feature_columns_numeric:
+        fig = go.Figure()
+        fig.add_trace(go.Histogram(x=df[col], nbinsx=50, name=col))
+        fig.update_layout(
+            title_text=f"{col}",
+            xaxis_title_text="",
+            yaxis_title_text="",
+            bargap=0.2,
+            bargroupgap=0.1,
+            autosize=False,
+            width=500,
+            height=500,
+            margin=dict(l=50, r=50, b=100, t=100, pad=4),
         )
+        figures.append(fig)
+
+    return tuple(figures)

validmind/tests/data_validation/TargetRateBarPlots.py

@@ -2,13 +2,18 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
+import numpy as np
 import plotly.graph_objs as go
 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.vm_models import VMDataset
 
 
-class TargetRateBarPlots(Metric):
+@tags("tabular_data", "visualization", "categorical_data")
+@tasks("classification")
+def TargetRateBarPlots(dataset: VMDataset):
     """
     Generates bar plots visualizing the default rates of categorical features for a classification machine learning
     model.
@@ -43,107 +48,63 @@ class TargetRateBarPlots(Metric):
 
     ### Limitations
 
-    - The test is less useful when dealing with numeric or continuous data, as it's designed specifically for
-    categorical features.
-    - If the model in question is dealing with a multi-class problem rather than binary classification, the test's
-    assumption of binary target values (0s and 1s) becomes a significant limitation.
     - The readability of the bar plots drops as the number of distinct categories increases in the dataset, which can
     make them harder to understand and less useful.
     """
-
-    name = "target_rate_bar_plots"
-    required_inputs = ["dataset"]
-    default_params = {"default_column": None, "columns": None}
-    tasks = ["classification"]
-    tags = ["tabular_data", "visualization", "categorical_data"]
-
-    def plot_loan_default_ratio(self, default_column, columns=None):
-        df = self.inputs.dataset.df
-
-        # Use all categorical features if columns is not specified, else use selected columns
-        if columns is None:
-            features = self.inputs.dataset.feature_columns_categorical
-        else:
-            features = columns
-
-        figures = []
-        for feature in features:
-            fig = make_subplots(
-                rows=1,
-                cols=2,
-            )
-
-            # Calculate counts and default rate for each category
-            counts = df[feature].value_counts()
-            default_rate = df.groupby(feature)[default_column].mean()
-
-            # Left plot: Counts
-            fig.add_trace(
-                go.Bar(
-                    x=counts.index,
-                    y=counts.values,
-                    name="Counts",
-                    marker_color="#6699cc",
-                ),
-                row=1,
-                col=1,
-            )
-
-            # Right plot: Default rate
-            fig.add_trace(
-                go.Bar(
-                    x=default_rate.index,
-                    y=default_rate.values,
-                    name="Target Rate",
-                    marker_color="orange",
-                ),
-                row=1,
-                col=2,
-            )
-
-            fig.update_layout(
-                title_text=f"{feature}",  # title of plot
-                autosize=False,
-                width=500,
-                height=400,
-                margin=dict(l=50, r=50, b=100, t=100, pad=4),
-            )
-
-            figures.append(
-                Figure(
-                    for_object=self,
-                    key=f"{self.key}:{feature}",
-                    figure=fig,
-                )
-            )
-
-        return self.cache_results(
-            figures=figures,
+    if np.unique(dataset.df[dataset.target_column]).size != 2:
+        raise SkipTestError(
+            f"Target column '{dataset.target_column}' is not binary. "
+            "This test only works for binary classification tasks."
         )
 
-    def check_default_column(self, default_column):
-        if default_column is None:
-            raise ValueError("The default_column parameter needs to be specified.")
+    if len(dataset.feature_columns_categorical) == 0:
+        raise SkipTestError("No categorical columns found in the dataset")
 
-        unique_values = self.inputs.dataset.df[default_column].unique()
-        binary_values = [0, 1]
+    df = dataset.df
+    figures = []
 
-        if sorted(unique_values) != binary_values:
-            raise ValueError(
-                f"The column {default_column} is not binary. It contains: {unique_values}"
-            )
+    for col in dataset.feature_columns_categorical:
 
-        print(f"The column {default_column} is correct and contains only 1 and 0.")
+        # Calculate counts and default rate for each category
+        counts = df[col].value_counts()
+        default_rate = df.groupby(col)[dataset.target_column].mean()
 
-    def run(self):
-        default_column = (
-            self.params.get("default_column") or self.inputs.dataset.target_column
+        fig = make_subplots(
+            rows=1,
+            cols=2,
         )
-        columns = self.params["columns"]
 
-        # Check loan status variable has only 1 and 0
-        self.check_default_column(default_column)
+        # Left plot: Counts
+        fig.add_trace(
+            go.Bar(
+                x=counts.index,
+                y=counts.values,
+                name="Counts",
+                marker_color="#6699cc",
+            ),
+            row=1,
+            col=1,
+        )
+        # Right plot: Default rate
+        fig.add_trace(
+            go.Bar(
+                x=default_rate.index,
+                y=default_rate.values,
+                name="Target Rate",
+                marker_color="orange",
+            ),
+            row=1,
+            col=2,
+        )
 
-        return self.plot_loan_default_ratio(
-            default_column=default_column, columns=columns
+        fig.update_layout(
+            title_text=col,
+            autosize=False,
+            width=500,
+            height=400,
+            margin=dict(l=50, r=50, b=100, t=100, pad=4),
         )
+
+        figures.append(fig)
+
+    return tuple(figures)

validmind/tests/data_validation/TimeSeriesFrequency.py

@@ -2,23 +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 plotly.graph_objects as go
 
-from validmind.vm_models import (
-    Figure,
-    ResultSummary,
-    ResultTable,
-    ResultTableMetadata,
-    ThresholdTest,
-    ThresholdTestResult,
-)
+from validmind import tags, tasks
+from validmind.errors import SkipTestError
+from validmind.vm_models import VMDataset
 
 
-@dataclass
-class TimeSeriesFrequency(ThresholdTest):
+@tags("time_series_data")
+@tasks("regression")
+def TimeSeriesFrequency(dataset: VMDataset):
     """
     Evaluates consistency of time series data frequency and generates a frequency plot.
 
@@ -63,129 +57,50 @@ class TimeSeriesFrequency(ThresholdTest):
     - Depending on context or the model under development, mixed frequencies might sometimes be acceptable, but this
     test considers them a failing condition.
     """
-
-    name = "time_series_frequency"
-    required_inputs = ["dataset"]
-    tasks = ["regression"]
-    tags = ["time_series_data"]
-
-    def summary(self, results, all_passed):
-        """
-        Example output:
-        [
-            {
-                "values": {
-                    "Variable": ["MORTGAGE30US", "GS10", "FEDFUNDS"],
-                    "Frequency": ["Monthly", "Monthly", "Monthly"]
-                },
-                "passed": true
-            }
-        ]
-        """
-        first_result = results[0]
-        variables = first_result.values["Variable"]
-        frequencies = first_result.values["Frequency"]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=pd.DataFrame(
-                        {"Variable": variables, "Frequency": frequencies}
-                    ),
-                    metadata=ResultTableMetadata(
-                        title="Frequency of Time Series Variables"
-                    ),
-                )
-            ]
-        )
-
-    def run(self):
-        # Check if the index of dataframe is datetime
-        is_datetime = pd.api.types.is_datetime64_any_dtype(self.inputs.dataset.df.index)
-        if not is_datetime:
-            raise ValueError("Dataset must be provided with datetime index")
-
-        freq_df = self._identify_frequencies(self.inputs.dataset.df)
-        n_frequencies = len(freq_df["Frequency"].unique())
-        test_results = [
-            ThresholdTestResult(
-                passed=n_frequencies == 1,
-                values=freq_df.to_dict(orient="list"),
-            )
-        ]
-        fig_frequency = self._frequency_plot(self.inputs.dataset.df)
-        test_figures = []
-        test_figures.append(
-            Figure(
-                for_object=self,
-                key=f"{self.name}:frequencyplot",
-                figure=fig_frequency,
-                metadata={"type": "frequencyplot"},
-            )
-        )
-        return self.cache_results(
-            test_results,
-            passed=all([r.passed for r in test_results]),
-            figures=test_figures,
-        )
-
-    def _identify_frequencies(self, df):
-        """
-        Identify the frequency of each series in the DataFrame.
-        :param df: Time-series DataFrame
-        :return: DataFrame with two columns: 'Variable' and 'Frequency'
-        """
-        frequencies = []
-        freq_dict = {
-            "S": "Second",
-            "T": "Minute",
-            "min": "Minute",
-            "H": "Hourly",
-            "D": "Daily",
-            "B": "Business day",
-            "W": "Weekly",
-            "MS": "Monthly",
-            "M": "Monthly",
-            "Q": "Quarterly",
-            "A": "Yearly",
-            "Y": "Yearly",
-        }
-
-        for column in df.columns:
-            series = df[column].dropna()
-            if not series.empty:
-                freq = pd.infer_freq(series.index)
-                label = freq_dict.get(freq, freq)
-            else:
-                label = None
-
-            frequencies.append({"Variable": column, "Frequency": label})
-
-        freq_df = pd.DataFrame(frequencies)
-
-        return freq_df
-
-    def _frequency_plot(self, df):
-        """
-        Creates a frequency plot of time differences between consecutive entries in a DataFrame index using Plotly.
-        Args:
-        df (pandas.DataFrame): The input DataFrame.
-        Returns:
-        A Plotly Figure object representing the frequency plot of time differences.
-        """
-        # Calculate the time differences between consecutive entries
-        time_diff = df.index.to_series().diff().dropna()
-
-        # Convert the time differences to a suitable unit (e.g., days)
-        time_diff_days = time_diff.dt.total_seconds() / (60 * 60 * 24)
-
-        # Create a Plotly histogram
-        fig = go.Figure(data=[go.Histogram(x=time_diff_days, nbinsx=50)])
-        fig.update_layout(
+    df = dataset.df
+
+    if not pd.api.types.is_datetime64_any_dtype(df.index):
+        raise SkipTestError("Dataset must be provided with datetime index")
+
+    frequencies = []
+    freq_dict = {
+        "S": "Second",
+        "T": "Minute",
+        "min": "Minute",
+        "H": "Hourly",
+        "D": "Daily",
+        "B": "Business day",
+        "W": "Weekly",
+        "MS": "Monthly",
+        "M": "Monthly",
+        "Q": "Quarterly",
+        "A": "Yearly",
+        "Y": "Yearly",
+    }
+
+    for column in dataset.feature_columns_numeric:
+        series = df[column].dropna()
+        if not series.empty:
+            freq = pd.infer_freq(series.index)
+            label = freq_dict.get(freq, freq)
+        else:
+            label = None
+
+        frequencies.append({"Variable": column, "Frequency": label})
+
+    # Calculate the time differences between consecutive entries
+    time_diff = df.index.to_series().diff().dropna()
+    # Convert the time differences to a suitable unit (e.g., days)
+    time_diff_days = time_diff.dt.total_seconds() / (60 * 60 * 24)
+    # Plot the time differences as a histogram
+    fig = go.Figure(
+        data=[go.Histogram(x=time_diff_days, nbinsx=50)],
+        layout=go.Layout(
             title="Histogram of Time Differences (Days)",
             xaxis_title="Days",
             yaxis_title="Frequency",
             font=dict(size=16),
-        )
+        ),
+    )
 
-        return fig
+    return frequencies, fig, len(set(item["Frequency"] for item in frequencies)) == 1

validmind/tests/data_validation/TimeSeriesHistogram.py

@@ -2,12 +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.express as px
 
 from validmind import tags, tasks
+from validmind.logging import get_logger
 
+logger = get_logger(__name__)
 
-@tags("data_validation", "visualization")
+
+@tags("data_validation", "visualization", "time_series_data")
 @tasks("regression", "time_series_forecasting")
 def TimeSeriesHistogram(dataset, nbins=30):
     """
@@ -51,6 +55,9 @@ def TimeSeriesHistogram(dataset, nbins=30):
 
     df = dataset.df
 
+    if not pd.api.types.is_datetime64_any_dtype(df.index):
+        raise ValueError(f"Dataset {dataset.input_id} must have a datetime index")
+
     columns = list(dataset.df.columns)
 
     if not set(columns).issubset(set(df.columns)):
@@ -58,12 +65,26 @@ def TimeSeriesHistogram(dataset, nbins=30):
 
     figures = []
     for col in columns:
+        # Check for missing values and log if any are found
+        missing_count = df[col].isna().sum()
+        if missing_count > 0:
+            logger.info(
+                f"Column '{col}' contains {missing_count} missing values which will be excluded from the histogram."
+            )
+
+        # Drop missing values for the current column
+        valid_data = df[~df[col].isna()]
+
         fig = px.histogram(
-            df, x=col, marginal="violin", nbins=nbins, title=f"Histogram for {col}"
+            valid_data,
+            x=col,
+            marginal="violin",
+            nbins=nbins,
+            title=f"Histogram for {col}",
         )
         fig.update_layout(
             title={
-                "text": f"{col}",
+                "text": f"{col} (n={len(valid_data)})",
                 "y": 0.9,
                 "x": 0.5,
                 "xanchor": "center",