def test_deploy_model_with_accelerator(
mxnet_training_job,
sagemaker_session,
mxnet_eia_latest_version,
mxnet_eia_py_version,
cpu_instance_type,
):
endpoint_name = "test-mxnet-deploy-model-ei-{}".format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job
)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
script_path = os.path.join(DATA_DIR, "mxnet_mnist", "mnist.py")
model = MXNetModel(
model_data,
"SageMakerRole",
entry_point=script_path,
framework_version=mxnet_eia_latest_version,
py_version=mxnet_eia_py_version,
sagemaker_session=sagemaker_session,
)
predictor = model.deploy(
1, cpu_instance_type, endpoint_name=endpoint_name, accelerator_type="ml.eia1.medium"
)
data = numpy.zeros(shape=(1, 1, 28, 28))
result = predictor.predict(data)
assert result is not None
def test_deploy_model(
mxnet_training_job,
sagemaker_session,
mxnet_inference_latest_version,
mxnet_inference_latest_py_version,
cpu_instance_type,
):
endpoint_name = "test-mxnet-deploy-model-{}".format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job
)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
script_path = os.path.join(DATA_DIR, "mxnet_mnist", "mnist.py")
model = MXNetModel(
model_data,
"SageMakerRole",
entry_point=script_path,
py_version=mxnet_inference_latest_py_version,
sagemaker_session=sagemaker_session,
framework_version=mxnet_inference_latest_version,
)
predictor = model.deploy(1, cpu_instance_type, endpoint_name=endpoint_name)
data = numpy.zeros(shape=(1, 1, 28, 28))
result = predictor.predict(data)
assert result is not None
predictor.delete_model()
with pytest.raises(Exception) as exception:
sagemaker_session.sagemaker_client.describe_model(ModelName=model.name)
assert "Could not find model" in str(exception.value)
def test_git_support_codecommit_with_mxnet(sagemaker_local_session):
script_path = "mnist.py"
data_path = os.path.join(DATA_DIR, "mxnet_mnist")
git_config = {
"repo": CODECOMMIT_REPO,
"branch": CODECOMMIT_BRANCH,
"username": "******",
"password": "******",
}
source_dir = "mxnet"
dependencies = ["foo/bar.py"]
mx = MXNet(
entry_point=script_path,
role="SageMakerRole",
source_dir=source_dir,
dependencies=dependencies,
framework_version=MXNet.LATEST_VERSION,
py_version=PYTHON_VERSION,
train_instance_count=1,
train_instance_type="local",
sagemaker_session=sagemaker_local_session,
git_config=git_config,
)
mx.fit(
{
"train": "file://" + os.path.join(data_path, "train"),
"test": "file://" + os.path.join(data_path, "test"),
}
)
files = [file for file in os.listdir(mx.source_dir)]
assert "some_file" in files
assert "mnist.py" in files
assert os.path.exists(mx.dependencies[0])
with lock.lock(LOCK_PATH):
try:
client = sagemaker_local_session.sagemaker_client
desc = client.describe_training_job(TrainingJobName=mx.latest_training_job.name)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
model = MXNetModel(
model_data,
"SageMakerRole",
entry_point=script_path,
source_dir=source_dir,
dependencies=dependencies,
py_version=PYTHON_VERSION,
sagemaker_session=sagemaker_local_session,
framework_version=MXNet.LATEST_VERSION,
git_config=git_config,
)
predictor = model.deploy(1, "local")
data = numpy.zeros(shape=(1, 1, 28, 28))
result = predictor.predict(data)
assert result is not None
finally:
predictor.delete_endpoint()
def test_deploy_model_with_tags_and_kms(
mxnet_training_job,
sagemaker_session,
mxnet_inference_latest_version,
mxnet_inference_latest_py_version,
cpu_instance_type,
):
endpoint_name = "test-mxnet-deploy-model-{}".format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job
)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
script_path = os.path.join(DATA_DIR, "mxnet_mnist", "mnist.py")
model = MXNetModel(
model_data,
"SageMakerRole",
entry_point=script_path,
py_version=mxnet_inference_latest_py_version,
sagemaker_session=sagemaker_session,
framework_version=mxnet_inference_latest_version,
)
tags = [{"Key": "TagtestKey", "Value": "TagtestValue"}]
kms_key_arn = get_or_create_kms_key(sagemaker_session)
model.deploy(
1, cpu_instance_type, endpoint_name=endpoint_name, tags=tags, kms_key=kms_key_arn
)
returned_model = sagemaker_session.sagemaker_client.describe_model(ModelName=model.name)
returned_model_tags = sagemaker_session.sagemaker_client.list_tags(
ResourceArn=returned_model["ModelArn"]
)["Tags"]
endpoint = sagemaker_session.sagemaker_client.describe_endpoint(EndpointName=endpoint_name)
endpoint_tags = sagemaker_session.sagemaker_client.list_tags(
ResourceArn=endpoint["EndpointArn"]
)["Tags"]
endpoint_config = sagemaker_session.sagemaker_client.describe_endpoint_config(
EndpointConfigName=endpoint["EndpointConfigName"]
)
endpoint_config_tags = sagemaker_session.sagemaker_client.list_tags(
ResourceArn=endpoint_config["EndpointConfigArn"]
)["Tags"]
production_variants = endpoint_config["ProductionVariants"]
assert returned_model_tags == tags
assert endpoint_config_tags == tags
assert endpoint_tags == tags
assert production_variants[0]["InstanceType"] == cpu_instance_type
assert production_variants[0]["InitialInstanceCount"] == 1
assert endpoint_config["KmsKeyId"] == kms_key_arn
def test_deploy_model(mxnet_training_job, sagemaker_session):
endpoint_name = 'test-mxnet-deploy-model-{}'.format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(TrainingJobName=mxnet_training_job)
model_data = desc['ModelArtifacts']['S3ModelArtifacts']
script_path = os.path.join(DATA_DIR, 'mxnet_mnist', 'mnist.py')
model = MXNetModel(model_data, 'SageMakerRole', entry_point=script_path, sagemaker_session=sagemaker_session)
predictor = model.deploy(1, 'ml.m4.xlarge', endpoint_name=endpoint_name)
data = numpy.zeros(shape=(1, 1, 28, 28))
predictor.predict(data)
def test_deploy_model(mxnet_training_job, sagemaker_session):
endpoint_name = 'test-mxnet-deploy-model-{}'.format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session, minutes=20):
desc = sagemaker_session.sagemaker_client.describe_training_job(TrainingJobName=mxnet_training_job)
model_data = desc['ModelArtifacts']['S3ModelArtifacts']
script_path = os.path.join(DATA_DIR, 'mxnet_mnist', 'mnist.py')
model = MXNetModel(model_data, 'SageMakerRole', entry_point=script_path, sagemaker_session=sagemaker_session)
predictor = model.deploy(1, 'ml.m4.xlarge', endpoint_name=endpoint_name)
data = numpy.zeros(shape=(1, 1, 28, 28))
predictor.predict(data)
def predictor(docker_image, sagemaker_local_session, local_instance_type):
default_handler_path = os.path.join(RESOURCE_PATH, 'default_handlers')
m = MXNetModel('file://{}'.format(os.path.join(default_handler_path, 'model')), 'SageMakerRole',
os.path.join(default_handler_path, 'code', 'empty_module.py'),
image=docker_image, sagemaker_session=sagemaker_local_session,
model_server_workers=NUM_MODEL_SERVER_WORKERS)
with local_mode_utils.lock():
try:
predictor = m.deploy(1, local_instance_type)
yield predictor
finally:
sagemaker_local_session.delete_endpoint(m.endpoint_name)
def predictor(docker_image, sagemaker_local_session, local_instance_type):
model = MXNetModel('file://{}'.format(MODEL_PATH),
'SageMakerRole',
SCRIPT_PATH,
image=docker_image,
sagemaker_session=sagemaker_local_session)
with local_mode_utils.lock():
try:
predictor = model.deploy(1, local_instance_type)
yield predictor
finally:
predictor.delete_endpoint()
def test_deploy_model_with_accelerator(mxnet_training_job, sagemaker_session, ei_mxnet_full_version):
endpoint_name = 'test-mxnet-deploy-model-ei-{}'.format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(TrainingJobName=mxnet_training_job)
model_data = desc['ModelArtifacts']['S3ModelArtifacts']
script_path = os.path.join(DATA_DIR, 'mxnet_mnist', 'mnist.py')
model = MXNetModel(model_data, 'SageMakerRole', entry_point=script_path,
framework_version=ei_mxnet_full_version, py_version=PYTHON_VERSION,
sagemaker_session=sagemaker_session)
predictor = model.deploy(1, 'ml.m4.xlarge', endpoint_name=endpoint_name, accelerator_type='ml.eia1.medium')
data = numpy.zeros(shape=(1, 1, 28, 28))
predictor.predict(data)
def test_deploy_model_with_tags_and_kms(mxnet_training_job, sagemaker_session,
mxnet_full_version):
endpoint_name = 'test-mxnet-deploy-model-{}'.format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job)
model_data = desc['ModelArtifacts']['S3ModelArtifacts']
script_path = os.path.join(DATA_DIR, 'mxnet_mnist', 'mnist.py')
model = MXNetModel(model_data,
'SageMakerRole',
entry_point=script_path,
py_version=PYTHON_VERSION,
sagemaker_session=sagemaker_session,
framework_version=mxnet_full_version)
tags = [{'Key': 'TagtestKey', 'Value': 'TagtestValue'}]
kms_key_arn = get_or_create_kms_key(sagemaker_session)
model.deploy(1,
'ml.m4.xlarge',
endpoint_name=endpoint_name,
tags=tags,
kms_key=kms_key_arn)
returned_model = sagemaker_session.describe_model(
EndpointName=model.name)
returned_model_tags = sagemaker_session.list_tags(
ResourceArn=returned_model['ModelArn'])['Tags']
endpoint = sagemaker_session.describe_endpoint(
EndpointName=endpoint_name)
endpoint_tags = sagemaker_session.list_tags(
ResourceArn=endpoint['EndpointArn'])['Tags']
endpoint_config = sagemaker_session.describe_endpoint_config(
EndpointConfigName=endpoint['EndpointConfigName'])
endpoint_config_tags = sagemaker_session.list_tags(
ResourceArn=endpoint_config['EndpointConfigArn'])['Tags']
production_variants = endpoint_config['ProductionVariants']
assert returned_model_tags == tags
assert endpoint_config_tags == tags
assert endpoint_tags == tags
assert production_variants[0]['InstanceType'] == 'ml.m4.xlarge'
assert production_variants[0]['InitialInstanceCount'] == 1
assert endpoint_config['KmsKeyId'] == kms_key_arn
def create_model(self, model_server_workers=None, role=None):
"""Create a SageMaker ``MXNetModel`` object that can be deployed to an ``Endpoint``.
Args:
role (str): The ``ExecutionRoleArn`` IAM Role ARN for the ``Model``, which is also used during
transform jobs. If not specified, the role from the Estimator will be used.
model_server_workers (int): Optional. The number of worker processes used by the inference server.
If None, server will use one worker per vCPU.
Returns:
sagemaker.mxnet.model.MXNetModel: A SageMaker ``MXNetModel`` object.
See :func:`~sagemaker.mxnet.model.MXNetModel` for full details.
"""
role = role or self.role
return MXNetModel(
self.model_data,
role,
self.entry_point,
source_dir=self._model_source_dir(),
enable_cloudwatch_metrics=self.enable_cloudwatch_metrics,
name=self._current_job_name,
container_log_level=self.container_log_level,
code_location=self.code_location,
py_version=self.py_version,
framework_version=self.framework_version,
image=self.image_name,
model_server_workers=model_server_workers,
sagemaker_session=self.sagemaker_session)
def create_model(self, model_server_workers=None):
"""Create a SageMaker ``MXNetModel`` object that can be deployed to an ``Endpoint``.
Args:
model_server_workers (int): Optional. The number of worker processes used by the inference server.
If None, server will use one worker per vCPU.
Returns:
sagemaker.mxnet.model.MXNetModel: A SageMaker ``MXNetModel`` object.
See :func:`~sagemaker.mxnet.model.MXNetModel` for full details.
"""
return MXNetModel(
self.model_data,
self.role,
self.entry_point,
source_dir=self._model_source_dir(),
enable_cloudwatch_metrics=self.enable_cloudwatch_metrics,
name=self._current_job_name,
container_log_level=self.container_log_level,
code_location=self.code_location,
py_version=self.py_version,
framework_version=self.framework_version,
image=self.image_name,
model_server_workers=model_server_workers,
sagemaker_session=self.sagemaker_session)
def _test_hosting_function(ecr_image, sagemaker_session, instance_type, framework_version):
prefix = 'mxnet-serving/default-handlers'
model_data = sagemaker_session.upload_data(path=MODEL_PATH, key_prefix=prefix)
model = MXNetModel(model_data,
'SageMakerRole',
SCRIPT_PATH,
framework_version=framework_version,
image_uri=ecr_image,
sagemaker_session=sagemaker_session)
endpoint_name = utils.unique_name_from_base('test-mxnet-serving')
with timeout.timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
predictor = model.deploy(1, instance_type, endpoint_name=endpoint_name)
output = predictor.predict([[1, 2]])
assert [[4.9999918937683105]] == output
def test_hosting(docker_image, sagemaker_local_session, local_instance_type):
model = MXNetModel('file://{}'.format(MODEL_PATH),
'SageMakerRole',
SCRIPT_PATH,
image=docker_image,
sagemaker_session=sagemaker_local_session)
input = json.dumps({'some': 'json'})
with local_mode_utils.lock():
try:
predictor = model.deploy(1, local_instance_type)
output = predictor.predict(input)
assert input == output
finally:
sagemaker_local_session.delete_endpoint(model.endpoint_name)
def test_hosting(docker_image, sagemaker_local_session, local_instance_type):
hosting_resource_path = os.path.join(RESOURCE_PATH, 'dummy_hosting')
m = MXNetModel('file://{}'.format(os.path.join(hosting_resource_path, 'code')), 'SageMakerRole',
os.path.join(hosting_resource_path, 'code', 'dummy_hosting_module.py'),
image=docker_image, sagemaker_session=sagemaker_local_session,
model_server_workers=NUM_MODEL_SERVER_WORKERS)
input = json.dumps({'some': 'json'})
with local_mode_utils.lock():
try:
predictor = m.deploy(1, local_instance_type)
output = predictor.predict(input)
assert input == output
finally:
sagemaker_local_session.delete_endpoint(m.endpoint_name)
def test_inferentia_deploy_model(
mxnet_training_job,
sagemaker_session,
inf_instance_type,
inf_instance_family,
inferentia_mxnet_latest_version,
inferentia_mxnet_latest_py_version,
):
endpoint_name = unique_name_from_base("test-neo-deploy-model")
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
script_path = os.path.join(DATA_DIR, "mxnet_mnist", "mnist_neo.py")
role = "SageMakerRole"
model = MXNetModel(
model_data,
role,
entry_point=script_path,
framework_version=inferentia_mxnet_latest_version,
py_version=inferentia_mxnet_latest_py_version,
sagemaker_session=sagemaker_session,
)
model.compile(
target_instance_family=inf_instance_family,
input_shape={
"data": [1, 1, 28, 28],
"softmax_label": [1]
},
role=role,
job_name=unique_name_from_base(
"test-deploy-model-compilation-job"),
output_path="/".join(model_data.split("/")[:-1]),
)
serializer = JSONSerializer()
serializer.CONTENT_TYPE = "application/vnd+python.numpy+binary"
predictor = model.deploy(1,
inf_instance_type,
serializer=serializer,
endpoint_name=endpoint_name)
data = numpy.zeros(shape=(1, 1, 28, 28))
predictor.predict(data)
def test_gluon_hosting(docker_image, sagemaker_local_session, local_instance_type):
model = MXNetModel('file://{}'.format(MODEL_PATH),
'SageMakerRole',
SCRIPT_PATH,
image=docker_image,
sagemaker_session=sagemaker_local_session)
with open(os.path.join(RESOURCE_PATH, 'mnist', 'images', '04.json'), 'r') as f:
input = json.load(f)
with local_mode_utils.lock():
try:
predictor = model.deploy(1, local_instance_type)
output = predictor.predict(input)
assert [4.0] == output
finally:
predictor.delete_endpoint()
def create_model(self, model_url):
from sagemaker.mxnet.model import MXNetModel
return MXNetModel(model_data=model_url,
role=self.role_name,
entry_point=self.script,
py_version=self.python,
name=self.endpoint_name,
env=self.environment)
def test_register_model_package_versioned(
mxnet_training_job,
sagemaker_session,
mxnet_inference_latest_version,
mxnet_inference_latest_py_version,
cpu_instance_type,
):
endpoint_name = "test-mxnet-deploy-model-{}".format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job)
model_package_group_name = "register-model-package-{}".format(
sagemaker_timestamp())
sagemaker_session.sagemaker_client.create_model_package_group(
ModelPackageGroupName=model_package_group_name)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
script_path = os.path.join(DATA_DIR, "mxnet_mnist", "mnist.py")
model = MXNetModel(
model_data,
"SageMakerRole",
entry_point=script_path,
py_version=mxnet_inference_latest_py_version,
sagemaker_session=sagemaker_session,
framework_version=mxnet_inference_latest_version,
)
model_pkg = model.register(
content_types=["application/json"],
response_types=["application/json"],
inference_instances=["ml.m5.large"],
transform_instances=["ml.m5.large"],
model_package_group_name=model_package_group_name,
approval_status="Approved",
)
assert isinstance(model_pkg, ModelPackage)
predictor = model.deploy(1,
cpu_instance_type,
endpoint_name=endpoint_name)
data = numpy.zeros(shape=(1, 1, 28, 28))
result = predictor.predict(data)
assert result is not None
sagemaker_session.sagemaker_client.delete_model_package(
ModelPackageName=model_pkg.model_package_arn)
sagemaker_session.sagemaker_client.delete_model_package_group(
ModelPackageGroupName=model_package_group_name)
def test_deploy_model(mxnet_training_job, sagemaker_session, mxnet_full_version):
endpoint_name = 'test-mxnet-deploy-model-{}'.format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(TrainingJobName=mxnet_training_job)
model_data = desc['ModelArtifacts']['S3ModelArtifacts']
script_path = os.path.join(DATA_DIR, 'mxnet_mnist', 'mnist.py')
model = MXNetModel(model_data, 'SageMakerRole', entry_point=script_path,
py_version=PYTHON_VERSION, sagemaker_session=sagemaker_session,
framework_version=mxnet_full_version)
predictor = model.deploy(1, 'ml.m4.xlarge', endpoint_name=endpoint_name)
data = numpy.zeros(shape=(1, 1, 28, 28))
predictor.predict(data)
predictor.delete_model()
with pytest.raises(Exception) as exception:
sagemaker_session.sagemaker_client.describe_model(ModelName=model.name)
assert 'Could not find model' in str(exception.value)
def deploy_bert(model_data, sagemaker_session, ecr_image, instance_type, framework_version, role, script="bert_inference.py"):
"""
"""
model = MXNetModel(model_data,
role,
etnry_point=script,
source_dir="code",
image_uri=ecr_image,
py_version="py3",
framework_version=framework_version,
sagemaker_session=sagemaker_session)
endpoint_name = utils.unique_name_from_base('bert')
print("Deploying...")
predictor = model.deploy(1, instance_type, endpoint_name=endpoint_name)
print("\nEndpoint Name: {}".format(endpoint_name))
return predictor
def test_deploy_model_and_update_endpoint(
mxnet_training_job,
sagemaker_session,
mxnet_inference_latest_version,
mxnet_inference_latest_py_version,
cpu_instance_type,
alternative_cpu_instance_type,
):
endpoint_name = "test-mxnet-deploy-model-{}".format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
script_path = os.path.join(DATA_DIR, "mxnet_mnist", "mnist.py")
model = MXNetModel(
model_data,
"SageMakerRole",
entry_point=script_path,
py_version=mxnet_inference_latest_py_version,
sagemaker_session=sagemaker_session,
framework_version=mxnet_inference_latest_version,
)
predictor = model.deploy(1,
alternative_cpu_instance_type,
endpoint_name=endpoint_name)
endpoint_desc = sagemaker_session.sagemaker_client.describe_endpoint(
EndpointName=endpoint_name)
old_config_name = endpoint_desc["EndpointConfigName"]
predictor.update_endpoint(initial_instance_count=1,
instance_type=cpu_instance_type)
endpoint_desc = sagemaker_session.sagemaker_client.describe_endpoint(
EndpointName=endpoint_name)
new_config_name = endpoint_desc["EndpointConfigName"]
new_config = sagemaker_session.sagemaker_client.describe_endpoint_config(
EndpointConfigName=new_config_name)
assert old_config_name != new_config_name
assert new_config["ProductionVariants"][0][
"InstanceType"] == cpu_instance_type
assert new_config["ProductionVariants"][0]["InitialInstanceCount"] == 1
def test_jumpstart_mxnet_image_uri(patched_get_model_specs, session):
patched_get_model_specs.side_effect = get_prototype_model_spec
model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"
instance_type = "ml.p2.xlarge"
region = "us-west-2"
model_specs = accessors.JumpStartModelsAccessor.get_model_specs(
region, model_id, model_version)
# inference
uri = image_uris.retrieve(
framework=None,
region=region,
image_scope="inference",
model_id=model_id,
model_version=model_version,
instance_type=instance_type,
)
framework_class_uri = MXNetModel(
role="mock_role",
model_data="mock_data",
entry_point="mock_entry_point",
framework_version=model_specs.hosting_ecr_specs.framework_version,
py_version=model_specs.hosting_ecr_specs.py_version,
sagemaker_session=session,
).serving_image_uri(region, instance_type)
assert uri == framework_class_uri
assert uri == "763104351884.dkr.ecr.us-west-2.amazonaws.com/mxnet-inference:1.7.0-gpu-py3"
# training
uri = image_uris.retrieve(
framework=None,
region=region,
image_scope="training",
model_id=model_id,
model_version=model_version,
instance_type=instance_type,
)
framework_class_uri = MXNet(
role="mock_role",
entry_point="mock_entry_point",
framework_version=model_specs.training_ecr_specs.framework_version,
py_version=model_specs.training_ecr_specs.py_version,
instance_type=instance_type,
instance_count=1,
sagemaker_session=session,
).training_image_uri(region=region)
assert uri == framework_class_uri
assert uri == "763104351884.dkr.ecr.us-west-2.amazonaws.com/mxnet-training:1.7.0-gpu-py3"
def test_hosting(docker_image, sagemaker_local_session, local_instance_type,
framework_version):
model = MXNetModel(model_data="file://{}".format(MODEL_PATH),
image_uri=docker_image,
role='SageMakerRole',
entry_point=SCRIPT_PATH,
framework_version=framework_version,
sagemaker_session=sagemaker_local_session)
with local_mode_utils.lock():
try:
predictor = model.deploy(1,
local_instance_type,
deserializer=StringDeserializer())
input = 'some data'
output = predictor.predict(input)
assert '"' + input + '"' == output
finally:
predictor.delete_endpoint()
def test_hosting(docker_image, sagemaker_local_session, local_instance_type):
model = MXNetModel('file://{}'.format(MODEL_PATH),
'SageMakerRole',
SCRIPT_PATH,
image=docker_image,
sagemaker_session=sagemaker_local_session)
with local_mode_utils.lock():
try:
predictor = model.deploy(1, local_instance_type)
predictor.serializer = None
predictor.deserializer = StringDeserializer()
predictor.accept = None
predictor.content_type = None
input = 'some data'
output = predictor.predict(input)
assert input == output
finally:
predictor.delete_endpoint()
def create_model(
self,
model_server_workers=None,
role=None,
vpc_config_override=VPC_CONFIG_DEFAULT,
entry_point=None,
source_dir=None,
dependencies=None,
):
"""Create a SageMaker ``MXNetModel`` object that can be deployed to an
``Endpoint``.
Args:
model_server_workers (int): Optional. The number of worker processes
used by the inference server. If None, server will use one
worker per vCPU.
role (str): The ``ExecutionRoleArn`` IAM Role ARN for the ``Model``,
which is also used during transform jobs. If not specified, the
role from the Estimator will be used.
vpc_config_override (dict[str, list[str]]): Optional override for VpcConfig set on
the model. Default: use subnets and security groups from this Estimator.
* 'Subnets' (list[str]): List of subnet ids.
* 'SecurityGroupIds' (list[str]): List of security group ids.
entry_point (str): Path (absolute or relative) to the local Python source file which
should be executed as the entry point to training. If not specified, the training
entry point is used.
source_dir (str): Path (absolute or relative) to a directory with any other serving
source code dependencies aside from the entry point file.
If not specified, the model source directory from training is used.
dependencies (list[str]): A list of paths to directories (absolute or relative) with
any additional libraries that will be exported to the container.
If not specified, the dependencies from training are used.
Returns:
sagemaker.mxnet.model.MXNetModel: A SageMaker ``MXNetModel`` object.
See :func:`~sagemaker.mxnet.model.MXNetModel` for full details.
"""
return MXNetModel(
self.model_data,
role or self.role,
entry_point or self.entry_point,
source_dir=(source_dir or self._model_source_dir()),
enable_cloudwatch_metrics=self.enable_cloudwatch_metrics,
name=self._current_job_name,
container_log_level=self.container_log_level,
code_location=self.code_location,
py_version=self.py_version,
framework_version=self.framework_version,
image=self.image_name,
model_server_workers=model_server_workers,
sagemaker_session=self.sagemaker_session,
vpc_config=self.get_vpc_config(vpc_config_override),
dependencies=(dependencies or self.dependencies),
)
def test_batch_transform(sagemaker_session, ecr_image, instance_type, framework_version):
s3_prefix = 'mxnet-serving/mnist'
model_data = sagemaker_session.upload_data(path=MODEL_PATH, key_prefix=s3_prefix)
model = MXNetModel(model_data,
'SageMakerRole',
SCRIPT_PATH,
image=ecr_image,
framework_version=framework_version,
sagemaker_session=sagemaker_session)
transformer = model.transformer(1, instance_type)
with timeout.timeout_and_delete_model_with_transformer(transformer, sagemaker_session, minutes=20):
input_data = sagemaker_session.upload_data(path=DATA_PATH, key_prefix=s3_prefix)
job_name = utils.unique_name_from_base('test-mxnet-serving-batch')
transformer.transform(input_data, content_type='text/csv', job_name=job_name)
transformer.wait()
prediction = _transform_result(sagemaker_session.boto_session, transformer.output_path)
assert prediction == 7
def test_gluon_hosting(docker_image, sagemaker_local_session,
local_instance_type):
gluon_path = os.path.join(RESOURCE_PATH, 'gluon_hosting')
m = MXNetModel('file://{}'.format(os.path.join(gluon_path, 'model')),
'SageMakerRole',
os.path.join(gluon_path, 'code', 'gluon.py'),
image=docker_image,
sagemaker_session=sagemaker_local_session,
model_server_workers=NUM_MODEL_SERVER_WORKERS)
with open(os.path.join(RESOURCE_PATH, 'mnist_images', '04.json'),
'r') as f:
input = json.load(f)
with local_mode_utils.lock():
try:
predictor = m.deploy(1, local_instance_type)
output = predictor.predict(input)
assert [4.0] == output
finally:
sagemaker_local_session.delete_endpoint(m.endpoint_name)
def test_default_model_fn(docker_image, sagemaker_local_session,
local_instance_type):
default_handler_path = os.path.join(RESOURCE_PATH, 'default_handlers')
m = MXNetModel('file://{}'.format(
os.path.join(default_handler_path, 'model')),
'SageMakerRole',
os.path.join(default_handler_path, 'code',
'empty_module.py'),
image=docker_image,
sagemaker_session=sagemaker_local_session,
model_server_workers=NUM_MODEL_SERVER_WORKERS)
input = [[1, 2]]
with local_mode_utils.lock():
try:
predictor = m.deploy(1, local_instance_type)
output = predictor.predict(input)
assert [[4.9999918937683105]] == output
finally:
sagemaker_local_session.delete_endpoint(m.endpoint_name)
def test_deploy_model_with_update_endpoint(mxnet_training_job,
sagemaker_session,
mxnet_full_version):
endpoint_name = 'test-mxnet-deploy-model-{}'.format(sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job)
model_data = desc['ModelArtifacts']['S3ModelArtifacts']
script_path = os.path.join(DATA_DIR, 'mxnet_mnist', 'mnist.py')
model = MXNetModel(model_data,
'SageMakerRole',
entry_point=script_path,
py_version=PYTHON_VERSION,
sagemaker_session=sagemaker_session,
framework_version=mxnet_full_version)
model.deploy(1, 'ml.t2.medium', endpoint_name=endpoint_name)
old_endpoint = sagemaker_session.describe_endpoint(
EndpointName=endpoint_name)
old_config_name = old_endpoint['EndpointConfigName']
model.deploy(1,
'ml.m4.xlarge',
update_endpoint=True,
endpoint_name=endpoint_name)
new_endpoint = sagemaker_session.describe_endpoint(
EndpointName=endpoint_name)['ProductionVariants']
new_production_variants = new_endpoint['ProductionVariants']
new_config_name = new_endpoint['EndpointConfigName']
assert old_config_name != new_config_name
assert new_production_variants['InstanceType'] == 'ml.m4.xlarge'
assert new_production_variants['InitialInstanceCount'] == 1
assert new_production_variants['AcceleratorType'] is None
def test_deploy_model_with_update_non_existing_endpoint(
mxnet_training_job, sagemaker_session, mxnet_full_version):
endpoint_name = 'test-mxnet-deploy-model-{}'.format(sagemaker_timestamp())
expected_error_message = 'Endpoint with name "{}" does not exist; ' \
'please use an existing endpoint name'.format(endpoint_name)
with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session):
desc = sagemaker_session.sagemaker_client.describe_training_job(
TrainingJobName=mxnet_training_job)
model_data = desc['ModelArtifacts']['S3ModelArtifacts']
script_path = os.path.join(DATA_DIR, 'mxnet_mnist', 'mnist.py')
model = MXNetModel(model_data,
'SageMakerRole',
entry_point=script_path,
py_version=PYTHON_VERSION,
sagemaker_session=sagemaker_session,
framework_version=mxnet_full_version)
model.deploy(1, 'ml.t2.medium', endpoint_name=endpoint_name)
sagemaker_session.describe_endpoint(EndpointName=endpoint_name)
with pytest.raises(ValueError, message=expected_error_message):
model.deploy(1,
'ml.m4.xlarge',
update_endpoint=True,
endpoint_name='non-existing-endpoint')
