validmind 2.4.1__py3-none-any.whl → 2.4.5__py3-none-any.whl

validmind/models/huggingface.py

@@ -56,7 +56,6 @@ class HFModel(VMModel):
             return [result["label"] for result in results]
         elif tasks[-1] == "feature_extraction":
             # Extract [CLS] token embedding for each input and return as list of lists
-            print(f"len(results): {len(results)}")
             return [embedding[0][0] for embedding in results]
         else:
             return results

validmind/tests/data_validation/IQROutliersBarPlot.py

@@ -4,7 +4,6 @@
 
 from dataclasses import dataclass
 
-import numpy as np
 import plotly.graph_objects as go
 
 from validmind.vm_models import Figure, Metric
@@ -62,22 +61,27 @@ class IQROutliersBarPlot(Metric):
 
     name = "iqr_outliers_bar_plot"
     required_inputs = ["dataset"]
-    default_params = {"threshold": 1.5, "num_features": None, "fig_width": 800}
+    default_params = {"threshold": 1.5, "fig_width": 800}
     tasks = ["classification", "regression"]
     tags = ["tabular_data", "visualization", "numerical_data"]
 
     def run(self):
         df = self.inputs.dataset.df
-        num_features = self.params["num_features"]
+
+        # Select numerical features
+        features = self.inputs.dataset.feature_columns_numeric
+
+        # Select non-binary features
+        features = [
+            feature
+            for feature in features
+            if len(self.inputs.dataset.df[feature].unique()) > 2
+        ]
+
         threshold = self.params["threshold"]
         fig_width = self.params["fig_width"]
 
-        # If num_features is None, use all numeric columns.
-        # Otherwise, only use the columns provided in num_features.
-        if num_features is None:
-            df = df.select_dtypes(include=[np.number])
-        else:
-            df = df[num_features]
+        df = df[features]
 
         return self.detect_and_visualize_outliers(df, threshold, fig_width)
 
@@ -98,6 +102,9 @@ class IQROutliersBarPlot(Metric):
             # Compute outliers
             outliers = self.compute_outliers(df[col], threshold)
 
+            if outliers.empty:
+                continue  # Skip plotting if there are no outliers
+
             Q1_count = outliers[
                 (outliers >= 0) & (outliers < outliers.quantile(0.25))
             ].count()

validmind/tests/data_validation/IQROutliersTable.py

@@ -4,7 +4,6 @@
 
 from dataclasses import dataclass
 
-import numpy as np
 import pandas as pd
 
 from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
@@ -53,12 +52,22 @@ class IQROutliersTable(Metric):
 
     name = "iqr_outliers_table"
     required_inputs = ["dataset"]
-    default_params = {"features": None, "threshold": 1.5}
+    default_params = {"threshold": 1.5}
     tasks = ["classification", "regression"]
     tags = ["tabular_data", "numerical_data"]
 
     def run(self):
-        features = self.params["features"]
+
+        # Select numerical features
+        features = self.inputs.dataset.feature_columns_numeric
+
+        # Select non-binary features
+        features = [
+            feature
+            for feature in features
+            if len(self.inputs.dataset.df[feature].unique()) > 2
+        ]
+
         threshold = self.params["threshold"]
 
         df = self.inputs.dataset.df
@@ -80,9 +89,7 @@ class IQROutliersTable(Metric):
         upper_bound = Q3 + threshold * IQR
         return series[(series < lower_bound) | (series > upper_bound)]
 
-    def detect_and_analyze_outliers(self, df, features=None, threshold=1.5):
-        if features is None:
-            features = df.select_dtypes(include=[np.number]).columns.tolist()
+    def detect_and_analyze_outliers(self, df, features, threshold=1.5):
 
         outliers_summary = []
         for feature in features:

validmind/tests/data_validation/TabularDescriptionTables.py

@@ -2,15 +2,14 @@
 # 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
 
-from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
+from validmind import tags, tasks
 
 
-@dataclass
-class TabularDescriptionTables(Metric):
+@tags("tabular_data")
+@tasks("classification", "regression")
+def TabularDescriptionTables(dataset):
     """
     Summarizes key descriptive statistics for numerical, categorical, and datetime variables in a dataset.
 
@@ -54,155 +53,104 @@ class TabularDescriptionTables(Metric):
     chosen algorithm.
     """
 
-    name = "tabular_description_tables"
-    required_inputs = ["dataset"]
-
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data"]
-
-    def get_summary_statistics_numerical(self, numerical_fields):
-        summary_stats = self.inputs.dataset.df[numerical_fields].describe().T
-        summary_stats["Missing Values (%)"] = (
-            self.inputs.dataset.df[numerical_fields].isnull().mean() * 100
-        )
-        summary_stats["Data Type"] = self.inputs.dataset.df[
-            numerical_fields
-        ].dtypes.astype(str)
-        summary_stats = summary_stats[
-            ["count", "mean", "min", "max", "Missing Values (%)", "Data Type"]
-        ]
-        summary_stats.columns = [
-            "Num of Obs",
-            "Mean",
-            "Min",
-            "Max",
-            "Missing Values (%)",
-            "Data Type",
-        ]
-        summary_stats["Num of Obs"] = summary_stats["Num of Obs"].astype(int)
-        summary_stats = summary_stats.sort_values(
-            by="Missing Values (%)", ascending=False
-        )
-        summary_stats.reset_index(inplace=True)
-        summary_stats.rename(columns={"index": "Numerical Variable"}, inplace=True)
-        return summary_stats
-
-    def get_summary_statistics_categorical(self, categorical_fields):
-        summary_stats = pd.DataFrame()
-        if categorical_fields:  # check if the list is not empty
-            for column in self.inputs.dataset.df[categorical_fields].columns:
-                summary_stats.loc[column, "Num of Obs"] = int(
-                    self.inputs.dataset.df[column].count()
-                )
-                summary_stats.loc[
-                    column, "Num of Unique Values"
-                ] = self.inputs.dataset.df[column].nunique()
-                summary_stats.loc[column, "Unique Values"] = str(
-                    self.inputs.dataset.df[column].unique()
-                )
-                summary_stats.loc[column, "Missing Values (%)"] = (
-                    self.inputs.dataset.df[column].isnull().mean() * 100
-                )
-                summary_stats.loc[column, "Data Type"] = str(
-                    self.inputs.dataset.df[column].dtype
-                )
-
-            summary_stats = summary_stats.sort_values(
-                by="Missing Values (%)", ascending=False
-            )
-            summary_stats.reset_index(inplace=True)
-            summary_stats.rename(
-                columns={"index": "Categorical Variable"}, inplace=True
-            )
-        return summary_stats
-
-    def get_summary_statistics_datetime(self, datetime_fields):
-        summary_stats = pd.DataFrame()
-        for column in self.inputs.dataset.df[datetime_fields].columns:
-            summary_stats.loc[column, "Num of Obs"] = int(
-                self.inputs.dataset.df[column].count()
-            )
-            summary_stats.loc[column, "Num of Unique Values"] = self.inputs.dataset.df[
+    numerical_fields = get_numerical_columns(dataset)
+    categorical_fields = get_categorical_columns(dataset)
+    datetime_fields = get_datetime_columns(dataset)
+
+    summary_stats_numerical = get_summary_statistics_numerical(
+        dataset, numerical_fields
+    )
+    summary_stats_categorical = get_summary_statistics_categorical(
+        dataset, categorical_fields
+    )
+    summary_stats_datetime = get_summary_statistics_datetime(dataset, datetime_fields)
+
+    return (summary_stats_numerical, summary_stats_categorical, summary_stats_datetime)
+
+
+def get_summary_statistics_numerical(dataset, numerical_fields):
+    summary_stats = dataset.df[numerical_fields].describe().T
+    summary_stats["Missing Values (%)"] = (
+        dataset.df[numerical_fields].isnull().mean() * 100
+    )
+    summary_stats["Data Type"] = dataset.df[numerical_fields].dtypes.astype(str)
+    summary_stats = summary_stats[
+        ["count", "mean", "min", "max", "Missing Values (%)", "Data Type"]
+    ]
+    summary_stats.columns = [
+        "Num of Obs",
+        "Mean",
+        "Min",
+        "Max",
+        "Missing Values (%)",
+        "Data Type",
+    ]
+    summary_stats["Num of Obs"] = summary_stats["Num of Obs"].astype(int)
+    summary_stats = summary_stats.sort_values(by="Missing Values (%)", ascending=False)
+    summary_stats.reset_index(inplace=True)
+    summary_stats.rename(columns={"index": "Numerical Variable"}, inplace=True)
+    return summary_stats
+
+
+def get_summary_statistics_categorical(dataset, categorical_fields):
+    summary_stats = pd.DataFrame()
+    if categorical_fields:  # check if the list is not empty
+        for column in dataset.df[categorical_fields].columns:
+            summary_stats.loc[column, "Num of Obs"] = int(dataset.df[column].count())
+            summary_stats.loc[column, "Num of Unique Values"] = dataset.df[
                 column
             ].nunique()
-            summary_stats.loc[column, "Earliest Date"] = self.inputs.dataset.df[
-                column
-            ].min()
-            summary_stats.loc[column, "Latest Date"] = self.inputs.dataset.df[
-                column
-            ].max()
-            summary_stats.loc[column, "Missing Values (%)"] = (
-                self.inputs.dataset.df[column].isnull().mean() * 100
+            summary_stats.loc[column, "Unique Values"] = str(
+                dataset.df[column].unique()
             )
-            summary_stats.loc[column, "Data Type"] = str(
-                self.inputs.dataset.df[column].dtype
+            summary_stats.loc[column, "Missing Values (%)"] = (
+                dataset.df[column].isnull().mean() * 100
             )
+            summary_stats.loc[column, "Data Type"] = str(dataset.df[column].dtype)
 
-        if not summary_stats.empty:
-            summary_stats = summary_stats.sort_values(
-                by="Missing Values (%)", ascending=False
-            )
+        summary_stats = summary_stats.sort_values(
+            by="Missing Values (%)", ascending=False
+        )
         summary_stats.reset_index(inplace=True)
-        summary_stats.rename(columns={"index": "Datetime Variable"}, inplace=True)
-        return summary_stats
-
-    def summary(self, metric_value):
-        summary_stats_numerical = metric_value["numerical"]
-        summary_stats_categorical = metric_value["categorical"]
-        summary_stats_datetime = metric_value["datetime"]
-
-        return ResultSummary(
-            results=[
-                ResultTable(
-                    data=summary_stats_numerical,
-                    metadata=ResultTableMetadata(title="Numerical Variables"),
-                ),
-                ResultTable(
-                    data=summary_stats_categorical,
-                    metadata=ResultTableMetadata(title="Categorical Variables"),
-                ),
-                ResultTable(
-                    data=summary_stats_datetime,
-                    metadata=ResultTableMetadata(title="Datetime Variables"),
-                ),
-            ]
+        summary_stats.rename(columns={"index": "Categorical Variable"}, inplace=True)
+    return summary_stats
+
+
+def get_summary_statistics_datetime(dataset, datetime_fields):
+    summary_stats = pd.DataFrame()
+    for column in dataset.df[datetime_fields].columns:
+        summary_stats.loc[column, "Num of Obs"] = int(dataset.df[column].count())
+        summary_stats.loc[column, "Num of Unique Values"] = dataset.df[column].nunique()
+        summary_stats.loc[column, "Earliest Date"] = dataset.df[column].min()
+        summary_stats.loc[column, "Latest Date"] = dataset.df[column].max()
+        summary_stats.loc[column, "Missing Values (%)"] = (
+            dataset.df[column].isnull().mean() * 100
         )
+        summary_stats.loc[column, "Data Type"] = str(dataset.df[column].dtype)
 
-    def get_categorical_columns(self):
-        categorical_columns = self.inputs.dataset.df.select_dtypes(
-            include=["object", "category"]
-        ).columns.tolist()
-        return categorical_columns
-
-    def get_numerical_columns(self):
-        numerical_columns = self.inputs.dataset.df.select_dtypes(
-            include=["int", "float", "uint8"]
-        ).columns.tolist()
-        return numerical_columns
-
-    def get_datetime_columns(self):
-        datetime_columns = self.inputs.dataset.df.select_dtypes(
-            include=["datetime"]
-        ).columns.tolist()
-        return datetime_columns
-
-    def run(self):
-        numerical_fields = self.get_numerical_columns()
-        categorical_fields = self.get_categorical_columns()
-        datetime_fields = self.get_datetime_columns()
-
-        summary_stats_numerical = self.get_summary_statistics_numerical(
-            numerical_fields
-        )
-        summary_stats_categorical = self.get_summary_statistics_categorical(
-            categorical_fields
-        )
-        summary_stats_datetime = self.get_summary_statistics_datetime(datetime_fields)
-
-        return self.cache_results(
-            {
-                "numerical": summary_stats_numerical.to_dict(orient="records"),
-                "categorical": summary_stats_categorical.to_dict(orient="records"),
-                "datetime": summary_stats_datetime.to_dict(orient="records"),
-            }
+    if not summary_stats.empty:
+        summary_stats = summary_stats.sort_values(
+            by="Missing Values (%)", ascending=False
         )
+    summary_stats.reset_index(inplace=True)
+    summary_stats.rename(columns={"index": "Datetime Variable"}, inplace=True)
+    return summary_stats
+
+
+def get_categorical_columns(dataset):
+    categorical_columns = dataset.df.select_dtypes(
+        include=["object", "category"]
+    ).columns.tolist()
+    return categorical_columns
+
+
+def get_numerical_columns(dataset):
+    numerical_columns = dataset.df.select_dtypes(
+        include=["int", "float", "uint8"]
+    ).columns.tolist()
+    return numerical_columns
+
+
+def get_datetime_columns(dataset):
+    datetime_columns = dataset.df.select_dtypes(include=["datetime"]).columns.tolist()
+    return datetime_columns

validmind/tests/model_validation/embeddings/ClusterDistribution.py

@@ -52,7 +52,7 @@ class ClusterDistribution(Metric):
         "num_clusters": 5,
     }
     tasks = ["feature_extraction"]
-    tags = ["llm", "text_data", "text_embeddings", "visualization"]
+    tags = ["llm", "text_data", "embeddings", "visualization"]
 
     def run(self):
         # run kmeans clustering on embeddings

validmind/tests/model_validation/embeddings/CosineSimilarityDistribution.py

@@ -51,7 +51,7 @@ class CosineSimilarityDistribution(Metric):
     name = "Text Embeddings Cosine Similarity Distribution"
     required_inputs = ["model", "dataset"]
     tasks = ["feature_extraction"]
-    tags = ["llm", "text_data", "text_embeddings", "visualization"]
+    tags = ["llm", "text_data", "embeddings", "visualization"]
 
     def run(self):
         # Compute cosine similarity

validmind/tests/model_validation/embeddings/DescriptiveAnalytics.py

@@ -54,7 +54,7 @@ class DescriptiveAnalytics(Metric):
     name = "Descriptive Analytics for Text Embeddings Models"
     required_inputs = ["model", "dataset"]
     tasks = ["feature_extraction"]
-    tags = ["llm", "text_data", "text_embeddings", "visualization"]
+    tags = ["llm", "text_data", "embeddings", "visualization"]
 
     def run(self):
         # Assuming y_pred returns a 2D array of embeddings [samples, features]

validmind/tests/model_validation/embeddings/EmbeddingsVisualization2D.py

@@ -54,7 +54,7 @@ class EmbeddingsVisualization2D(Metric):
         "perplexity": 30,
     }
     tasks = ["feature_extraction"]
-    tags = ["llm", "text_data", "text_embeddings", "visualization"]
+    tags = ["llm", "text_data", "embeddings", "visualization"]
 
     def run(self):
         cluster_column = self.params.get("cluster_column")

validmind/tests/model_validation/embeddings/StabilityAnalysis.py

@@ -30,7 +30,7 @@ class StabilityAnalysis(ThresholdTest):
         "mean_similarity_threshold": 0.7,
     }
     tasks = ["feature_extraction"]
-    tags = ["llm", "text_data", "text_embeddings", "visualization"]
+    tags = ["llm", "text_data", "embeddings", "visualization"]
 
     @abstractmethod
     def perturb_data(self, data: str) -> str:
@@ -62,7 +62,8 @@ class StabilityAnalysis(ThresholdTest):
 
     def run(self):
         # Perturb the test dataset
-        original = self.inputs.dataset.df
+        text_column = self.inputs.dataset.text_column
+        original = self.inputs.dataset.df[[text_column]]
         perturbed = original.copy()
         perturbed.update(
             perturbed.select_dtypes(include="object").applymap(self.perturb_data)

validmind/tests/model_validation/embeddings/StabilityAnalysisTranslation.py

@@ -4,8 +4,12 @@
 
 from transformers import MarianMTModel, MarianTokenizer
 
+from validmind.logging import get_logger
+
 from .StabilityAnalysis import StabilityAnalysis
 
+logger = get_logger(__name__)
+
 
 class StabilityAnalysisTranslation(StabilityAnalysis):
     """
@@ -61,8 +65,11 @@ class StabilityAnalysisTranslation(StabilityAnalysis):
     }
 
     def perturb_data(self, data: str):
-        if not isinstance(data, str):
-            return data
+        if len(data) > 512:
+            logger.info(
+                "Data length exceeds 512 tokens. Truncating data to 512 tokens."
+            )
+            data = data[:512]
 
         source_lang = self.params["source_lang"]
         target_lang = self.params["target_lang"]

validmind/tests/model_validation/embeddings/TSNEComponentsPairwisePlots.py

@@ -53,7 +53,6 @@ def TSNEComponentsPairwisePlots(
     - t-SNE visualizations can be misleading if interpreted without considering the stochastic nature of the algorithm;
     two runs with the same parameters might yield different visual outputs, necessitating multiple runs for a consistent interpretation.
     """
-
     # Get embeddings from the dataset using the model
     embeddings = np.stack(dataset.y_pred(model))
 

validmind/tests/model_validation/sklearn/HyperParametersTuning.py

@@ -60,8 +60,9 @@ class HyperParametersTuning(Metric):
         param_grid = self.params["param_grid"]
         if param_grid is None:
             raise SkipTestError(
-                "param_grid in dictnary format must be provide to run hyper parameter tuning"
+                "param_grid in dictonary format must be provided to run this test"
             )
+
         model = self.inputs.model.model
         estimators = GridSearchCV(
             model, param_grid=param_grid, scoring=self.params["scoring"]

validmind/tests/run.py

@@ -118,7 +118,7 @@ def _combine_figures(figure_lists: List[List[Any]], input_groups: List[Dict[str,
 
     title_template = "{current_title}({input_description})"
 
-    for i, figures in enumerate(list(zip(*figure_lists))):
+    for figures in list(zip(*figure_lists)):
         if is_plotly_figure(figures[0].figure):
             _update_plotly_titles(figures, input_groups, title_template)
         elif is_matplotlib_figure(figures[0].figure):

validmind/vm_models/dataset/dataset.py

@@ -139,13 +139,25 @@ class VMDataset:
         )
 
     def _add_column(self, column_name, column_values):
-        if len(column_values) != len(self.df):
-            raise ValueError(
-                "Length of values doesn't match number of rows in the DataFrame."
-            )
+        column_values = np.array(column_values)
+
+        if column_values.ndim == 1:
+            if len(column_values) != len(self.df):
+                raise ValueError(
+                    "Length of values doesn't match number of rows in the DataFrame."
+                )
+            self.columns.append(column_name)
+            self.df[column_name] = column_values
+        elif column_values.ndim == 2:
+            if column_values.shape[0] != len(self.df):
+                raise ValueError(
+                    "Number of rows in values doesn't match number of rows in the DataFrame."
+                )
+            self.columns.append(column_name)
+            self.df[column_name] = column_values.tolist()
 
-        self.columns.append(column_name)
-        self.df[column_name] = column_values
+        else:
+            raise ValueError("Only 1D and 2D arrays are supported for column_values.")
 
     def _validate_assign_predictions(
         self,

validmind/vm_models/test_suite/summary.py

@@ -93,10 +93,10 @@ class TestSuiteSummary:
 
     def _add_results_link(self):
         # avoid circular import
-        from ...api_client import get_api_host, get_api_project
+        from ...api_client import get_api_host, get_api_model
 
         ui_host = get_api_host().replace("/api/v1/tracking", "").replace("api", "app")
-        link = f"{ui_host}/projects/{get_api_project()}/project-overview"
+        link = f"{ui_host}/projects/{get_api_model()}/project-overview"
         results_link = f"""
         <h3>
             Check out the updated documentation in your

{validmind-2.4.1.dist-info → validmind-2.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: validmind
-Version: 2.4.1
+Version: 2.4.5
 Summary: ValidMind Developer Framework
 License: Commercial License
 Author: Andres Rodriguez
@@ -32,7 +32,7 @@ Requires-Dist: mistune (>=3.0.2,<4.0.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numba (<0.59.0)
 Requires-Dist: numpy
-Requires-Dist: openai (>=1) ; extra == "all" or extra == "llm"
+Requires-Dist: openai (>=1) ; extra == "all"
 Requires-Dist: pandas (>=1.1,<2)
 Requires-Dist: plotly
 Requires-Dist: plotly-express
@@ -46,6 +46,7 @@ Requires-Dist: scikit-learn
 Requires-Dist: scipy
 Requires-Dist: scorecardpy (>=0.1.9.6,<0.2.0.0)
 Requires-Dist: seaborn
+Requires-Dist: sentencepiece (>=0.2.0,<0.3.0) ; extra == "all" or extra == "huggingface" or extra == "llm"
 Requires-Dist: sentry-sdk (>=1.24.0,<2.0.0)
 Requires-Dist: shap (>=0.42.0,<0.43.0)
 Requires-Dist: statsmodels
@@ -53,7 +54,7 @@ Requires-Dist: tabulate (>=0.8.9,<0.9.0)
 Requires-Dist: textblob (>=0.18.0.post0,<0.19.0)
 Requires-Dist: torch (>=1.10.0) ; extra == "all" or extra == "llm" or extra == "pytorch"
 Requires-Dist: tqdm
-Requires-Dist: transformers (>=4.32.0,<5.0.0) ; extra == "all" or extra == "llm" or extra == "huggingface"
+Requires-Dist: transformers (>=4.32.0,<5.0.0) ; extra == "all" or extra == "huggingface" or extra == "llm"
 Requires-Dist: xgboost (>=1.5.2,<3)
 Requires-Dist: ydata-profiling
 Description-Content-Type: text/markdown