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()