autogluon.cloud 0.4.2__tar.gz → 0.5.0__tar.gz

autogluon_cloud-0.5.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: autogluon.cloud
+Version: 0.5.0
+Summary: Train and deploy AutoGluon backed models on the cloud
+Home-page: https://github.com/autogluon/autogluon-cloud
+Author: AutoGluon Community
+License: Apache-2.0
+Project-URL: Documentation, https://auto.gluon.ai
+Project-URL: Bug Reports, https://github.com/autogluon/autogluon-cloud/issues
+Project-URL: Source, https://github.com/autogluon/autogluon-cloud/
+Project-URL: Contribute!, https://github.com/autogluon/autogluon-cloud/blob/master/CONTRIBUTING.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Customer Service
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: >=3.10, <3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: autogluon.common<1.6,>=0.7
+Requires-Dist: boto3<2,>=1.10
+Requires-Dist: packaging<27,>=23.0
+Requires-Dist: sagemaker<3,>=2.126.0
+Requires-Dist: pyarrow<25,>=19.0.1
+Requires-Dist: PyYAML~=6.0
+Requires-Dist: Pillow<13,>=10.2
+Requires-Dist: huggingface_hub<2,>=0.20
+Requires-Dist: typing_extensions<5,>=4.0
+Requires-Dist: click<9,>=8.0
+Requires-Dist: rich<15,>=13.0
+Provides-Extra: ray
+Requires-Dist: ray[default]<2.56,>=2.10.0; extra == "ray"
+Provides-Extra: all
+Requires-Dist: autogluon<1.6,>=0.7; extra == "all"
+Requires-Dist: ray[default]<2.56,>=2.10.0; extra == "all"
+Provides-Extra: tests
+Requires-Dist: moto; extra == "tests"
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: autogluon.common>=0.7; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: tox; extra == "tests"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/16392542/77208906-224aa500-6aba-11ea-96bd-e81806074030.png" width="350">
+
+## Train and Deploy AutoGluon in the Cloud
+
+[![PyPI](https://img.shields.io/pypi/v/autogluon.cloud.svg)](https://pypi.org/project/autogluon.cloud/)
+[![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)](https://pypi.org/project/autogluon.cloud/)
+[![GitHub license](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+[![Continuous Integration](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml)
+
+[AutoGluon-Cloud Documentation](https://auto.gluon.ai/cloud/stable/index.html) | [AutoGluon Documentation](https://auto.gluon.ai)
+
+</div>
+
+AutoGluon-Cloud lets you train and deploy state-of-the-art ML models in the cloud in a few lines of code. Run [AutoGluon](https://auto.gluon.ai/stable/index.html) on [Amazon SageMaker](https://aws.amazon.com/sagemaker/) without worrying about infrastructure, dependencies, or a heavy local ML environment. It supports two workflows:
+
+- **[Train your own predictor](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html)** — the same `fit → deploy → predict` workflow as local AutoGluon, with all the heavy lifting offloaded to SageMaker.
+- **[Run pretrained foundation models](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html)** — deploy state-of-the-art pretrained models like [Chronos-2](https://huggingface.co/amazon/chronos-2) for zero-shot inference, with no training required.
+
+## 💾 Installation & setup
+
+```bash
+pip install autogluon.cloud
+```
+
+Then provision the IAM role and S3 bucket AutoGluon-Cloud needs to run on AWS:
+
+```python
+from autogluon.cloud import bootstrap
+
+bootstrap()
+```
+
+See the [Setup tutorial](https://auto.gluon.ai/cloud/stable/tutorials/setup.html) for the full walkthrough, including how to register an existing role and bucket instead.
+
+## ⚙️ Train your own model
+
+Train an AutoGluon predictor on your data and serve it from a SageMaker endpoint — same API as local AutoGluon, all heavy lifting on AWS. Full walkthrough: [tabular](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html), [time series](https://auto.gluon.ai/cloud/stable/tutorials/predictor-timeseries.html).
+
+```python
+from autogluon.cloud import TabularCloudPredictor
+
+# `train_data` and `test_data` can be a local path, S3 URL, or pandas DataFrame
+train_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/train.csv"
+test_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv"
+
+# Train
+cloud_predictor = TabularCloudPredictor()
+cloud_predictor.fit(
+    train_data=train_data,
+    predictor_init_args={"label": "class"},  # passed to TabularPredictor()
+    predictor_fit_args={"time_limit": 120},  # passed to TabularPredictor.fit()
+)
+
+# Real-time inference endpoint
+cloud_predictor.deploy()
+result = cloud_predictor.predict_real_time(test_data)
+cloud_predictor.cleanup_deployment()
+
+# Batch prediction
+result = cloud_predictor.predict(test_data)
+```
+
+## 🚀 Run a pretrained foundation model
+
+Skip training entirely — deploy a pretrained model like Chronos-2 to SageMaker and get zero-shot predictions out of the box. Full walkthrough: [time series](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html).
+
+```python
+from autogluon.cloud import TimeSeriesFoundationModel
+
+# `data` can be a local path, S3 URL, or pandas DataFrame
+data = "https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_tiny/train.csv"
+
+model = TimeSeriesFoundationModel("chronos-2")
+
+# Batch prediction — no training required
+predictions = model.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+
+# Real-time inference endpoint
+endpoint = model.deploy()
+predictions = endpoint.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+endpoint.delete_endpoint()
+```

autogluon_cloud-0.5.0/README.md

@@ -0,0 +1,93 @@
+
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/16392542/77208906-224aa500-6aba-11ea-96bd-e81806074030.png" width="350">
+
+## Train and Deploy AutoGluon in the Cloud
+
+[![PyPI](https://img.shields.io/pypi/v/autogluon.cloud.svg)](https://pypi.org/project/autogluon.cloud/)
+[![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)](https://pypi.org/project/autogluon.cloud/)
+[![GitHub license](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+[![Continuous Integration](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml)
+
+[AutoGluon-Cloud Documentation](https://auto.gluon.ai/cloud/stable/index.html) | [AutoGluon Documentation](https://auto.gluon.ai)
+
+</div>
+
+AutoGluon-Cloud lets you train and deploy state-of-the-art ML models in the cloud in a few lines of code. Run [AutoGluon](https://auto.gluon.ai/stable/index.html) on [Amazon SageMaker](https://aws.amazon.com/sagemaker/) without worrying about infrastructure, dependencies, or a heavy local ML environment. It supports two workflows:
+
+- **[Train your own predictor](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html)** — the same `fit → deploy → predict` workflow as local AutoGluon, with all the heavy lifting offloaded to SageMaker.
+- **[Run pretrained foundation models](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html)** — deploy state-of-the-art pretrained models like [Chronos-2](https://huggingface.co/amazon/chronos-2) for zero-shot inference, with no training required.
+
+## 💾 Installation & setup
+
+```bash
+pip install autogluon.cloud
+```
+
+Then provision the IAM role and S3 bucket AutoGluon-Cloud needs to run on AWS:
+
+```python
+from autogluon.cloud import bootstrap
+
+bootstrap()
+```
+
+See the [Setup tutorial](https://auto.gluon.ai/cloud/stable/tutorials/setup.html) for the full walkthrough, including how to register an existing role and bucket instead.
+
+## ⚙️ Train your own model
+
+Train an AutoGluon predictor on your data and serve it from a SageMaker endpoint — same API as local AutoGluon, all heavy lifting on AWS. Full walkthrough: [tabular](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html), [time series](https://auto.gluon.ai/cloud/stable/tutorials/predictor-timeseries.html).
+
+```python
+from autogluon.cloud import TabularCloudPredictor
+
+# `train_data` and `test_data` can be a local path, S3 URL, or pandas DataFrame
+train_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/train.csv"
+test_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv"
+
+# Train
+cloud_predictor = TabularCloudPredictor()
+cloud_predictor.fit(
+    train_data=train_data,
+    predictor_init_args={"label": "class"},  # passed to TabularPredictor()
+    predictor_fit_args={"time_limit": 120},  # passed to TabularPredictor.fit()
+)
+
+# Real-time inference endpoint
+cloud_predictor.deploy()
+result = cloud_predictor.predict_real_time(test_data)
+cloud_predictor.cleanup_deployment()
+
+# Batch prediction
+result = cloud_predictor.predict(test_data)
+```
+
+## 🚀 Run a pretrained foundation model
+
+Skip training entirely — deploy a pretrained model like Chronos-2 to SageMaker and get zero-shot predictions out of the box. Full walkthrough: [time series](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html).
+
+```python
+from autogluon.cloud import TimeSeriesFoundationModel
+
+# `data` can be a local path, S3 URL, or pandas DataFrame
+data = "https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_tiny/train.csv"
+
+model = TimeSeriesFoundationModel("chronos-2")
+
+# Batch prediction — no training required
+predictions = model.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+
+# Real-time inference endpoint
+endpoint = model.deploy()
+predictions = endpoint.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+endpoint.delete_endpoint()
+```

autogluon_cloud-0.5.0/pyproject.toml

@@ -0,0 +1,37 @@
+[tool.ruff]
+line-length = 119
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+ignore = ["E501"]
+per-file-ignores = {"*/__init__.py" = ["F401"]}
+
+[tool.ruff.lint.isort]
+known-first-party = ["autogluon"]
+
+[tool.mypy]
+warn_unused_configs = true
+show_error_context = true
+pretty = true
+check_untyped_defs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--strict-markers"
+xfail_strict = true
+
+[tool.coverage.run]
+source = ["autogluon.cloud"]
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+fail_under = 80
+
+[tool.coverage.paths]
+source = [
+    "src/autogluon/cloud",
+    "*/site-packages/autogluon/cloud",
+]

autogluon_cloud-0.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{autogluon.cloud-0.4.2 → autogluon_cloud-0.5.0}/setup.py

@@ -5,7 +5,7 @@ from setuptools import setup
 AUTOGLUON = "autogluon"
 CLOUD = "cloud"
 
-PYTHON_REQUIRES = ">=3.8, <3.12"
+PYTHON_REQUIRES = ">=3.10, <3.14"
 
 
 def create_version_file(*, version):
@@ -43,7 +43,7 @@ def update_version(version, use_file_if_exists=True, create_file=False):
 
 
 def default_setup_args(*, version):
-    from setuptools import find_packages
+    from setuptools import find_namespace_packages
 
     long_description = open("README.md").read()
     name = f"{AUTOGLUON}.{CLOUD}"
@@ -58,17 +58,17 @@ def default_setup_args(*, version):
         license="Apache-2.0",
         license_files=("LICENSE", "NOTICE"),
         # Package info
-        packages=find_packages("src"),
+        packages=find_namespace_packages("src"),
         package_dir={"": "src"},
-        namespace_packages=[AUTOGLUON],
         zip_safe=True,
         include_package_data=True,
         python_requires=PYTHON_REQUIRES,
         package_data={
-            AUTOGLUON: [
-                "LICENSE",
+            "autogluon.cloud": [
+                "default_cluster_configs/*.yaml",
+                "utils/autogluon_dlc.json",
+                "templates/*.yaml",
             ],
-            'autogluon.cloud': ['default_cluster_configs/*.yaml'],
         },
         classifiers=[
             "Development Status :: 4 - Beta",
@@ -85,10 +85,10 @@ def default_setup_args(*, version):
             "Operating System :: POSIX",
             "Operating System :: Unix",
             "Programming Language :: Python :: 3",
-            "Programming Language :: Python :: 3.8",
-            "Programming Language :: Python :: 3.9",
             "Programming Language :: Python :: 3.10",
             "Programming Language :: Python :: 3.11",
+            "Programming Language :: Python :: 3.12",
+            "Programming Language :: Python :: 3.13",
             "Topic :: Software Development",
             "Topic :: Scientific/Engineering :: Artificial Intelligence",
             "Topic :: Scientific/Engineering :: Information Analysis",
@@ -104,27 +104,32 @@ def default_setup_args(*, version):
     return setup_args
 
 
-version = "0.4.2"
+version = "0.5.0"
 version = update_version(version, use_file_if_exists=False, create_file=True)
 
 install_requires = [
     # common module provides utils with stable api across minor version
-    "autogluon.common>=0.7",
+    "autogluon.common>=0.7,<1.6",
     # <2 because unlikely to introduce breaking changes in minor releases. >=1.10 because 1.10 is 3 years old, no need to support older
-    "boto3>=1.10,<2.0",
-    "packaging>=23.0,<25.0",
-    # updated sagemaker is required to fetch latest container info, so we don't want to cap the version too strict
-    # otherwise cloud module needs to be released to support new container
-    "sagemaker>=2.126.0,<3.0",
-    "pyarrow>=11.0,<11.1",
+    "boto3>=1.10,<2",
+    "packaging>=23.0,<27",
+    "sagemaker>=2.126.0,<3",
+    "pyarrow>=19.0.1,<25",  # lower bound to avoid https://github.com/apache/arrow/issues/45283
     "PyYAML~=6.0",
-    "Pillow>=10.2,<11",  # unlikely to introduce breaking changes in minor releases
-    "ray[default]>=2.10.0,<2.11",
+    "Pillow>=10.2,<13",
+    "huggingface_hub>=0.20,<2",
+    "typing_extensions>=4.0,<5",
+    # CLI dependencies (autogluon-cloud command)
+    "click>=8.0,<9",
+    "rich>=13.0,<15",
 ]
 
 extras_require = dict()
 
-all_requires = ["autogluon>=0.7"]  # To allow user to pass ag objects
+ray_requires = ["ray[default]>=2.10.0,<2.56"]
+extras_require["ray"] = ray_requires
+
+all_requires = ["autogluon>=0.7,<1.6"] + ray_requires  # To allow user to pass ag objects
 extras_require["all"] = all_requires
 
 test_requirements = [
@@ -144,5 +149,10 @@ if __name__ == "__main__":
     setup(
         install_requires=install_requires,
         extras_require=extras_require,
+        entry_points={
+            "console_scripts": [
+                "autogluon-cloud=autogluon.cloud.cli:main",
+            ],
+        },
         **setup_args,
     )

autogluon_cloud-0.5.0/src/autogluon/cloud/__init__.py

@@ -0,0 +1,32 @@
+import logging
+
+import sagemaker
+from packaging.version import Version
+
+if Version(sagemaker.__version__) >= Version("3.0"):
+    raise ImportError(
+        f"SageMaker SDK >= 3.0 is currently not supported (found {sagemaker.__version__}). "
+        "Please downgrade: pip install -U 'sagemaker<3'"
+    )
+
+from autogluon.common.utils.log_utils import _add_stream_handler
+
+from .cloud_setup import bootstrap, register, status, teardown
+from .endpoint.timeseries_endpoint import TimeSeriesEndpoint
+from .model.foundation_model import TimeSeriesFoundationModel
+from .predictor import MultiModalCloudPredictor, TabularCloudPredictor, TimeSeriesCloudPredictor
+
+_add_stream_handler()
+logging.getLogger(__name__).setLevel(logging.INFO)
+
+__all__ = [
+    "MultiModalCloudPredictor",
+    "TabularCloudPredictor",
+    "TimeSeriesCloudPredictor",
+    "TimeSeriesEndpoint",
+    "TimeSeriesFoundationModel",
+    "bootstrap",
+    "register",
+    "status",
+    "teardown",
+]

{autogluon.cloud-0.4.2 → autogluon_cloud-0.5.0}/src/autogluon/cloud/backend/backend.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import pickle
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Union
@@ -18,7 +19,11 @@ class Backend(ABC):
     @property
     def cloud_output_path(self) -> str:
         if not self._cloud_output_path:
-            raise ValueError(f"cloud_output_path is needed. Please pass it during init of {self.__class__.__name__}")
+            raise ValueError(
+                "No `cloud_output_path` was provided and no bucket is configured in "
+                "~/.autogluon/cloud.yaml. Either pass `cloud_output_path=` explicitly, or run "
+                "`autogluon.cloud.bootstrap()` / `register(bucket=...)` once to persist a bucket."
+            )
         return self._cloud_output_path
 
     def initialize(
@@ -29,11 +34,7 @@ class Backend(ABC):
         self._cloud_output_path = cloud_output_path
         self.predictor_type = predictor_type
         self.original_features = None
-
-    @abstractmethod
-    def generate_default_permission(self, **kwargs) -> Dict[str, str]:
-        """Generate default permission file user could use to setup the corresponding entity, i.e. IAM Role in AWS"""
-        raise NotImplementedError
+        self.endpoint: Optional[Endpoint] = None
 
     @abstractmethod
     def parse_backend_fit_kwargs(self, kwargs: Dict) -> Dict[str, Any]:
@@ -91,6 +92,7 @@ class Backend(ABC):
         """
         assert self.predictor_type is not None
         config = self._construct_ag_args(**kwargs)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
         with open(path, "wb") as f:
             pickle.dump(config, f)
 
@@ -172,3 +174,10 @@ class Backend(ABC):
     def predict_proba(self, test_data: Union[str, pd.DataFrame], **kwargs) -> Union[pd.DataFrame, pd.Series]:
         """Batch inference probability"""
         raise NotImplementedError
+
+    def get_fit_predict_results(self) -> pd.DataFrame:
+        """
+        Retrieve predictions produced by a completed ``fit_predict`` job.
+
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support `fit_predict`.")

autogluon_cloud-0.5.0/src/autogluon/cloud/backend/backend_factory.py

@@ -0,0 +1,39 @@
+from .backend import Backend
+from .constant import RAY_AWS, TABULAR_RAY_AWS
+from .multimodal_sagemaker_backend import MultiModalSagemakerBackend
+from .sagemaker_backend import SagemakerBackend
+from .tabular_sagemaker_backend import TabularSagemakerBackend
+from .timeseries_sagemaker_backend import TimeSeriesSagemakerBackend
+
+
+class BackendFactory:
+    _SAGEMAKER_BACKENDS = {
+        SagemakerBackend.name: SagemakerBackend,
+        TabularSagemakerBackend.name: TabularSagemakerBackend,
+        MultiModalSagemakerBackend.name: MultiModalSagemakerBackend,
+        TimeSeriesSagemakerBackend.name: TimeSeriesSagemakerBackend,
+    }
+    _RAY_BACKEND_NAMES = {RAY_AWS, TABULAR_RAY_AWS}
+
+    @staticmethod
+    def get_backend_cls(backend: str) -> type[Backend]:
+        if backend in BackendFactory._SAGEMAKER_BACKENDS:
+            return BackendFactory._SAGEMAKER_BACKENDS[backend]
+        if backend in BackendFactory._RAY_BACKEND_NAMES:
+            try:
+                from .ray_aws_backend import RayAWSBackend, TabularRayAWSBackend
+            except ImportError as e:
+                raise ImportError(
+                    f"The '{backend}' backend requires ray. Install with: pip install 'autogluon.cloud[ray]'"
+                ) from e
+            return {
+                RayAWSBackend.name: RayAWSBackend,
+                TabularRayAWSBackend.name: TabularRayAWSBackend,
+            }[backend]
+        supported = sorted(BackendFactory._SAGEMAKER_BACKENDS.keys() | BackendFactory._RAY_BACKEND_NAMES)
+        raise ValueError(f"{backend} not supported. Supported backends: {supported}")
+
+    @staticmethod
+    def get_backend(backend: str, **init_args) -> Backend:
+        """Return the corresponding backend"""
+        return BackendFactory.get_backend_cls(backend)(**init_args)

{autogluon.cloud-0.4.2 → autogluon_cloud-0.5.0}/src/autogluon/cloud/backend/constant.py

@@ -5,3 +5,6 @@ TIMESERIES_SAGEMAKER = "timeseries_sagemaker"
 RAY = "ray"
 RAY_AWS = "ray_aws"
 TABULAR_RAY_AWS = "tabular_ray_aws"
+
+# Backends the top-level setup API can provision via CloudFormation.
+SUPPORTED_BACKENDS = (SAGEMAKER, RAY_AWS)

{autogluon.cloud-0.4.2 → autogluon_cloud-0.5.0}/src/autogluon/cloud/backend/ray_aws_backend.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import Dict, Optional
+from typing import Optional
 
 import boto3
 
@@ -55,14 +55,9 @@ class RayAWSBackend(RayBackend):
         super().initialize(**kwargs)
         self._boto_session = boto3.session.Session()
         self.region = self._boto_session.region_name
-        assert (
-            self.region is not None
-        ), "Please setup a region via `export AWS_DEFAULT_REGION=YOUR_REGION` in the terminal"
-
-    @staticmethod
-    def generate_default_permission(**kwargs) -> Dict[str, str]:
-        """Generate default permission file user could use to setup the corresponding entity, i.e. IAM Role in AWS"""
-        return RayAWSClusterManager.generate_default_permission(**kwargs)
+        assert self.region is not None, (
+            "Please setup a region via `export AWS_DEFAULT_REGION=YOUR_REGION` in the terminal"
+        )
 
     def _setup_role_and_permission(self):
         """

{autogluon.cloud-0.4.2 → autogluon_cloud-0.5.0}/src/autogluon/cloud/backend/ray_backend.py

@@ -8,7 +8,6 @@ import time
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import pandas as pd
-from sagemaker import image_uris
 
 from autogluon.common.utils.s3_utils import s3_bucket_prefix_to_path, s3_path_to_bucket_prefix
 
@@ -19,7 +18,7 @@ from ..endpoint.endpoint import Endpoint
 from ..job.ray_job import RayFitJob
 from ..scripts import ScriptManager
 from ..utils.constants import CLOUD_RESOURCE_PREFIX
-from ..utils.dlc_utils import parse_framework_version
+from ..utils.dlc_utils import parse_framework_version, retrieve_image_uri
 from ..utils.ec2 import get_latest_ami
 from ..utils.iam import get_instance_profile_arn
 from ..utils.ray_aws_iam import RAY_INSTANCE_PROFILE_NAME
@@ -53,11 +52,6 @@ class RayBackend(Backend):
         self._fit_job = RayFitJob()
         os.makedirs(os.path.join(self.local_output_path, "job"), exist_ok=True)
 
-    @staticmethod
-    def generate_default_permission(**kwargs) -> Dict[str, str]:
-        """Generate default permission file user could use to setup the corresponding entity, i.e. IAM Role in AWS"""
-        return RayClusterManager.generate_default_permission(**kwargs)
-
     def parse_backend_fit_kwargs(self, kwargs: Dict) -> Dict[str, Any]:
         """Parse backend specific kwargs and get them ready to be sent to fit call"""
         custom_config = kwargs.get("custom_config", None)
@@ -110,6 +104,7 @@ class RayBackend(Backend):
         *,
         predictor_init_args: Dict[str, Any],
         predictor_fit_args: Dict[str, Any],
+        data_channels: Dict[str, Optional[Union[str, pd.DataFrame]]],
         image_column: Optional[str] = None,
         leaderboard: bool = True,
         framework_version: str = "latest",
@@ -182,9 +177,11 @@ class RayBackend(Backend):
         """
         if image_column is not None:
             raise ValueError("Distributed training doesn't support image modality yet")
+        if data_channels.get("train_data") is None:
+            raise ValueError("`data_channels['train_data']` is required.")
         predictor_fit_args = copy.deepcopy(predictor_fit_args)
-        train_data = predictor_fit_args.pop("train_data")
-        tune_data = predictor_fit_args.pop("tuning_data", None)
+        train_data = data_channels["train_data"]
+        tune_data = data_channels.get("tuning_data")
         presets = predictor_fit_args.pop("presets", [])
         num_bag_folds = predictor_fit_args.get("num_bag_folds", None)
         hyperparameter_tune_kwargs = predictor_fit_args.get("hyperparameter_tune_kwargs", None)
@@ -387,13 +384,12 @@ class RayBackend(Backend):
                 framework_version, "training", minimum_version="0.7.0"
             )
             logger.log(20, f"Training with framework_version=={framework_version}")
-            image_uri = image_uris.retrieve(
-                "autogluon",
+            image_uri = retrieve_image_uri(
+                framework_version=framework_version,
                 region=self.region,
-                version=framework_version,
-                py_version=py_version,
                 image_scope="training",
                 instance_type=instance_type,
+                py_version=py_version,
             )
         return image_uri