def test_generic_deploy_vpc_config_override(sagemaker_session):
vpc_config_a = {'Subnets': ['foo'], 'SecurityGroupIds': ['bar']}
vpc_config_b = {'Subnets': ['foo', 'bar'], 'SecurityGroupIds': ['baz']}
e = Estimator(IMAGE_NAME,
ROLE,
INSTANCE_COUNT,
INSTANCE_TYPE,
sagemaker_session=sagemaker_session)
e.fit({'train': 's3://bucket/training-prefix'})
e.deploy(INSTANCE_COUNT, INSTANCE_TYPE)
assert sagemaker_session.create_model.call_args_list[0][1][
'vpc_config'] is None
e.subnets = vpc_config_a['Subnets']
e.security_group_ids = vpc_config_a['SecurityGroupIds']
e.deploy(INSTANCE_COUNT, INSTANCE_TYPE)
assert sagemaker_session.create_model.call_args_list[1][1][
'vpc_config'] == vpc_config_a
e.deploy(INSTANCE_COUNT, INSTANCE_TYPE, vpc_config_override=vpc_config_b)
assert sagemaker_session.create_model.call_args_list[2][1][
'vpc_config'] == vpc_config_b
e.deploy(INSTANCE_COUNT, INSTANCE_TYPE, vpc_config_override=None)
assert sagemaker_session.create_model.call_args_list[3][1][
'vpc_config'] is None
def test_generic_deploy_accelerator_type(sagemaker_session):
e = Estimator(IMAGE_NAME,
ROLE,
INSTANCE_COUNT,
INSTANCE_TYPE,
sagemaker_session=sagemaker_session)
e.fit({'train': 's3://bucket/training-prefix'})
e.deploy(INSTANCE_COUNT, INSTANCE_TYPE, ACCELERATOR_TYPE)
args = e.sagemaker_session.endpoint_from_production_variants.call_args[0]
assert args[0].startswith(IMAGE_NAME)
assert args[1][0]['AcceleratorType'] == ACCELERATOR_TYPE
assert args[1][0]['InitialInstanceCount'] == INSTANCE_COUNT
assert args[1][0]['InstanceType'] == INSTANCE_TYPE
def test_generic_to_deploy(sagemaker_session):
e = Estimator(IMAGE_NAME,
ROLE,
INSTANCE_COUNT,
INSTANCE_TYPE,
output_path=OUTPUT_PATH,
sagemaker_session=sagemaker_session)
e.set_hyperparameters(**HYPERPARAMS)
e.fit({'train': 's3://bucket/training-prefix'})
predictor = e.deploy(INSTANCE_COUNT, INSTANCE_TYPE)
sagemaker_session.train.assert_called_once()
assert len(sagemaker_session.train.call_args[0]) == 0
args = sagemaker_session.train.call_args[1]
assert args['job_name'].startswith(IMAGE_NAME)
args.pop('job_name')
args.pop('role')
assert args == HP_TRAIN_CALL
sagemaker_session.create_model.assert_called_once()
args = sagemaker_session.create_model.call_args[0]
assert args[0].startswith(IMAGE_NAME)
assert args[1] == ROLE
assert args[2]['Image'] == IMAGE_NAME
assert args[2]['ModelDataUrl'] == MODEL_DATA
assert isinstance(predictor, RealTimePredictor)
assert predictor.endpoint.startswith(IMAGE_NAME)
assert predictor.sagemaker_session == sagemaker_session
def test_generic_to_deploy(sagemaker_session):
e = Estimator(IMAGE_NAME, ROLE, INSTANCE_COUNT, INSTANCE_TYPE, output_path=OUTPUT_PATH,
sagemaker_session=sagemaker_session)
e.set_hyperparameters(**HYPERPARAMS)
e.fit({'train': 's3://bucket/training-prefix'})
predictor = e.deploy(INSTANCE_COUNT, INSTANCE_TYPE)
sagemaker_session.train.assert_called_once()
assert len(sagemaker_session.train.call_args[0]) == 0
args = sagemaker_session.train.call_args[1]
assert args['job_name'].startswith(IMAGE_NAME)
args.pop('job_name')
args.pop('role')
assert args == HP_TRAIN_CALL
sagemaker_session.create_model.assert_called_once()
args = sagemaker_session.create_model.call_args[0]
assert args[0].startswith(IMAGE_NAME)
assert args[1] == ROLE
assert args[2]['Image'] == IMAGE_NAME
assert args[2]['ModelDataUrl'] == MODEL_DATA
assert isinstance(predictor, RealTimePredictor)
assert predictor.endpoint.startswith(IMAGE_NAME)
assert predictor.sagemaker_session == sagemaker_session
def train(self):
"""
Train and deploy the XOR model with Sagemaker Linear Learner
"""
estimator = Estimator(
image_uri=self.DOCKER_IMAGE_URI,
role=self.SAGEMAKER_ROLE,
instance_count=1,
hyperparameters={"predictor_type": "binary_classifier"},
instance_type="ml.m5.large",
)
estimator.fit({"train": self.location})
estimator.deploy(initial_instance_count=1,
instance_type=self.SAGEMAKER_INSTANCE,
wait=False)
self.next(self.end)
def main():
download_training_and_eval_data()
image = 'sagemaker-tensorflow2-local'
print('Starting model training.')
california_housing_estimator = Estimator(
image,
DUMMY_IAM_ROLE,
hyperparameters={'epochs': 10,
'batch_size': 64,
'learning_rate': 0.1},
instance_count=1,
instance_type="local")
inputs = {'train': 'file://./data/train', 'test': 'file://./data/test'}
california_housing_estimator.fit(inputs, logs=True)
print('Completed model training')
print('Deploying endpoint in local mode')
predictor = california_housing_estimator.deploy(initial_instance_count=1, instance_type='local')
do_inference_on_local_endpoint(predictor)
print('About to delete the endpoint to stop paying (if in cloud mode).')
predictor.delete_endpoint(predictor.endpoint_name)
from sagemaker import get_execution_role
role = get_execution_role()
from sagemaker.estimator import Estimator
hyperparameters = {'train-steps': 100}
instance_type = 'ml.p2.xlarge'
estimator = Estimator(role=role,
train_instance_count=1,
train_instance_type=instance_type,
image_name='<insert image name>',
output_path='s3://<insert output path>',
hyperparameters=hyperparameters)
# The fit function uploads the tar.gz file to the bucket.
# fit checks to see if this file is actually there, but it may not be using it.
estimator.fit('s3://<insert bucket path to csv>')
# estimator.fit('file://./data/pima-indians-diabetes.csv')
# Code - https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/tensorflow_bring_your_own/tensorflow_bring_your_own.ipynb
predictor = estimator.deploy(1, instance_type)
local_train = './data/train/boston_train.csv'
local_validation = './data/validation/boston_validation.csv'
local_test = './data/test/boston_test.csv'
trainX.to_csv(local_train, header=None, index=False)
valX.to_csv(local_validation, header=None, index=False)
testX.to_csv(local_test, header=None, index=False)
image = 'sagemaker-catboost-regressor-local'
local_regressor = Estimator(
image,
role,
instance_count=1,
instance_type="local")
train_location = 'file://'+local_train
validation_location = 'file://'+local_validation
local_regressor.fit({'train':train_location, 'validation': validation_location}, logs=True)
predictor = local_regressor.deploy(1, 'local', serializer=csv_serializer)
with open(local_test, 'r') as f:
payload = f.read().strip()
predicted = predictor.predict(payload).decode('utf-8')
print(predicted)
predictor.delete_endpoint(predictor.endpoint)
predictor.delete_model()
instance_count=1,
instance_type="local",
hyperparameters={
'boosting_type': 'gbdt',
'objective': 'regression',
'num_leaves': 31,
'learning_rate': 0.05,
'feature_fraction': 0.9,
'bagging_fraction': 0.8,
'bagging_freq': 5,
'verbose': 0
})
train_location = 'file://' + local_train
validation_location = 'file://' + local_validation
local_lightgbm.fit({
'train': train_location,
'validation': validation_location
},
logs=True)
predictor = local_lightgbm.deploy(1, 'local', serializer=csv_serializer)
with open(local_test, 'r') as f:
payload = f.read().strip()
predicted = predictor.predict(payload).decode('utf-8')
print(predicted)
predictor.delete_endpoint(predictor.endpoint)
predictor.delete_model()
def test_jumpstart_transfer_learning_estimator_class(setup):
model_id, model_version = "huggingface-spc-bert-base-cased", "1.0.0"
training_instance_type = "ml.p3.2xlarge"
inference_instance_type = "ml.p2.xlarge"
instance_count = 1
print("Starting training...")
image_uri = image_uris.retrieve(
region=None,
framework=None,
image_scope="training",
model_id=model_id,
model_version=model_version,
instance_type=training_instance_type,
)
script_uri = script_uris.retrieve(
model_id=model_id, model_version=model_version, script_scope="training"
)
model_uri = model_uris.retrieve(
model_id=model_id, model_version=model_version, model_scope="training"
)
default_hyperparameters = hyperparameters.retrieve_default(
model_id=model_id,
model_version=model_version,
)
default_hyperparameters["epochs"] = "1"
estimator = Estimator(
image_uri=image_uri,
source_dir=script_uri,
model_uri=model_uri,
entry_point=TRAINING_ENTRY_POINT_SCRIPT_NAME,
role=get_sm_session().get_caller_identity_arn(),
sagemaker_session=get_sm_session(),
enable_network_isolation=True,
hyperparameters=default_hyperparameters,
tags=[{"Key": JUMPSTART_TAG, "Value": os.environ[ENV_VAR_JUMPSTART_SDK_TEST_SUITE_ID]}],
instance_count=instance_count,
instance_type=training_instance_type,
)
estimator.fit(
{
"training": f"s3://{get_jumpstart_content_bucket(JUMPSTART_DEFAULT_REGION_NAME)}/"
f"{get_training_dataset_for_model_and_version(model_id, model_version)}",
}
)
print("Starting inference...")
image_uri = image_uris.retrieve(
region=None,
framework=None,
image_scope="inference",
model_id=model_id,
model_version=model_version,
instance_type=inference_instance_type,
)
script_uri = script_uris.retrieve(
model_id=model_id, model_version=model_version, script_scope="inference"
)
model_uri = model_uris.retrieve(
model_id=model_id, model_version=model_version, model_scope="inference"
)
endpoint_name = name_from_base(f"{model_id}-transfer-learning")
estimator.deploy(
initial_instance_count=instance_count,
instance_type=inference_instance_type,
entry_point=INFERENCE_ENTRY_POINT_SCRIPT_NAME,
image_uri=image_uri,
source_dir=script_uri,
endpoint_name=endpoint_name,
)
endpoint_invoker = EndpointInvoker(
endpoint_name=endpoint_name,
)
response = endpoint_invoker.invoke_spc_endpoint(["hello", "world"])
assert response is not None
# 2. Docker Desktop has to be installed on your computer, and running.
# 3. Docker Desktop has to be allocated with 6 CPUs and 8 GB of Memory.
# 4. Open terminal and run the following commands:
# docker build -t sagemaker-prophet-local container/.
########################################################################################################################
import pandas as pd
from sagemaker.estimator import Estimator
from sagemaker.local import LocalSession
from sagemaker.predictor import csv_serializer
sagemaker_session = LocalSession()
sagemaker_session.config = {'local': {'local_code': True}}
# For local training a dummy role will be sufficient
role = 'arn:aws:iam::111111111111:role/service-role/AmazonSageMaker-ExecutionRole-20200101T000001'
image = 'sagemaker-prophet-local'
print(image)
local_tseries = Estimator(image, role, instance_count=1, instance_type="local")
local_tseries.fit('file://./data/')
local_predictor = local_tseries.deploy(1, 'local', serializer=csv_serializer)
predicted = local_predictor.predict("30").decode('utf-8')
print(predicted)
local_predictor.delete_endpoint()
