def __init__(
self,
endpoint_name,
sagemaker_session=None,
serializer=CSVSerializer(),
**kwargs,
):
"""Initializes a SparkMLPredictor which should be used with SparkMLModel
to perform predictions against SparkML models serialized via MLeap. The
response is returned in text/csv format which is the default response
format for SparkML Serving container.
Args:
endpoint (str): The name of the endpoint to perform inference on.
sagemaker_session (sagemaker.session.Session): Session object which
manages interactions with Amazon SageMaker APIs and any other
AWS services needed. If not specified, the estimator creates one
using the default AWS configuration chain.
serializer (sagemaker.serializers.BaseSerializer): Optional. Default
serializes input data to text/csv.
"""
sagemaker_session = sagemaker_session or Session()
super(SparkMLPredictor, self).__init__(
endpoint_name=endpoint_name,
sagemaker_session=sagemaker_session,
serializer=serializer,
**kwargs,
)
def _test_sm_trained_model(sagemaker_session, ecr_image, instance_type, framework_version):
model_dir = os.path.join(RESOURCE_PATH, 'model')
source_dir = os.path.join(RESOURCE_PATH, 'scripts')
endpoint_name = sagemaker.utils.unique_name_from_base("sagemaker-autogluon-serving-trained-model")
ag_framework_version = '0.3.1' if framework_version == '0.3.2' else framework_version
model_data = sagemaker_session.upload_data(path=os.path.join(model_dir, f'model_{ag_framework_version}.tar.gz'), key_prefix='sagemaker-autogluon-serving-trained-model/models')
model = MXNetModel(
model_data=model_data,
role='SageMakerRole',
image_uri=ecr_image,
sagemaker_session=sagemaker_session,
source_dir=source_dir,
entry_point="tabular_serve.py",
framework_version="1.8.0"
)
with timeout_and_delete_endpoint(endpoint_name, sagemaker_session, minutes=30):
predictor = model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
)
predictor.serializer = CSVSerializer()
predictor.deserializer = JSONDeserializer()
data_path = os.path.join(RESOURCE_PATH, 'data')
data = pd.read_csv(f'{data_path}/data.csv')
assert 3 == len(data)
preds = predictor.predict(data.values)
assert preds == [' <=50K', ' <=50K', ' <=50K']
def __init__(
self,
endpoint_name,
sagemaker_session=None,
serializer=CSVSerializer(),
deserializer=JSONDeserializer(),
):
"""Creates object to be used to get dot product of entity nad IP address.
Args:
endpoint_name (str): Name of the Amazon SageMaker endpoint to which
requests are sent.
sagemaker_session (sagemaker.session.Session): A SageMaker Session
object, used for SageMaker interactions (default: None). If not
specified, one is created using the default AWS configuration
chain.
serializer (sagemaker.serializers.BaseSerializer): Optional. Default
serializes input data to text/csv.
deserializer (callable): Optional. Default parses JSON responses
using ``json.load(...)``.
"""
super(IPInsightsPredictor, self).__init__(
endpoint_name,
sagemaker_session,
serializer=serializer,
deserializer=deserializer,
)
def deploy_model(estimator):
predictor = estimator.deploy(
initial_instance_count=INSTANCE_CONFIG['inference_instance_count'],
instance_type=INSTANCE_CONFIG['inference_instance_type'],
serializer=CSVSerializer())
return predictor
def main(deploy_data, train_data):
inference_id_prefix = 'sts_' # Comes from deploymodel.py
outputs = {'inferences': []}
# 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)
# Load a predictor using the endpoint name
predictor = SKLearnPredictor(
deploy_data['endpoint']['name'],
sagemaker_session=sm_session,
serializer=CSVSerializer(), # necesary or MQM don't work
deserializer=CSVDeserializer() # necesary or MQM don't work
)
# read test data
test_data = load_dataset(train_data['train']['test'],
'test.csv',
sagemaker_session=sm_session)
print(f"Loadding {train_data['train']['test']}")
# remove labels in the test dataset
test_data.drop(test_data.columns[0], axis=1, inplace=True)
# Iterate over the test data and call the endpoint for each row,
# stop for 2 seconds for rows divisible by 3, just to make time
x_test_rows = test_data.values
print(f"Sending trafic to the endpoint: {deploy_data['endpoint']['name']}")
with progressbar.ProgressBar(max_value=len(x_test_rows)) as bar:
for index, x_test_row in enumerate(x_test_rows, start=1):
# Auto-generate an inference-id to track the request/response
# in the captured data
inference_id = '{}{}'.format(inference_id_prefix, index)
result = predictor.predict(x_test_row, inference_id=inference_id)
outputs['inferences'].append({
inference_id: {
'input': x_test_row.tolist(),
'result': result
}
})
# show progress
bar.update(index)
with open('testendpoint_out.json', 'w') as f:
json.dump(outputs, f)
def test_predict_csv(tfs_predictor):
input_data = "1.0,2.0,5.0\n1.0,2.0,5.0"
expected_result = {"predictions": [[3.5, 4.0, 5.5], [3.5, 4.0, 5.5]]}
predictor = TensorFlowPredictor(
tfs_predictor.endpoint_name, tfs_predictor.sagemaker_session, serializer=CSVSerializer(),
)
result = predictor.predict(input_data)
assert expected_result == result
def _assert_prediction(predictor):
predictor.serializer = CSVSerializer()
predictor.deserializer = JSONDeserializer()
data_path = os.path.join(RESOURCE_PATH, 'data')
data = pd.read_csv(f'{data_path}/data.csv')
assert 3 == len(data)
preds = predictor.predict(data.values)
assert preds == [' <=50K', ' <=50K', ' <=50K']
def test_predict_with_inference_id(sagemaker_session, endpoint_name):
predictor = Predictor(
endpoint_name=endpoint_name,
sagemaker_session=sagemaker_session,
serializer=CSVSerializer(),
)
# Validate that no exception is raised when the target_variant is specified.
response = predictor.predict(TEST_CSV_DATA, inference_id="foo")
assert response
def real_time_inference_job(endpoint_name):
predictor = Predictor(endpoint_name=endpoint_name,
sagemaker_session=SAGEMAKER_SESSION,
serializer=CSVSerializer())
logger.info(
f"Endpoint context for {endpoint_name}: {predictor.endpoint_context()}\n"
)
return predictor
def test_predict_invocation_with_target_variant(sagemaker_session,
multi_variant_endpoint):
predictor = Predictor(
endpoint_name=multi_variant_endpoint.endpoint_name,
sagemaker_session=sagemaker_session,
serializer=CSVSerializer(),
)
# Validate that no exception is raised when the target_variant is specified.
predictor.predict(TEST_CSV_DATA, target_variant=TEST_VARIANT_1)
predictor.predict(TEST_CSV_DATA, target_variant=TEST_VARIANT_2)
def deploy_model(model, deploy_type='batch', batch_output=None):
if deploy_type == 'batch':
xgb_predictor = xgb_model.transformer(instance_count=1,
instance_type='ml.m4.xlarge',
output_path=batch_output)
else:
xgb_predictor = model.deploy(initial_instance_count=1,
instance_type='ml.t2.medium',
serializer=CSVSerializer())
return xgb_predictor
def test_marketplace_attach(sagemaker_session, cpu_instance_type):
with timeout(minutes=15):
data_path = os.path.join(DATA_DIR, "marketplace", "training")
region = sagemaker_session.boto_region_name
account = REGION_ACCOUNT_MAP[region]
algorithm_arn = ALGORITHM_ARN.format(partition=_aws_partition(region),
region=region,
account=account)
mktplace = AlgorithmEstimator(
algorithm_arn=algorithm_arn,
role="SageMakerRole",
instance_count=1,
instance_type=cpu_instance_type,
sagemaker_session=sagemaker_session,
base_job_name="test-marketplace",
)
train_input = mktplace.sagemaker_session.upload_data(
path=data_path, key_prefix="integ-test-data/marketplace/train")
mktplace.fit({"training": train_input}, wait=False)
training_job_name = mktplace.latest_training_job.name
print("Waiting to re-attach to the training job: %s" %
training_job_name)
time.sleep(20)
endpoint_name = "test-marketplace-estimator{}".format(
sagemaker_timestamp())
with timeout_and_delete_endpoint_by_name(endpoint_name,
sagemaker_session,
minutes=20):
print("Re-attaching now to: %s" % training_job_name)
estimator = AlgorithmEstimator.attach(
training_job_name=training_job_name,
sagemaker_session=sagemaker_session)
predictor = estimator.deploy(1,
cpu_instance_type,
endpoint_name=endpoint_name,
serializer=CSVSerializer())
shape = pandas.read_csv(os.path.join(data_path, "iris.csv"),
header=None)
a = [50 * i for i in range(3)]
b = [40 + i for i in range(10)]
indices = [i + j for i, j in itertools.product(a, b)]
test_data = shape.iloc[indices[:-1]]
test_x = test_data.iloc[:, 1:]
print(predictor.predict(test_x.values).decode("utf-8"))
def test_predictor_csv(sagemaker_session):
predictor = TensorFlowPredictor("endpoint", sagemaker_session, serializer=CSVSerializer())
mock_response(json.dumps(PREDICT_RESPONSE).encode("utf-8"), sagemaker_session)
result = predictor.predict([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
assert_invoked(
sagemaker_session,
EndpointName="endpoint",
ContentType=CSV_CONTENT_TYPE,
Accept=JSON_CONTENT_TYPE,
Body="1.0,2.0,3.0\n4.0,5.0,6.0",
)
assert PREDICT_RESPONSE == result
def test_predict_invocation_with_target_variant_local_mode(
sagemaker_session, multi_variant_endpoint):
if sagemaker_session._region_name is None:
sagemaker_session._region_name = DEFAULT_REGION
predictor = Predictor(
endpoint_name=multi_variant_endpoint.endpoint_name,
sagemaker_session=sagemaker_session,
serializer=CSVSerializer(),
deserializer=CSVDeserializer(),
)
# Validate that no exception is raised when the target_variant is specified.
predictor.predict(TEST_CSV_DATA, target_variant=TEST_VARIANT_1)
predictor.predict(TEST_CSV_DATA, target_variant=TEST_VARIANT_2)
def __init__(self, endpoint_name, sagemaker_session=None):
"""
Args:
endpoint_name (str): Name of the Amazon SageMaker endpoint to which
requests are sent.
sagemaker_session (sagemaker.session.Session): A SageMaker Session
object, used for SageMaker interactions (default: None). If not
specified, one is created using the default AWS configuration
chain.
"""
super(IPInsightsPredictor, self).__init__(
endpoint_name,
sagemaker_session,
serializer=CSVSerializer(),
deserializer=JSONDeserializer(),
)
def main():
image_name = "sagemaker-sklearn-rf-regressor-local"
# Prepare data for model inference - we use the Boston housing dataset
print('Preparing data for model inference')
data = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(data.data,
data.target,
test_size=0.25,
random_state=42)
# we don't train a model, so we will need only the testing data
testX = pd.DataFrame(X_test, columns=data.feature_names)
# Download a pre-trained model file
print('Downloading a pre-trained model file')
s3.download_file(
'aws-ml-blog',
'artifacts/scikit_learn_bring_your_own_model/model.joblib',
'model.joblib')
# Creating a model.tar.gz file
tar = tarfile.open('model.tar.gz', 'w:gz')
tar.add('model.joblib')
tar.close()
model = Model(image_uri=image_name,
role=DUMMY_IAM_ROLE,
model_data='file://./model.tar.gz')
print('Deploying endpoint in local mode')
endpoint = model.deploy(initial_instance_count=1,
instance_type='local',
endpoint_name="my-local-endpoint")
predictor = Predictor(endpoint_name="my-local-endpoint",
sagemaker_session=sagemaker_session,
serializer=CSVSerializer(),
deserializer=CSVDeserializer())
predictions = predictor.predict(testX[data.feature_names].head(5).to_csv(
header=False, index=False))
print(f"Predictions: {predictions}")
print('About to delete the endpoint to stop paying (if in cloud mode).')
predictor.delete_endpoint(predictor.endpoint_name)
def test_predict_call_with_multiple_accept_types():
sagemaker_session = ret_csv_sagemaker_session()
predictor = Predictor(ENDPOINT,
sagemaker_session,
serializer=CSVSerializer(),
deserializer=PandasDeserializer())
data = [1, 2]
predictor.predict(data)
assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called
expected_request_args = {
"Accept": "text/csv, application/json",
"Body": "1,2",
"ContentType": CSV_CONTENT_TYPE,
"EndpointName": ENDPOINT,
}
call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args
assert kwargs == expected_request_args
def test_predict_call_with_csv():
sagemaker_session = ret_csv_sagemaker_session()
predictor = Predictor(ENDPOINT,
sagemaker_session,
serializer=CSVSerializer(),
deserializer=CSVDeserializer())
data = [1, 2]
result = predictor.predict(data)
assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called
expected_request_args = {
"Accept": CSV_CONTENT_TYPE,
"Body": "1,2",
"ContentType": CSV_CONTENT_TYPE,
"EndpointName": ENDPOINT,
}
call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args
assert kwargs == expected_request_args
assert result == [["1", "2", "3"]]
def __init__(self, *args, **kwargs):
super().__init__(*args,
serializer=CSVSerializer(),
deserializer=StringDeserializer(),
**kwargs)
from sagemaker.serializers import CSVSerializer
from urllib import request
base_url='http://localhost:8080'
csv_serializer = CSVSerializer()
payloads = [
[4.6, 3.1, 1.5, 0.2], # 0
[7.7, 2.6, 6.9, 2.3], # 2
[6.1, 2.8, 4.7, 1.2] # 1
]
def predict(payload):
headers = {
'Content-type': 'text/csv',
'Accept': 'text/csv'
}
req = request.Request("%s/invocations" % base_url, data=csv_serializer.serialize(payload).encode('utf-8'), headers=headers)
resp = request.urlopen(req)
print("Response code: %d, Prediction: %s\n" % (resp.getcode(), resp.read()))
for i in resp.headers:
print(i, resp.headers[i])
for p in payloads:
predict(p)
from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVDeserializer, CSVSerializer
import time
endpoint_name = "xgb-churn-monitor"
predictor = Predictor(
endpoint_name=endpoint_name,
deserializer=CSVDeserializer(),
serializer=CSVSerializer(),
)
# get a subset of test data for a quick test
#!head -120 test_data/test-dataset-input-cols.csv > test_data/test_sample.csv
print("Sending test traffic to the endpoint {}. \nPlease wait...".format(
endpoint_name))
with open("test_data/test_sample.csv", "r") as f:
for row in f:
payload = row.rstrip("\n")
response = predictor.predict(data=payload)
time.sleep(0.5)
print("Done!")
def predict_wrapper(endpoint, session):
return sagemaker.Predictor(endpoint,
session,
serializer=CSVSerializer())
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[7]:
xgb.fit({'train': s3_input_train})
# In[8]:
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')
# In[9]:
from sagemaker.serializers import CSVSerializer
test_data_array = test_data.drop(['y_no', 'y_yes'],
axis=1).values #load the data into an array
xgb_predictor.serializer = CSVSerializer() # set the serializer type
predictions = xgb_predictor.predict(test_data_array).decode(
'utf-8') # predict!
predictions_array = np.fromstring(
predictions[1:], sep=',') # and turn the prediction into an array
print(predictions_array.shape)
# In[10]:
cm = pd.crosstab(index=test_data['y_yes'],
columns=np.round(predictions_array),
rownames=['Observed'],
colnames=['Predicted'])
tn = cm.iloc[0, 0]
fn = cm.iloc[1, 0]
tp = cm.iloc[1, 1]
def test_predictor_regress_bad_content_type(sagemaker_session):
predictor = TensorFlowPredictor("endpoint", sagemaker_session,
CSVSerializer())
with pytest.raises(ValueError):
predictor.regress(REGRESS_INPUT)
def test_predictor_classify_bad_content_type(sagemaker_session):
predictor = TensorFlowPredictor("endpoint", sagemaker_session,
CSVSerializer())
with pytest.raises(ValueError):
predictor.classify(CLASSIFY_INPUT)
# provide the link to the training report (click Trust Report in order to see the graphs)
from IPython.display import FileLink, FileLinks
display("Click link below to view the XGBoost Training report",
FileLink("CreateXgboostReport/xgboost_report.html"))
# find the locaiton of the model object
xgb_model.model_data
# use the deploy class method to host the the model on Amazon EC2 using Amazon SageMaker
from sagemaker.serializers import CSVSerializer
xgb_predictor = xgb_model.deploy(
initial_instance_count=1, # the number of instances to deploy the model
instance_type=
'ml.t2.medium', # the type of instance that will operate this model
serializer=CSVSerializer(
) # serialize inputs as csv because XGboost accepts csv as inputs
)
# retrieve the name of the endpoint generated
xgb_predictor.endpoint_name
# define the prediction function - the rows argument is to specify the number of lines to predict at a time.
import numpy as np
def predict(data, rows=1000):
split_array = np.array_split(data, int(data.shape[0] / float(rows) + 1))
predictions = ''
for array in split_array:
predictions = ','.join(
[predictions,
def csv_serializer():
return CSVSerializer()