def _init_sagemaker_session_if_does_not_exist(self, instance_type): """Set ``self.sagemaker_session`` to be a ``LocalSession`` or ``Session`` if it is not already. The type of session object is determined by the instance type. """ if self.sagemaker_session: return if instance_type in ("local", "local_gpu"): self.sagemaker_session = local.LocalSession() else: self.sagemaker_session = session.Session()
def deploy(self, initial_instance_count, instance_type, accelerator_type=None, endpoint_name=None, tags=None): """Deploy this ``Model`` to an ``Endpoint`` and optionally return a ``Predictor``. Create a SageMaker ``Model`` and ``EndpointConfig``, and deploy an ``Endpoint`` from this ``Model``. If ``self.predictor_cls`` is not None, this method returns a the result of invoking ``self.predictor_cls`` on the created endpoint name. The name of the created model is accessible in the ``name`` field of this ``Model`` after deploy returns The name of the created endpoint is accessible in the ``endpoint_name`` field of this ``Model`` after deploy returns. Args: instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'. initial_instance_count (int): The initial number of instances to run in the ``Endpoint`` created from this ``Model``. accelerator_type (str): Type of Elastic Inference accelerator to deploy this model for model loading and inference, for example, 'ml.eia1.medium'. If not specified, no Elastic Inference accelerator will be attached to the endpoint. For more information: https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html endpoint_name (str): The name of the endpoint to create (default: None). If not specified, a unique endpoint name will be created. tags(List[dict[str, str]]): The list of tags to attach to this specific endpoint. Returns: callable[string, sagemaker.session.Session] or None: Invocation of ``self.predictor_cls`` on the created endpoint name, if ``self.predictor_cls`` is not None. Otherwise, return None. """ if not self.sagemaker_session: if instance_type in ('local', 'local_gpu'): self.sagemaker_session = local.LocalSession() else: self.sagemaker_session = session.Session() if self.role is None: raise ValueError("Role can not be null for deploying a model") compiled_model_suffix = '-'.join(instance_type.split('.')[:-1]) if self._is_compiled_model: self.name += compiled_model_suffix self._create_sagemaker_model(instance_type, accelerator_type) production_variant = sagemaker.production_variant(self.name, instance_type, initial_instance_count, accelerator_type=accelerator_type) if endpoint_name: self.endpoint_name = endpoint_name else: self.endpoint_name = self.name if self._is_compiled_model and not self.endpoint_name.endswith(compiled_model_suffix): self.endpoint_name += compiled_model_suffix self.sagemaker_session.endpoint_from_production_variants(self.endpoint_name, [production_variant], tags) if self.predictor_cls: return self.predictor_cls(self.endpoint_name, self.sagemaker_session)
def upload_zip_file(repo_name, bucket, extra_args, dir="."): """ 1. Zip up the PWD. 2. Replace placeholders in buildspec.yml and add to the Zip. 3. Upload to S3. """ if not bucket: # The SDK logs a warning for not having pandas and this is the only way to suppress it. # https://github.com/aws/sagemaker-python-sdk/issues/1696 logging.basicConfig(level=logging.CRITICAL) import sagemaker.session as session logging.basicConfig(level=logging.INFO) bucket = session.Session().default_bucket() random_suffix = "".join(random.choices(string.ascii_letters, k=16)) key = f"codebuild-sagemaker-container-{random_suffix}.zip" origdir = os.getcwd() os.chdir(dir) try: with tempfile.TemporaryFile() as tmp: with zipfile.ZipFile(tmp, "w") as zip: # Zip all files in "dir" for dirname, _, filelist in os.walk("."): for file in filelist: zip.write(f"{dirname}/{file}") # Add buildspec.yml data_dir = os.path.join( os.path.dirname(os.path.abspath(__file__)), "data" ) with tempfile.NamedTemporaryFile() as buildspec: with open( os.path.join(data_dir, "buildspec.template.yml") ) as buildspec_template: buildspec_replaced = buildspec_template.read().replace( "REPLACE_ME_BUILD_ARGS", extra_args ) buildspec.write(buildspec_replaced.encode()) buildspec.seek(0) zip.write(buildspec.name, "buildspec.yml") tmp.seek(0) s3 = boto3.session.Session().client("s3") s3.upload_fileobj(tmp, bucket, key) return (bucket, key) finally: os.chdir(origdir)
def test_elastic_inference(): endpoint_name = utils.unique_name_from_base('mx-p3-8x-resnet') instance_type = 'ml.p3.8xlarge' framework_version = '1.4.1' maeve_client = boto3.client( "maeve", "us-west-2", endpoint_url="https://maeve.loadtest.us-west-2.ml-platform.aws.a2z.com" ) runtime_client = boto3.client( "sagemaker-runtime", "us-west-2", endpoint_url= "https://maeveruntime.loadtest.us-west-2.ml-platform.aws.a2z.com") sagemaker_session = session.Session( sagemaker_client=maeve_client, sagemaker_runtime_client=runtime_client) with timeout_and_delete_endpoint_by_name( endpoint_name=endpoint_name, sagemaker_session=sagemaker_session, minutes=20): prefix = 'mxnet-serving/default-handlers' model_data = sagemaker_session.upload_data(path=MODEL_PATH, key_prefix=prefix) model = MXNetModel( model_data=model_data, entry_point=SCRIPT_PATH, role='arn:aws:iam::841569659894:role/sagemaker-access-role', image= '763104351884.dkr.ecr.us-west-2.amazonaws.com/mxnet-inference:1.4.1-gpu-py36-cu100-ubuntu16.04', framework_version=framework_version, py_version='py3', sagemaker_session=sagemaker_session) predictor = model.deploy(initial_instance_count=1, instance_type=instance_type, endpoint_name=endpoint_name) output = predictor.predict([[1, 2]]) assert [[4.9999918937683105]] == output
def deploy( self, initial_instance_count, instance_type, accelerator_type=None, endpoint_name=None, update_endpoint=False, tags=None, kms_key=None, wait=True, ): """Deploy this ``Model`` to an ``Endpoint`` and optionally return a ``Predictor``. Create a SageMaker ``Model`` and ``EndpointConfig``, and deploy an ``Endpoint`` from this ``Model``. If ``self.predictor_cls`` is not None, this method returns a the result of invoking ``self.predictor_cls`` on the created endpoint name. The name of the created model is accessible in the ``name`` field of this ``Model`` after deploy returns The name of the created endpoint is accessible in the ``endpoint_name`` field of this ``Model`` after deploy returns. Args: instance_type (str): The EC2 instance type to deploy this Model to. For example, 'ml.p2.xlarge'. initial_instance_count (int): The initial number of instances to run in the ``Endpoint`` created from this ``Model``. accelerator_type (str): Type of Elastic Inference accelerator to deploy this model for model loading and inference, for example, 'ml.eia1.medium'. If not specified, no Elastic Inference accelerator will be attached to the endpoint. For more information: https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html endpoint_name (str): The name of the endpoint to create (default: None). If not specified, a unique endpoint name will be created. update_endpoint (bool): Flag to update the model in an existing Amazon SageMaker endpoint. If True, this will deploy a new EndpointConfig to an already existing endpoint and delete resources corresponding to the previous EndpointConfig. If False, a new endpoint will be created. Default: False tags(List[dict[str, str]]): The list of tags to attach to this specific endpoint. kms_key (str): The ARN of the KMS key that is used to encrypt the data on the storage volume attached to the instance hosting the endpoint. wait (bool): Whether the call should wait until the deployment of this model completes (default: True). Returns: callable[string, sagemaker.session.Session] or None: Invocation of ``self.predictor_cls`` on the created endpoint name, if ``self.predictor_cls`` is not None. Otherwise, return None. """ if not self.sagemaker_session: if instance_type in ("local", "local_gpu"): self.sagemaker_session = local.LocalSession() else: self.sagemaker_session = session.Session() if self.role is None: raise ValueError("Role can not be null for deploying a model") compiled_model_suffix = "-".join(instance_type.split(".")[:-1]) if self._is_compiled_model: self.name += compiled_model_suffix self._create_sagemaker_model(instance_type, accelerator_type, tags) production_variant = sagemaker.production_variant( self.name, instance_type, initial_instance_count, accelerator_type=accelerator_type) if endpoint_name: self.endpoint_name = endpoint_name else: self.endpoint_name = self.name if self._is_compiled_model and not self.endpoint_name.endswith( compiled_model_suffix): self.endpoint_name += compiled_model_suffix if update_endpoint: endpoint_config_name = self.sagemaker_session.create_endpoint_config( name=self.name, model_name=self.name, initial_instance_count=initial_instance_count, instance_type=instance_type, accelerator_type=accelerator_type, tags=tags, kms_key=kms_key, ) self.sagemaker_session.update_endpoint(self.endpoint_name, endpoint_config_name) else: self.sagemaker_session.endpoint_from_production_variants( self.endpoint_name, [production_variant], tags, kms_key, wait) if self.predictor_cls: return self.predictor_cls(self.endpoint_name, self.sagemaker_session)
from sagemaker import s3, session bucket = session.Session().default_bucket() inputs = s3.S3Uploader.upload('data', 's3://{}/mxnet-gluon-sentiment-example/data'.format(bucket)) pygmentize 'sentiment.py' #Se corre un training job de sagemaker from sagemaker import get_execution_role from sagemaker.mxnet import MXNet m = MXNet('sentiment.py', role=get_execution_role(), train_instance_count=1, train_instance_type='ml.c4.xlarge', framework_version='1.6.0', py_version='py3', distributions={'parameter_server': {'enabled': True}}, hyperparameters={'batch-size': 8, 'epochs': 2, 'learning-rate': 0.01, 'embedding-size': 50, 'log-interval': 1000}) #Fit y generación de resultados m.fit(inputs) predictor = m.deploy(initial_instance_count=1, instance_type='ml.c4.xlarge')
from ...sm_utils import get_sm_execution_role, parse_infer_args ON_SAGEMAKER_NOTEBOOK = False endpoint_name = 'XGBoostEndpoint-2020-05-24-17-23-16' s3_capture_upload_path = 's3://sagemaker-ap-southeast-2-454979696062/sagemaker-xgboost-2020-05-24-16-41-30-869/output/endpoint-data-capture' #baseline_prefix = prefix + '/baselining' #baseline_data_prefix = baseline_prefix + '/data' #baseline_results_prefix = baseline_prefix + '/results' baseline_data_uri = 's3://sagemaker-ap-southeast-2-454979696062/sagemaker/sklearncontainer/boston_train_xgb_n.csv' baseline_results_uri = 's3://sagemaker-ap-southeast-2-454979696062/sagemaker-xgboost-2020-05-24-16-41-30-869/output/baseline-results' boto_sess = boto3.Session() sm_session = session.Session(boto_sess) def capture(): # Change parameters as you would like - adjust sampling percentage, # chose to capture request or response or both. # Learn more from our documentation data_capture_config = DataCaptureConfig( enable_capture = True, sampling_percentage=50, destination_s3_uri=s3_capture_upload_path, kms_key_id=None, capture_options=["REQUEST", "RESPONSE"], csv_content_types=["text/csv"], json_content_types=["application/json"]) # Now it is time to apply the new configuration and wait for it to be applied
import boto3 import pandas as pd from sagemaker import session from sagemaker import RealTimePredictor from sagemaker.model_monitor import ( CronExpressionGenerator, DefaultModelMonitor, DataCaptureConfig, ) from sagemaker import get_execution_role from sagemaker.model_monitor.dataset_format import DatasetFormat sm_client = boto3.client("sagemaker") sm_session = session.Session(boto3.Session()) s3_client = boto3.Session().client("s3") role = "${module.step-functions.iam_role_arn}" # give a name to the data drift monitor job mon_schedule_name = "${var.data_drift_monitor_name}" endpoint_name = "${var.endpoint_name}" frequency = "${var.data_drift_monitoring_frequency}" # define a url path for the captured data output s3_capture_upload_path = ( "s3://${aws_s3_bucket.ml_bucket[0].id}/monitor_output/endpoint-data-capture" ) # define the url path for train data which is the baseline data baseline_data_uri = "s3://${aws_s3_bucket.ml_bucket[0].id}/" + "${var.train_key}"
## Deploy a pretrained model as part of the lifecycle configuration import os import boto3 import re import json from sagemaker import get_execution_role, session region = boto3.Session().region_name role = get_execution_role() print("RoleArn: {}".format(role)) # You can modify the bucket to be your own, but make sure the role you chose for this notebook # has s3:PutObject permissions. This is the bucket into which the data will be captured bucket = session.Session(boto3.Session()).default_bucket() print("Recommendations Bucket: {}".format(bucket)) prefix = 'sagemaker/Recommendations-ModelMonitor' data_capture_prefix = '{}/datacapture'.format(prefix) s3_capture_upload_path = 's3://{}/{}'.format(bucket, data_capture_prefix) reports_prefix = '{}/reports'.format(prefix) s3_report_path = 's3://{}/{}'.format(bucket, reports_prefix) code_prefix = '{}/code'.format(prefix) s3_code_preprocessor_uri = 's3://{}/{}/{}'.format(bucket, code_prefix, 'preprocessor.py') s3_code_postprocessor_uri = 's3://{}/{}/{}'.format(bucket, code_prefix, 'postprocessor.py') print("Capture path: {}".format(s3_capture_upload_path)) print("Report path: {}".format(s3_report_path))