validmind 2.1.1__py3-none-any.whl → 2.2.4__py3-none-any.whl

validmind/models/foundation.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 import pandas as pd
 
 from validmind.logging import get_logger
-from validmind.vm_models.model import ModelAttributes, VMModel
+from validmind.models.function import FunctionModel
 
 logger = get_logger(__name__)
 
@@ -18,7 +18,7 @@ class Prompt:
     variables: list
 
 
-class FoundationModel(VMModel):
+class FoundationModel(FunctionModel):
     """FoundationModel class wraps a Foundation LLM endpoint
 
     This class wraps a predict function that is user-defined and adapts it to works
@@ -29,22 +29,14 @@ class FoundationModel(VMModel):
           and return the result from the model
         prompt (Prompt): The prompt object that defines the prompt template and the
           variables (if any)
-        attributes (ModelAttributes, optional): The attributes of the model. Defaults to None.
+        name (str, optional): The name of the model. Defaults to name of the predict_fn
     """
 
-    def __init__(
-        self,
-        predict_fn: callable,
-        prompt: Prompt,  # prompt used for model (for now just a string)
-        attributes: ModelAttributes = None,
-        input_id: str = None,
-    ):
-        super().__init__(
-            attributes=attributes,
-            input_id=input_id,
-        )
-        self.predict_fn = predict_fn
-        self.prompt = prompt
+    def __post_init__(self):
+        if not getattr(self, "predict_fn") or not callable(self.predict_fn):
+            raise ValueError("FoundationModel requires a callable predict_fn")
+
+        self.name = self.name or self.predict_fn.__name__
 
     def _build_prompt(self, x: pd.DataFrame):
         """
@@ -59,21 +51,3 @@ class FoundationModel(VMModel):
         Predict method for the model. This is a wrapper around the model's
         """
         return [self.predict_fn(self._build_prompt(x[1])) for x in X.iterrows()]
-
-    def model_library(self):
-        """
-        Returns the model library name
-        """
-        return "FoundationModel"
-
-    def model_class(self):
-        """
-        Returns the model class name
-        """
-        return "FoundationModel"
-
-    def model_name(self):
-        """
-        Returns model name
-        """
-        return "FoundationModel"

validmind/models/function.py

@@ -0,0 +1,51 @@
+# 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 validmind.vm_models.model import VMModel
+
+
+# semi-immutable dict
+class Input(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._new = set()
+
+    def __setitem__(self, key, value):
+        self._new.add(key)
+        super().__setitem__(key, value)
+
+    def __delitem__(self, _):
+        raise TypeError("Cannot delete keys from Input")
+
+    def get_new(self):
+        return {k: self[k] for k in self._new}
+
+
+class FunctionModel(VMModel):
+    """
+    FunctionModel class wraps a user-defined predict function
+
+    Attributes:
+        predict_fn (callable): The predict function that should take a dictionary of
+            input features and return a prediction.
+        input_id (str, optional): The input ID for the model. Defaults to None.
+        name (str, optional): The name of the model. Defaults to the name of the predict_fn.
+    """
+
+    def __post_init__(self):
+        if not getattr(self, "predict_fn") or not callable(self.predict_fn):
+            raise ValueError("FunctionModel requires a callable predict_fn")
+
+        self.name = self.name or self.predict_fn.__name__
+
+    def predict(self, X):
+        """Compute predictions for the input (X)
+
+        Args:
+            X (pandas.DataFrame): The input features to predict on
+
+        Returns:
+            list: The predictions
+        """
+        return [self.predict_fn(x) for x in X.to_dict(orient="records")]

validmind/models/huggingface.py

@@ -4,41 +4,32 @@
 
 from dataclasses import dataclass
 
-import pandas as pd
-
 from validmind.errors import MissingOrInvalidModelPredictFnError
 from validmind.logging import get_logger
-from validmind.vm_models.model import (
-    ModelAttributes,
-    VMModel,
-    has_method_with_arguments,
-)
+from validmind.vm_models.model import VMModel, has_method_with_arguments
 
 logger = get_logger(__name__)
 
 
 @dataclass
 class HFModel(VMModel):
-    """
-    An Hugging Face model class that wraps a trained model instance and its associated data.
-
-    Attributes:
-        attributes (ModelAttributes, optional): The attributes of the model. Defaults to None.
-        model (object, optional): The trained model instance. Defaults to None.
-    """
-
     def __init__(
         self,
         input_id: str = None,
-        model: object = None,  # Trained model instance
-        attributes: ModelAttributes = None,
+        model: object = None,
+        attributes: object = None,
+        name: str = None,
+        **kwargs,
     ):
         super().__init__(
-            model=model,
-            input_id=input_id,
-            attributes=attributes,
+            input_id=input_id, model=model, attributes=attributes, name=name, **kwargs
         )
 
+    def __post_init__(self):
+        self.library = self.model.__class__.__module__.split(".")[0]
+        self.class_ = self.model.__class__.__name__
+        self.name = self.name or type(self.model).__name__
+
     def predict_proba(self, *args, **kwargs):
         """
         Invoke predict_proba from underline model
@@ -57,36 +48,15 @@ class HFModel(VMModel):
         Predict method for the model. This is a wrapper around the HF model's pipeline function
         """
         results = self.model([str(datapoint) for datapoint in data])
-
         tasks = self.model.__class__.__module__.split(".")
 
         if "text2text_generation" in tasks:
-            return pd.DataFrame(results).summary_text.values
+            return [result["summary_text"] for result in results]
         elif "text_classification" in tasks:
-            return pd.DataFrame(results).label.values
+            return [result["label"] for result in results]
         elif tasks[-1] == "feature_extraction":
-            # extract [CLS] token embedding for each input and wrap in dataframe
-            return pd.DataFrame([embedding[0][0] for embedding in results])
+            # 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
-
-    def model_library(self):
-        """
-        Returns the model library name
-        """
-        return self.model.__class__.__module__.split(".")[0]
-
-    def model_class(self):
-        """
-        Returns the model class name
-        """
-        return self.model.__class__.__name__
-
-    def model_name(self):
-        """
-        Returns model name
-        """
-        return type(self.model).__name__
-
-    def is_pytorch_model(self):
-        return self.model_library() == "torch"

validmind/models/metadata.py

@@ -0,0 +1,42 @@
+# 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 validmind.errors import MissingOrInvalidModelPredictFnError
+from validmind.vm_models.model import VMModel
+
+
+class MetadataModel(VMModel):
+    """
+    MetadataModel is designed to represent a model that is not available for inference
+    for various reasons but for which metadata and pre-computed predictions are available.
+
+    Model attributes are required since this will be the only information we can
+    collect and log about the model.
+
+    This class should not be instantiated directly. Instead call `vm.init_model()` and
+    pass in a dictionary with the required metadata as `attributes`.
+
+    Attributes:
+        attributes (ModelAttributes): The attributes of the model. Required.
+        input_id (str, optional): The input ID for the model. Defaults to None.
+        name (str, optional): The name of the model. Defaults to the class name.
+    """
+
+    def __post_init__(self):
+        if not getattr(self, "attributes"):
+            raise ValueError("MetadataModel requires attributes")
+
+        self.name = self.name or "Metadata Model"
+
+    def predict(self, *args, **kwargs):
+        """Not implemented for MetadataModel"""
+        raise MissingOrInvalidModelPredictFnError(
+            "MetadataModel does not support inference"
+        )
+
+    def predict_proba(self, *args, **kwargs):
+        """Not implemented for MetadataModel"""
+        raise MissingOrInvalidModelPredictFnError(
+            "MetadataModel does not support inference"
+        )

validmind/models/pipeline.py

@@ -0,0 +1,66 @@
+# 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 validmind.logging import get_logger
+from validmind.vm_models.model import ModelAttributes, ModelPipeline, VMModel
+
+logger = get_logger(__name__)
+
+
+class PipelineModel(VMModel):
+    """
+    An base class that wraps a trained model instance and its associated data.
+
+    Attributes:
+        pipeline (ModelPipeline): A pipeline of models to be executed. ModelPipeline
+            is just a simple container class with a list that can be chained with the
+            `|` operator.
+        input_id (str, optional): The input ID for the model. Defaults to None.
+        attributes (ModelAttributes, optional): The attributes of the model. Defaults to None.
+        name (str, optional): The name of the model. Defaults to the class name.
+    """
+
+    predict_col: str = None
+
+    def __init__(
+        self,
+        pipeline: ModelPipeline,
+        attributes: ModelAttributes = None,
+        input_id: str = None,
+        name: str = None,
+    ):
+        self.pipeline = pipeline
+        self.input_id = input_id
+
+        self.language = "Python"
+        self.library = self.__class__.__name__
+        self.library_version = "N/A"
+        self.class_ = self.__class__.__name__
+
+        self.name = name or self.__class__.__name__
+
+        self.attributes = attributes
+
+    def __or__(self, other):
+        if not isinstance(other, VMModel):
+            raise ValueError("Can only chain VMModel objects")
+
+        return ModelPipeline([self, other])
+
+    def serialize(self):
+        """
+        Serializes the model to a dictionary so it can be sent to the API
+        """
+        return {
+            "attributes": self.attributes.__dict__,
+        }
+
+    def predict(self, X):
+        X = X.copy()
+
+        for model in self.pipeline.models:
+            predictions = model.predict(X)
+            X[model.input_id] = predictions
+
+        return predictions

validmind/models/pytorch.py

@@ -4,37 +4,21 @@
 
 from validmind.errors import MissingOrInvalidModelPredictFnError
 from validmind.logging import get_logger
-from validmind.vm_models.model import (
-    ModelAttributes,
-    VMModel,
-    has_method_with_arguments,
-)
+from validmind.vm_models.model import VMModel, has_method_with_arguments
 
 logger = get_logger(__name__)
 
 
 class PyTorchModel(VMModel):
-    """
-    An PyTorch model class that wraps a trained model instance and its associated data.
+    """PyTorchModel class wraps a PyTorch model"""
 
-    Attributes:
-        attributes (ModelAttributes, optional): The attributes of the model. Defaults to None.
-        model (object, optional): The trained model instance. Defaults to None.
-        device_type(str, optional) The device where model is trained
-    """
+    def __post_init__(self):
+        if not self.model:
+            raise ValueError("Model object is a required argument for PyTorchModel")
 
-    def __init__(
-        self,
-        model: object = None,  # Trained model instance
-        input_id: str = None,
-        attributes: ModelAttributes = None,
-    ):
-        super().__init__(
-            model=model,
-            input_id=input_id,
-            attributes=attributes,
-        )
-        self._device_type = next(self.model.parameters()).device
+        self.library = "torch"
+        self.name = self.name or "PyTorch Neural Network"
+        self.device_type = next(self.model.parameters()).device
 
     def predict_proba(self, *args, **kwargs):
         """
@@ -61,21 +45,3 @@ class PyTorchModel(VMModel):
         import torch
 
         return self.model.predict(torch.tensor(args[0]).to(self.device_type))
-
-    def model_library(self):
-        """
-        Returns the model library name
-        """
-        return "torch"
-
-    def model_class(self):
-        """
-        Returns the model class name
-        """
-        return "PyTorchModel"
-
-    def model_name(self):
-        """
-        Returns model architecture
-        """
-        return "PyTorch Neural Networks"

validmind/models/r_model.py

@@ -6,7 +6,7 @@ import numpy as np
 import pandas as pd
 
 from validmind.logging import get_logger
-from validmind.vm_models.model import ModelAttributes, VMModel
+from validmind.vm_models.model import VMModel
 
 logger = get_logger(__name__)
 
@@ -16,49 +16,23 @@ def get_full_class_name(obj):
 
 
 class RModel(VMModel):
-    """
-    An R model class that wraps a "fitted" R model instance and its associated data.
-
-    Attributes:
-        attributes (ModelAttributes, optional): The attributes of the model. Defaults to None.
-        model (object, optional): The trained model instance. Defaults to None.
-        device_type(str, optional) The device where model is trained
-    """
-
-    def __init__(
-        self,
-        r: object = None,  # R instance
-        model: object = None,  # Trained model instance
-        attributes: ModelAttributes = None,
-    ):
-        self.r = r
-        self._is_classification_model = False
-
-        super().__init__(
-            model=model,
-            attributes=attributes,
+    """An R model class that wraps a "fitted" R model instance and its associated data."""
+
+    def __post_init__(self):
+        self.language = self.r["version"].rx2("version.string")[0]
+        self.library = self.class_ = "R"
+
+        name_map = {
+            "xgb.Booster": "XGBoost",
+            "glm": self.__glm_model_class(),
+            "lm": "Linear Regression",
+        }
+        self.name = self.name or name_map.get(
+            self.__model_class(), self.__model_class()
         )
 
         self._is_classification_model = self.__is_classification_model()
 
-    def __get_predict_data_as_df(self, new_data):
-        """
-        Builds the correct data shape and format for the predict method when the
-        caller has passed a Pandas dataframe as input. This function makes sure to
-        adjust the shape of the input dataset to the predict() signature depending
-        if it's a regular R model or an XGBoost model
-        """
-        if self.__model_class() == "xgb.Booster":
-            return new_data.df.drop(new_data.target_column, axis=1)
-
-        return new_data.df
-
-    def __model_class(self):
-        """
-        Returns the model class name
-        """
-        return self.r["class"](self.model)[0]
-
     def __is_classification_model(self):
         """
         Only supported classification models are XGBClassifier and GLM with binomial family (logistic regression).
@@ -78,6 +52,24 @@ class RModel(VMModel):
 
         return False
 
+    def __get_predict_data_as_df(self, new_data):
+        """
+        Builds the correct data shape and format for the predict method when the
+        caller has passed a Pandas dataframe as input. This function makes sure to
+        adjust the shape of the input dataset to the predict() signature depending
+        if it's a regular R model or an XGBoost model
+        """
+        if self.__model_class() == "xgb.Booster":
+            return new_data.df.drop(new_data.target_column, axis=1)
+
+        return new_data.df
+
+    def __model_class(self):
+        """
+        Returns the model class name
+        """
+        return self.r["class"](self.model)[0]
+
     def __glm_model_class(self):
         """
         Returns the model class name for GLM models which include family and link function
@@ -142,9 +134,7 @@ class RModel(VMModel):
 
         if new_data_class == "numpy.ndarray":
             # We need to reconstruct the DataFrame from the ndarray using the column names
-            new_data = pd.DataFrame(
-                new_data, columns=self.test_ds.get_features_columns()
-            )
+            new_data = pd.DataFrame(new_data, columns=self.test_ds.feature_columns)
         elif new_data_class != "pandas.core.frame.DataFrame":
             raise ValueError(
                 f"new_data must be a DataFrame or ndarray. Got {new_data_class}"
@@ -163,45 +153,6 @@ class RModel(VMModel):
 
         return predicted_probs
 
-    def model_language(self):
-        """
-        Returns the model library name
-        """
-        return self.r["version"].rx2("version.string")[0]
-
-    def model_library(self):
-        """
-        Returns the model library name
-        """
-        return "R"
-
-    def model_library_version(self, *args, **kwargs):
-        """
-        Model framework library version
-        """
-        return "N/A"
-
-    def model_class(self):
-        """
-        Returns the model class name
-        """
-        return "R"
-
-    def model_name(self):
-        """
-        Returns model name
-        """
-        model_class_name = self.__model_class()
-
-        if model_class_name == "lm":
-            return "Linear Regression"
-        elif model_class_name == "xgb.Booster":
-            return "XGBoost"
-        elif model_class_name == "glm":
-            return self.__glm_model_class()
-
-        return model_class_name
-
     def regression_coefficients(self):
         """
         Returns the regression coefficients summary of the model

validmind/models/sklearn.py

@@ -2,38 +2,23 @@
 # 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
+
 from validmind.errors import MissingOrInvalidModelPredictFnError
 from validmind.logging import get_logger
-from validmind.vm_models.model import (
-    ModelAttributes,
-    VMModel,
-    has_method_with_arguments,
-)
+from validmind.vm_models.model import VMModel, has_method_with_arguments
 
 logger = get_logger(__name__)
 
 
 class SKlearnModel(VMModel):
-    """
-    An SKlearn model class that wraps a trained model instance and its associated data.
-
-    Attributes:
-        attributes (ModelAttributes, optional): The attributes of the model. Defaults to None.
-        model (object, optional): The trained model instance. Defaults to None.
-        device_type(str, optional) The device where model is trained
-    """
-
-    def __init__(
-        self,
-        model: object = None,  # Trained model instance
-        input_id: str = None,
-        attributes: ModelAttributes = None,
-    ):
-        super().__init__(
-            model=model,
-            input_id=input_id,
-            attributes=attributes,
-        )
+    def __post_init__(self):
+        if not self.model:
+            raise ValueError("Model object is a required argument for SKlearnModel")
+
+        self.library = self.model.__class__.__module__.split(".")[0]
+        self.class_ = self.model.__class__.__name__
+        self.name = self.name or type(self.model).__name__
 
     def predict_proba(self, *args, **kwargs):
         """
@@ -54,20 +39,36 @@ class SKlearnModel(VMModel):
         """
         return self.model.predict(*args, **kwargs)
 
-    def model_library(self):
-        """
-        Returns the model library name
-        """
-        return self.model.__class__.__module__.split(".")[0]
 
-    def model_class(self):
-        """
-        Returns the model class name
-        """
-        return self.model.__class__.__name__
+class CatBoostModel(SKlearnModel):
+    """Wrapper for CatBoost model"""
+
+    pass
+
 
-    def model_name(self):
+class XGBoostModel(SKlearnModel):
+    """Wrapper for XGBoost model"""
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.library = "xgboost"
+
+
+class StatsModelsModel(SKlearnModel):
+    """Wrapper for StatsModels model"""
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.library = "statsmodels"
+
+    def regression_coefficients(self):
         """
-        Returns model name
+        Returns the regression coefficients summary of the model
         """
-        return type(self.model).__name__
+        raw_summary = self.model.summary()
+
+        table = raw_summary.tables[1].data
+        headers = table.pop(0)
+        headers[0] = "Feature"
+
+        return pd.DataFrame(table, columns=headers)