validmind 2.2.5__py3-none-any.whl → 2.3.1__py3-none-any.whl

validmind/tests/{model_validation/statsmodels → data_validation}/KPSS.py

@@ -4,9 +4,13 @@
 
 from dataclasses import dataclass
 
+import pandas as pd
 from statsmodels.tsa.stattools import kpss
 
-from validmind.vm_models import Metric
+from validmind.logging import get_logger
+from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+
+logger = get_logger(__name__)
 
 
 @dataclass
@@ -64,14 +68,63 @@ class KPSS(Metric):
         """
         dataset = self.inputs.dataset.df
 
-        kpss_values = {}
+        # 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 KPSS results
+        kpss_values = []
+
         for col in dataset.columns:
-            kpss_stat, pvalue, usedlag, critical_values = kpss(dataset[col].values)
-            kpss_values[col] = {
-                "stat": kpss_stat,
-                "pvalue": pvalue,
-                "usedlag": usedlag,
-                "critical_values": critical_values,
-            }
-
-        return self.cache_results(kpss_values)
+            try:
+                kpss_stat, pvalue, usedlag, critical_values = kpss(dataset[col].values)
+                kpss_values.append(
+                    {
+                        "Variable": col,
+                        "stat": kpss_stat,
+                        "pvalue": pvalue,
+                        "usedlag": usedlag,
+                        "critical_values": critical_values,
+                    }
+                )
+            except Exception as e:
+                logger.error(f"Error processing column '{col}': {e}")
+                kpss_values.append(
+                    {
+                        "Variable": col,
+                        "stat": None,
+                        "pvalue": None,
+                        "usedlag": None,
+                        "critical_values": None,
+                        "error": str(e),
+                    }
+                )
+
+        return self.cache_results({"kpss_results": kpss_values})
+
+    def summary(self, metric_value):
+        """
+        Build a table for summarizing the KPSS results
+        """
+        kpss_results = metric_value["kpss_results"]
+
+        return ResultSummary(
+            results=[
+                ResultTable(
+                    data=kpss_results,
+                    metadata=ResultTableMetadata(title="KPSS Test Results"),
+                )
+            ]
+        )

validmind/tests/{model_validation/statsmodels → data_validation}/PhillipsPerronArch.py

@@ -4,9 +4,14 @@
 
 from dataclasses import dataclass
 
+import pandas as pd
 from arch.unitroot import PhillipsPerron
+from numpy.linalg import LinAlgError
 
-from validmind.vm_models import Metric
+from validmind.logging import get_logger
+from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+
+logger = get_logger(__name__)
 
 
 @dataclass
@@ -62,14 +67,63 @@ class PhillipsPerronArch(Metric):
         """
         dataset = self.inputs.dataset.df
 
-        pp_values = {}
+        # 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:
-            pp = PhillipsPerron(dataset[col].values)
-            pp_values[col] = {
-                "stat": pp.stat,
-                "pvalue": pp.pvalue,
-                "usedlag": pp.lags,
-                "nobs": pp.nobs,
-            }
-
-        return self.cache_results(pp_values)
+            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"]
+
+        return ResultSummary(
+            results=[
+                ResultTable(
+                    data=pp_results,
+                    metadata=ResultTableMetadata(title="Phillips-Perron Test Results"),
+                )
+            ]
+        )

validmind/tests/data_validation/ScatterPlot.py

@@ -51,7 +51,7 @@ class ScatterPlot(Metric):
     """
 
     name = "scatter_plot"
-    required_inputs = ["dataset", "dataset.target_column"]
+    required_inputs = ["dataset"]
     metadata = {
         "task_types": ["classification", "regression"],
         "tags": ["tabular_data", "visualization"],

validmind/tests/data_validation/SeasonalDecompose.py

@@ -90,14 +90,18 @@ class SeasonalDecompose(Metric):
         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"})
+                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)
+                Date=lambda x: (
+                    x["Date"].astype(str)
+                    if "Date" in x.columns
+                    else x.index.astype(str)
+                )
             )
             for series in results.values()
         ]
@@ -200,7 +204,8 @@ class SeasonalDecompose(Metric):
                     )
                 else:
                     warnings.warn(
-                        f"No frequency could be inferred for variable '{col}'. Skipping seasonal decomposition and plots for this variable."
+                        f"No frequency could be inferred for variable '{col}'. "
+                        "Skipping seasonal decomposition and plots for this variable."
                     )
 
         return self.cache_results(results, figures=figures)

validmind/tests/data_validation/TabularDateTimeHistograms.py

@@ -2,8 +2,8 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-import matplotlib.pyplot as plt
-import seaborn as sns
+import pandas as pd
+import plotly.graph_objects as go
 
 from validmind.vm_models import Figure, Metric
 
@@ -50,45 +50,41 @@ class TabularDateTimeHistograms(Metric):
 
     metadata = {
         "task_types": ["classification", "regression"],
-        "tags": ["tabular_data", "visualization"],
+        "tags": ["time_series_data", "visualization"],
     }
 
     def run(self):
         df = self.inputs.dataset.df
 
-        # Extract datetime columns from the dataset
-        datetime_columns = df.select_dtypes(include=["datetime64"]).columns.tolist()
-
-        if len(datetime_columns) == 0:
-            raise ValueError("No datetime columns found in the dataset")
+        # 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 = []
-        for col in datetime_columns:
-            plt.figure()
-            fig, _ = plt.subplots()
-
-            # Calculate the difference between consecutive dates and convert to days
-            date_diffs = df[col].sort_values().diff().dt.days.dropna()
-
-            # Filter out 0 values
-            date_diffs = date_diffs[date_diffs != 0]
-
-            ax = sns.histplot(date_diffs, kde=False, bins=30)
-            plt.title(f"{col}", weight="bold", fontsize=20)
-
-            plt.xticks(fontsize=18)
-            plt.yticks(fontsize=18)
-            ax.set_xlabel("Days Between Consecutive Dates", fontsize=18)
-            ax.set_ylabel("Frequency", fontsize=18)
-            figures.append(
-                Figure(
-                    for_object=self,
-                    key=f"{self.key}:{col}",
-                    figure=fig,
-                )
-            )
 
-        plt.close("all")
+        # 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,

validmind/tests/data_validation/WOEBinPlots.py

@@ -58,7 +58,7 @@ class WOEBinPlots(Metric):
     """
 
     name = "woe_bin_plots"
-    required_context = ["dataset"]
+    required_inputs = ["dataset"]
     default_params = {"breaks_adj": None, "fig_height": 600, "fig_width": 500}
     metadata = {
         "task_types": ["classification"],

validmind/tests/data_validation/WOEBinTable.py

@@ -46,7 +46,7 @@ class WOEBinTable(Metric):
     """
 
     name = "woe_bin_table"
-    required_context = ["dataset"]
+    required_inputs = ["dataset"]
     default_params = {"breaks_adj": None}
     metadata = {
         "task_types": ["classification"],

validmind/tests/{model_validation/statsmodels → data_validation}/ZivotAndrewsArch.py

@@ -4,9 +4,14 @@
 
 from dataclasses import dataclass
 
+import pandas as pd
 from arch.unitroot import ZivotAndrews
+from numpy.linalg import LinAlgError
 
-from validmind.vm_models import Metric
+from validmind.logging import get_logger
+from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+
+logger = get_logger(__name__)
 
 
 @dataclass
@@ -57,14 +62,63 @@ class ZivotAndrewsArch(Metric):
         """
         dataset = self.inputs.dataset.df
 
-        za_values = {}
+        # 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:
-            za = ZivotAndrews(dataset[col].values)
-            za_values[col] = {
-                "stat": za.stat,
-                "pvalue": za.pvalue,
-                "usedlag": za.lags,
-                "nobs": za.nobs,
-            }
-
-        return self.cache_results(za_values)
+            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"),
+                )
+            ]
+        )

validmind/tests/data_validation/nlp/CommonWords.py

@@ -52,7 +52,7 @@ class CommonWords(Metric):
     """
 
     name = "common_words"
-    required_inputs = ["dataset", "dataset.text_column"]
+    required_inputs = ["dataset"]
     metadata = {
         "task_types": ["text_classification", "text_summarization"],
         "tags": ["nlp", "text_data", "visualization", "frequency_analysis"],

validmind/tests/data_validation/nlp/Hashtags.py

@@ -54,7 +54,7 @@ class Hashtags(ThresholdTest):
     """
 
     name = "hashtags"
-    required_inputs = ["dataset", "dataset.text_column"]
+    required_inputs = ["dataset"]
     default_params = {"top_hashtags": 25}
     metadata = {
         "task_types": ["text_classification", "text_summarization"],

validmind/tests/data_validation/nlp/Mentions.py

@@ -54,7 +54,7 @@ class Mentions(ThresholdTest):
 
     name = "mentions"
 
-    required_inputs = ["dataset", "dataset.text_column"]
+    required_inputs = ["dataset"]
     default_params = {"top_mentions": 25}
     metadata = {
         "task_types": ["text_classification", "text_summarization"],

validmind/tests/data_validation/nlp/PolarityAndSubjectivity.py

@@ -10,7 +10,7 @@ from textblob import TextBlob
 from validmind import tags, tasks
 
 
-@tags("data_validation")
+@tags("nlp", "text_data", "data_validation")
 @tasks("nlp")
 def PolarityAndSubjectivity(dataset):
     """
@@ -27,6 +27,7 @@ def PolarityAndSubjectivity(dataset):
     Returns:
         plotly.graph_objs._figure.Figure: A Plotly scatter plot of polarity vs subjectivity.
     """
+
     # Function to calculate sentiment and subjectivity
     def analyze_sentiment(text):
         analysis = TextBlob(text)

validmind/tests/data_validation/nlp/Punctuations.py

@@ -51,7 +51,7 @@ class Punctuations(Metric):
     """
 
     name = "punctuations"
-    required_inputs = ["dataset", "dataset.text_column"]
+    required_inputs = ["dataset"]
     metadata = {
         "task_types": ["text_classification", "text_summarization"],
         "tags": ["nlp", "text_data", "visualization", "frequency_analysis"],

validmind/tests/data_validation/nlp/Sentiment.py

@@ -11,7 +11,7 @@ from nltk.sentiment import SentimentIntensityAnalyzer
 from validmind import tags, tasks
 
 
-@tags("data_validation")
+@tags("nlp", "text_data", "data_validation")
 @tasks("nlp")
 def Sentiment(dataset):
     """

validmind/tests/data_validation/nlp/TextDescription.py

@@ -60,7 +60,7 @@ class TextDescription(Metric):
     """
 
     name = "text_description"
-    required_inputs = ["dataset", "dataset.text_column"]
+    required_inputs = ["dataset"]
     default_params = {
         "unwanted_tokens": {
             "s",
@@ -79,6 +79,10 @@ class TextDescription(Metric):
         "num_top_words": 3,
         "lang": "english",
     }
+    metadata = {
+        "task_types": ["text_classification", "text_summarization"],
+        "tags": ["nlp", "text_data", "visualization"],
+    }
 
     def general_text_metrics(self, df, text_column):
         nltk.download("punkt", quiet=True)

validmind/tests/data_validation/nlp/Toxicity.py

@@ -9,7 +9,7 @@ import seaborn as sns
 from validmind import tags, tasks
 
 
-@tags("data_validation")
+@tags("nlp", "text_data", "data_validation")
 @tasks("nlp")
 def Toxicity(dataset):
     """

validmind/tests/decorator.py

@@ -13,9 +13,9 @@ from uuid import uuid4
 
 import pandas as pd
 
+from validmind.ai.test_descriptions import get_description_metadata
 from validmind.errors import MissingRequiredTestInputError
 from validmind.logging import get_logger
-from validmind.utils import get_description_metadata
 from validmind.vm_models import (
     Metric,
     MetricResult,

validmind/tests/model_validation/FeaturesAUC.py

@@ -55,10 +55,12 @@ class FeaturesAUC(Metric):
     }
 
     def run(self):
-        x = self.inputs.dataset.x_df()
-        y = self.inputs.dataset.y_df()
+        dataset = self.inputs.dataset
+        x = dataset.x_df()
+        y = dataset.y_df()
+        n_targets = dataset.df[dataset.target_column].nunique()
 
-        if y.nunique() != 2:
+        if n_targets != 2:
             raise SkipTestError("FeaturesAUC metric requires a binary target variable.")
 
         aucs = pd.DataFrame(index=x.columns, columns=["AUC"])

validmind/tests/model_validation/embeddings/CosineSimilarityComparison.py

@@ -9,7 +9,11 @@ import pandas as pd
 import plotly.express as px
 from sklearn.metrics.pairwise import cosine_similarity
 
+from validmind import tags, tasks
 
+
+@tags("visualization", "dimensionality_reduction", "embeddings")
+@tasks("text_qa", "text_generation", "text_summarization")
 def CosineSimilarityComparison(dataset, models):
     """
     Computes pairwise cosine similarities between model embeddings and visualizes the results through bar charts,

validmind/tests/model_validation/embeddings/CosineSimilarityHeatmap.py

@@ -6,7 +6,11 @@ import numpy as np
 import plotly.express as px
 from sklearn.metrics.pairwise import cosine_similarity
 
+from validmind import tags, tasks
 
+
+@tags("visualization", "dimensionality_reduction", "embeddings")
+@tasks("text_qa", "text_generation", "text_summarization")
 def CosineSimilarityHeatmap(
     dataset,
     model,

validmind/tests/model_validation/embeddings/EuclideanDistanceComparison.py

@@ -9,7 +9,11 @@ import pandas as pd
 import plotly.express as px
 from sklearn.metrics.pairwise import euclidean_distances
 
+from validmind import tags, tasks
 
+
+@tags("visualization", "dimensionality_reduction", "embeddings")
+@tasks("text_qa", "text_generation", "text_summarization")
 def EuclideanDistanceComparison(dataset, models):
     """
     Computes pairwise Euclidean distances between model embeddings and visualizes the results through bar charts,

validmind/tests/model_validation/embeddings/EuclideanDistanceHeatmap.py

@@ -6,7 +6,11 @@ import numpy as np
 import plotly.express as px
 from sklearn.metrics.pairwise import euclidean_distances
 
+from validmind import tags, tasks
 
+
+@tags("visualization", "dimensionality_reduction", "embeddings")
+@tasks("text_qa", "text_generation", "text_summarization")
 def EuclideanDistanceHeatmap(
     dataset,
     model,

validmind/tests/model_validation/embeddings/PCAComponentsPairwisePlots.py

@@ -10,7 +10,11 @@ import plotly.express as px
 from sklearn.decomposition import PCA
 from sklearn.preprocessing import StandardScaler
 
+from validmind import tags, tasks
 
+
+@tags("visualization", "dimensionality_reduction", "embeddings")
+@tasks("text_qa", "text_generation", "text_summarization")
 def PCAComponentsPairwisePlots(dataset, model, n_components=3):
     """
     Generates scatter plots for pairwise combinations of principal component analysis (PCA) components of model embeddings.

validmind/tests/model_validation/embeddings/TSNEComponentsPairwisePlots.py

@@ -10,7 +10,11 @@ import plotly.express as px
 from sklearn.manifold import TSNE
 from sklearn.preprocessing import StandardScaler
 
+from validmind import tags, tasks
 
+
+@tags("visualization", "dimensionality_reduction", "embeddings")
+@tasks("text_qa", "text_generation", "text_summarization")
 def TSNEComponentsPairwisePlots(
     dataset,
     model,

validmind/tests/model_validation/ragas/AnswerCorrectness.py

@@ -11,7 +11,7 @@ from ragas.metrics import answer_correctness
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm")
@@ -104,7 +104,7 @@ def AnswerCorrectness(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df), metrics=[answer_correctness]
+        Dataset.from_pandas(df), metrics=[answer_correctness], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(x=result_df["answer_correctness"].to_list(), nbins=10)
@@ -112,7 +112,7 @@ def AnswerCorrectness(
 
     return (
         {
-            "Scores": result_df[
+            "Scores (will not be uploaded to UI)": result_df[
                 ["question", "answer", "ground_truth", "answer_correctness"]
             ],
             "Aggregate Scores": [