def prepare_container_def(self, instance_type):
"""Return a container definition with framework configuration set in model environment variables.
This also uploads user-supplied code to S3.
Args:
instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'.
Returns:
dict[str, str]: A container definition object usable with the CreateModel API.
"""
deploy_image = self.image
if not deploy_image:
region_name = self.sagemaker_session.boto_region_name
deploy_image = create_image_uri(region_name, self.__framework_name__, instance_type,
self.framework_version, self.py_version)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name, deploy_image)
self._upload_code(deploy_key_prefix)
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(self.model_server_workers)
return sagemaker.container_def(deploy_image, self.model_data, deploy_env)
def prepare_container_def(self, instance_type):
"""Return a dict created by ``sagemaker.container_def()`` for deploying this model to a specified instance type.
Subclasses can override this to provide custom container definitions for
deployment to a specific instance type. Called by ``deploy()``.
Args:
instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'.
Returns:
dict: A container definition object usable with the CreateModel API.
"""
return sagemaker.container_def(self.image, self.model_data, self.env)
def prepare_container_def(self, instance_type, accelerator_type=None):
"""Return a container definition with framework configuration set in
model environment variables.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
For example, 'ml.p2.xlarge'.
accelerator_type (str): The Elastic Inference accelerator type to
deploy to the instance for loading and making inferences to the
model. For example, 'ml.eia1.medium'.
Returns:
dict[str, str]: A container definition object usable with the
CreateModel API.
"""
lowest_mms_version = pkg_resources.parse_version(
self._LOWEST_MMS_VERSION)
framework_version = pkg_resources.parse_version(self.framework_version)
is_mms_version = framework_version >= lowest_mms_version
deploy_image = self.image
if not deploy_image:
region_name = self.sagemaker_session.boto_session.region_name
framework_name = self.__framework_name__
if is_mms_version:
framework_name += "-serving"
deploy_image = create_image_uri(
region_name,
framework_name,
instance_type,
self.framework_version,
self.py_version,
accelerator_type=accelerator_type,
)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name,
deploy_image)
self._upload_code(deploy_key_prefix, repack=is_mms_version)
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(
self.model_server_workers)
return sagemaker.container_def(
deploy_image, self.repacked_model_data or self.model_data,
deploy_env)
def prepare_container_def(self, instance_type):
"""Return a container definition with framework configuration set in model environment variables.
This also uploads user-supplied code to S3.
Args:
instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'.
Returns:
dict[str, str]: A container definition object usable with the CreateModel API.
"""
self._upload_code(self.key_prefix or self.name
or name_from_image(self.image))
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
return sagemaker.container_def(self.image, self.model_data, deploy_env)
def prepare_container_def(self, instance_type):
"""Return a container definition with framework configuration set in model environment variables.
This also uploads user-supplied code to S3.
Args:
instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'.
Returns:
dict[str, str]: A container definition object usable with the CreateModel API.
"""
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name, self.image)
self._upload_code(deploy_key_prefix)
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
return sagemaker.container_def(self.image, self.model_data, deploy_env)
def prepare_container_def(self,
instance_type=None,
accelerator_type=None,
serverless_inference_config=None):
"""A container definition with framework configuration set in model environment variables.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
For example, 'ml.p2.xlarge'.
accelerator_type (str): The Elastic Inference accelerator type to
deploy to the instance for loading and making inferences to the
model.
serverless_inference_config (sagemaker.serverless.ServerlessInferenceConfig):
Specifies configuration related to serverless endpoint. Instance type is
not provided in serverless inference. So this is used to find image URIs.
Returns:
dict[str, str]: A container definition object usable with the
CreateModel API.
"""
deploy_image = self.image_uri
if not deploy_image:
if instance_type is None and serverless_inference_config is None:
raise ValueError(
"Must supply either an instance type (for choosing CPU vs GPU) or an image URI."
)
region_name = self.sagemaker_session.boto_session.region_name
deploy_image = self.serving_image_uri(
region_name,
instance_type,
accelerator_type=accelerator_type,
serverless_inference_config=serverless_inference_config,
)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name,
deploy_image)
self._upload_code(deploy_key_prefix, repack=True)
deploy_env = dict(self.env)
deploy_env.update(self._script_mode_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(
self.model_server_workers)
return sagemaker.container_def(
deploy_image, self.repacked_model_data or self.model_data,
deploy_env)
def prepare_container_def(self, instance_type, accelerator_type=None): # pylint disable=unused-argument
"""Return a container definition with framework configuration set in model environment variables.
This also uploads user-supplied code to S3.
Args:
instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'.
accelerator_type (str): The Elastic Inference accelerator type to deploy to the instance for loading and
making inferences to the model. For example, 'ml.eia1.medium'.
Returns:
dict[str, str]: A container definition object usable with the CreateModel API.
"""
deploy_key_prefix = fw_utils.model_code_key_prefix(self.key_prefix, self.name, self.image)
self._upload_code(deploy_key_prefix)
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
return sagemaker.container_def(self.image, self.model_data, deploy_env)
def prepare_container_def(self, instance_type, accelerator_type=None): # pylint: disable=unused-argument
"""Return a dict created by ``sagemaker.container_def()`` for deploying
this model to a specified instance type.
Subclasses can override this to provide custom container definitions
for deployment to a specific instance type. Called by ``deploy()``.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
For example, 'ml.p2.xlarge'.
accelerator_type (str): The Elastic Inference accelerator type to
deploy to the instance for loading and making inferences to the
model. For example, 'ml.eia1.medium'.
Returns:
dict: A container definition object usable with the CreateModel API.
"""
return sagemaker.container_def(self.image, self.model_data, self.env)
def prepare_container_def(self, instance_type, accelerator_type=None):
image = self._get_image_uri(instance_type, accelerator_type)
env = self._get_container_env()
if self.entry_point:
key_prefix = sagemaker.fw_utils.model_code_key_prefix(
self.key_prefix, self.name, image)
bucket = self.bucket or self.sagemaker_session.default_bucket()
model_data = 's3://' + os.path.join(bucket, key_prefix,
'model.tar.gz')
sagemaker.utils.repack_model(self.entry_point, self.source_dir,
self.dependencies, self.model_data,
model_data, self.sagemaker_session)
else:
model_data = self.model_data
return sagemaker.container_def(image, model_data, env)
def prepare_container_def(self, instance_type, accelerator_type=None):
"""Return a container definition with framework configuration set in
model environment variables.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
For example, 'ml.p2.xlarge'.
accelerator_type (str): The Elastic Inference accelerator type to
deploy to the instance for loading and making inferences to the
model. For example, 'ml.eia1.medium'. Note: accelerator types
are not supported by SKLearnModel.
Returns:
dict[str, str]: A container definition object usable with the
CreateModel API.
"""
if accelerator_type:
raise ValueError(
"Accelerator types are not supported for Scikit-Learn.")
deploy_image = self.image
if not deploy_image:
image_tag = "{}-{}-{}".format(self.framework_version, "cpu",
self.py_version)
deploy_image = default_framework_uri(
self.__framework_name__,
self.sagemaker_session.boto_region_name, image_tag)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name,
deploy_image)
self._upload_code(key_prefix=deploy_key_prefix,
repack=self.enable_network_isolation())
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(
self.model_server_workers)
model_data_uri = (self.repacked_model_data if
self.enable_network_isolation() else self.model_data)
return sagemaker.container_def(deploy_image, model_data_uri,
deploy_env)
def prepare_container_def(self,
instance_type=None,
accelerator_type=None,
serverless_inference_config=None):
"""Return a container definition with framework configuration.
The framework configuration is set in model environment variables.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
accelerator_type (str): The Elastic Inference accelerator type to deploy to the
instance for loading and making inferences to the model. This parameter is
unused because accelerator types are not supported by XGBoostModel.
serverless_inference_config (sagemaker.serverless.ServerlessInferenceConfig):
Specifies configuration related to serverless endpoint. Instance type is
not provided in serverless inference. So this is used to find image URIs.
Returns:
dict[str, str]: A container definition object usable with the CreateModel API.
"""
deploy_image = self.image_uri
if not deploy_image:
deploy_image = self.serving_image_uri(
self.sagemaker_session.boto_region_name,
instance_type,
serverless_inference_config=serverless_inference_config,
)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name,
deploy_image)
self._upload_code(key_prefix=deploy_key_prefix,
repack=self.enable_network_isolation())
deploy_env = dict(self.env)
deploy_env.update(self._script_mode_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(
self.model_server_workers)
model_data = (self.repacked_model_data
if self.enable_network_isolation() else self.model_data)
return sagemaker.container_def(deploy_image, model_data, deploy_env)
def prepare_container_def(self, instance_type, accelerator_type=None):
"""Return a container definition with framework configuration set in
model environment variables.
This also uploads user-supplied code to S3.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
For example, 'ml.p2.xlarge'.
accelerator_type (str): The Elastic Inference accelerator type to
deploy to the instance for loading and making inferences to the
model. For example, 'ml.eia1.medium'.
Returns:
dict[str, str]: A container definition object usable with the
CreateModel API.
"""
deploy_image = self.image
if not deploy_image:
region_name = self.sagemaker_session.boto_region_name
deploy_image = create_image_uri(
region_name,
self.__framework_name__,
instance_type,
self.framework_version,
self.py_version,
accelerator_type=accelerator_type,
)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name,
deploy_image)
self._upload_code(deploy_key_prefix)
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(
self.model_server_workers)
return sagemaker.container_def(deploy_image, self.model_data,
deploy_env)
def prepare_container_def(self, instance_type=None, accelerator_type=None):
"""Return a container definition with framework configuration.
Framework configuration is set in model environment variables.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
For example, 'ml.p2.xlarge'.
accelerator_type (str): The Elastic Inference accelerator type to
deploy to the instance for loading and making inferences to the
model. For example, 'ml.eia1.medium'.
Returns:
dict[str, str]: A container definition object usable with the
CreateModel API.
"""
deploy_image = self.image_uri
if not deploy_image:
if instance_type is None:
raise ValueError(
"Must supply either an instance type (for choosing CPU vs GPU) or an image URI."
)
region_name = self.sagemaker_session.boto_session.region_name
deploy_image = self.serving_image_uri(
region_name, instance_type, accelerator_type=accelerator_type)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name,
deploy_image)
self._upload_code(deploy_key_prefix, self._is_mms_version())
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(
self.model_server_workers)
return sagemaker.container_def(
deploy_image, self.repacked_model_data or self.model_data,
deploy_env)
def prepare_container_def(self, instance_type=None, accelerator_type=None):
"""Prepare the container definition.
Args:
instance_type: Instance type of the container.
accelerator_type: Accelerator type, if applicable.
Returns:
A container definition for deploying a ``Model`` to an ``Endpoint``.
"""
if self.image_uri is None and instance_type is None:
raise ValueError(
"Must supply either an instance type (for choosing CPU vs GPU) or an image URI."
)
image_uri = self._get_image_uri(instance_type, accelerator_type)
env = self._get_container_env()
if self.entry_point:
key_prefix = sagemaker.fw_utils.model_code_key_prefix(
self.key_prefix, self.name, image_uri
)
bucket = self.bucket or self.sagemaker_session.default_bucket()
model_data = s3.s3_path_join("s3://", bucket, key_prefix, "model.tar.gz")
sagemaker.utils.repack_model(
self.entry_point,
self.source_dir,
self.dependencies,
self.model_data,
model_data,
self.sagemaker_session,
kms_key=self.model_kms_key,
)
else:
model_data = self.model_data
return sagemaker.container_def(image_uri, model_data, env)
def prepare_container_def(self, instance_type=None, accelerator_type=None):
"""Return a container definition with framework configuration set in
model environment variables.
Args:
instance_type (str): The EC2 instance type to deploy this Model to.
This parameter is unused because Scikit-learn supports only CPU.
accelerator_type (str): The Elastic Inference accelerator type to
deploy to the instance for loading and making inferences to the
model. This parameter is unused because accelerator types
are not supported by SKLearnModel.
Returns:
dict[str, str]: A container definition object usable with the
CreateModel API.
"""
if accelerator_type:
raise ValueError(
"Accelerator types are not supported for Scikit-Learn.")
deploy_image = self.image
if not deploy_image:
deploy_image = self.serving_image_uri(
self.sagemaker_session.boto_region_name, instance_type)
deploy_key_prefix = model_code_key_prefix(self.key_prefix, self.name,
deploy_image)
self._upload_code(key_prefix=deploy_key_prefix,
repack=self.enable_network_isolation())
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(
self.model_server_workers)
model_data_uri = (self.repacked_model_data if
self.enable_network_isolation() else self.model_data)
return sagemaker.container_def(deploy_image, model_data_uri,
deploy_env)
def prepare_container_def(self, instance_type):
"""Return a container definition with framework configuration set in model environment variables.
Args:
instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'.
Returns:
dict[str, str]: A container definition object usable with the CreateModel API.
"""
deploy_image = self.image
if not deploy_image:
region_name = self.sagemaker_session.boto_session.region_name
deploy_image = create_image_uri(region_name, self.__framework_name__, instance_type,
self.framework_version, self.py_version)
deploy_key_prefix = self.key_prefix or self.name or name_from_image(deploy_image)
self._upload_code(deploy_key_prefix)
deploy_env = dict(self.env)
deploy_env.update(self._framework_env_vars())
if self.model_server_workers:
deploy_env[MODEL_SERVER_WORKERS_PARAM_NAME.upper()] = str(self.model_server_workers)
return sagemaker.container_def(deploy_image, self.model_data, deploy_env)
def model_create(job,
model_artifact,
name,
session: sagemaker.Session,
inference_image,
inference_image_path,
inference_image_accounts,
role,
force,
multimodel=False,
accelerator_type=None):
job = cli_argument(job, session=session)
name = cli_argument(name, session=session)
model_artifact = cli_argument(model_artifact, session=session)
image_config = Image(tag=inference_image,
path=inference_image_path,
accounts=inference_image_accounts)
image_uri = ecr_ensure_image(image=image_config,
session=session.boto_session)
if (job and model_artifact) or (not (job or model_artifact)):
raise click.UsageError('Specify one of job_name or model_artifact')
if model_artifact and not name:
raise click.UsageError('name is required if job is not provided')
iam = session.boto_session.client('iam')
client = session.boto_session.client('sagemaker')
role = ensure_inference_role(iam=iam, role_name=role)
if job:
client = session.boto_session.client('sagemaker')
model_artifact = training_describe(
job_name=job,
field='ModelArtifacts.S3ModelArtifacts',
session=session)
if not name:
name = job
print("Creating model [{}] from job [{}] artifact [{}]".format(
name, job, model_artifact))
else:
if not model_artifact.startswith('s3://'):
if model_artifact.startswith('/'):
model_artifact = model_artifact[1:]
bucket = session.default_bucket()
model_artifact = 's3://{}/{}'.format(bucket, model_artifact)
print("Creating model [{}] from artifact [{}]".format(
name, model_artifact))
if model_exists(name=name, client=client):
if force:
print("Deleting existing model")
model_delete(name=name, client=client)
else:
raise click.UsageError('Specify force if overwriting model')
model = sagemaker.Model(
image_uri=image_uri,
model_data=model_artifact,
role=role,
predictor_cls=None,
env=None,
name=name,
# vpc_config=None,
sagemaker_session=session,
# enable_network_isolation=False,
# model_kms_key=None
)
container_def = sagemaker.container_def(
model.image_uri,
model.model_data,
model.env,
container_mode='MultiModel' if multimodel else 'SingleModel')
"""
client.create_model(
ModelName='string',
PrimaryContainer={
'ContainerHostname': 'string',
'Image': 'string',
'ImageConfig': {
'RepositoryAccessMode': 'Platform'|'Vpc'
},
'Mode': 'SingleModel'|'MultiModel',
'ModelDataUrl': 'string',
'Environment': {
'string': 'string'
},
'ModelPackageName': 'string'
},
"""
# self._ensure_base_name_if_needed(container_def["Image"])
# self._set_model_name_if_needed()
enable_network_isolation = model.enable_network_isolation()
# self._init_sagemaker_session_if_does_not_exist(instance_type)
session.create_model(
model.name,
model.role,
container_def,
vpc_config=model.vpc_config,
enable_network_isolation=enable_network_isolation,
# tags=tags,
)
def prepare_container_def(self, instance_type, accelerator_type=None):
image = self._get_image_uri(instance_type)
env = self._get_container_env()
return sagemaker.container_def(image, self.model_data, env)
def prepare_container_def(self,
instance_type=None,
accelerator_type=None,
serverless_inference_config=None):
"""Prepare the container definition.
Args:
instance_type: Instance type of the container.
accelerator_type: Accelerator type, if applicable.
serverless_inference_config (sagemaker.serverless.ServerlessInferenceConfig):
Specifies configuration related to serverless endpoint. Instance type is
not provided in serverless inference. So this is used to find image URIs.
Returns:
A container definition for deploying a ``Model`` to an ``Endpoint``.
"""
if not self.image_uri:
if instance_type is None and serverless_inference_config is None:
raise ValueError(
"Must supply either an instance type (for choosing CPU vs GPU) or an image URI."
)
image_uri = self._get_image_uri(
instance_type,
accelerator_type,
serverless_inference_config=serverless_inference_config)
env = self._get_container_env()
if self.entry_point and not is_pipeline_variable(self.model_data):
key_prefix = sagemaker.fw_utils.model_code_key_prefix(
self.key_prefix, self.name, image_uri)
bucket = self.bucket or self.sagemaker_session.default_bucket()
model_data = s3.s3_path_join("s3://", bucket, key_prefix,
"model.tar.gz")
sagemaker.utils.repack_model(
self.entry_point,
self.source_dir,
self.dependencies,
self.model_data,
model_data,
self.sagemaker_session,
kms_key=self.model_kms_key,
)
elif self.entry_point and is_pipeline_variable(self.model_data):
# model is not yet there, defer repacking to later during pipeline execution
if isinstance(self.sagemaker_session, PipelineSession):
self.sagemaker_session.context.need_runtime_repack.add(
id(self))
else:
# TODO: link the doc in the warning once ready
logging.warning(
"The model_data is a Pipeline variable of type %s, "
"which should be used under `PipelineSession` and "
"leverage `ModelStep` to create or register model. "
"Otherwise some functionalities e.g. "
"runtime repack may be missing",
type(self.model_data),
)
model_data = self.model_data
else:
model_data = self.model_data
return sagemaker.container_def(image_uri, model_data, env)
