autogluon.core 1.2.1b20250220__tar.gz → 1.2.1b20250221__tar.gz

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.core
-Version: 1.2.1b20250220
+Version: 1.2.1b20250221
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/src/autogluon/core/hpo/executors.py

@@ -184,10 +184,10 @@ class HpoExecutor(ABC):
                 self.hyperparameter_tune_kwargs["resources_per_trial"] = {"num_cpus": cpu_per_trial, "num_gpus": gpu_per_trial}
         if "resources_per_trial" not in self.hyperparameter_tune_kwargs:
             # User didn't provide any requirements
-            num_jobs_in_parallel_with_mem = math.inf
 
-            if initialized_model.estimate_memory_usage is not None:
-                model_estimate_memory_usage = initialized_model.estimate_memory_usage(**kwargs)
+            num_jobs_in_parallel_with_mem = math.inf
+            model_estimate_memory_usage = initialized_model.estimate_memory_usage(**kwargs)
+            if model_estimate_memory_usage is not None:
                 total_memory_available = ResourceManager.get_available_virtual_mem()
                 num_jobs_in_parallel_with_mem = total_memory_available // model_estimate_memory_usage
 

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/src/autogluon/core/models/__init__.py

@@ -1,4 +1,4 @@
-from .abstract.abstract_model import AbstractModel
+from .abstract.abstract_model import ModelBase, AbstractModel, Tunable
 from .dummy.dummy_model import DummyModel
 from .ensemble.bagged_ensemble_model import BaggedEnsembleModel
 from .ensemble.stacker_ensemble_model import StackerEnsembleModel

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/src/autogluon/core/models/abstract/abstract_model.py

@@ -9,10 +9,12 @@ import os
 import pickle
 import sys
 import time
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
+from typing_extensions import Self
 
 from autogluon.common.features.feature_metadata import FeatureMetadata
 from autogluon.common.space import Space
@@ -51,7 +53,119 @@ dup_filter = DuplicateFilter()
 logger.addFilter(dup_filter)
 
 
-class AbstractModel:
+class Taggable(ABC):
+    @classmethod
+    def _class_tags(cls) -> dict:
+        return _DEFAULT_CLASS_TAGS
+
+    def _more_tags(self) -> dict:
+        return _DEFAULT_TAGS
+
+    def _get_tags(self) -> dict:
+        """
+        Tags are key-value pairs assigned to an object.
+        These can be accessed after initializing an object.
+        Tags are used for identifying if an object supports certain functionality.
+        """
+        # first get class tags, which are overwritten by any object tags
+        collected_tags = self._get_class_tags()
+        for base_class in reversed(inspect.getmro(self.__class__)):
+            if hasattr(base_class, "_more_tags"):
+                # need the if because mixins might not have _more_tags
+                # but might do redundant work in estimators
+                # (i.e. calling more tags on BaseEstimator multiple times)
+                more_tags = base_class._more_tags(self)
+                collected_tags.update(more_tags)
+        return collected_tags
+
+    @classmethod
+    def _get_class_tags(cls) -> dict:
+        """
+        Class tags are tags assigned to a class that are fixed.
+        These can be accessed prior to initializing an object.
+        Tags are used for identifying if an object supports certain functionality.
+        """
+        collected_tags = {}
+        for base_class in reversed(inspect.getmro(cls)):
+            if hasattr(base_class, "_class_tags"):
+                # need the if because mixins might not have _class_tags
+                # but might do redundant work in estimators
+                # (i.e. calling more tags on BaseEstimator multiple times)
+                more_tags = base_class._class_tags()
+                collected_tags.update(more_tags)
+        return collected_tags
+
+
+# TODO: refactor this class as a clean interface HPO works with. The methods below are not
+# an exhaustive set of all methods the HPO module needs!
+class Tunable(ABC):
+    def estimate_memory_usage(self, *args, **kwargs) -> float | None:
+        """Return the estimated memory usage of the model. None if memory usage cannot be
+        estimated.
+        """
+        return None
+
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
+        return {
+            "num_cpus": 1,
+        }
+
+    # TODO: remove. this is needed by hpo to determine if the model is an ensemble.
+    @abstractmethod
+    def _get_model_base(self) -> "Tunable":
+        pass
+
+    @abstractmethod
+    def get_params(self) -> dict:
+        """Return a clean copy of constructor parameters that can be used to
+        clone the current model.
+        """
+        pass
+        
+    @abstractmethod
+    def hyperparameter_tune(self, *args, **kwargs) -> tuple:
+        pass
+
+
+class ModelBase(Taggable, Tunable, ABC):
+    @abstractmethod
+    def __init__(
+        self,
+        path: str | None = None,
+        name: str | None = None,
+        hyperparameters: dict[str, Any] | None = None,
+    ):
+        self.name: str
+        self.path: str
+
+    @abstractmethod
+    def rename(self, name: str) -> None:
+        pass
+
+    @abstractmethod
+    def get_info(self, *args, **kwargs) -> dict[str, Any]:
+        pass 
+
+    @abstractmethod
+    def fit(self, *args, **kwargs) -> Self:
+        pass
+
+    @abstractmethod
+    def predict(self, *args, **kwargs) -> Any:
+        pass
+
+    @abstractmethod
+    def save(self, path: str | None = None, verbose: bool = True) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def load(cls, path: str, reset_paths: bool = True) -> Self:
+        pass
+
+
+# TODO: move to tabular, rename AbstractTabularModel
+class AbstractModel(ModelBase):
     """
     Abstract model implementation from which all AutoGluon models inherit.
 
@@ -2488,50 +2602,6 @@ class AbstractModel:
     def _features(self) -> List[str]:
         return self._features_internal
 
-    def _get_tags(self) -> dict:
-        """
-        Tags are key-value pairs assigned to an object.
-        These can be accessed after initializing an object.
-        Tags are used for identifying if an object supports certain functionality.
-        """
-        # first get class tags, which are overwritten by any object tags
-        collected_tags = self._get_class_tags()
-        for base_class in reversed(inspect.getmro(self.__class__)):
-            if hasattr(base_class, "_more_tags"):
-                # need the if because mixins might not have _more_tags
-                # but might do redundant work in estimators
-                # (i.e. calling more tags on BaseEstimator multiple times)
-                more_tags = base_class._more_tags(self)
-                collected_tags.update(more_tags)
-        return collected_tags
-
-    @classmethod
-    def _get_class_tags(cls) -> dict:
-        """
-        Class tags are tags assigned to a class that are fixed.
-        These can be accessed prior to initializing an object.
-        Tags are used for identifying if an object supports certain functionality.
-        """
-        collected_tags = {}
-        for base_class in reversed(inspect.getmro(cls)):
-            if hasattr(base_class, "_class_tags"):
-                # need the if because mixins might not have _class_tags
-                # but might do redundant work in estimators
-                # (i.e. calling more tags on BaseEstimator multiple times)
-                more_tags = base_class._class_tags()
-                collected_tags.update(more_tags)
-        return collected_tags
-
-    @classmethod
-    def _class_tags(cls) -> dict:
-        """
-        [Advanced] Optional tags used to communicate model capabilities to AutoML systems, such as if the model supports text features.
-        """
-        return _DEFAULT_CLASS_TAGS
-
-    def _more_tags(self) -> dict:
-        return _DEFAULT_TAGS
-
     def _get_model_base(self):
         return self
 

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/src/autogluon/core/trainer/abstract_trainer.py

@@ -6,11 +6,11 @@ from typing import Any, Generic, Type, TypeVar
 import networkx as nx
 from typing_extensions import Self
 
-from autogluon.core.models import AbstractModel
+from autogluon.core.models import ModelBase 
 from autogluon.core.utils.loaders import load_pkl
 from autogluon.core.utils.savers import save_json, save_pkl
 
-ModelTypeT = TypeVar("ModelTypeT", bound=AbstractModel)
+ModelTypeT = TypeVar("ModelTypeT", bound=ModelBase)
 
 
 class AbstractTrainer(Generic[ModelTypeT]):
@@ -132,7 +132,7 @@ class AbstractTrainer(Generic[ModelTypeT]):
     def load_model(
         self, model_name: str | ModelTypeT, path: str | None = None, model_type: Type[ModelTypeT] | None = None
     ) -> ModelTypeT:
-        if isinstance(model_name, AbstractModel):
+        if isinstance(model_name, ModelBase):
             return model_name
         if model_name in self.models.keys():
             return self.models[model_name]

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/src/autogluon/core/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.2.1b20250220"
+__version__ = "1.2.1b20250221"
 __lite__ = False

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/src/autogluon.core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.core
-Version: 1.2.1b20250220
+Version: 1.2.1b20250221
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.core-1.2.1b20250220 → autogluon.core-1.2.1b20250221}/src/autogluon.core.egg-info/requires.txt

@@ -7,13 +7,13 @@ tqdm<5,>=4.38
 requests
 matplotlib<3.11,>=3.7.0
 boto3<2,>=1.10
-autogluon.common==1.2.1b20250220
+autogluon.common==1.2.1b20250221
 
 [all]
-ray[default,tune]<2.43,>=2.10.0
 ray[default]<2.43,>=2.10.0
 pyarrow>=15.0.0
 hyperopt<0.2.8,>=0.2.7
+ray[default,tune]<2.43,>=2.10.0
 
 [ray]
 ray[default]<2.43,>=2.10.0
@@ -24,8 +24,8 @@ ray[default,tune]<2.43,>=2.10.0
 hyperopt<0.2.8,>=0.2.7
 
 [tests]
-pytest-mypy
 types-setuptools
-flake8
+pytest-mypy
 types-requests
 pytest
+flake8