validmind 2.8.29__py3-none-any.whl → 2.9.2__py3-none-any.whl

validmind/unit_metrics/classification/individual/ProbabilityError.py

@@ -0,0 +1,54 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+from typing import List
+
+import numpy as np
+
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset, VMModel
+
+
+@tasks("classification")
+@tags("classification")
+def ProbabilityError(model: VMModel, dataset: VMDataset, **kwargs) -> List[float]:
+    """Calculates the probability error per row for a classification model.
+
+    For binary classification tasks, this computes the absolute difference between
+    the true class labels (0 or 1) and the predicted probabilities for each row.
+    This provides insight into how confident the model's predictions are and
+    how far off they are from the actual labels.
+
+    Args:
+        model: The classification model to evaluate
+        dataset: The dataset containing true labels and predicted probabilities
+        **kwargs: Additional parameters (unused for compatibility)
+
+    Returns:
+        List[float]: Per-row probability errors as a list of float values
+
+    Raises:
+        ValueError: If probability column is not found for the model
+    """
+    y_true = dataset.y
+
+    # Try to get probabilities, fall back to predictions if not available
+    try:
+        y_prob = dataset.y_prob(model)
+        # For binary classification, use the positive class probability
+        if y_prob.ndim > 1 and y_prob.shape[1] > 1:
+            y_prob = y_prob[:, 1]  # Use probability of positive class
+    except ValueError:
+        # Fall back to predictions if probabilities not available
+        y_prob = dataset.y_pred(model)
+
+    # Convert to numpy arrays and ensure same data type
+    y_true = np.asarray(y_true, dtype=float)
+    y_prob = np.asarray(y_prob, dtype=float)
+
+    # Compute absolute difference between true labels and predicted probabilities
+    probability_errors = np.abs(y_true - y_prob)
+
+    # Return as a list of floats
+    return probability_errors.tolist()

validmind/unit_metrics/classification/individual/Uncertainty.py

@@ -0,0 +1,60 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+from typing import List
+
+import numpy as np
+
+from validmind import tags, tasks
+from validmind.vm_models import VMDataset, VMModel
+
+
+@tasks("classification")
+@tags("classification")
+def Uncertainty(model: VMModel, dataset: VMDataset, **kwargs) -> List[float]:
+    """Calculates the prediction uncertainty per row for a classification model.
+
+    Uncertainty is measured using the entropy of the predicted probability distribution.
+    Higher entropy indicates higher uncertainty in the prediction. For binary
+    classification, maximum uncertainty occurs at probability 0.5.
+
+    Args:
+        model: The classification model to evaluate
+        dataset: The dataset containing true labels and predicted probabilities
+        **kwargs: Additional parameters (unused for compatibility)
+
+    Returns:
+        List[float]: Per-row uncertainty scores as a list of float values
+
+    Raises:
+        ValueError: If probability column is not found for the model
+    """
+    # Try to get probabilities
+    try:
+        y_prob = dataset.y_prob(model)
+
+        if y_prob.ndim > 1 and y_prob.shape[1] > 1:
+            # Multi-class: calculate entropy across all classes
+            # Clip to avoid log(0)
+            y_prob_clipped = np.clip(y_prob, 1e-15, 1 - 1e-15)
+            # Entropy: -sum(p * log(p))
+            uncertainty = -np.sum(y_prob_clipped * np.log(y_prob_clipped), axis=1)
+        else:
+            # Binary classification: calculate binary entropy
+            y_prob = np.asarray(y_prob, dtype=float)
+            # Clip to avoid log(0)
+            y_prob_clipped = np.clip(y_prob, 1e-15, 1 - 1e-15)
+            # Binary entropy: -[p*log(p) + (1-p)*log(1-p)]
+            uncertainty = -(
+                y_prob_clipped * np.log(y_prob_clipped)
+                + (1 - y_prob_clipped) * np.log(1 - y_prob_clipped)
+            )
+
+    except ValueError:
+        # If no probabilities available, assume zero uncertainty for hard predictions
+        n_samples = len(dataset.y)
+        uncertainty = np.zeros(n_samples)
+
+    # Return as a list of floats
+    return uncertainty.tolist()

validmind/vm_models/dataset/dataset.py

@@ -8,7 +8,7 @@ Dataset class wrapper
 
 import warnings
 from copy import deepcopy
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -458,6 +458,152 @@ class VMDataset(VMInput):
 
         return self.extra_columns.probability_column(model, column_name)
 
+    def assign_scores(
+        self,
+        model: VMModel,
+        metrics: Union[str, List[str]],
+        **kwargs: Dict[str, Any],
+    ) -> None:
+        """Assign computed unit metric scores to the dataset as new columns.
+
+        This method computes unit metrics for the given model and dataset, then adds
+        the computed scores as new columns to the dataset using the naming convention:
+        {model.input_id}_{metric_name}
+
+        Args:
+            model (VMModel): The model used to compute the scores.
+            metrics (Union[str, List[str]]): Single metric ID or list of metric IDs.
+                Can be either:
+                - Short name (e.g., "F1", "Precision")
+                - Full metric ID (e.g., "validmind.unit_metrics.classification.F1")
+            **kwargs: Additional parameters passed to the unit metrics.
+
+        Examples:
+            # Single metric
+            dataset.assign_scores(model, "F1")
+
+            # Multiple metrics
+            dataset.assign_scores(model, ["F1", "Precision", "Recall"])
+
+            # With parameters
+            dataset.assign_scores(model, "ROC_AUC", average="weighted")
+
+        Raises:
+            ValueError: If the model input_id is None or if metric computation fails.
+            ImportError: If unit_metrics module cannot be imported.
+        """
+        if model.input_id is None:
+            raise ValueError("Model input_id must be set to use assign_scores")
+
+        # Import unit_metrics module
+        try:
+            from validmind.unit_metrics import run_metric
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import unit_metrics module: {e}. "
+                "Make sure validmind.unit_metrics is available."
+            ) from e
+
+        # Normalize metrics to a list
+        if isinstance(metrics, str):
+            metrics = [metrics]
+
+        # Process each metric
+        for metric in metrics:
+            # Normalize metric ID
+            metric_id = self._normalize_metric_id(metric)
+
+            # Extract metric name for column naming
+            metric_name = self._extract_metric_name(metric_id)
+
+            # Generate column name
+            column_name = f"{model.input_id}_{metric_name}"
+
+            try:
+                # Run the unit metric
+                result = run_metric(
+                    metric_id,
+                    inputs={
+                        "model": model,
+                        "dataset": self,
+                    },
+                    params=kwargs,
+                    show=False,  # Don't show widget output
+                )
+
+                # Extract the metric value
+                metric_value = result.metric
+
+                # Create column values (repeat the scalar value for all rows)
+                if np.isscalar(metric_value):
+                    column_values = np.full(len(self._df), metric_value)
+                else:
+                    if len(metric_value) != len(self._df):
+                        raise ValueError(
+                            f"Metric value length {len(metric_value)} does not match dataset length {len(self._df)}"
+                        )
+                    column_values = metric_value
+
+                # Add the column to the dataset
+                self.add_extra_column(column_name, column_values)
+
+                logger.info(f"Added metric column '{column_name}'")
+            except Exception as e:
+                logger.error(f"Failed to compute metric {metric_id}: {e}")
+                raise ValueError(f"Failed to compute metric {metric_id}: {e}") from e
+
+    def _normalize_metric_id(self, metric: str) -> str:
+        """Normalize metric identifier to full validmind unit metric ID.
+
+        Args:
+            metric (str): Metric identifier (short name or full ID)
+
+        Returns:
+            str: Full metric ID
+        """
+        # If already a full ID, return as-is
+        if metric.startswith("validmind.unit_metrics."):
+            return metric
+
+        # Try to find the metric by short name
+        try:
+            from validmind.unit_metrics import list_metrics
+
+            available_metrics = list_metrics()
+
+            # Look for exact match with short name
+            for metric_id in available_metrics:
+                if metric_id.endswith(f".{metric}"):
+                    return metric_id
+
+            # If no exact match found, raise error with suggestions
+            suggestions = [m for m in available_metrics if metric.lower() in m.lower()]
+            if suggestions:
+                raise ValueError(
+                    f"Metric '{metric}' not found. Did you mean one of: {suggestions[:5]}"
+                )
+            else:
+                raise ValueError(
+                    f"Metric '{metric}' not found. Available metrics: {available_metrics[:10]}..."
+                )
+
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import unit_metrics for metric lookup: {e}"
+            ) from e
+
+    def _extract_metric_name(self, metric_id: str) -> str:
+        """Extract the metric name from a full metric ID.
+
+        Args:
+            metric_id (str): Full metric ID
+
+        Returns:
+            str: Metric name
+        """
+        # Extract the last part after the final dot
+        return metric_id.split(".")[-1]
+
     def add_extra_column(self, column_name, column_values=None):
         """Adds an extra column to the dataset without modifying the dataset `features` and `target` columns.
 

validmind/vm_models/result/result.py

@@ -7,6 +7,7 @@ Result objects for test results
 """
 import asyncio
 import json
+import os
 from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Union
@@ -20,7 +21,7 @@ from ipywidgets import HTML, VBox
 from ... import api_client
 from ...ai.utils import DescriptionFuture
 from ...errors import InvalidParameterError
-from ...logging import get_logger
+from ...logging import get_logger, log_api_operation
 from ...utils import (
     HumanReadableEncoder,
     NumpyEncoder,
@@ -177,7 +178,7 @@ class TestResult(Result):
     title: Optional[str] = None
     doc: Optional[str] = None
     description: Optional[Union[str, DescriptionFuture]] = None
-    metric: Optional[Union[int, float]] = None
+    metric: Optional[Union[int, float, List[Union[int, float]]]] = None
     tables: Optional[List[ResultTable]] = None
     raw_data: Optional[RawData] = None
     figures: Optional[List[Figure]] = None
@@ -476,9 +477,30 @@ class TestResult(Result):
             )
 
         if self.figures:
-            tasks.extend(
-                [api_client.alog_figure(figure) for figure in (self.figures or [])]
+            batch_size = min(
+                len(self.figures), int(os.getenv("VM_FIGURE_MAX_BATCH_SIZE", 20))
             )
+            figure_batches = [
+                self.figures[i : i + batch_size]
+                for i in range(0, len(self.figures), batch_size)
+            ]
+
+            async def upload_figures_in_batches():
+                for batch in figure_batches:
+
+                    @log_api_operation(
+                        operation_name=f"Uploading batch of {len(batch)} figures"
+                    )
+                    async def process_batch():
+                        batch_tasks = [
+                            api_client.alog_figure(figure) for figure in batch
+                        ]
+                        return await asyncio.gather(*batch_tasks)
+
+                    await process_batch()
+
+            tasks.append(upload_figures_in_batches())
+
         if self.description:
             revision_name = (
                 AI_REVISION_NAME

{validmind-2.8.29.dist-info → validmind-2.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: validmind
-Version: 2.8.29
+Version: 2.9.2
 Summary: ValidMind Library
 License: Commercial License
 Author: Andres Rodriguez
@@ -24,7 +24,7 @@ Requires-Dist: datasets (>=2.10.0,<3.0.0)
 Requires-Dist: evaluate
 Requires-Dist: h11 (>=0.16.0)
 Requires-Dist: ipywidgets
-Requires-Dist: kaleido (>=0.2.1,!=0.2.1.post1)
+Requires-Dist: kaleido (>=0.2.1,!=0.2.1.post1,<1.0.0)
 Requires-Dist: langchain-openai (>=0.1.8) ; extra == "all" or extra == "llm"
 Requires-Dist: langdetect
 Requires-Dist: llvmlite ; python_version >= "3.8" and python_full_version <= "3.11.0"

{validmind-2.8.29.dist-info → validmind-2.9.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
 validmind/__init__.py,sha256=7nOHbSRUKtpIuHvf6oQd4D9_R8oh1PQ2CkeU62S14A0,4329
-validmind/__version__.py,sha256=6FQh-CGg741faEnufOSp2cRuF5ODdGQ7-BxZ8EkOrrU,23
-validmind/ai/test_descriptions.py,sha256=eBF09MAyqAAD-Ah7vxXVRbHxOmGx5_10ZkoJmMvEaEA,7123
-validmind/ai/utils.py,sha256=IkqDCBiZiDQ95ElCZpi5sVgmNDiSushmF7wAizAO-74,8497
-validmind/api_client.py,sha256=WNAdiYc2NctAFc2itLdz-0mf3_4JPghW4pPF_VAn5jw,16970
+validmind/__version__.py,sha256=2wNk1TdqAeMl8njYHKnxyR5LsTqRh1L9eYia7D6rWHg,22
+validmind/ai/test_descriptions.py,sha256=CzeXPfdJaZyPcXWnxchPBIAx1Om-MxShLdCWDDd-gyI,6981
+validmind/ai/utils.py,sha256=2VEOS2W37FtTvWqcHmG1Mys5BTuTSxrUhvpA2G2fvP0,7600
+validmind/api_client.py,sha256=AcnyaZF1t4HoeHyGmUPVPI2YhYP5iKoNFrMdxc4iHQ0,16711
 validmind/client.py,sha256=XKb4uc7yXVV_3NH9-zTrS9jCbLPX2zZZU12vKKlSpIc,19049
 validmind/client_config.py,sha256=O1gopTaNADM4ZVPj383AJTjcpjdxyEvUQY5cFt7nbIs,1366
 validmind/datasets/__init__.py,sha256=c0hQZN_6GrUEJxdFHdQaEsQrSYNABG84ZCY0H-PzOZk,260
@@ -65,7 +65,7 @@ validmind/experimental/agents.py,sha256=UAn62qflCYnzS1m2XL_y3xUNaw0PJr9dRvNb-c-r
 validmind/html_templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 validmind/html_templates/content_blocks.py,sha256=vFMRS4Ogq4RZq88WzG3teNEOq3U4OLgLDzD3lBx4h-g,4050
 validmind/input_registry.py,sha256=bgZqJhrBCDoTV54Eq6YhNcU9yn5GjH0aidDwrnKm_pI,1043
-validmind/logging.py,sha256=NKI4g4MFO1tZRE5G_g6gZU0knRRtsYoD3uPQHT7or58,5457
+validmind/logging.py,sha256=FuLfiGGJp2PbQpdU4Z8F-6lQkAh_v5PXIUgvhBqWjxA,7013
 validmind/models/__init__.py,sha256=lraTbNwoKckXNP3Dbyj-euI78UTkZ_w5wpUOb8l5nWs,729
 validmind/models/foundation.py,sha256=wqVyOps3_tZtkOH9sVXPbv2Sh-EYtPuFfat7_hiKSyk,1854
 validmind/models/function.py,sha256=pwP_4pIQ1Jbh3JVKnsyEPc5wP23AbSPHDeWvqE6zbWA,2373
@@ -89,8 +89,8 @@ validmind/test_suites/summarization.py,sha256=VKwcbf9PD-hnPkDlYJWZKW4nHyOnI4q6Y3
 validmind/test_suites/tabular_datasets.py,sha256=WE4eLzRCfiqAxRqXnZFRR3Lo_u-TI6KM6hmTbR8rg5o,1798
 validmind/test_suites/text_data.py,sha256=YGVGBB05356jN9Gzcy5CHShRzo1fm5mKsZY7YBq0cYU,739
 validmind/test_suites/time_series.py,sha256=3hzWc9gXHBf8aMecD-1YYGFS5RI1o8A-eor9akeBzSU,4403
-validmind/tests/__init__.py,sha256=U6wUS7R8lYFjwUZmAkG7gC8Av9Z4TTDZS7uWZqbzxVM,1665
-validmind/tests/__types__.py,sha256=3if3CVI-YHWQpX0t_8WYh1a6dd01us0oP7r2ZsX2NX0,12589
+validmind/tests/__init__.py,sha256=kEutKQ414BnIj_9l5MnnVxFs5_41UsNFG95dW93ooQY,1691
+validmind/tests/__types__.py,sha256=EYq1XzwnzUCoYvFEA7LXBAS9Egs_3_oUPOxADZ7O3gA,13654
 validmind/tests/_store.py,sha256=W867LRVOuvuGKxWZuGwKaQr7jXc81MA0oogNebfSwx4,2685
 validmind/tests/comparison.py,sha256=3s0kiCtgzU5x6HBo9eGtBR8pVKD92O5OAg9Dl-GTHts,14723
 validmind/tests/data_validation/ACFandPACFPlot.py,sha256=KEpr-WjdfQah3fEuBWvoHDKAxrb8dYjFFJpwZhqAMmY,4380
@@ -278,7 +278,12 @@ validmind/tests/ongoing_monitoring/ROCCurveDrift.py,sha256=dN0R2Grr4ZgYJjBRSw5-q
 validmind/tests/ongoing_monitoring/ScoreBandsDrift.py,sha256=If2x6i56uVfqXkAfJSiBsSMsBHU9sMIYfuccpIGlC6s,7826
 validmind/tests/ongoing_monitoring/ScorecardHistogramDrift.py,sha256=tZc3oluyuTDqXVBsXpDnya_416kWCDCmClLMtFkYDDY,7324
 validmind/tests/ongoing_monitoring/TargetPredictionDistributionPlot.py,sha256=Mk7psHw8ymg8rGkxHhufK7WGIM_PJGQ2j9r21j4o5bA,5340
-validmind/tests/output.py,sha256=UXSZDiW_GD411QP2F9r2Vh7uXtb5a2y990bNRZhnZVQ,6153
+validmind/tests/output.py,sha256=0YCVRx51MnsAOrZLAvwHKQTEjgw223JiWs45CKJ_jKk,6473
+validmind/tests/plots/BoxPlot.py,sha256=5N9aEkiN7vo9UNU03GOzcQVfpPVQ4iyMYG96JqnN0-M,8071
+validmind/tests/plots/CorrelationHeatmap.py,sha256=OcluzdbO1FQo6jjGAsc2ek3yBg4qLx5AKLIGWYswkPI,7773
+validmind/tests/plots/HistogramPlot.py,sha256=Ktjidzr_H31yeLkkNKFyyaFn9rKoiaGX3qetLKzsPAc,7315
+validmind/tests/plots/ViolinPlot.py,sha256=AucJUMMttwPfyV7Pz_a9C0DSDanBN1cPHClTL6P_qis,4044
+validmind/tests/plots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 validmind/tests/prompt_validation/Bias.py,sha256=5W1XNPPJnB-TU-x02xWM3GcUXSMSUgLIqs04sEnOyzQ,5940
 validmind/tests/prompt_validation/Clarity.py,sha256=_3RTNA5tEo4OhY5aW466fikT6Kc8WtXK2sftFjl7Bt0,5085
 validmind/tests/prompt_validation/Conciseness.py,sha256=YH3sdiOLkzuFyMMv3TU1EZF8y9tAIN6ucnQlSAUk6M4,4829
@@ -289,6 +294,11 @@ validmind/tests/prompt_validation/Specificity.py,sha256=hEjnSZ5PiKzdRR9lzkreQoW6
 validmind/tests/prompt_validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 validmind/tests/prompt_validation/ai_powered_test.py,sha256=sWMf9fRXAkOpI5JYdhLHmJXlwnthjUDZGoLgCZlQZxo,2240
 validmind/tests/run.py,sha256=ftUCywJbHQ0vbZ7096iz8yq0htLbQbOWhvURjCqiqog,14211
+validmind/tests/stats/CorrelationAnalysis.py,sha256=v-o5TTd5529SGlUUiQUvNQ09brd45K-pgAZ21LGHaKc,8923
+validmind/tests/stats/DescriptiveStats.py,sha256=q8Ovv1x9y-xU4w03DVL5336dHGJ5HnqPWSKKN-4DaZ8,7066
+validmind/tests/stats/NormalityTests.py,sha256=o0bL_niZAHPt0ySjPw_URilkV9lFK6MEMuavg7FYbb4,5062
+validmind/tests/stats/OutlierDetection.py,sha256=hrbixL76jkDzUkKbAa2RN4_Kv09gJxh7t7hTyJmQdkw,5963
+validmind/tests/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 validmind/tests/test_providers.py,sha256=S0_yNYAor_MX5joRJntrVjV8J3ypvUcaaSqtkBqhOsI,6021
 validmind/tests/utils.py,sha256=sPnk9HWIb0IoySqL88h7uP3LixfrfKFgFebnyTUP5EE,3950
 validmind/unit_metrics/__init__.py,sha256=ZKXMtMk7qN9QlapZFyiCcjC3HhjXJXlbQ7E4x0m8wCM,957
@@ -297,6 +307,17 @@ validmind/unit_metrics/classification/F1.py,sha256=INZUraU4T72k8ON6Scmgh0JzRAUMQ
 validmind/unit_metrics/classification/Precision.py,sha256=CGBJy9dpfYnYOho2nB-1YtF_8N0s6NC1PBb1ecqidT8,575
 validmind/unit_metrics/classification/ROC_AUC.py,sha256=fXl9cEhGy4SfLcP02XEY21bwTAV-CHvcIeZSYQIL9jw,1162
 validmind/unit_metrics/classification/Recall.py,sha256=HYna-tAKStoPo51JnNpawDKBEioTg3DFq5YyEaS2b3A,563
+validmind/unit_metrics/classification/individual/AbsoluteError.py,sha256=1tmNXGKGT6PnVHgC4Qs7vb-7ISxEcuiUYLEdtmTYzrI,1515
+validmind/unit_metrics/classification/individual/BrierScore.py,sha256=Ftl9QoE5R5A_l6xW57uDlxVulNL6LZysghdmiTSR798,2062
+validmind/unit_metrics/classification/individual/CalibrationError.py,sha256=Nkrr351Sh14DE6t_xeLe2TdNbH8tVghxLQ_Id9I7a-8,2804
+validmind/unit_metrics/classification/individual/ClassBalance.py,sha256=ccQDEJ3SukCGrgg3kG8IkuLwYcAWBXkhwjKwhBkA8Bo,2338
+validmind/unit_metrics/classification/individual/Confidence.py,sha256=_ZFK4il8HJ2OJPsiyYrBv2vLssDw8KRXhZz1kVRiA4w,2049
+validmind/unit_metrics/classification/individual/Correctness.py,sha256=Gu4-PwqxWJFCj93JUvFmys8YoWypzXSO7KNJiEEf0XI,1344
+validmind/unit_metrics/classification/individual/LogLoss.py,sha256=bVGQdJQBm1SsVxFuiuv8u6bBOt9LUBaJWrpHes5Hkns,2245
+validmind/unit_metrics/classification/individual/OutlierScore.py,sha256=j9wNViBFwbP2vbchZoFfSFEa2Ntx3qY_TcW4HnuVhnI,3107
+validmind/unit_metrics/classification/individual/ProbabilityError.py,sha256=5P-4nvxhXw174CamFsMy41_0vN0kFzWvIoCwT-3jNb0,2030
+validmind/unit_metrics/classification/individual/Uncertainty.py,sha256=BYy6K8tRMFuNQkDUZvsrI1-nVp3X-owYo73QHmyEnBs,2276
+validmind/unit_metrics/classification/individual/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 validmind/unit_metrics/regression/AdjustedRSquaredScore.py,sha256=37aVMrkZ9JbR21_rPcBkgt4JKqU0wFAqyy9zy2juOf4,757
 validmind/unit_metrics/regression/GiniCoefficient.py,sha256=lDJYQPwpRE7dEXQt5a0d7gVaqdUUdVrn2AJ3QzI0Qxc,1115
 validmind/unit_metrics/regression/HuberLoss.py,sha256=po_cA2oEeon-93ekxHIoa4oocwnfRVTSwLwPA_jF8vQ,805
@@ -311,22 +332,22 @@ validmind/unit_metrics/regression/RootMeanSquaredError.py,sha256=QJYK_wVBjzJTa6P
 validmind/utils.py,sha256=59WWVV_JhvxzPr8Y625qw_wsyu_ZVRoLJyi0Pw3MTMU,28613
 validmind/vm_models/__init__.py,sha256=lcqf9q2aRzrVrNN6R--81IkrnSa6BXPbhJ8SnkT_hcI,702
 validmind/vm_models/dataset/__init__.py,sha256=U4CxZjdoc0dd9u2AqBl5PJh1UVbzXWNrmundmjLF-qE,346
-validmind/vm_models/dataset/dataset.py,sha256=stmZ_DnvLQQT_4WRlOXXw9KQNFkCMpz8tID9eE5iqgc,32254
+validmind/vm_models/dataset/dataset.py,sha256=vgpPFh9Ep4tkmGzbzUbQPRf_C6v7_VNWQ2lTSDQukaE,37608
 validmind/vm_models/dataset/utils.py,sha256=g6mBPrBmVYf8wJAlTxeg9DTiNvts4ZaaT5mbnQAPWaU,5638
 validmind/vm_models/figure.py,sha256=ZMO_nIIleNhkBV1vJeF_UUsVDCzrXNOYwV1Lbg9E0XY,6303
 validmind/vm_models/input.py,sha256=nTBQB6aqirhF-0Gmg5mYc4_vNyypvbYUfahMovcK02M,1095
 validmind/vm_models/model.py,sha256=s9pPIprHrju-qmGbzOZBcSHjZ_xgSv5ACXk92U1hEFY,6489
 validmind/vm_models/result/__init__.py,sha256=c0vMWMSY0O6ZeSCf0HfrWAI5t--4FKLEW5cZ2EZ70Ms,443
 validmind/vm_models/result/result.jinja,sha256=Yvovwm5gInCBukFRlvJXNlDIUpl2eFz4dz1lS3Sn_Gc,311
-validmind/vm_models/result/result.py,sha256=2Y1BwJ38YCp6rmPwENXp6q5xQ6utqxKX9C-e-il21gI,21283
+validmind/vm_models/result/result.py,sha256=UcIHi67gnIZ1X6Q6W9HbZA8UIMupPTB2-aqfT5wo1HI,22097
 validmind/vm_models/result/utils.py,sha256=kjU8yaDBX874gebdKLA2KcCyW6ojk_nSTBZxHG7Gszc,4155
 validmind/vm_models/test_suite/__init__.py,sha256=tfTYd8yvzsDXzk5WDKMwCzPAbvkVUyEvtY5z5BPy-zk,215
 validmind/vm_models/test_suite/runner.py,sha256=JqW8LW4X1Ri2C6wSsAGSki-JxGUGV8zmruOnxybmZ1s,5432
 validmind/vm_models/test_suite/summary.py,sha256=7P4zhfeU7a3I1MMBn8f7s-2lzdAz7U4y6LblpR89_vE,5401
 validmind/vm_models/test_suite/test.py,sha256=C8xPGKSyYF9oMJ3VegwFJDF7cwYlIgtQoQ7nzXIS1uc,3914
 validmind/vm_models/test_suite/test_suite.py,sha256=CciC6IhrLEeWwcpY3Np8EmQCB8XEF2ljwEXcvmNYgZc,5090
-validmind-2.8.29.dist-info/LICENSE,sha256=XonPUfwjvrC5Ombl3y-ko0Wubb1xdG_7nzvIbkZRKHw,35772
-validmind-2.8.29.dist-info/METADATA,sha256=ZeBJF4CRuXpd8aiaxQQGBDbJxMkOz5sKThmWxkpGONg,6061
-validmind-2.8.29.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-validmind-2.8.29.dist-info/entry_points.txt,sha256=HuW7YyOv9u_OEWpViQXtv0nfoI67uieJHawKWA4Hv9A,76
-validmind-2.8.29.dist-info/RECORD,,
+validmind-2.9.2.dist-info/LICENSE,sha256=XonPUfwjvrC5Ombl3y-ko0Wubb1xdG_7nzvIbkZRKHw,35772
+validmind-2.9.2.dist-info/METADATA,sha256=0WjmrpvJ0GiX69Y8AJw4CAnMcimIswh7WGFumNGgvp8,6067
+validmind-2.9.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+validmind-2.9.2.dist-info/entry_points.txt,sha256=HuW7YyOv9u_OEWpViQXtv0nfoI67uieJHawKWA4Hv9A,76
+validmind-2.9.2.dist-info/RECORD,,