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)