def tfs_predictor_with_accelerator(sagemaker_session, tensorflow_eia_latest_version, cpu_instance_type): endpoint_name = sagemaker.utils.unique_name_from_base( "sagemaker-tensorflow-serving") model_data = sagemaker_session.upload_data( path=os.path.join(tests.integ.DATA_DIR, "tensorflow-serving-test-model.tar.gz"), key_prefix="tensorflow-serving/models", ) with tests.integ.timeout.timeout_and_delete_endpoint_by_name( endpoint_name, sagemaker_session): model = TensorFlowModel( model_data=model_data, role="SageMakerRole", framework_version=tensorflow_eia_latest_version, sagemaker_session=sagemaker_session, name=endpoint_name, ) predictor = model.deploy( 1, cpu_instance_type, endpoint_name=endpoint_name, accelerator_type="ml.eia1.medium", ) yield predictor
def get_model(cls): # Load if cls.model == None: # INPUT_TENSOR_NAME = 'inputs' # exported_model = classifier.export_savedmodel(export_dir_base = 'export/Servo', serving_input_reciever_fn = serving_input_fn) # with tarfile.open(os.path.join(model_path, 'model4.tar.gz'), mode='w:gz') as inp: # ''' # opt/ml/model에 있는 어떤 type의 model? # https://aws.amazon.com/blogs/machine-learning/bring-your-own-pre-trained-mxnet-or-tensorflow-models-into-amazon-sagemaker/ # ''' # # tar = tarfile.open(inp, "r:gz") # # tar.extractall() # # tar.close() # archive.add('export', recursive=True) role = 'AmazonSageMaker-ExecutionRole-20200615T164342' # role = get_execution_role() # sagemaker_session = sagemaker.Session() # inputs = sagemaker_session.upload_data(path='model.tar.gz', key_prefix='model') sagemaker_model = TensorFlowModel( model_data='s3://sagemaker-bucket-cj2/model/model4.tar.gz', role=role, container_log_level=20, name='DP-MODEL5', framework_version='1.15') predictor = sagemaker_model.deploy(initial_instance_count=1, instance_type='ml.m4.xlarge') cls.model = predictor return cls.model
def deploy(): "Deploy the model in a SageMaker Endpoint " print("Get the latest training job name...") with open(FILENAME_TRAINING_JOB_NAME) as f: training_job_name = f.read() print("Training job name :", training_job_name) print("Build the Model...") model = TensorFlowModel( entry_point=ENTRY_POINT_INFERENCE, source_dir=SOURCE_DIR, framework_version=FRAMEWORK_VERSION, model_data= f"{MODEL_ARTIFACTS_S3_LOCATION}/{training_job_name}/output/model.tar.gz", code_location=CUSTOM_CODE_SERVING_UPLOAD_S3_LOCATION, name=MODEL_NAME, role=ROLE_ARN, sagemaker_session=SESS) print("Build an endpoint...") predictor = model.deploy(endpoint_name=ENDPOINT_NAME, initial_instance_count=DEPLOY_INSTANCE_COUNT, instance_type=DEPLOY_INSTANCE_TYPE) return predictor
def tfs_predictor_with_model_and_entry_point_and_dependencies( sagemaker_local_session, tensorflow_inference_latest_version): endpoint_name = sagemaker.utils.unique_name_from_base( "sagemaker-tensorflow-serving") entry_point = os.path.join( tests.integ.DATA_DIR, "tfs/tfs-test-entrypoint-and-dependencies/inference.py") dependencies = [ os.path.join( tests.integ.DATA_DIR, "tfs/tfs-test-entrypoint-and-dependencies/dependency.py", ) ] model_data = "file://" + os.path.join( tests.integ.DATA_DIR, "tensorflow-serving-test-model.tar.gz") model = TensorFlowModel( entry_point=entry_point, model_data=model_data, role="SageMakerRole", dependencies=dependencies, framework_version=tensorflow_inference_latest_version, sagemaker_session=sagemaker_local_session, name=endpoint_name, ) predictor = model.deploy(1, "local", endpoint_name=endpoint_name) try: yield predictor finally: predictor.delete_endpoint()
def deploy_api_from_model(role, sagemaker_session): ''' to do: check if create_endpoint call is needed before using entry_point ''' ''' define entry point to api ''' with open('entry_point.py', 'w') as f: f.write('\n') f.close() ''' define sagemaker predictor object with s3 model file ''' try: s3_model_file = 's3://' + sagemaker_session.default_bucket() + '/model/model.tar.gz' sagemaker_model = TensorFlowModel( model_data = s3_model_file, role = role, framework_version = '1.12', entry_point = 'entry_point.py' ) except Exception as e: print('define api model error', e) ''' deploy api from sagemaker predictor object ''' try: predictor = sagemaker_model.deploy(initial_instance_count=1, instance_type='ml.t2.medium') if predictor: ''' get endpoint to build arn from deploy response ''' return predictor except Exception as e: print('deploy api model error', e) return False
def load_model(): sagemaker_model = TensorFlowModel( role= 'arn:aws:iam::821488635735:role/service-role/AmazonSageMaker-ExecutionRole-20171216T132860', model_data= 's3://sagemaker-us-east-2-821488635735/object_detection/model.tar.gz', entry_point='object_detect.py') predictor = sagemaker_model.deploy(initial_instance_count=1, instance_type='ml.m4.xlarge') print("Model Loaded, Now start predicting") return predictor
def test_enabling_data_capture_on_endpoint_shows_correct_data_capture_status( sagemaker_session, tensorflow_inference_latest_version): endpoint_name = unique_name_from_base("sagemaker-tensorflow-serving") model_data = sagemaker_session.upload_data( path=os.path.join(tests.integ.DATA_DIR, "tensorflow-serving-test-model.tar.gz"), key_prefix="tensorflow-serving/models", ) with tests.integ.timeout.timeout_and_delete_endpoint_by_name( endpoint_name, sagemaker_session): model = TensorFlowModel( model_data=model_data, role=ROLE, framework_version=tensorflow_inference_latest_version, sagemaker_session=sagemaker_session, ) predictor = model.deploy( initial_instance_count=INSTANCE_COUNT, instance_type=INSTANCE_TYPE, endpoint_name=endpoint_name, ) endpoint_desc = sagemaker_session.sagemaker_client.describe_endpoint( EndpointName=predictor.endpoint_name) endpoint_config_desc = sagemaker_session.sagemaker_client.describe_endpoint_config( EndpointConfigName=endpoint_desc["EndpointConfigName"]) assert endpoint_config_desc.get("DataCaptureConfig") is None predictor.enable_data_capture() # Wait for endpoint to finish updating # Endpoint update takes ~7min. 25 retries * 60s sleeps = 25min timeout for _ in retries( max_retry_count=25, exception_message_prefix= "Waiting for 'InService' endpoint status", seconds_to_sleep=60, ): new_endpoint = sagemaker_session.sagemaker_client.describe_endpoint( EndpointName=predictor.endpoint_name) if new_endpoint["EndpointStatus"] == "InService": break endpoint_desc = sagemaker_session.sagemaker_client.describe_endpoint( EndpointName=predictor.endpoint_name) endpoint_config_desc = sagemaker_session.sagemaker_client.describe_endpoint_config( EndpointConfigName=endpoint_desc["EndpointConfigName"]) assert endpoint_config_desc["DataCaptureConfig"]["EnableCapture"]
def create_model( self, role=None, vpc_config_override=VPC_CONFIG_DEFAULT, entry_point=None, source_dir=None, dependencies=None, **kwargs ): """Creates ``TensorFlowModel`` object to be used for creating SageMaker model entities. This can be done by deploying it to a SageMaker endpoint, or starting SageMaker Batch Transform jobs. Args: role (str): The ``TensorFlowModel``, which is also used during transform jobs. If not specified, the role from the Estimator is used. vpc_config_override (dict[str, list[str]]): Optional override for VpcConfig set on the model. Default: use subnets and security groups from this Estimator. * 'Subnets' (list[str]): List of subnet ids. * 'SecurityGroupIds' (list[str]): List of security group ids. entry_point (str): Path (absolute or relative) to the local Python source file which should be executed as the entry point to training. If ``source_dir`` is specified, then ``entry_point`` must point to a file located at the root of ``source_dir``. If not specified and ``endpoint_type`` is 'tensorflow-serving', no entry point is used. If ``endpoint_type`` is also ``None``, then the training entry point is used. source_dir (str): Path (absolute or relative or an S3 URI) to a directory with any other serving source code dependencies aside from the entry point file (default: None). dependencies (list[str]): A list of paths to directories (absolute or relative) with any additional libraries that will be exported to the container (default: None). **kwargs: Additional kwargs passed to :class:`~sagemaker.tensorflow.model.TensorFlowModel`. Returns: sagemaker.tensorflow.model.TensorFlowModel: A ``TensorFlowModel`` object. See :class:`~sagemaker.tensorflow.model.TensorFlowModel` for full details. """ kwargs["name"] = self._get_or_create_name(kwargs.get("name")) if "image_uri" not in kwargs: kwargs["image_uri"] = self.image_uri if "enable_network_isolation" not in kwargs: kwargs["enable_network_isolation"] = self.enable_network_isolation() return TensorFlowModel( model_data=self.model_data, role=role or self.role, container_log_level=self.container_log_level, framework_version=self.framework_version, sagemaker_session=self.sagemaker_session, vpc_config=self.get_vpc_config(vpc_config_override), entry_point=entry_point, source_dir=source_dir, dependencies=dependencies, **kwargs )
def create_model(self, model_server_workers=None): """Create a SageMaker ``TensorFlowModel`` object that can be deployed to an ``Endpoint``. Args: model_server_workers (int): Optional. The number of worker processes used by the inference server. If None, server will use one worker per vCPU. Returns: sagemaker.tensorflow.model.TensorFlowModel: A SageMaker ``TensorFlowModel`` object. See :func:`~sagemaker.tensorflow.model.TensorFlowModel` for full details. """ env = {'SAGEMAKER_REQUIREMENTS': self.requirements_file} return TensorFlowModel( self.model_data, self.role, self.entry_point, source_dir=self._model_source_dir(), enable_cloudwatch_metrics=self.enable_cloudwatch_metrics, env=env, name=self._current_job_name, container_log_level=self.container_log_level, code_location=self.code_location, py_version=self.py_version, framework_version=self.framework_version, model_server_workers=model_server_workers, sagemaker_session=self.sagemaker_session)
def _create_default_model(self, model_server_workers, role, vpc_config_override, entry_point=None, source_dir=None, dependencies=None, **kwargs): """Placeholder docstring""" return TensorFlowModel( self.model_data, role, entry_point or self.entry_point, source_dir=source_dir or self._model_source_dir(), enable_cloudwatch_metrics=self.enable_cloudwatch_metrics, env={"SAGEMAKER_REQUIREMENTS": self.requirements_file}, image=self.image_name, name=self._current_job_name, container_log_level=self.container_log_level, code_location=self.code_location, py_version=self.py_version, framework_version=self.framework_version, model_server_workers=model_server_workers, sagemaker_session=self.sagemaker_session, vpc_config=self.get_vpc_config(vpc_config_override), dependencies=dependencies or self.dependencies, enable_network_isolation=self.enable_network_isolation(), **kwargs)
def create_model(self, role=None, vpc_config_override=VPC_CONFIG_DEFAULT, entry_point=None, source_dir=None, dependencies=None, **kwargs): """Creates ``TensorFlowModel`` object to be used for creating SageMaker model entities""" kwargs["name"] = self._get_or_create_name(kwargs.get("name")) if "enable_network_isolation" not in kwargs: kwargs["enable_network_isolation"] = self.enable_network_isolation( ) return TensorFlowModel( model_data=self.model_data, role=role or self.role, container_log_level=self.container_log_level, framework_version="2.3.1", sagemaker_session=self.sagemaker_session, vpc_config=self.get_vpc_config(vpc_config_override), entry_point=entry_point, source_dir=source_dir, dependencies=dependencies, **kwargs)
def create_model(self, model_url): from sagemaker.tensorflow.model import TensorFlowModel return TensorFlowModel(model_data=model_url, role=self.role_name, entry_point=self.script, py_version=self.python, name=self.endpoint_name, env=self.environment)
def test_jumpstart_tensorflow_image_uri(patched_get_model_specs, session): patched_get_model_specs.side_effect = get_prototype_model_spec model_id, model_version = "tensorflow-ic-bit-m-r101x1-ilsvrc2012-classification-1", "*" instance_type = "ml.p2.xlarge" region = "us-west-2" model_specs = accessors.JumpStartModelsAccessor.get_model_specs( region, model_id, model_version) # inference uri = image_uris.retrieve( framework=None, region=region, image_scope="inference", model_id=model_id, model_version=model_version, instance_type=instance_type, ) framework_class_uri = TensorFlowModel( role="mock_role", model_data="mock_data", entry_point="mock_entry_point", framework_version=model_specs.hosting_ecr_specs.framework_version, sagemaker_session=session, ).serving_image_uri(region, instance_type) assert uri == framework_class_uri assert uri == "763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-inference:2.3-gpu" # training uri = image_uris.retrieve( framework=None, region=region, image_scope="training", model_id=model_id, model_version=model_version, instance_type=instance_type, ) framework_class_uri = TensorFlow( role="mock_role", entry_point="mock_entry_point", framework_version=model_specs.training_ecr_specs.framework_version, py_version=model_specs.training_ecr_specs.py_version, instance_type=instance_type, instance_count=1, sagemaker_session=session, ).training_image_uri(region=region) assert uri == framework_class_uri assert uri == "763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.3-gpu-py37"
def tfs_predictor_with_model_and_entry_point_same_tar( sagemaker_local_session, tensorflow_inference_latest_version, tmpdir): endpoint_name = sagemaker.utils.unique_name_from_base( "sagemaker-tensorflow-serving") model_tar = tar_dir( os.path.join(tests.integ.DATA_DIR, "tfs/tfs-test-model-with-inference"), tmpdir) model = TensorFlowModel( model_data="file://" + model_tar, role="SageMakerRole", framework_version=tensorflow_inference_latest_version, sagemaker_session=sagemaker_local_session, name=endpoint_name, ) predictor = model.deploy(1, "local", endpoint_name=endpoint_name) try: yield predictor finally: predictor.delete_endpoint()
def main(ecr_image_path, model_s3_path, instance_type, endpoint_name): role = get_execution_role() sagemaker_model = TensorFlowModel(model_data=model_s3_path, role=role, image=ecr_image_path, entry_point='bert/run_classifier.py') predictor = sagemaker_model.deploy(initial_instance_count=1, instance_type=instance_type, endpoint_name=endpoint_name) # get the status of the endpoint sagemaker = boto3.client(service_name='sagemaker') response = sagemaker.describe_endpoint(EndpointName=endpoint_name) status = response['EndpointStatus'] print('EndpointStatus = {}'.format(status)) if status == 'InService': print( 'Endpoint creation ended with EndpointStatus = {}'.format(status)) else: print( 'Endpoint creation ended with EndpointStatus = {}'.format(status)) return endpoint_name
def _create_default_model(self, model_server_workers, role, vpc_config_override): return TensorFlowModel(self.model_data, role, self.entry_point, source_dir=self._model_source_dir(), enable_cloudwatch_metrics=self.enable_cloudwatch_metrics, env={'SAGEMAKER_REQUIREMENTS': self.requirements_file}, image=self.image_name, name=self._current_job_name, container_log_level=self.container_log_level, code_location=self.code_location, py_version=self.py_version, framework_version=self.framework_version, model_server_workers=model_server_workers, sagemaker_session=self.sagemaker_session, vpc_config=self.get_vpc_config(vpc_config_override), dependencies=self.dependencies)
def create_model(self, model_server_workers=None, role=None): """Create a SageMaker ``TensorFlowModel`` object that can be deployed to an ``Endpoint``. Args: role (str): The ``ExecutionRoleArn`` IAM Role ARN for the ``Model``, which is also used during transform jobs. If not specified, the role from the Estimator will be used. model_server_workers (int): Optional. The number of worker processes used by the inference server. If None, server will use one worker per vCPU. Returns: sagemaker.tensorflow.model.TensorFlowModel: A SageMaker ``TensorFlowModel`` object. See :func:`~sagemaker.tensorflow.model.TensorFlowModel` for full details. """ env = {'SAGEMAKER_REQUIREMENTS': self.requirements_file} role = role or self.role return TensorFlowModel(self.model_data, role, self.entry_point, source_dir=self._model_source_dir(), enable_cloudwatch_metrics=self.enable_cloudwatch_metrics, env=env, image=self.image_name, name=self._current_job_name, container_log_level=self.container_log_level, code_location=self.code_location, py_version=self.py_version, framework_version=self.framework_version, model_server_workers=model_server_workers, sagemaker_session=self.sagemaker_session)
def create_model(self, model_server_workers=None, role=None, vpc_config_override=VPC_CONFIG_DEFAULT): """Create a SageMaker ``TensorFlowModel`` object that can be deployed to an ``Endpoint``. Args: role (str): The ``ExecutionRoleArn`` IAM Role ARN for the ``Model``, which is also used during transform jobs. If not specified, the role from the Estimator will be used. model_server_workers (int): Optional. The number of worker processes used by the inference server. If None, server will use one worker per vCPU. vpc_config_override (dict[str, list[str]]): Optional override for VpcConfig set on the model. Default: use subnets and security groups from this Estimator. * 'Subnets' (list[str]): List of subnet ids. * 'SecurityGroupIds' (list[str]): List of security group ids. Returns: sagemaker.tensorflow.model.TensorFlowModel: A SageMaker ``TensorFlowModel`` object. See :func:`~sagemaker.tensorflow.model.TensorFlowModel` for full details. """ env = {'SAGEMAKER_REQUIREMENTS': self.requirements_file} role = role or self.role return TensorFlowModel( self.model_data, role, self.entry_point, source_dir=self._model_source_dir(), enable_cloudwatch_metrics=self.enable_cloudwatch_metrics, env=env, image=self.image_name, name=self._current_job_name, container_log_level=self.container_log_level, code_location=self.code_location, py_version=self.py_version, framework_version=self.framework_version, model_server_workers=model_server_workers, sagemaker_session=self.sagemaker_session, vpc_config=self.get_vpc_config(vpc_config_override))
archive.add('export', recursive=True) import sagemaker sagemaker_session = sagemaker.Session() inputs = sagemaker_session.upload_data(path='model.tar.gz', key_prefix='model') # Deploy the trained model get_ipython().system('touch train.py') from sagemaker.tensorflow.model import TensorFlowModel sagemaker_model = TensorFlowModel(model_data='s3://' + sagemaker_session.default_bucket() + '/model/model.tar.gz', role=role, framework_version='1.12', entry_point='train.py') predictor = sagemaker_model.deploy(initial_instance_count=1, instance_type='ml.m4.xlarge') endpoint_name = 'XXXXXXXXXXXXX' sagemaker_session = sagemaker.Session() import sagemaker from sagemaker.tensorflow.model import TensorFlowModel predictor = sagemaker.tensorflow.model.TensorFlowPredictor( endpoint_name, sagemaker_session)
def test_disabling_data_capture_on_endpoint_shows_correct_data_capture_status( sagemaker_session, tensorflow_inference_latest_version): endpoint_name = unique_name_from_base("sagemaker-tensorflow-serving") model_data = sagemaker_session.upload_data( path=os.path.join(tests.integ.DATA_DIR, "tensorflow-serving-test-model.tar.gz"), key_prefix="tensorflow-serving/models", ) with tests.integ.timeout.timeout_and_delete_endpoint_by_name( endpoint_name, sagemaker_session): model = TensorFlowModel( model_data=model_data, role=ROLE, framework_version=tensorflow_inference_latest_version, sagemaker_session=sagemaker_session, ) destination_s3_uri = os.path.join("s3://", sagemaker_session.default_bucket(), endpoint_name, "custom") predictor = model.deploy( initial_instance_count=INSTANCE_COUNT, instance_type=INSTANCE_TYPE, endpoint_name=endpoint_name, data_capture_config=DataCaptureConfig( enable_capture=True, sampling_percentage=CUSTOM_SAMPLING_PERCENTAGE, destination_s3_uri=destination_s3_uri, capture_options=CUSTOM_CAPTURE_OPTIONS, csv_content_types=CUSTOM_CSV_CONTENT_TYPES, json_content_types=CUSTOM_JSON_CONTENT_TYPES, sagemaker_session=sagemaker_session, ), ) endpoint_desc = sagemaker_session.sagemaker_client.describe_endpoint( EndpointName=predictor.endpoint_name) endpoint_config_desc = sagemaker_session.sagemaker_client.describe_endpoint_config( EndpointConfigName=endpoint_desc["EndpointConfigName"]) assert endpoint_config_desc["DataCaptureConfig"]["EnableCapture"] assert (endpoint_config_desc["DataCaptureConfig"] ["InitialSamplingPercentage"] == CUSTOM_SAMPLING_PERCENTAGE) assert endpoint_config_desc["DataCaptureConfig"]["CaptureOptions"] == [ { "CaptureMode": "Input" } ] assert (endpoint_config_desc["DataCaptureConfig"] ["CaptureContentTypeHeader"]["CsvContentTypes"] == CUSTOM_CSV_CONTENT_TYPES) assert (endpoint_config_desc["DataCaptureConfig"] ["CaptureContentTypeHeader"]["JsonContentTypes"] == CUSTOM_JSON_CONTENT_TYPES) predictor.disable_data_capture() # Wait for endpoint to finish updating # Endpoint update takes ~7min. 25 retries * 60s sleeps = 25min timeout for _ in retries( max_retry_count=25, exception_message_prefix= "Waiting for 'InService' endpoint status", seconds_to_sleep=60, ): new_endpoint = sagemaker_session.sagemaker_client.describe_endpoint( EndpointName=predictor.endpoint_name) if new_endpoint["EndpointStatus"] == "InService": break endpoint_desc = sagemaker_session.sagemaker_client.describe_endpoint( EndpointName=predictor.endpoint_name) endpoint_config_desc = sagemaker_session.sagemaker_client.describe_endpoint_config( EndpointConfigName=endpoint_desc["EndpointConfigName"]) assert not endpoint_config_desc["DataCaptureConfig"]["EnableCapture"]
# In[65]: import sagemaker sagemaker_session = sagemaker.Session() inputs = sagemaker_session.upload_data(path='model.tar.gz', key_prefix='model') # In[66]: get_ipython().system('touch train.py') # In[74]: from sagemaker.tensorflow.model import TensorFlowModel sagemaker_model = TensorFlowModel(model_data='s3://' + sagemaker_session.default_bucket() + '/model/model.tar.gz', role=role, framework_version='2.2.0', entry_point='train.py') # In[75]: get_ipython().run_cell_magic( 'time', '', "predictor = sagemaker_model.deploy(initial_instance_count=1,\n instance_type='ml.t2.medium')" ) # In[77]: predictor.endpoint # In[78]:
def create_model( self, role=None, vpc_config_override=VPC_CONFIG_DEFAULT, entry_point=None, source_dir=None, dependencies=None, **kwargs ): """Create a SageMaker ``RLEstimatorModel`` object that can be deployed to an Endpoint. Args: role (str): The ``ExecutionRoleArn`` IAM Role ARN for the ``Model``, which is also used during transform jobs. If not specified, the role from the Estimator will be used. vpc_config_override (dict[str, list[str]]): Optional override for VpcConfig set on the model. Default: use subnets and security groups from this Estimator. * 'Subnets' (list[str]): List of subnet ids. * 'SecurityGroupIds' (list[str]): List of security group ids. entry_point (str): Path (absolute or relative) to the Python source file which should be executed as the entry point for MXNet hosting (default: self.entry_point). If ``source_dir`` is specified, then ``entry_point`` must point to a file located at the root of ``source_dir``. source_dir (str): Path (absolute or relative) to a directory with any other training source code dependencies aside from the entry point file (default: self.source_dir). Structure within this directory are preserved when hosting on Amazon SageMaker. dependencies (list[str]): A list of paths to directories (absolute or relative) with any additional libraries that will be exported to the container (default: self.dependencies). The library folders will be copied to SageMaker in the same folder where the entry_point is copied. If the ```source_dir``` points to S3, code will be uploaded and the S3 location will be used instead. This is not supported with "local code" in Local Mode. **kwargs: Additional kwargs passed to the :class:`~sagemaker.model.FrameworkModel` constructor. Returns: sagemaker.model.FrameworkModel: Depending on input parameters returns one of the following: * :class:`~sagemaker.model.FrameworkModel` - if ``image_uri`` is specified on the estimator; * :class:`~sagemaker.mxnet.MXNetModel` - if ``image_uri`` isn't specified and MXNet is used as the RL backend; * :class:`~sagemaker.tensorflow.model.TensorFlowModel` - if ``image_uri`` isn't specified and TensorFlow is used as the RL backend. Raises: ValueError: If image_uri is not specified and framework enum is not valid. """ base_args = dict( model_data=self.model_data, role=role or self.role, image_uri=kwargs.get("image_uri", self.image_uri), container_log_level=self.container_log_level, sagemaker_session=self.sagemaker_session, vpc_config=self.get_vpc_config(vpc_config_override), ) base_args["name"] = self._get_or_create_name(kwargs.get("name")) if not entry_point and (source_dir or dependencies): raise AttributeError("Please provide an `entry_point`.") entry_point = entry_point or self._model_entry_point() source_dir = source_dir or self._model_source_dir() dependencies = dependencies or self.dependencies extended_args = dict( entry_point=entry_point, source_dir=source_dir, code_location=self.code_location, dependencies=dependencies, ) extended_args.update(base_args) if self.image_uri: return FrameworkModel(**extended_args) if self.toolkit == RLToolkit.RAY.value: raise NotImplementedError( "Automatic deployment of Ray models is not currently available." " Train policy parameters are available in model checkpoints" " in the TrainingJob output." ) if self.framework == RLFramework.TENSORFLOW.value: return TensorFlowModel(framework_version=self.framework_version, **base_args) if self.framework == RLFramework.MXNET.value: return MXNetModel( framework_version=self.framework_version, py_version=PYTHON_VERSION, **extended_args ) raise ValueError( "An unknown RLFramework enum was passed in. framework: {}".format(self.framework) )
filepath = os.path.join('1') model.save(filepath) # ARCHIVE SAVED MODEL FOR DEPLOYMENT os.system('tar -czvf model.tar.gz 1/') ''' # DEPLOY MODEL # 'model.tar.gz' and tokenizer ('20211005T1859_tokenizer.pkl' as loaded in inference.py) are in the same S3 folder as 'model_data' below # 'inference.py' and 'bb_classifier_inference.py' are in the same location from which this deploy script is being run # normally, 'source_dir' is used to indicated the location of the last 2 files on S3, but it's not working in this case for some reason tf_model = TensorFlowModel( role='', model_data='s3:// /model.tar.gz', #source_dir = 's3://', entry_point='./inference.py', framework_version='2.4.1', dependencies=['./bb_classifier_inference.py'], ) # CREATE ENDPOINT endpoint = 'test-bin-bias-model-00' tf_model.deploy( initial_instance_count=1, instance_type='ml.g4dn.xlarge', endpoint_name=endpoint, wait=True, update_endpoint=True, #aws_region='eu-central-1', )
model_path = 's3://sagemaker-models-euwest2/inception_resnetv2_nainet49_v1.tar.gz' def resolve_sm_role(): client = boto3.client('iam', region_name='eu-west-1') response_roles = client.list_roles(PathPrefix='/', MaxItems=999) for role in response_roles['Roles']: if role['RoleName'].startswith('AmazonSageMaker-ExecutionRole-'): print('Resolved SageMaker IAM Role to: ' + str(role)) return role['Arn'] raise Exception( 'Could not resolve what should be the SageMaker role to be used') role = resolve_sm_role() sagemaker_model = TensorFlowModel(model_data=model_path, role=role, entry_point='entry_point.py', name=MODEL_NAME) try: client = boto3.client('sagemaker') client.delete_endpoint(EndpointName=MODEL_NAME) client.delete_model(ModelName=MODEL_NAME) except: pass sagemaker_model.deploy(initial_instance_count=1, instance_type='ml.m4.xlarge')
role = get_execution_role() sess = sage.Session() client = boto3.client('sagemaker') name = client.list_training_jobs( SortBy='CreationTime')['TrainingJobSummaries'][0]['TrainingJobName'] s3_model_path = 's3://cop-group9/model/' + name + '/output/model.tar.gz' print('S3 path for model', s3_model_path) #get_ipython().system('touch train1.py') sagemaker_model = TensorFlowModel( model_data=s3_model_path, role=role, framework_version='1.12.0', #py_version='py2', entry_point='train1.py') print('Starting deployment...') predictor = sagemaker_model.deploy(initial_instance_count=1, instance_type='ml.m4.xlarge') endpoint_name = predictor.endpoint print('Finished deployment of Endpoint: ', endpoint_name) endpoint_file = open("endpoint_name.txt", "w") endpoint_file.write(endpoint_name) endpoint_file.close() print('Endpoint name written to file: endpoint_name.txt')