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 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()
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 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)
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,
content_type=CONTENT_TYPE_CSV,
accept=CONTENT_TYPE_CSV)
test_data = test_data.drop("churn", axis=1)
train_data = train_data.drop("churn", axis=1)
# 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,
tags=[{"Key": "Project", "Value": "SM Example"}],
)
transformer.transform(args.input_file, content_type="text/csv")
transformer.wait()
preprocessed_train = transformer.output_path
print(f'Preprocessed data at {preprocessed_train}')
elif 'ep' == infer_mode:
model.deploy(instance_type='ml.c5.xlarge', initial_instance_count=1)
else:
raise Exception(f'Unknown inference mode {infer_mode}')