def run_as_local_main():
args = parse_infer_args()
sm_boto3 = boto3.client('sagemaker')
sess = sagemaker.Session()
region = sess.boto_session.region_name
model_url = args.model_file
model = SKLearnModel(model_data=model_url,
source_dir=os.path.abspath(os.path.dirname(__file__)),
role=get_sm_execution_role(ON_SAGEMAKER_NOTEBOOK,
region),
entry_point='inference.py')
infer_mode = args.infer_mode
if 'bt' == infer_mode:
env = {'MODEL_SERVER_TIMEOUT': '120'}
transformer = model.transformer(
instance_count=1,
instance_type='ml.c5.xlarge',
output_path=args.output_dir,
max_payload=99,
env=env,
max_concurrent_transforms=1,
tags=[{
"Key": "Project",
"Value": "SM Example"
}],
)
transformer.transform(args.input_file, content_type="text/csv")
transformer.wait()
elif 'ep' == infer_mode:
model.deploy(instance_type='ml.c5.xlarge', initial_instance_count=1)
else:
raise Exception(f'Unknown inference mode {infer_mode}')
def attach_model(self):
# Ok this is working -> Just need to provide a model func
self.model = SKLearnModel(model_data=self.model_path,
role=aws_role,
entry_point=self.script_path,
framework_version="0.20.0",
sagemaker_session=self.session)
def test_private_github_with_2fa(sagemaker_local_session,
sklearn_latest_version,
sklearn_latest_py_version):
script_path = "mnist.py"
data_path = os.path.join(DATA_DIR, "sklearn_mnist")
git_config = {
"repo": PRIVATE_GIT_REPO_2FA,
"branch": PRIVATE_BRANCH_2FA,
"commit": PRIVATE_COMMIT_2FA,
"2FA_enabled": True,
"token": "", # TODO: find a secure approach
}
source_dir = "sklearn"
sklearn = SKLearn(
entry_point=script_path,
role="SageMakerRole",
source_dir=source_dir,
py_version=sklearn_latest_py_version,
instance_count=1,
instance_type="local",
sagemaker_session=sagemaker_local_session,
framework_version=sklearn_latest_version,
hyperparameters={"epochs": 1},
git_config=git_config,
)
train_input = "file://" + os.path.join(data_path, "train")
test_input = "file://" + os.path.join(data_path, "test")
sklearn.fit({"train": train_input, "test": test_input})
assert os.path.isdir(sklearn.source_dir)
with lock.lock(LOCK_PATH):
try:
client = sagemaker_local_session.sagemaker_client
desc = client.describe_training_job(
TrainingJobName=sklearn.latest_training_job.name)
model_data = desc["ModelArtifacts"]["S3ModelArtifacts"]
model = SKLearnModel(
model_data,
"SageMakerRole",
entry_point=script_path,
framework_version=sklearn_latest_version,
source_dir=source_dir,
sagemaker_session=sagemaker_local_session,
git_config=git_config,
)
predictor = model.deploy(1, "local")
data = numpy.zeros((100, 784), dtype="float32")
result = predictor.predict(data)
assert result is not None
finally:
predictor.delete_endpoint()
def create_model(self, model_server_workers=None, role=None,
vpc_config_override=VPC_CONFIG_DEFAULT, **kwargs):
"""Create a SageMaker ``SKLearnModel`` 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.
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.
**kwargs: Passed to initialization of ``SKLearnModel``.
Returns:
sagemaker.sklearn.model.SKLearnModel: A SageMaker ``SKLearnModel`` object.
See :func:`~sagemaker.sklearn.model.SKLearnModel` for full details.
"""
role = role or self.role
return SKLearnModel(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,
model_server_workers=model_server_workers, image=self.image_name,
sagemaker_session=self.sagemaker_session,
vpc_config=self.get_vpc_config(vpc_config_override),
**kwargs)
class Deployment:
def __init__(self, model_path, script_path):
self.model_path = model_path
self.script_path = script_path
self.session = get_sagemaker_session()
self.attach_model()
def attach_model(self):
# Ok this is working -> Just need to provide a model func
self.model = SKLearnModel(model_data=self.model_path,
role=aws_role,
entry_point=self.script_path,
framework_version="0.20.0",
sagemaker_session=self.session)
def deploy(self):
self.predictor = self.model.deploy(instance_type="ml.c4.xlarge",
initial_instance_count=1,
wait=False)
self.deployed = True
def get_endpointname(self):
return self.predictor.endpoint_name
def create_model(
self,
model_server_workers=None,
role=None,
vpc_config_override=VPC_CONFIG_DEFAULT,
entry_point=None,
source_dir=None,
dependencies=None,
**kwargs
):
"""Create a SageMaker ``SKLearnModel`` 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 ``source_dir`` is specified,
then ``entry_point`` must point to a file located at the root of ``source_dir``.
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.
**kwargs: Additional kwargs passed to the :class:`~sagemaker.sklearn.model.SKLearnModel`
constructor.
Returns:
sagemaker.sklearn.model.SKLearnModel: A SageMaker ``SKLearnModel``
object. See :func:`~sagemaker.sklearn.model.SKLearnModel` for full details.
"""
role = role or self.role
if "image" not in kwargs:
kwargs["image"] = self.image_name
if "enable_network_isolation" not in kwargs:
kwargs["enable_network_isolation"] = self.enable_network_isolation()
if "name" not in kwargs:
kwargs["name"] = self._current_job_name
return SKLearnModel(
self.model_data,
role,
entry_point or self.entry_point,
source_dir=(source_dir or self._model_source_dir()),
enable_cloudwatch_metrics=self.enable_cloudwatch_metrics,
container_log_level=self.container_log_level,
code_location=self.code_location,
py_version=self.py_version,
framework_version=self.framework_version,
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),
**kwargs
)
def main(datacapture=False):
# Load config from environment and set required defaults
# AWS especific
AWS_DEFAULT_REGION = os.getenv('AWS_DEFAULT_REGION', 'eu-west-1')
AWS_PROFILE = os.getenv('AWS_PROFILE', 'default')
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID', None)
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY', None)
b3_session, sm_client, sm_runtime, sm_session = get_sm_session(
region=AWS_DEFAULT_REGION,
profile_name=AWS_PROFILE,
aws_access_key_id=AWS_ACCESS_KEY_ID,
aws_secret_access_key=AWS_SECRET_ACCESS_KEY
)
ROLE_ARN = os.getenv('AWS_ROLE', sagemaker.get_execution_role())
MODEL_PACKAGE_GROUP_NAME = os.getenv(
'MODEL_PACKAGE_GROUP_NAME', 'sts-sklearn-grp')
BASE_JOB_PREFIX = os.getenv('BASE_JOB_PREFIX', 'sts')
# define useful const's
bucket = sm_session.default_bucket()
endpoint_name = "{}-sklearn-{}".format(
BASE_JOB_PREFIX,
datetime.datetime.now().strftime("%Y%m%d%H%M")
)
prefix = "{}/{}".format(BASE_JOB_PREFIX, endpoint_name)
data_capture_prefix = "{}/datacapture".format(prefix)
s3_capture_upload_path = "s3://{}/{}".format(bucket, data_capture_prefix)
# outputs is a dict to save to json
outputs = dict()
if datacapture is True:
# if data capture was enabled output the S3 Uri for data capture
outputs['monitor'] = {
's3_capture_upload_path': s3_capture_upload_path
}
# get the last version aproved in the model package group
model_package_arn = get_approved_package(
MODEL_PACKAGE_GROUP_NAME, sm_client)
_l.info(f"Latest approved model package: {model_package_arn}")
model_info = sm_client.describe_model_package(
ModelPackageName=model_package_arn)
outputs['model_info'] = model_info
model_uri = model_info.get(
'InferenceSpecification')['Containers'][0]['ModelDataUrl']
_l.info(f"Model data uri: {model_uri}")
sk_model = SKLearnModel(
model_uri, # s3 uri for the model.tar.gz
ROLE_ARN, # sagemaker role to be used
'model_loader.py', # script to load the model
framework_version='0.23-1'
)
data_capture_config=None
if datacapture is True:
# if data capture was enabled generated the required config
_l.info("Enabling data capture as requested")
_l.info(f"s3_capture_upload_path: {s3_capture_upload_path}")
data_capture_config = DataCaptureConfig(
enable_capture=True, sampling_percentage=100,
destination_s3_uri=s3_capture_upload_path,
capture_options=["REQUEST", "RESPONSE"],
sagemaker_session=sm_session
)
# Deploy the endpoint
predictor = sk_model.deploy(
instance_type="ml.m5.xlarge",
initial_instance_count=1,
serializer=CSVSerializer(),
deserializer=CSVDeserializer(),
data_capture_config=data_capture_config,
endpoint_name=endpoint_name
)
_l.info(f"Endpoint name: {predictor.endpoint_name}")
outputs['endpoint'] = {
'name': endpoint_name,
'config_name': predictor.endpoint_name # is the same as the endpoint ?
}
outputs['model_info'].update({"name": sk_model.name})
# ENDPOINT deploy done
# save useful outputs to a file
with open('deploymodel_out.json', 'w') as f:
json.dump(outputs, f, default=json_default)
# In[ ]:
sm_boto3 = boto3.client('sagemaker')
artifact = sm_boto3.describe_training_job(
TrainingJobName=sklearn_estimator.latest_training_job.name
)['ModelArtifacts']['S3ModelArtifacts']
print('Model artifact persisted at ' + artifact)
# In[ ]:
from sagemaker.sklearn.model import SKLearnModel
model = SKLearnModel(model_data=artifact,
role=get_execution_role(),
entry_point='script.py')
endpoint_name = 'auroraml-churn-endpoint'
model.deploy(instance_type='ml.c5.large',
initial_instance_count=1,
endpoint_name=endpoint_name)
# In[ ]:
import sagemaker.sklearn
from sagemaker.predictor import json_serializer, csv_serializer, json_deserializer, RealTimePredictor
from sagemaker.content_types import CONTENT_TYPE_CSV, CONTENT_TYPE_JSON
predictor = RealTimePredictor(endpoint=endpoint_name,
sagemaker_session=sess,
args = parse_infer_args()
sm_boto3 = boto3.client('sagemaker')
sess = sagemaker.Session()
region = sess.boto_session.region_name
model_url = args.model_file
# Define a SKLearn Transformer from the trained SKLearn Estimator
# transformer = sklearn_preprocessor.transformer(
# instance_count=1,
# instance_type='ml.m4.xlarge',
# assemble_with = 'Line',
# accept = 'text/csv')
model = SKLearnModel(
model_data=model_url,
source_dir=os.path.abspath(os.path.dirname(__file__)),
role=get_sm_execution_role(False, region),
entry_point='infer_preproc.py')
infer_mode = args.infer_mode
if 'bt' == infer_mode:
env = {'MODEL_SERVER_TIMEOUT':'120'}
transformer = model.transformer(
instance_count=1,
instance_type='ml.m4.xlarge',
output_path=args.output_dir,
assemble_with='Line',
max_payload=99,
accept='text/csv',
env=env,
max_concurrent_transforms=1,
def test_jumpstart_sklearn_image_uri(patched_get_model_specs, session):
patched_get_model_specs.side_effect = get_prototype_model_spec
model_id, model_version = "sklearn-classification-linear", "*"
instance_type = "ml.m2.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 = SKLearnModel(
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 ==
"246618743249.dkr.ecr.us-west-2.amazonaws.com/sagemaker-scikit-learn:0.23-1-cpu-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 = SKLearn(
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,
image_uri_region=region,
sagemaker_session=session,
).training_image_uri(region=region)
assert uri == framework_class_uri
assert (
uri ==
"246618743249.dkr.ecr.us-west-2.amazonaws.com/sagemaker-scikit-learn:0.23-1-cpu-py3"
)
with pytest.raises(ValueError):
image_uris.retrieve(
framework=None,
region="us-west-2",
image_scope="training",
model_id=model_id,
model_version=model_version,
instance_type="ml.p2.xlarge",
)
"""
Inference batch transform job interacts with SageMaker
"""
if __name__ == "__main__":
args = parse_infer_args()
sm_boto3 = boto3.client('sagemaker')
sess = sagemaker.Session()
region = sess.boto_session.region_name
model_url = args.model_file
preproc_model_url = args.preproc_model
sm_role = get_sm_execution_role(False, region)
preproc_model = SKLearnModel(model_data=preproc_model_url,
source_dir=os.path.abspath(
os.path.dirname(__file__)),
role=sm_role,
entry_point='infer_preproc.py',
sagemaker_session=sess)
ll_image = get_image_uri(region, 'linear-learner')
ll_model = Model(model_data=model_url,
image=ll_image,
role=sm_role,
sagemaker_session=sess)
timestamp_prefix = strftime("%Y-%m-%d-%H-%M-%S", gmtime())
model_name = 'inference-pipeline-' + timestamp_prefix
endpoint_name = 'inference-pipeline-ep-' + timestamp_prefix
sm_model = PipelineModel(name=model_name,
