def test_predict_call_with_headers_and_json(): sagemaker_session = json_sagemaker_session() predictor = RealTimePredictor( ENDPOINT, sagemaker_session, content_type="not/json", accept="also/not-json", serializer=json_serializer, ) data = [1, 2] result = predictor.predict(data) assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called expected_request_args = { "Accept": "also/not-json", "Body": json.dumps(data), "ContentType": "not/json", "EndpointName": ENDPOINT, } call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args assert kwargs == expected_request_args assert result == json.dumps([RETURN_VALUE])
def test_classification_request_pb(sagemaker_session): request = classification_pb2.ClassificationRequest() request.model_spec.name = "generic_model" request.model_spec.signature_name = DEFAULT_SERVING_SIGNATURE_DEF_KEY example = request.input.example_list.examples.add() example.features.feature[PREDICT_INPUTS].float_list.value.extend([6.4, 3.2, 4.5, 1.5]) predictor = RealTimePredictor(sagemaker_session=sagemaker_session, endpoint=ENDPOINT, deserializer=tf_deserializer, serializer=tf_serializer) expected_response = classification_pb2.ClassificationResponse() classes = expected_response.result.classifications.add().classes class_0 = classes.add() class_0.label = "0" class_0.score = 0.00128903763834 class_1 = classes.add() class_1.label = "1" class_1.score = 0.981432199478 class_2 = classes.add() class_2.label = "2" class_2.score = 0.0172787327319 mock_response(expected_response.SerializeToString(), sagemaker_session, PROTO_CONTENT_TYPE) result = predictor.predict(request) sagemaker_session.sagemaker_runtime_client.invoke_endpoint.assert_called_once_with( Accept=PROTO_CONTENT_TYPE, Body=request.SerializeToString(), ContentType=PROTO_CONTENT_TYPE, EndpointName='myendpoint' ) # python 2 and 3 protobuf serialization has different precision so I'm checking # the version here if sys.version_info < (3, 0): assert str(result) == """result { classifications { classes { label: "0" score: 0.00128903763834 } classes { label: "1" score: 0.981432199478 } classes { label: "2" score: 0.0172787327319 } } } """ else: assert str(result) == """result {
def test_delete_endpoint_only(): sagemaker_session = empty_sagemaker_session() predictor = RealTimePredictor(ENDPOINT, sagemaker_session=sagemaker_session) predictor.delete_endpoint(delete_endpoint_config=False) sagemaker_session.delete_endpoint.assert_called_with(ENDPOINT) sagemaker_session.delete_endpoint_config.assert_not_called()
def test_predict_tensor_request_csv(sagemaker_session): data = [6.4, 3.2, 0.5, 1.5] tensor_proto = tf.make_tensor_proto(values=np.asarray(data), shape=[1, len(data)], dtype=tf.float32) predictor = RealTimePredictor( serializer=tf_csv_serializer, deserializer=tf_json_deserializer, sagemaker_session=sagemaker_session, endpoint=ENDPOINT, ) mock_response( json.dumps(CLASSIFICATION_RESPONSE).encode("utf-8"), sagemaker_session, JSON_CONTENT_TYPE) result = predictor.predict(tensor_proto) sagemaker_session.sagemaker_runtime_client.invoke_endpoint.assert_called_once_with( Accept=JSON_CONTENT_TYPE, Body="6.4,3.2,0.5,1.5", ContentType=CSV_CONTENT_TYPE, EndpointName="myendpoint", ) assert result == CLASSIFICATION_RESPONSE
def execute_inference(image): """ Receives image and executes inference against sagemaker endpoint. """ boto_session = boto3.Session( aws_access_key_id=settings.AWS_ACCESS_KEY_ID, aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY) sess = sagemaker.Session(boto_session=boto_session) ENDPOINT_MODEL = 'clothes-30-model' predictor = RealTimePredictor(endpoint=ENDPOINT_MODEL, sagemaker_session=sess, content_type='application/json', accept='application/json') # Convert tensor to JSON format. image = image.tolist() image = json.dumps(image) # Get a prediction from the endpoint. result = predictor.predict(image) # Convert result into python dict. result = json.loads(result) return result
def test_delete_endpoint_with_config(): sagemaker_session = empty_sagemaker_session() sagemaker_session.sagemaker_client.describe_endpoint = Mock(return_value={'EndpointConfigName': 'endpoint-config'}) predictor = RealTimePredictor(ENDPOINT, sagemaker_session=sagemaker_session) predictor.delete_endpoint() sagemaker_session.delete_endpoint.assert_called_with(ENDPOINT) sagemaker_session.delete_endpoint_config.assert_called_with('endpoint-config')
def test_multi_data_model_deploy_pretrained_models_local_mode(container_image, sagemaker_session): timestamp = sagemaker_timestamp() endpoint_name = "test-multimodel-endpoint-{}".format(timestamp) model_name = "test-multimodel-{}".format(timestamp) # Define pretrained model local path pretrained_model_data_local_path = os.path.join(DATA_DIR, "sparkml_model", "mleap_model.tar.gz") with timeout(minutes=30): model_data_prefix = os.path.join( "s3://", sagemaker_session.default_bucket(), "multimodel-{}/".format(timestamp) ) multi_data_model = MultiDataModel( name=model_name, model_data_prefix=model_data_prefix, image=container_image, role=ROLE, sagemaker_session=sagemaker_session, ) # Add model before deploy multi_data_model.add_model(pretrained_model_data_local_path, PRETRAINED_MODEL_PATH_1) # Deploy model to an endpoint multi_data_model.deploy(1, "local", endpoint_name=endpoint_name) # Add models after deploy multi_data_model.add_model(pretrained_model_data_local_path, PRETRAINED_MODEL_PATH_2) endpoint_models = [] for model_path in multi_data_model.list_models(): endpoint_models.append(model_path) assert PRETRAINED_MODEL_PATH_1 in endpoint_models assert PRETRAINED_MODEL_PATH_2 in endpoint_models predictor = RealTimePredictor( endpoint=endpoint_name, sagemaker_session=multi_data_model.sagemaker_session, serializer=npy_serializer, deserializer=string_deserializer, ) data = numpy.zeros(shape=(1, 1, 28, 28)) result = predictor.predict(data, target_model=PRETRAINED_MODEL_PATH_1) assert result == "Invoked model: {}".format(PRETRAINED_MODEL_PATH_1) result = predictor.predict(data, target_model=PRETRAINED_MODEL_PATH_2) assert result == "Invoked model: {}".format(PRETRAINED_MODEL_PATH_2) # Cleanup multi_data_model.sagemaker_session.sagemaker_client.delete_endpoint_config( EndpointConfigName=endpoint_name ) multi_data_model.sagemaker_session.delete_endpoint(endpoint_name) multi_data_model.delete_model() with pytest.raises(Exception) as exception: sagemaker_session.sagemaker_client.describe_model(ModelName=multi_data_model.name) assert "Could not find model" in str(exception.value) sagemaker_session.sagemaker_client.describe_endpoint_config(name=endpoint_name) assert "Could not find endpoint" in str(exception.value)
class Predictor(object): def __init__(self, endpoint_name, sagemaker_session=None): """ Args: endpoint_name (str): name of the Sagemaker endpoint sagemaker_session (sagemaker.session.Session): Manage interactions with the Amazon SageMaker APIs and any other AWS services needed. """ self.endpoint_name = endpoint_name self._realtime_predictor = RealTimePredictor( endpoint_name, serializer=sagemaker.predictor.json_serializer, deserializer=sagemaker.predictor.json_deserializer, sagemaker_session=sagemaker_session) def get_action(self, obs=None): """Get prediction from the endpoint Args: obs (list/str): observation of the environment Returns: action: action to take from the prediction event_id: event id of the current prediction model_id: model id of the hosted model action_prob: action probability distribution sample_prob: sample probability distribution used for data split """ payload = {} payload['request_type'] = "observation" payload['observation'] = obs response = self._realtime_predictor.predict(payload) action = response['action'] action_prob = response['action_prob'] event_id = response['event_id'] model_id = response['model_id'] sample_prob = response['sample_prob'] return action, event_id, model_id, action_prob, sample_prob def get_hosted_model_id(self): """Return hostdd model id in the hosting endpoint Returns: str: model id of the model being hosted """ payload = {} payload['request_type'] = "model_id" payload['observation'] = None response = self._realtime_predictor.predict(payload) model_id = response['model_id'] return model_id def delete_endpoint(self): """Delete the Sagemaker endpoint """ logger.warning(f"Deleting hosting endpoint '{self.endpoint_name}'...") self._realtime_predictor.delete_endpoint()
def test_delete_model_fail(): sagemaker_session = empty_sagemaker_session() sagemaker_session.sagemaker_client.delete_model = Mock(side_effect=Exception('Could not find model.')) expected_error_message = 'One or more models cannot be deleted, please retry.' predictor = RealTimePredictor(ENDPOINT, sagemaker_session=sagemaker_session) with pytest.raises(Exception) as exception: predictor.delete_model() assert expected_error_message in str(exception.val)
def test_delete_model(): sagemaker_session = empty_sagemaker_session() predictor = RealTimePredictor(ENDPOINT, sagemaker_session=sagemaker_session) predictor.delete_model() expected_call_count = 2 expected_call_args_list = [call("model-1"), call("model-2")] assert sagemaker_session.delete_model.call_count == expected_call_count assert sagemaker_session.delete_model.call_args_list == expected_call_args_list
def test_inference_pipeline_model_deploy(sagemaker_session, cpu_instance_type): sparkml_data_path = os.path.join(DATA_DIR, "sparkml_model") xgboost_data_path = os.path.join(DATA_DIR, "xgboost_model") endpoint_name = "test-inference-pipeline-deploy-{}".format( sagemaker_timestamp()) sparkml_model_data = sagemaker_session.upload_data( path=os.path.join(sparkml_data_path, "mleap_model.tar.gz"), key_prefix="integ-test-data/sparkml/model", ) xgb_model_data = sagemaker_session.upload_data( path=os.path.join(xgboost_data_path, "xgb_model.tar.gz"), key_prefix="integ-test-data/xgboost/model", ) with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session): sparkml_model = SparkMLModel( model_data=sparkml_model_data, env={"SAGEMAKER_SPARKML_SCHEMA": SCHEMA}, sagemaker_session=sagemaker_session, ) xgb_image = get_image_uri(sagemaker_session.boto_region_name, "xgboost") xgb_model = Model(model_data=xgb_model_data, image=xgb_image, sagemaker_session=sagemaker_session) model = PipelineModel( models=[sparkml_model, xgb_model], role="SageMakerRole", sagemaker_session=sagemaker_session, name=endpoint_name, ) model.deploy(1, cpu_instance_type, endpoint_name=endpoint_name) predictor = RealTimePredictor( endpoint=endpoint_name, sagemaker_session=sagemaker_session, serializer=json_serializer, content_type=CONTENT_TYPE_CSV, accept=CONTENT_TYPE_CSV, ) with open(VALID_DATA_PATH, "r") as f: valid_data = f.read() assert predictor.predict(valid_data) == "0.714013934135" with open(INVALID_DATA_PATH, "r") as f: invalid_data = f.read() assert predictor.predict(invalid_data) is None model.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_predict_invocation_with_target_variant(sagemaker_session, multi_variant_endpoint): predictor = RealTimePredictor( endpoint=multi_variant_endpoint.endpoint_name, sagemaker_session=sagemaker_session, serializer=csv_serializer, content_type=CONTENT_TYPE_CSV, accept=CONTENT_TYPE_CSV, ) # 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 Sagemaker endpoint sagemaker_session (sagemaker.session.Session): Manage interactions with the Amazon SageMaker APIs and any other AWS services needed. """ self.endpoint_name = endpoint_name self._realtime_predictor = RealTimePredictor( endpoint_name, serializer=sagemaker.predictor.json_serializer, deserializer=sagemaker.predictor.json_deserializer, sagemaker_session=sagemaker_session)
def test_predict_call_pass_through(): sagemaker_session = empty_sagemaker_session() predictor = RealTimePredictor(ENDPOINT, sagemaker_session) data = "untouched" result = predictor.predict(data) assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called expected_request_args = {"Body": data, "EndpointName": ENDPOINT} call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args assert kwargs == expected_request_args assert result == RETURN_VALUE
def test_predict_call_pass_through(): sagemaker_session = empty_sagemaker_session() predictor = RealTimePredictor(ENDPOINT, sagemaker_session) data = "untouched" result = predictor.predict(data) assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called expected_request_args = { 'Body': data, 'EndpointName': ENDPOINT } call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args assert kwargs == expected_request_args assert result == RETURN_VALUE
def predict(payload): # Configurations region = os.environ['REGION'] access_id = os.environ['ACCESS_ID'] secret_key = os.environ['SECRET_KEY'] endpoint = 'brain-model-ep--2020-06-16-14-46-14' boto_session = boto3.Session(region_name=region, aws_access_key_id=access_id, aws_secret_access_key=secret_key) session = sagemaker.Session(boto_session=boto_session) predictor = RealTimePredictor(endpoint=endpoint, sagemaker_session=session, serializer=None) class_mappings = ['Intracranial', 'Mass Effect', 'Midline Shift'] # Predicting prediction = json.loads(predictor.predict(payload)) return class_mappings[np.argmax(prediction)]
def main(): args = parse_args() sm = boto3.client('sagemaker') endpoint_desc = sm.describe_endpoint(EndpointName=args.endpoint) print(endpoint_desc) print('----------') predictor = RealTimePredictor(endpoint=args.endpoint) with open(args.file, 'rb') as f: payload = f.read() payload = payload response = predictor.predict(data=payload).decode('utf-8') print(response)
def test_inference_pipeline_model_deploy(sagemaker_session): sparkml_data_path = os.path.join(DATA_DIR, 'sparkml_model') xgboost_data_path = os.path.join(DATA_DIR, 'xgboost_model') endpoint_name = 'test-inference-pipeline-deploy-{}'.format( sagemaker_timestamp()) sparkml_model_data = sagemaker_session.upload_data( path=os.path.join(sparkml_data_path, 'mleap_model.tar.gz'), key_prefix='integ-test-data/sparkml/model') xgb_model_data = sagemaker_session.upload_data( path=os.path.join(xgboost_data_path, 'xgb_model.tar.gz'), key_prefix='integ-test-data/xgboost/model') with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session): sparkml_model = SparkMLModel(model_data=sparkml_model_data, env={'SAGEMAKER_SPARKML_SCHEMA': SCHEMA}, sagemaker_session=sagemaker_session) xgb_image = get_image_uri(sagemaker_session.boto_region_name, 'xgboost') xgb_model = Model(model_data=xgb_model_data, image=xgb_image, sagemaker_session=sagemaker_session) model = PipelineModel(models=[sparkml_model, xgb_model], role='SageMakerRole', sagemaker_session=sagemaker_session, name=endpoint_name) model.deploy(1, 'ml.m4.xlarge', endpoint_name=endpoint_name) predictor = RealTimePredictor(endpoint=endpoint_name, sagemaker_session=sagemaker_session, serializer=json_serializer, content_type=CONTENT_TYPE_CSV, accept=CONTENT_TYPE_CSV) with open(VALID_DATA_PATH, 'r') as f: valid_data = f.read() assert predictor.predict(valid_data) == '0.714013934135' with open(INVALID_DATA_PATH, 'r') as f: invalid_data = f.read() assert (predictor.predict(invalid_data) is None) model.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_classification_request_csv(sagemaker_session): data = [1, 2, 3] predictor = RealTimePredictor(serializer=tf_csv_serializer, deserializer=tf_deserializer, sagemaker_session=sagemaker_session, endpoint=ENDPOINT) expected_response = json_format.Parse( json.dumps(CLASSIFICATION_RESPONSE), classification_pb2.ClassificationResponse() ).SerializeToString() mock_response(expected_response, sagemaker_session, PROTO_CONTENT_TYPE) result = predictor.predict(data) sagemaker_session.sagemaker_runtime_client.invoke_endpoint.assert_called_once_with( Accept=PROTO_CONTENT_TYPE, Body='1,2,3', ContentType=CSV_CONTENT_TYPE, EndpointName='myendpoint' ) # python 2 and 3 protobuf serialization has different precision so I'm checking # the version here if sys.version_info < (3, 0): assert str(result) == """result { classifications { classes { label: "0" score: 0.00128903763834 } classes { label: "1" score: 0.981432199478 } classes { label: "2" score: 0.0172787327319 } } } """ else: assert str(result) == """result {
def test_classification_request_json(sagemaker_session): data = [1, 2, 3] predictor = RealTimePredictor(endpoint=ENDPOINT, sagemaker_session=sagemaker_session, deserializer=tf_json_deserializer, serializer=tf_json_serializer) mock_response(json.dumps(CLASSIFICATION_RESPONSE).encode('utf-8'), sagemaker_session, JSON_CONTENT_TYPE) result = predictor.predict(data) sagemaker_session.sagemaker_runtime_client.invoke_endpoint.assert_called_once_with( Accept=JSON_CONTENT_TYPE, Body='[1, 2, 3]', ContentType=JSON_CONTENT_TYPE, EndpointName='myendpoint' ) assert result == CLASSIFICATION_RESPONSE
def lambda_handler(event, context): #print("Received event: " + json.dumps(event, indent=2)) data = json.loads(json.dumps(event)) payload = data['data'] # Overwriting value payload["contact__has_telephone"] = False #print(payload) entities = [ 'data', 'features', 'descriptions', 'prediction', 'explanation_shap_values', 'explanation_shap_interaction_values' ] explainer = RealTimePredictor( endpoint=ENDPOINT_NAME, sagemaker_session=sagemaker_session, serializer=json_serializer, deserializer=json_deserializer, content_type="application/json; entities={}".format( ",".join(entities)), accept=CONTENT_TYPE_JSON, ) output = explainer.predict(payload) shap_values = output['explanation']['shap_values'] #print(shap_values) prediction = output['prediction'] print("Credit default risk: {:.2%}".format(prediction)) credit_balance = abs( shap_values['finance__accounts__checking__balance__negative']) credit_amount = abs(shap_values['credit__amount']) print(credit_balance, credit_amount) if credit_balance > credit_amount: result = "credit_balance: {}".format(credit_balance) else: result = "credit_amount: {}".format(credit_amount) print(result) return result
def test_predict_tensor_request_csv(sagemaker_session): data = [6.4, 3.2, .5, 1.5] tensor_proto = tf.make_tensor_proto(values=np.asarray(data), shape=[1, len(data)], dtype=tf.float32) predictor = RealTimePredictor(serializer=tf_csv_serializer, deserializer=tf_json_deserializer, sagemaker_session=sagemaker_session, endpoint=ENDPOINT) mock_response(json.dumps(CLASSIFICATION_RESPONSE).encode('utf-8'), sagemaker_session, JSON_CONTENT_TYPE) result = predictor.predict(tensor_proto) sagemaker_session.sagemaker_runtime_client.invoke_endpoint.assert_called_once_with( Accept=JSON_CONTENT_TYPE, Body='6.4,3.2,0.5,1.5', ContentType=CSV_CONTENT_TYPE, EndpointName='myendpoint' ) assert result == CLASSIFICATION_RESPONSE
def test_predict_call_with_headers(): sagemaker_session = empty_sagemaker_session() predictor = RealTimePredictor(ENDPOINT, sagemaker_session, content_type=DEFAULT_CONTENT_TYPE, accept=DEFAULT_CONTENT_TYPE) data = "untouched" result = predictor.predict(data) assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called expected_request_args = { 'Accept': DEFAULT_CONTENT_TYPE, 'Body': data, 'ContentType': DEFAULT_CONTENT_TYPE, 'EndpointName': ENDPOINT } call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args assert kwargs == expected_request_args assert result == RETURN_VALUE
def test_predict_call_with_headers_and_csv(): sagemaker_session = ret_csv_sagemaker_session() predictor = RealTimePredictor(ENDPOINT, sagemaker_session, accept=CSV_CONTENT_TYPE, serializer=csv_serializer) 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 == CSV_RETURN_VALUE
def test_predict_call_with_headers_and_json(): sagemaker_session = json_sagemaker_session() predictor = RealTimePredictor(ENDPOINT, sagemaker_session, content_type='not/json', accept='also/not-json', serializer=json_serializer) data = [1, 2] result = predictor.predict(data) assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called expected_request_args = { 'Accept': 'also/not-json', 'Body': json.dumps(data), 'ContentType': 'not/json', 'EndpointName': ENDPOINT } call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args assert kwargs == expected_request_args assert result == json.dumps([RETURN_VALUE])
def test_multi_model_predict_call_with_headers(): sagemaker_session = empty_sagemaker_session() predictor = RealTimePredictor( ENDPOINT, sagemaker_session, content_type=DEFAULT_CONTENT_TYPE, accept=DEFAULT_CONTENT_TYPE ) data = "untouched" result = predictor.predict(data, target_model="model.tar.gz") assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called expected_request_args = { "Accept": DEFAULT_CONTENT_TYPE, "Body": data, "ContentType": DEFAULT_CONTENT_TYPE, "EndpointName": ENDPOINT, "TargetModel": "model.tar.gz", } call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args assert kwargs == expected_request_args assert result == RETURN_VALUE
def test_predict_call_with_target_variant(): sagemaker_session = empty_sagemaker_session() predictor = RealTimePredictor( ENDPOINT, sagemaker_session, content_type=DEFAULT_CONTENT_TYPE, accept=DEFAULT_CONTENT_TYPE ) data = "untouched" result = predictor.predict(data, target_variant=PRODUCTION_VARIANT_1) assert sagemaker_session.sagemaker_runtime_client.invoke_endpoint.called expected_request_args = { "Accept": DEFAULT_CONTENT_TYPE, "Body": data, "ContentType": DEFAULT_CONTENT_TYPE, "EndpointName": ENDPOINT, "TargetVariant": PRODUCTION_VARIANT_1, } call_args, kwargs = sagemaker_session.sagemaker_runtime_client.invoke_endpoint.call_args assert kwargs == expected_request_args assert result == RETURN_VALUE
def lambda_handler(event, context): sm_fm_endpoint = event["sm_fm_endpoint"] attribute = event["attribute"] fm_predictor = RealTimePredictor(endpoint=sm_fm_endpoint, sagemaker_session=sm_sess) fm_predictor.content_type = 'application/json' fm_predictor.serializer = fm_serializer fm_predictor.deserializer = json_deserializer payload = build_spare_matrix_payload(attribute) result = fm_predictor.predict(payload) pp_result = post_process(result) return {'statusCode': 200, 'body': pp_result}
def predict_wrapper(endpoint, session): return RealTimePredictor(endpoint, session, serializer, deserializer, content_type, accept)
def create_predictor(self, endpoint_name): return RealTimePredictor(endpoint_name, sagemaker_session=self.sagemaker_session)
def test_inference_pipeline_model_deploy(sagemaker_session): sparkml_data_path = os.path.join(DATA_DIR, 'sparkml_model') xgboost_data_path = os.path.join(DATA_DIR, 'xgboost_model') endpoint_name = 'test-inference-pipeline-deploy-{}'.format(sagemaker_timestamp()) sparkml_model_data = sagemaker_session.upload_data( path=os.path.join(sparkml_data_path, 'mleap_model.tar.gz'), key_prefix='integ-test-data/sparkml/model') xgb_model_data = sagemaker_session.upload_data( path=os.path.join(xgboost_data_path, 'xgb_model.tar.gz'), key_prefix='integ-test-data/xgboost/model') schema = json.dumps({ "input": [ { "name": "Pclass", "type": "float" }, { "name": "Embarked", "type": "string" }, { "name": "Age", "type": "float" }, { "name": "Fare", "type": "float" }, { "name": "SibSp", "type": "float" }, { "name": "Sex", "type": "string" } ], "output": { "name": "features", "struct": "vector", "type": "double" } }) with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session): sparkml_model = SparkMLModel(model_data=sparkml_model_data, env={'SAGEMAKER_SPARKML_SCHEMA': schema}, sagemaker_session=sagemaker_session) xgb_image = get_image_uri(sagemaker_session.boto_region_name, 'xgboost') xgb_model = Model(model_data=xgb_model_data, image=xgb_image, sagemaker_session=sagemaker_session) model = PipelineModel(models=[sparkml_model, xgb_model], role='SageMakerRole', sagemaker_session=sagemaker_session, name=endpoint_name) model.deploy(1, 'ml.m4.xlarge', endpoint_name=endpoint_name) predictor = RealTimePredictor(endpoint=endpoint_name, sagemaker_session=sagemaker_session, serializer=json_serializer, content_type=CONTENT_TYPE_CSV, accept=CONTENT_TYPE_CSV) valid_data = '1.0,C,38.0,71.5,1.0,female' assert predictor.predict(valid_data) == "0.714013934135" invalid_data = "1.0,28.0,C,38.0,71.5,1.0" assert (predictor.predict(invalid_data) is None) model.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)
default='../train/', help='Path to a directory that contains wav files.') parser.add_argument("--test_path", default='../test/phillipe_2.wav', help='Path to a directory that contains wav files.') parser.add_argument("--endpoint_feature", default='sagemaker-tensorflow-2019-05-24-12-40-42-099', help='Name of sagemaker endpoint of feature extraction') FLAGS = parser.parse_args() endpoint_feat_extract = FLAGS.endpoint_feature boto_session = boto3.Session(region_name="eu-west-1") session = sage.Session(boto_session=boto_session) predictor = RealTimePredictor(endpoint_feat_extract, sagemaker_session=session, serializer=npy_serializer, deserializer=numpy_deserializer) ArgsParameters = collections.namedtuple('ArgsParameters', [ 'gpu', 'batch_size', 'net', 'ghost_cluster', 'vlad_cluster', 'bottleneck_dim', 'aggregation_mode', 'resume', 'loss', 'test_type' ]) args = ArgsParameters(gpu='', batch_size=16, net='resnet34s', ghost_cluster=2, vlad_cluster=8, bottleneck_dim=512, aggregation_mode='gvlad', resume='./model/weights.h5', loss='softmax', test_type='normal')