def retrieve_default(
region=None,
model_id=None,
model_version=None,
) -> Dict[str, str]:
"""Retrieves the default container environment variables for the model matching the arguments.
Args:
region (str): Optional. The AWS Region for which to retrieve the default environment
variables. (Default: None).
model_id (str): Optional. The model ID of the model for which to
retrieve the default environment variables. (Default: None).
model_version (str): Optional. The version of the model for which to retrieve the
default environment variables. (Default: None).
Returns:
dict: The variables 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 `model_id` and `model_version` when retrieving environment variables."
)
return artifacts._retrieve_default_environment_variables(
model_id, model_version, region)
def retrieve_default(
region=None,
model_id=None,
model_version=None,
include_container_hyperparameters=False,
) -> 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).
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).
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 `model_id` and `model_version` when retrieving hyperparameters."
)
return artifacts._retrieve_default_hyperparameters(
model_id, model_version, region, include_container_hyperparameters)
def retrieve(
region=None,
model_id=None,
model_version=None,
script_scope=None,
tolerate_vulnerable_model: bool = False,
tolerate_deprecated_model: bool = False,
) -> str:
"""Retrieves the script S3 URI associated with the model matching the given arguments.
Args:
region (str): The AWS Region for which to retrieve the model script S3 URI.
model_id (str): The model ID of the JumpStart model for which to
retrieve the script S3 URI.
model_version (str): The version of the JumpStart model for which to retrieve the
model script S3 URI.
script_scope (str): The script type.
Valid values: "training" and "inference".
tolerate_vulnerable_model (bool): ``True`` if vulnerable versions of model
specifications should be tolerated without raising an exception. 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
without raising an exception. ``False`` if these models should raise an exception.
(Default: False).
Returns:
str: The model script URI for the corresponding model.
Raises:
NotImplementedError: If the scope is not supported.
ValueError: If the combination of arguments specified is not supported.
VulnerableJumpStartModelError: If any of the dependencies required by the script have
known security vulnerabilities.
DeprecatedJumpStartModelError: If the version of the model is deprecated.
"""
if not jumpstart_utils.is_jumpstart_model_input(model_id, model_version):
raise ValueError(
"Must specify `model_id` and `model_version` when retrieving script URIs."
)
return artifacts._retrieve_script_uri(
model_id,
model_version,
script_scope,
region,
tolerate_vulnerable_model,
tolerate_deprecated_model,
)
def validate(
region: Optional[str] = None,
model_id: Optional[str] = None,
model_version: Optional[str] = None,
hyperparameters: Optional[dict] = None,
validation_mode: Optional[HyperparameterValidationMode] = None,
) -> 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).
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).
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 `model_id` and `model_version` when validating hyperparameters."
)
if hyperparameters is None:
raise ValueError("Must specify hyperparameters.")
return validate_hyperparameters(
model_id=model_id,
model_version=model_version,
hyperparameters=hyperparameters,
validation_mode=validation_mode,
region=region,
)
def retrieve(
framework,
region,
version=None,
py_version=None,
instance_type=None,
accelerator_type=None,
image_scope=None,
container_version=None,
distribution=None,
base_framework_version=None,
training_compiler_config=None,
model_id=None,
model_version=None,
tolerate_vulnerable_model=False,
tolerate_deprecated_model=False,
) -> str:
"""Retrieves the ECR URI for the Docker image matching the given arguments.
Ideally this function should not be called directly, rather it should be called from the
fit() function inside framework estimator.
Args:
framework (str): The name of the framework or algorithm.
region (str): The AWS region.
version (str): The framework or algorithm version. This is required if there is
more than one supported version for the given framework or algorithm.
py_version (str): The Python version. This is required if there is
more than one supported Python version for the given framework version.
instance_type (str): The SageMaker instance type. For supported types, see
https://aws.amazon.com/sagemaker/pricing. This is required if
there are different images for different processor types.
accelerator_type (str): Elastic Inference accelerator type. For more, see
https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html.
image_scope (str): The image type, i.e. what it is used for.
Valid values: "training", "inference", "eia". If ``accelerator_type`` is set,
``image_scope`` is ignored.
container_version (str): the version of docker image.
Ideally the value of parameter should be created inside the framework.
For custom use, see the list of supported container versions:
https://github.com/aws/deep-learning-containers/blob/master/available_images.md
(default: None).
distribution (dict): A dictionary with information on how to run distributed training
training_compiler_config (:class:`~sagemaker.training_compiler.TrainingCompilerConfig`):
A configuration class for the SageMaker Training Compiler
(default: None).
model_id (str): The JumpStart model ID for which to retrieve the image URI
(default: None).
model_version (str): The version of the JumpStart model for which to retrieve the
image URI (default: None).
tolerate_vulnerable_model (bool): ``True`` if vulnerable versions of model specifications
should be tolerated without an exception 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 versions of model specifications
should be tolerated without an exception raised. If False, raises an exception
if the version of the model is deprecated. (Default: False).
Returns:
str: The ECR URI for the corresponding SageMaker Docker image.
Raises:
NotImplementedError: If the scope is not supported.
ValueError: If the combination of arguments specified is not supported.
VulnerableJumpStartModelError: If any of the dependencies required by the script have
known security vulnerabilities.
DeprecatedJumpStartModelError: If the version of the model is deprecated.
"""
if is_jumpstart_model_input(model_id, model_version):
return artifacts._retrieve_image_uri(
model_id,
model_version,
image_scope,
framework,
region,
version,
py_version,
instance_type,
accelerator_type,
container_version,
distribution,
base_framework_version,
training_compiler_config,
tolerate_vulnerable_model,
tolerate_deprecated_model,
)
if training_compiler_config is None:
config = _config_for_framework_and_scope(framework, image_scope,
accelerator_type)
elif framework == HUGGING_FACE_FRAMEWORK:
config = _config_for_framework_and_scope(
framework + "-training-compiler", image_scope, accelerator_type)
else:
raise ValueError(
"Unsupported Configuration: Training Compiler is only supported with HuggingFace"
)
original_version = version
version = _validate_version_and_set_if_needed(version, config, framework)
version_config = config["versions"][_version_for_config(version, config)]
if framework == HUGGING_FACE_FRAMEWORK:
if version_config.get("version_aliases"):
full_base_framework_version = version_config[
"version_aliases"].get(base_framework_version,
base_framework_version)
_validate_arg(full_base_framework_version, list(version_config.keys()),
"base framework")
version_config = version_config.get(full_base_framework_version)
py_version = _validate_py_version_and_set_if_needed(
py_version, version_config, framework)
version_config = version_config.get(py_version) or version_config
registry = _registry_from_region(region, version_config["registries"])
hostname = utils._botocore_resolver().construct_endpoint(
"ecr", region)["hostname"]
repo = version_config["repository"]
processor = _processor(
instance_type,
config.get("processors") or version_config.get("processors"))
# if container version is available in .json file, utilize that
if version_config.get("container_version"):
container_version = version_config["container_version"][processor]
if framework == HUGGING_FACE_FRAMEWORK:
pt_or_tf_version = (re.compile("^(pytorch|tensorflow)(.*)$").match(
base_framework_version).group(2))
_version = original_version
if repo in [
"huggingface-pytorch-trcomp-training",
"huggingface-tensorflow-trcomp-training",
]:
_version = version
tag_prefix = f"{pt_or_tf_version}-transformers{_version}"
else:
tag_prefix = version_config.get("tag_prefix", version)
tag = _format_tag(
tag_prefix,
processor,
py_version,
container_version,
)
if _should_auto_select_container_version(instance_type, distribution):
container_versions = {
"tensorflow-2.3-gpu-py37": "cu110-ubuntu18.04-v3",
"tensorflow-2.3.1-gpu-py37": "cu110-ubuntu18.04",
"tensorflow-2.3.2-gpu-py37": "cu110-ubuntu18.04",
"tensorflow-1.15-gpu-py37": "cu110-ubuntu18.04-v8",
"tensorflow-1.15.4-gpu-py37": "cu110-ubuntu18.04",
"tensorflow-1.15.5-gpu-py37": "cu110-ubuntu18.04",
"mxnet-1.8-gpu-py37": "cu110-ubuntu16.04-v1",
"mxnet-1.8.0-gpu-py37": "cu110-ubuntu16.04",
"pytorch-1.6-gpu-py36": "cu110-ubuntu18.04-v3",
"pytorch-1.6.0-gpu-py36": "cu110-ubuntu18.04",
"pytorch-1.6-gpu-py3": "cu110-ubuntu18.04-v3",
"pytorch-1.6.0-gpu-py3": "cu110-ubuntu18.04",
}
key = "-".join([framework, tag])
if key in container_versions:
tag = "-".join([tag, container_versions[key]])
if tag:
repo += ":{}".format(tag)
return ECR_URI_TEMPLATE.format(registry=registry,
hostname=hostname,
repository=repo)