def __init__(
self,
endpoint_name,
sagemaker_session=None,
serializer=JSONSerializer(),
deserializer=JSONDeserializer(),
):
"""Initialize an ``HuggingFacePredictor``.
Args:
endpoint_name (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 .npy format. Handles lists and numpy
arrays.
deserializer (sagemaker.deserializers.BaseDeserializer): Optional.
Default parses the response from .npy format to numpy array.
"""
super(HuggingFacePredictor, self).__init__(
endpoint_name,
sagemaker_session,
serializer=serializer,
deserializer=deserializer,
)
def _test_hub_model(sagemaker_session, framework_version, ecr_image, instance_type, model_dir, accelerator_type=None):
endpoint_name = sagemaker.utils.unique_name_from_base("sagemaker-huggingface-serving-hub-model")
env = {
"HF_MODEL_ID": "sshleifer/tiny-distilbert-base-uncased-finetuned-sst-2-english",
"HF_TASK": "text-classification",
}
hf_model = Model(
env=env,
role="SageMakerRole",
image_uri=ecr_image,
sagemaker_session=sagemaker_session,
predictor_cls=Predictor,
)
with timeout_and_delete_endpoint(endpoint_name, sagemaker_session, minutes=30):
predictor = hf_model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
)
data = {
"inputs": "Camera - You are awarded a SiPix Digital Camera! call 09061221066 fromm landline. Delivery within 28 days."
}
predictor.serializer = JSONSerializer()
predictor.deserializer = JSONDeserializer()
output = predictor.predict(data)
assert "score" in output[0]
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 _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=JSONSerializer(),
deserializer=JSONDeserializer(),
):
"""Initialize an ``MXNetPredictor``.
Args:
endpoint_name (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 (callable): Optional. Default serializes input data to
json. Handles dicts, lists, and numpy arrays.
deserializer (callable): Optional. Default parses the response using
``json.load(...)``.
"""
super(MXNetPredictor, self).__init__(
endpoint_name,
sagemaker_session,
serializer=serializer,
deserializer=deserializer,
)
def _test_speech_model(
sagemaker_session, framework_version, ecr_image, instance_type, model_dir, accelerator_type=None
):
endpoint_name = sagemaker.utils.unique_name_from_base("sagemaker-huggingface-serving-speech-model")
if "tensorflow" in ecr_image:
# Zero-code deployments are currently not supported for TensorFlow
return True
env = {
"HF_MODEL_ID": "hf-internal-testing/tiny-random-wav2vec2",
"HF_TASK": "automatic-speech-recognition",
}
hf_model = HuggingFaceModel(
env=env,
role="SageMakerRole",
image_uri=ecr_image,
sagemaker_session=sagemaker_session,
predictor_cls=Predictor,
)
with timeout_and_delete_endpoint(endpoint_name, sagemaker_session, minutes=30):
predictor = hf_model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
)
predictor.serializer = DataSerializer(content_type="audio/wave")
predictor.deserializer = JSONDeserializer()
output = predictor.predict(audio_sample_file_path)
assert "text" in output
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 _assert_prediction(predictor):
predictor.serializer = JSONSerializer()
predictor.deserializer = JSONDeserializer()
data = {
"inputs":
"Camera - You are awarded a SiPix Digital Camera! call 09061221066 fromm landline. Delivery within 28 days."
}
output = predictor.predict(data)
assert "score" in output[0]
def test_predict_jsonlines(tfs_predictor):
input_data = "[1.0, 2.0, 5.0]\n[1.0, 2.0, 5.0]"
expected_result = {"predictions": [[3.5, 4.0, 5.5], [3.5, 4.0, 5.5]]}
predictor = sagemaker.Predictor(
tfs_predictor.endpoint_name,
tfs_predictor.sagemaker_session,
serializer=IdentitySerializer(content_type="application/jsonlines"),
deserializer=JSONDeserializer(),
)
result = predictor.predict(input_data)
assert expected_result == result
def __init__(self, endpoint_name, sagemaker_session=None):
"""Initialize an ``MXNetPredictor``.
Args:
endpoint_name (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.
"""
super(MXNetPredictor, self).__init__(endpoint_name, sagemaker_session,
JSONSerializer(),
JSONDeserializer())
def do_inference_on_local_endpoint(predictor):
print(f'\nStarting Inference on endpoint (local).')
x_test = np.load('./data/test/x_test.npy')
y_test = np.load('./data/test/y_test.npy')
data = {"instances": x_test[:10]}
predictor.serializer = JSONSerializer()
predictor.deserializer = JSONDeserializer()
results = predictor.predict(data)['predictions']
flat_list = [float('%.1f' % (item)) for sublist in results for item in sublist]
print('predictions: \t{}'.format(np.array(flat_list)))
print('target values: \t{}'.format(y_test[:10].round(decimals=1)))
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 __init__(
self,
endpoint_name,
sagemaker_session=None,
serializer=JSONSerializer(),
deserializer=JSONDeserializer(),
model_name=None,
model_version=None,
**kwargs,
):
"""Initialize a ``TensorFlowPredictor``.
See :class:`~sagemaker.predictor.Predictor` for more info about parameters.
Args:
endpoint_name (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 (callable): Optional. Default serializes input data to
json. Handles dicts, lists, and numpy arrays.
deserializer (callable): Optional. Default parses the response using
``json.load(...)``.
model_name (str): Optional. The name of the SavedModel model that
should handle the request. If not specified, the endpoint's
default model will handle the request.
model_version (str): Optional. The version of the SavedModel model
that should handle the request. If not specified, the latest
version of the model will be used.
"""
removed_kwargs("content_type", kwargs)
removed_kwargs("accept", kwargs)
super(TensorFlowPredictor, self).__init__(
endpoint_name,
sagemaker_session,
serializer,
deserializer,
)
attributes = []
if model_name:
attributes.append("tfs-model-name={}".format(model_name))
if model_version:
attributes.append("tfs-model-version={}".format(model_version))
self._model_attributes = ",".join(attributes) if attributes else None
def _test_sm_trained_model(sagemaker_session,
framework_version,
ecr_image,
instance_type,
model_dir,
accelerator_type=None):
endpoint_name = sagemaker.utils.unique_name_from_base(
"sagemaker-huggingface-serving-trained-model")
model_data = sagemaker_session.upload_data(
path=model_dir,
key_prefix="sagemaker-huggingface-serving-trained-model/models",
)
model_file = pt_model if "pytorch" in ecr_image else tf_model
hf_model = Model(
model_data=f"{model_data}/{model_file}",
role="SageMakerRole",
image_uri=ecr_image,
sagemaker_session=sagemaker_session,
predictor_cls=Predictor,
)
with timeout_and_delete_endpoint(endpoint_name,
sagemaker_session,
minutes=30):
predictor = hf_model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
)
data = {
"inputs":
"Camera - You are awarded a SiPix Digital Camera! call 09061221066 fromm landline. Delivery within 28 days."
}
predictor.serializer = JSONSerializer()
predictor.deserializer = JSONDeserializer()
output = predictor.predict(data)
assert "score" in output[0]
def _deploy_and_predict(sagemaker_session, tuner, data_set, cpu_instance_type):
best_training_job = tuner.best_training_job()
with timeout_and_delete_endpoint_by_name(best_training_job,
sagemaker_session):
print(
"Deploying best model of hyperparameter tuning job {}: {}".format(
tuner.latest_tuning_job.name, best_training_job))
predictor = tuner.deploy(
1,
cpu_instance_type,
endpoint_name=best_training_job,
serializer=PredictionDataSerializer(),
deserializer=JSONDeserializer(),
)
print("Making prediction using the deployed model")
data = data_set[0][:10]
result = predictor.predict(data)
assert len(result["predictions"]) == len(data)
for prediction in result["predictions"]:
assert prediction is not None
def _test_vision_model(sagemaker_session,
framework_version,
ecr_image,
instance_type,
model_dir,
accelerator_type=None):
endpoint_name = sagemaker.utils.unique_name_from_base(
"sagemaker-huggingface-serving-vision-model")
env = {
"HF_MODEL_ID": "hf-internal-testing/tiny-random-vit",
"HF_TASK": "image-classification",
}
hf_model = HuggingFaceModel(
env=env,
role="SageMakerRole",
image_uri=ecr_image,
sagemaker_session=sagemaker_session,
predictor_cls=Predictor,
)
with timeout_and_delete_endpoint(endpoint_name,
sagemaker_session,
minutes=30):
predictor = hf_model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
)
predictor.serializer = DataSerializer(content_type="image/png")
predictor.deserializer = JSONDeserializer()
output = predictor.predict(image_sample_file_path)
assert "score" in output[0]
production_variants = endpoint_config["ProductionVariants"]
return [d["ModelName"] for d in production_variants]
@property
def content_type(self):
"""The MIME type of the data sent to the inference endpoint."""
return self.serializer.CONTENT_TYPE
@property
def accept(self):
"""The content type(s) that are expected from the inference endpoint."""
return self.deserializer.ACCEPT
@property
def endpoint(self):
"""Deprecated attribute. Please use endpoint_name."""
renamed_warning("The endpoint attribute")
return self.endpoint_name
csv_serializer = deprecated_serialize(CSVSerializer(), "csv_serializer")
json_serializer = deprecated_serialize(JSONSerializer(), "json_serializer")
npy_serializer = deprecated_serialize(NumpySerializer(), "npy_serializer")
csv_deserializer = deprecated_deserialize(CSVDeserializer(),
"csv_deserializer")
json_deserializer = deprecated_deserialize(JSONDeserializer(),
"json_deserializer")
numpy_deserializer = deprecated_deserialize(NumpyDeserializer(),
"numpy_deserializer")
RealTimePredictor = deprecated_class(Predictor, "RealTimePredictor")
articles_df['inputs'] = articles_df[['content', 'description'
]].apply(lambda x: ''.join(x), axis=1)
articles_df.drop(['content', 'description'], axis=1, inplace=True)
articles_df.rename(columns={'source.name': 'source'}, inplace=True)
df = sec_df.append(articles_df, ignore_index=True)
data = {}
data['inputs'] = df['inputs'].tolist()
#initialize predictor from Endpoint
predictor = sagemaker.predictor.Predictor(
endpoint_name=args.endpoint_name,
sagemaker_session=sagemaker_session,
serializer=JSONSerializer(),
deserializer=JSONDeserializer())
# predict for all chunks
try:
response = predictor.predict(data)
response_df = pd.json_normalize(response)
response_df['source'] = df['source']
response_df = response_df[['source', 'label', 'score']]
response_df.to_csv(
f'/opt/ml/processing/output/{args.ticker_cik}_sentiment_result.csv',
index=False)
except ClientError as e:
stacktrace = traceback.format_exc()
error_message = e.response["Error"]["Message"]
LOGGER.error("{}".format(stacktrace))
def json_deserializer():
return JSONDeserializer()
def test_tuning_byo_estimator(sagemaker_session, cpu_instance_type):
"""Use Factorization Machines algorithm as an example here.
First we need to prepare data for training. We take standard data set, convert it to the
format that the algorithm can process and upload it to S3.
Then we create the Estimator and set hyperparamets as required by the algorithm.
Next, we can call fit() with path to the S3.
Later the trained model is deployed and prediction is called against the endpoint.
Default predictor is updated with json serializer and deserializer.
"""
image_uri = image_uris.retrieve("factorization-machines",
sagemaker_session.boto_region_name)
training_data_path = os.path.join(DATA_DIR, "dummy_tensor")
with timeout(minutes=TUNING_DEFAULT_TIMEOUT_MINUTES):
prefix = "test_byo_estimator"
key = "recordio-pb-data"
s3_train_data = sagemaker_session.upload_data(path=training_data_path,
key_prefix=os.path.join(
prefix, "train",
key))
estimator = Estimator(
image_uri=image_uri,
role="SageMakerRole",
instance_count=1,
instance_type=cpu_instance_type,
sagemaker_session=sagemaker_session,
)
estimator.set_hyperparameters(num_factors=10,
feature_dim=784,
mini_batch_size=100,
predictor_type="binary_classifier")
hyperparameter_ranges = {"mini_batch_size": IntegerParameter(100, 200)}
tuner = HyperparameterTuner(
estimator=estimator,
objective_metric_name="test:binary_classification_accuracy",
hyperparameter_ranges=hyperparameter_ranges,
max_jobs=2,
max_parallel_jobs=2,
)
tuning_job_name = unique_name_from_base("byo", 32)
print("Started hyperparameter tuning job with name {}:".format(
tuning_job_name))
tuner.fit(
{
"train": s3_train_data,
"test": s3_train_data
},
include_cls_metadata=False,
job_name=tuning_job_name,
)
best_training_job = tuner.best_training_job()
with timeout_and_delete_endpoint_by_name(best_training_job,
sagemaker_session):
predictor = tuner.deploy(
1,
cpu_instance_type,
endpoint_name=best_training_job,
serializer=_FactorizationMachineSerializer(),
deserializer=JSONDeserializer(),
)
result = predictor.predict(datasets.one_p_mnist()[0][:10])
assert len(result["predictions"]) == 10
for prediction in result["predictions"]:
assert prediction["score"] is not None
# Create a serializer function for the predictor
import json
from sagemaker.deserializers import JSONDeserializer
from sagemaker.serializers import BaseSerializer
class fm_serializer(BaseSerializer):
CONTENT_TYPE='application/json'
def serialize(data):
js = {'instances': []}
for row in data:
js['instances'].append({'features': row.tolist()})
return json.dumps(js)
fm_predictor.serializer = fm_serializer
fm_predictor.deserializer = JSONDeserializer()
print(f"Accepted content type: {fm_predictor.content_type}")
# Check how your training set did. Use the endpoint to get predictions from your model.
#
# First, look at what a single prediction looks like.
# Amazon SageMaker model containers must respond to requests within 60 seconds. The model itself can have a maximum processing time of 60 seconds before responding to the /invocations. To do that, call the `predict` function for 5 rows at a time and then add those rows to a list.
# In[37]:
# Pass the X_train data to the predictor deployed
ytrain_p = []
for i in range(0, 1000, 5):
def __init__(self, *args, **kwargs):
super().__init__(*args,
serializer=CSVSerializer(),
deserializer=JSONDeserializer(),
**kwargs)
