sagemaker-core 1.0.62__py3-none-any.whl → 2.1.1__py3-none-any.whl

sagemaker/core/huggingface/__init__.py

@@ -0,0 +1,29 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""HuggingFace framework support for SageMaker."""
+from __future__ import absolute_import
+
+from sagemaker.core.huggingface.estimator import HuggingFace  # noqa: F401
+from sagemaker.core.huggingface.llm_utils import get_huggingface_llm_image_uri  # noqa: F401
+from sagemaker.core.huggingface.model import HuggingFaceModel, HuggingFacePredictor  # noqa: F401
+from sagemaker.core.huggingface.processing import HuggingFaceProcessor  # noqa: F401
+from sagemaker.core.huggingface.training_compiler.config import TrainingCompilerConfig  # noqa: F401
+
+__all__ = [
+    "HuggingFace",
+    "HuggingFaceModel",
+    "HuggingFacePredictor",
+    "HuggingFaceProcessor",
+    "TrainingCompilerConfig",
+    "get_huggingface_llm_image_uri",
+]

sagemaker/core/huggingface/llm_utils.py

@@ -0,0 +1,150 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""Functions for generating ECR image URIs for pre-built SageMaker Docker images."""
+from __future__ import absolute_import
+
+import os
+from typing import Optional
+import importlib.util
+
+import urllib.request
+from urllib.error import HTTPError, URLError
+import json
+from json import JSONDecodeError
+import logging
+from sagemaker.core import image_uris
+from sagemaker.core.helper.session_helper import Session
+
+logger = logging.getLogger(__name__)
+
+
+def get_huggingface_llm_image_uri(
+    backend: str,
+    session: Optional[Session] = None,
+    region: Optional[str] = None,
+    version: Optional[str] = None,
+) -> str:
+    """Retrieves the image URI for inference.
+
+    Args:
+        backend (str): The backend to use. Valid values include "huggingface" and "lmi".
+        session (Session): The SageMaker Session to use. (Default: None).
+        region (str): The AWS region to use for image URI. (default: None).
+        version (str): The framework version for which to retrieve an
+            image URI. If no version is set, defaults to latest version. (default: None).
+
+    Returns:
+        str: The image URI string.
+    """
+
+    if region is None:
+        if session is None:
+            region = Session().boto_session.region_name
+        else:
+            region = session.boto_session.region_name
+    if backend == "huggingface":
+        return image_uris.retrieve(
+            "huggingface-llm",
+            region=region,
+            version=version,
+            image_scope="inference",
+        )
+    if backend == "huggingface-neuronx":
+        return image_uris.retrieve(
+            "huggingface-llm-neuronx",
+            region=region,
+            version=version,
+            image_scope="inference",
+            inference_tool="neuronx",
+        )
+    if backend == "huggingface-tei":
+        return image_uris.retrieve(
+            "huggingface-tei",
+            region=region,
+            version=version,
+            image_scope="inference",
+        )
+    if backend == "huggingface-tei-cpu":
+        return image_uris.retrieve(
+            "huggingface-tei-cpu",
+            region=region,
+            version=version,
+            image_scope="inference",
+        )
+    if backend == "lmi":
+        version = version or "0.24.0"
+        return image_uris.retrieve(framework="djl-deepspeed", region=region, version=version)
+    raise ValueError("Unsupported backend: %s" % backend)
+
+
+def get_huggingface_model_metadata(model_id: str, hf_hub_token: Optional[str] = None) -> dict:
+    """Retrieves the json metadata of the HuggingFace Model via HuggingFace API.
+
+    Args:
+        model_id (str): The HuggingFace Model ID
+        hf_hub_token (str): The HuggingFace Hub Token needed for Private/Gated HuggingFace Models
+
+    Returns:
+        dict: The model metadata retrieved with the HuggingFace API
+    """
+    if not model_id:
+        raise ValueError("Model ID is empty. Please provide a valid Model ID.")
+    hf_model_metadata_url = f"https://huggingface.co/api/models/{model_id}"
+    hf_model_metadata_json = None
+    try:
+        if hf_hub_token:
+            hf_model_metadata_url = urllib.request.Request(
+                hf_model_metadata_url, None, {"Authorization": "Bearer " + hf_hub_token}
+            )
+        with urllib.request.urlopen(hf_model_metadata_url) as response:
+            hf_model_metadata_json = json.load(response)
+    except (HTTPError, URLError, TimeoutError, JSONDecodeError) as e:
+        if "HTTP Error 401: Unauthorized" in str(e):
+            raise ValueError(
+                "Trying to access a gated/private HuggingFace model without valid credentials. "
+                "Please provide a HUGGING_FACE_HUB_TOKEN in env_vars"
+            )
+        logger.warning(
+            "Exception encountered while trying to retrieve HuggingFace model metadata %s. "
+            "Details: %s",
+            hf_model_metadata_url,
+            e,
+        )
+    if not hf_model_metadata_json:
+        raise ValueError(
+            "Did not find model metadata for the following HuggingFace Model ID %s" % model_id
+        )
+    return hf_model_metadata_json
+
+
+def download_huggingface_model_metadata(
+    model_id: str, model_local_path: str, hf_hub_token: Optional[str] = None
+) -> None:
+    """Downloads the HuggingFace Model snapshot via HuggingFace API.
+
+    Args:
+        model_id (str): The HuggingFace Model ID
+        model_local_path (str): The local path to save the HuggingFace Model snapshot.
+        hf_hub_token (str): The HuggingFace Hub Token
+
+    Raises:
+        ImportError: If huggingface_hub is not installed.
+    """
+    if not importlib.util.find_spec("huggingface_hub"):
+        raise ImportError("Unable to import huggingface_hub, check if huggingface_hub is installed")
+
+    from huggingface_hub import snapshot_download
+
+    os.makedirs(model_local_path, exist_ok=True)
+    logger.info("Downloading model %s from Hugging Face Hub to %s", model_id, model_local_path)
+    snapshot_download(repo_id=model_id, local_dir=model_local_path, token=hf_hub_token)

sagemaker/core/huggingface/processing.py

@@ -0,0 +1,139 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""This module contains code related to HuggingFace Processors which are used for Processing jobs.
+
+These jobs let customers perform data pre-processing, post-processing, feature engineering,
+data validation, and model evaluation and interpretation on SageMaker.
+"""
+from __future__ import absolute_import
+
+from typing import Union, Optional, List, Dict
+
+from sagemaker.core.helper.session_helper import Session
+from sagemaker.core.network import NetworkConfig
+from sagemaker.core.processing import FrameworkProcessor
+from sagemaker.core.huggingface.estimator import HuggingFace
+
+from sagemaker.core.helper.pipeline_variable import PipelineVariable
+from sagemaker.core.common_utils import format_tags, Tags
+
+
+class HuggingFaceProcessor(FrameworkProcessor):
+    """Handles Amazon SageMaker processing tasks for jobs using HuggingFace containers."""
+
+    estimator_cls = HuggingFace
+
+    def __init__(
+        self,
+        role: Optional[Union[str, PipelineVariable]] = None,
+        instance_count: Union[int, PipelineVariable] = None,
+        instance_type: Union[str, PipelineVariable] = None,
+        transformers_version: Optional[str] = None,
+        tensorflow_version: Optional[str] = None,
+        pytorch_version: Optional[str] = None,
+        py_version: str = "py36",
+        image_uri: Optional[Union[str, PipelineVariable]] = None,
+        command: Optional[List[str]] = None,
+        volume_size_in_gb: Union[int, PipelineVariable] = 30,
+        volume_kms_key: Optional[Union[str, PipelineVariable]] = None,
+        output_kms_key: Optional[Union[str, PipelineVariable]] = None,
+        code_location: Optional[str] = None,
+        max_runtime_in_seconds: Optional[Union[int, PipelineVariable]] = None,
+        base_job_name: Optional[str] = None,
+        sagemaker_session: Optional[Session] = None,
+        env: Optional[Dict[str, Union[str, PipelineVariable]]] = None,
+        tags: Optional[Tags] = None,
+        network_config: Optional[NetworkConfig] = None,
+    ):
+        """This processor executes a Python script in a HuggingFace execution environment.
+
+        Unless ``image_uri`` is specified, the environment is an Amazon-built Docker container
+        that executes functions defined in the supplied ``code`` Python script.
+
+        The arguments have the same meaning as in ``FrameworkProcessor``, with the following
+        exceptions.
+
+        Args:
+            transformers_version (str): Transformers version you want to use for
+                executing your model training code. Defaults to ``None``. Required unless
+                ``image_uri`` is provided. The current supported version is ``4.4.2``.
+            tensorflow_version (str): TensorFlow version you want to use for
+                executing your model training code. Defaults to ``None``. Required unless
+                ``pytorch_version`` is provided. The current supported version is ``2.4.1``.
+            pytorch_version (str): PyTorch version you want to use for
+                executing your model training code. Defaults to ``None``. Required unless
+                ``tensorflow_version`` is provided. The current supported version is ``1.6.0``.
+            py_version (str): Python version you want to use for executing your model training
+                code. Defaults to ``None``. Required unless ``image_uri`` is provided.  If
+                using PyTorch, the current supported version is ``py36``. If using TensorFlow,
+                the current supported version is ``py37``.
+
+        .. tip::
+
+            You can find additional parameters for initializing this class at
+            :class:`~sagemaker.processing.FrameworkProcessor`.
+        """
+        self.pytorch_version = pytorch_version
+        self.tensorflow_version = tensorflow_version
+        super().__init__(
+            self.estimator_cls,
+            transformers_version,
+            role,
+            instance_count,
+            instance_type,
+            py_version,
+            image_uri,
+            command,
+            volume_size_in_gb,
+            volume_kms_key,
+            output_kms_key,
+            code_location,
+            max_runtime_in_seconds,
+            base_job_name,
+            sagemaker_session,
+            env,
+            format_tags(tags),
+            network_config,
+        )
+
+    def _create_estimator(
+        self,
+        entry_point="",
+        source_dir=None,
+        dependencies=None,
+        git_config=None,
+    ):
+        """Override default estimator factory function for HuggingFace's different parameters
+
+        HuggingFace estimators have 3 framework version parameters instead of one: The version for
+        Transformers, PyTorch, and TensorFlow.
+        """
+        return self.estimator_cls(
+            transformers_version=self.framework_version,
+            tensorflow_version=self.tensorflow_version,
+            pytorch_version=self.pytorch_version,
+            py_version=self.py_version,
+            entry_point=entry_point,
+            source_dir=source_dir,
+            dependencies=dependencies,
+            git_config=git_config,
+            code_location=self.code_location,
+            enable_network_isolation=False,
+            image_uri=self.image_uri,
+            role=self.role,
+            instance_count=self.instance_count,
+            instance_type=self.instance_type,
+            sagemaker_session=self.sagemaker_session,
+            debugger_hook_config=False,
+            disable_profiler=True,
+        )

sagemaker/core/huggingface/training_compiler/config.py

@@ -0,0 +1,167 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""Configuration for the SageMaker Training Compiler."""
+from __future__ import absolute_import
+import logging
+from typing import Union
+from packaging.specifiers import SpecifierSet
+from packaging.version import Version
+
+from sagemaker.core.training_compiler.config import TrainingCompilerConfig as BaseConfig
+from sagemaker.core.helper.pipeline_variable import PipelineVariable
+
+logger = logging.getLogger(__name__)
+
+
+class TrainingCompilerConfig(BaseConfig):
+    """The SageMaker Training Compiler configuration class."""
+
+    SUPPORTED_INSTANCE_CLASS_PREFIXES = ["p3", "p3dn", "g4dn", "p4d", "g5"]
+    SUPPORTED_INSTANCE_TYPES_WITH_EFA = [
+        "ml.g4dn.8xlarge",
+        "ml.g4dn.12xlarge",
+        "ml.g5.48xlarge",
+        "ml.p3dn.24xlarge",
+        "ml.p4d.24xlarge",
+    ]
+
+    def __init__(
+        self,
+        enabled: Union[bool, PipelineVariable] = True,
+        debug: Union[bool, PipelineVariable] = False,
+    ):
+        """This class initializes a ``TrainingCompilerConfig`` instance.
+
+        `Amazon SageMaker Training Compiler
+        <https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler.html>`_
+        is a feature of SageMaker Training
+        and speeds up training jobs by optimizing model execution graphs.
+
+        You can compile Hugging Face models
+        by passing the object of this configuration class to the ``compiler_config``
+        parameter of the :class:`~sagemaker.huggingface.HuggingFace`
+        estimator.
+
+        Args:
+            enabled (bool or PipelineVariable): Optional. Switch to enable SageMaker
+                Training Compiler. The default is ``True``.
+            debug (bool or PipelineVariable): Optional. Whether to dump detailed logs
+                for debugging. This comes with a potential performance slowdown.
+                The default is ``False``.
+
+        **Example**: The following code shows the basic usage of the
+        :class:`sagemaker.huggingface.TrainingCompilerConfig()` class
+        to run a HuggingFace training job with the compiler.
+
+        .. code-block:: python
+
+            from sagemaker.core.huggingface import HuggingFace, TrainingCompilerConfig
+
+            huggingface_estimator=HuggingFace(
+                ...
+                compiler_config=TrainingCompilerConfig()
+            )
+
+        .. seealso::
+
+            For more information about how to enable SageMaker Training Compiler
+            for various training settings such as using TensorFlow-based models,
+            PyTorch-based models, and distributed training,
+            see `Enable SageMaker Training Compiler
+            <https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-enable.html>`_
+            in the `Amazon SageMaker Training Compiler developer guide
+            <https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler.html>`_.
+
+        """
+
+        super(TrainingCompilerConfig, self).__init__(enabled=enabled, debug=debug)
+
+    @classmethod
+    def validate(cls, estimator):
+        """Checks if SageMaker Training Compiler is configured correctly.
+
+        Args:
+            estimator (:class:`sagemaker.huggingface.HuggingFace`): An estimator object.
+                If SageMaker Training Compiler is enabled, it will validate whether
+                the estimator is configured to be compatible with Training Compiler.
+
+        Raises:
+            ValueError: Raised if the requested configuration is not compatible
+                        with SageMaker Training Compiler.
+        """
+
+        super(TrainingCompilerConfig, cls).validate(estimator)
+
+        if estimator.pytorch_version:
+            if (Version(estimator.pytorch_version) in SpecifierSet("< 1.9")) or (
+                Version(estimator.pytorch_version) in SpecifierSet("> 1.11")
+            ):
+                error_helper_string = (
+                    "SageMaker Training Compiler is only supported "
+                    "with HuggingFace PyTorch 1.9-1.11. "
+                    "Received pytorch_version={} which is unsupported."
+                )
+                raise ValueError(error_helper_string.format(estimator.pytorch_version))
+
+        if estimator.image_uri:
+            error_helper_string = (
+                "Overriding the image URI is currently not supported "
+                "for SageMaker Training Compiler."
+                "Specify the following parameters to run the Hugging Face training job "
+                "with SageMaker Training Compiler enabled: "
+                "transformer_version, tensorflow_version or pytorch_version, and compiler_config."
+            )
+            raise ValueError(error_helper_string)
+
+        if estimator.distribution:
+            pt_xla_present = "pytorchxla" in estimator.distribution
+            pt_xla_enabled = estimator.distribution.get("pytorchxla", {}).get("enabled", False)
+            if pt_xla_enabled:
+                if estimator.tensorflow_version:
+                    error_helper_string = (
+                        "Distribution mechanism 'pytorchxla' is currently only supported for "
+                        "PyTorch >= 1.11 when SageMaker Training Compiler is enabled. Received "
+                        "tensorflow_version={} which is unsupported."
+                    )
+                    raise ValueError(error_helper_string.format(estimator.tensorflow_version))
+                if estimator.pytorch_version:
+                    if Version(estimator.pytorch_version) in SpecifierSet("< 1.11"):
+                        error_helper_string = (
+                            "Distribution mechanism 'pytorchxla' is currently only supported for "
+                            "PyTorch >= 1.11 when SageMaker Training Compiler is enabled."
+                            " Received pytorch_version={} which is unsupported."
+                        )
+                        raise ValueError(error_helper_string.format(estimator.pytorch_version))
+                    if estimator.instance_type not in cls.SUPPORTED_INSTANCE_TYPES_WITH_EFA:
+                        logger.warning(
+                            "Consider using instances with EFA support when "
+                            "training with PyTorch >= 1.11 and SageMaker Training Compiler "
+                            "enabled. SageMaker Training Compiler leverages EFA to provide better "
+                            "performance for distributed training."
+                        )
+            if not pt_xla_present:
+                if estimator.pytorch_version:
+                    if Version(estimator.pytorch_version) in SpecifierSet(">= 1.11"):
+                        error_helper_string = (
+                            "'pytorchxla' is the only distribution mechanism currently supported "
+                            "for PyTorch >= 1.11 when SageMaker Training Compiler is enabled."
+                            " Received distribution={} which is unsupported."
+                        )
+                        raise ValueError(error_helper_string.format(estimator.distribution))
+        elif estimator.instance_count and estimator.instance_count > 1:
+            if estimator.pytorch_version:
+                if Version(estimator.pytorch_version) in SpecifierSet(">= 1.11"):
+                    logger.warning(
+                        "Consider setting 'distribution' to 'pytorchxla' for distributed "
+                        "training with PyTorch >= 1.11 and SageMaker Training Compiler enabled."
+                    )

sagemaker/core/hyperparameters.py

@@ -0,0 +1,172 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""Accessors to retrieve hyperparameters for training jobs."""
+
+from __future__ import absolute_import
+
+import logging
+from typing import Dict, Optional
+
+from sagemaker.core.jumpstart import utils as jumpstart_utils
+from sagemaker.core.jumpstart import artifacts
+from sagemaker.core.jumpstart.constants import DEFAULT_JUMPSTART_SAGEMAKER_SESSION
+from sagemaker.core.jumpstart.enums import HyperparameterValidationMode, JumpStartModelType
+from sagemaker.core.jumpstart.validators import validate_hyperparameters
+from sagemaker.core.helper.session_helper import Session
+
+logger = logging.getLogger(__name__)
+
+
+def retrieve_default(
+    region: Optional[str] = None,
+    model_id: Optional[str] = None,
+    model_version: Optional[str] = None,
+    hub_arn: Optional[str] = None,
+    instance_type: Optional[str] = None,
+    include_container_hyperparameters: bool = False,
+    tolerate_vulnerable_model: bool = False,
+    tolerate_deprecated_model: bool = False,
+    sagemaker_session: Session = DEFAULT_JUMPSTART_SAGEMAKER_SESSION,
+    config_name: Optional[str] = None,
+    model_type: JumpStartModelType = JumpStartModelType.OPEN_WEIGHTS,
+) -> Dict[str, str]:
+    """Retrieves the default training hyperparameters for the model matching the given arguments.
+
+    Args:
+        region (str): The AWS Region for which to retrieve the default hyperparameters.
+            Defaults to ``None``.
+        model_id (str): The model ID of the model for which to
+            retrieve the default hyperparameters. (Default: None).
+        model_version (str): The version of the model for which to retrieve the
+            default hyperparameters. (Default: None).
+        hub_arn (str): The arn of the SageMaker Hub for which to retrieve
+            model details from. (default: None).
+        instance_type (str): An instance type to optionally supply in order to get hyperparameters
+            specific for the instance type.
+        include_container_hyperparameters (bool): ``True`` if the container hyperparameters
+            should be returned. Container hyperparameters are not used to tune
+            the specific algorithm. They are used by SageMaker Training jobs to set up
+            the training container environment. For example, there is a container hyperparameter
+            that indicates the entrypoint script to use. These hyperparameters may be required
+            when creating a training job with boto3, however the ``Estimator`` classes
+            add required container hyperparameters to the job. (Default: False).
+        tolerate_vulnerable_model (bool): True if vulnerable versions of model
+            specifications should be tolerated (exception not raised). If False, raises an
+            exception if the script used by this version of the model has dependencies with known
+            security vulnerabilities. (Default: False).
+        tolerate_deprecated_model (bool): True if deprecated models should be tolerated
+            (exception not raised). False if these models should raise an exception.
+            (Default: False).
+        sagemaker_session (sagemaker.session.Session): A SageMaker Session
+            object, used for SageMaker interactions. If not
+            specified, one is created using the default AWS configuration
+            chain. (Default: sagemaker.jumpstart.constants.DEFAULT_JUMPSTART_SAGEMAKER_SESSION).
+        config_name (Optional[str]): Name of the JumpStart Model config to apply. (Default: None).
+        model_type (JumpStartModelType): The type of the model, can be open weights model
+            or proprietary model. (Default: JumpStartModelType.OPEN_WEIGHTS).
+    Returns:
+        dict: The hyperparameters to use for the model.
+
+    Raises:
+        ValueError: If the combination of arguments specified is not supported.
+    """
+    if not jumpstart_utils.is_jumpstart_model_input(model_id, model_version):
+        raise ValueError(
+            "Must specify JumpStart `model_id` and `model_version` when retrieving hyperparameters."
+        )
+
+    return artifacts._retrieve_default_hyperparameters(
+        model_id=model_id,
+        model_version=model_version,
+        hub_arn=hub_arn,
+        instance_type=instance_type,
+        region=region,
+        include_container_hyperparameters=include_container_hyperparameters,
+        tolerate_vulnerable_model=tolerate_vulnerable_model,
+        tolerate_deprecated_model=tolerate_deprecated_model,
+        sagemaker_session=sagemaker_session,
+        config_name=config_name,
+        model_type=model_type,
+    )
+
+
+def validate(
+    region: Optional[str] = None,
+    model_id: Optional[str] = None,
+    hub_arn: Optional[str] = None,
+    model_version: Optional[str] = None,
+    hyperparameters: Optional[dict] = None,
+    validation_mode: HyperparameterValidationMode = HyperparameterValidationMode.VALIDATE_PROVIDED,
+    tolerate_vulnerable_model: bool = False,
+    tolerate_deprecated_model: bool = False,
+    sagemaker_session: Session = DEFAULT_JUMPSTART_SAGEMAKER_SESSION,
+) -> None:
+    """Validates hyperparameters for models.
+
+    Args:
+        region (str): The AWS Region for which to validate hyperparameters. (Default: None).
+        model_id (str): The model ID of the model for which to validate hyperparameters.
+            (Default: None).
+        model_version (str): The version of the model for which to validate hyperparameters.
+            (Default: None).
+        hub_arn (str): The arn of the SageMaker Hub for which to retrieve
+            model details from. (default: None).
+        hyperparameters (dict): Hyperparameters to validate.
+            (Default: None).
+        validation_mode (HyperparameterValidationMode): Method of validation to use with
+          hyperparameters. If set to ``VALIDATE_PROVIDED``, only hyperparameters provided
+          to this function will be validated, the missing hyperparameters will be ignored.
+          If set to``VALIDATE_ALGORITHM``, all algorithm hyperparameters will be validated.
+          If set to ``VALIDATE_ALL``, all hyperparameters for the model will be validated.
+          (Default: None).
+        tolerate_vulnerable_model (bool): True if vulnerable versions of model
+            specifications should be tolerated (exception not raised). If False, raises an
+            exception if the script used by this version of the model has dependencies with known
+            security vulnerabilities. (Default: False).
+        tolerate_deprecated_model (bool): True if deprecated models should be tolerated
+            (exception not raised). False if these models should raise an exception.
+            (Default: False).
+        sagemaker_session (sagemaker.session.Session): A SageMaker Session
+            object, used for SageMaker interactions. If not
+            specified, one is created using the default AWS configuration
+            chain. (Default: sagemaker.jumpstart.constants.DEFAULT_JUMPSTART_SAGEMAKER_SESSION).
+
+    Raises:
+        JumpStartHyperparametersError: If the hyperparameter is not formatted correctly,
+            according to its specs in the model metadata.
+        ValueError: If the combination of arguments specified is not supported.
+
+    """
+
+    if not jumpstart_utils.is_jumpstart_model_input(model_id, model_version):
+        raise ValueError(
+            "Must specify JumpStart `model_id` and `model_version` when validating hyperparameters."
+        )
+
+    if model_id is None or model_version is None:
+        raise RuntimeError("Model ID and version must both be non-None")
+
+    if hyperparameters is None:
+        raise ValueError("Must specify hyperparameters.")
+
+    return validate_hyperparameters(
+        model_id=model_id,
+        model_version=model_version,
+        hub_arn=hub_arn,
+        hyperparameters=hyperparameters,
+        validation_mode=validation_mode,
+        region=region,
+        tolerate_vulnerable_model=tolerate_vulnerable_model,
+        tolerate_deprecated_model=tolerate_deprecated_model,
+        sagemaker_session=sagemaker_session,
+    )

sagemaker/core/image_retriever/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import absolute_import
+
+from sagemaker.core.image_retriever.image_retriever import ImageRetriever  # noqa: F401