Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Implementación de un modelo Para implementar un modelo SageMaker compilado por Amazon NEO en un punto final HTTPS, debe configurar y crear el punto final para el modelo mediante los servicios de alojamiento de Amazon SageMaker AI. Actualmente, los desarrolladores pueden usar Amazon SageMaker APIs para implementar módulos en instancias ml.c5, ml.c4, ml.m5, ml.m4, ml.p3, ml.p2 y ml.inf1. Para las instancias [Inferentia](https://aws.amazon.com/machine-learning/inferentia/) y [Trainium](https://aws.amazon.com/machine-learning/trainium/), los modelos deben compilarse específicamente para dichas instancias. No se garantiza que los modelos compilados para otros tipos de instancia funcionen con instancias Inferentia o Trainium. Cuando se implementa un modelo compilado, es preciso usar la misma instancia para el destino que utilizó para la compilación. Esto crea un punto final de IA que SageMaker puede usar para realizar inferencias. [Puede implementar un modelo compilado en NEO mediante cualquiera de las siguientes opciones: [Amazon SageMaker AI SDK for Python](https://sagemaker.readthedocs.io/en/stable/), [SDK for Python (Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)) y [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/reference/)la consola AI. SageMaker ](https://console.aws.amazon.com/sagemaker) **nota** Para implementar un modelo mediante AWS CLI la consola o Boto3, consulte [Neo Inference Container Images para seleccionar el URI de la imagen de inferencia para su contenedor](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) principal. **Topics** + [Requisitos previos](neo-deployment-hosting-services-prerequisites.md) + [Implemente un modelo compilado mediante el SDK SageMaker](neo-deployment-hosting-services-sdk.md) + [Implementa un modelo compilado con Boto3](neo-deployment-hosting-services-boto3.md) + [Implemente un modelo compilado mediante AWS CLI](neo-deployment-hosting-services-cli.md) + [Implementar un modelo compilado con la Consola](neo-deployment-hosting-services-console.md) # Requisitos previos **nota** Siga las instrucciones de esta sección si compiló el modelo con AWS SDK para Python (Boto3) AWS CLI, o con la consola de IA. SageMaker Para crear un modelo SageMaker compilado en NEO, necesita lo siguiente: 1. Un URI de Amazon ECR de imagen de Docker. Puede seleccionar uno que se adapte a sus necesidades de [esta lista](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html). 1. Un archivo de guión de punto de entrada: 1. **Para PyTorch y MXNet modelos:** *Si entrenó su modelo con SageMaker IA*, el guion de entrenamiento debe implementar las funciones que se describen a continuación. El script de entrenamiento sirve como script de punto de entrada durante la inferencia. En el ejemplo detallado en [MNIST Training, Compilation and Deployment with MXNet Module y SageMaker Neo](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_neo_compilation_jobs/mxnet_mnist/mxnet_mnist_neo.html), el script de entrenamiento (`mnist.py`) implementa las funciones requeridas. *Si no entrenó su modelo con SageMaker IA*, debe proporcionar un archivo de script (`inference.py`) de punto de entrada que pueda usarse en el momento de la inferencia. Según el marco, MXNet o PyTorch la ubicación del script de inferencia debe ajustarse a la estructura de [directorios del modelo del SDK de SageMaker Python para MxNet o la estructura](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#model-directory-structure) de [directorios del modelo para PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#model-directory-structure). Al utilizar imágenes de contenedor optimizadas para inferencias de Neo con **PyTorch**y **MXNet**sobre tipos de instancias de CPU y GPU, el script de inferencia debe implementar las siguientes funciones: + `model_fn`: Carga el modelo. (Opcional) + `input_fn`: Convierte la carga útil de la solicitud entrante en una matriz numpy. + `predict_fn`: Realiza la predicción. + `output_fn`: Convierte el resultado de la predicción en la carga útil de respuesta. + Como alternativa, puede `transform_fn` definir la combinación `input_fn`, `predict_fn` y `output_fn`. A continuación, se muestran ejemplos de `inference.py` scripts dentro de un directorio denominado `code` (`code/inference.py`) for **PyTorch y MXNet (Gluon and Module**). Los ejemplos cargan primero el modelo y, a continuación, lo muestran en los datos de imagen de una GPU: ------ #### [ MXNet Module ] ``` import numpy as np import json import mxnet as mx import neomx # noqa: F401 from collections import namedtuple Batch = namedtuple('Batch', ['data']) # Change the context to mx.cpu() if deploying to a CPU endpoint ctx = mx.gpu() def model_fn(model_dir): # The compiled model artifacts are saved with the prefix 'compiled' sym, arg_params, aux_params = mx.model.load_checkpoint('compiled', 0) mod = mx.mod.Module(symbol=sym, context=ctx, label_names=None) exe = mod.bind(for_training=False, data_shapes=[('data', (1,3,224,224))], label_shapes=mod._label_shapes) mod.set_params(arg_params, aux_params, allow_missing=True) # Run warm-up inference on empty data during model load (required for GPU) data = mx.nd.empty((1,3,224,224), ctx=ctx) mod.forward(Batch([data])) return mod def transform_fn(mod, image, input_content_type, output_content_type): # pre-processing decoded = mx.image.imdecode(image) resized = mx.image.resize_short(decoded, 224) cropped, crop_info = mx.image.center_crop(resized, (224, 224)) normalized = mx.image.color_normalize(cropped.astype(np.float32) / 255, mean=mx.nd.array([0.485, 0.456, 0.406]), std=mx.nd.array([0.229, 0.224, 0.225])) transposed = normalized.transpose((2, 0, 1)) batchified = transposed.expand_dims(axis=0) casted = batchified.astype(dtype='float32') processed_input = casted.as_in_context(ctx) # prediction/inference mod.forward(Batch([processed_input])) # post-processing prob = mod.get_outputs()[0].asnumpy().tolist() prob_json = json.dumps(prob) return prob_json, output_content_type ``` ------ #### [ MXNet Gluon ] ``` import numpy as np import json import mxnet as mx import neomx # noqa: F401 # Change the context to mx.cpu() if deploying to a CPU endpoint ctx = mx.gpu() def model_fn(model_dir): # The compiled model artifacts are saved with the prefix 'compiled' block = mx.gluon.nn.SymbolBlock.imports('compiled-symbol.json',['data'],'compiled-0000.params', ctx=ctx) # Hybridize the model & pass required options for Neo: static_alloc=True & static_shape=True block.hybridize(static_alloc=True, static_shape=True) # Run warm-up inference on empty data during model load (required for GPU) data = mx.nd.empty((1,3,224,224), ctx=ctx) warm_up = block(data) return block def input_fn(image, input_content_type): # pre-processing decoded = mx.image.imdecode(image) resized = mx.image.resize_short(decoded, 224) cropped, crop_info = mx.image.center_crop(resized, (224, 224)) normalized = mx.image.color_normalize(cropped.astype(np.float32) / 255, mean=mx.nd.array([0.485, 0.456, 0.406]), std=mx.nd.array([0.229, 0.224, 0.225])) transposed = normalized.transpose((2, 0, 1)) batchified = transposed.expand_dims(axis=0) casted = batchified.astype(dtype='float32') processed_input = casted.as_in_context(ctx) return processed_input def predict_fn(processed_input_data, block): # prediction/inference prediction = block(processed_input_data) return prediction def output_fn(prediction, output_content_type): # post-processing prob = prediction.asnumpy().tolist() prob_json = json.dumps(prob) return prob_json, output_content_type ``` ------ #### [ PyTorch 1.4 and Older ] ``` import os import torch import torch.nn.parallel import torch.optim import torch.utils.data import torch.utils.data.distributed import torchvision.transforms as transforms from PIL import Image import io import json import pickle def model_fn(model_dir): """Load the model and return it. Providing this function is optional. There is a default model_fn available which will load the model compiled using SageMaker Neo. You can override it here. Keyword arguments: model_dir -- the directory path where the model artifacts are present """ # The compiled model is saved as "compiled.pt" model_path = os.path.join(model_dir, 'compiled.pt') with torch.neo.config(model_dir=model_dir, neo_runtime=True): model = torch.jit.load(model_path) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) # We recommend that you run warm-up inference during model load sample_input_path = os.path.join(model_dir, 'sample_input.pkl') with open(sample_input_path, 'rb') as input_file: model_input = pickle.load(input_file) if torch.is_tensor(model_input): model_input = model_input.to(device) model(model_input) elif isinstance(model_input, tuple): model_input = (inp.to(device) for inp in model_input if torch.is_tensor(inp)) model(*model_input) else: print("Only supports a torch tensor or a tuple of torch tensors") return model def transform_fn(model, request_body, request_content_type, response_content_type): """Run prediction and return the output. The function 1. Pre-processes the input request 2. Runs prediction 3. Post-processes the prediction output. """ # preprocess decoded = Image.open(io.BytesIO(request_body)) preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize( mean=[ 0.485, 0.456, 0.406], std=[ 0.229, 0.224, 0.225]), ]) normalized = preprocess(decoded) batchified = normalized.unsqueeze(0) # predict device = torch.device("cuda" if torch.cuda.is_available() else "cpu") batchified = batchified.to(device) output = model.forward(batchified) return json.dumps(output.cpu().numpy().tolist()), response_content_type ``` ------ #### [ PyTorch 1.5 and Newer ] ``` import os import torch import torch.nn.parallel import torch.optim import torch.utils.data import torch.utils.data.distributed import torchvision.transforms as transforms from PIL import Image import io import json import pickle def model_fn(model_dir): """Load the model and return it. Providing this function is optional. There is a default_model_fn available, which will load the model compiled using SageMaker Neo. You can override the default here. The model_fn only needs to be defined if your model needs extra steps to load, and can otherwise be left undefined. Keyword arguments: model_dir -- the directory path where the model artifacts are present """ # The compiled model is saved as "model.pt" model_path = os.path.join(model_dir, 'model.pt') device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = torch.jit.load(model_path, map_location=device) model = model.to(device) return model def transform_fn(model, request_body, request_content_type, response_content_type): """Run prediction and return the output. The function 1. Pre-processes the input request 2. Runs prediction 3. Post-processes the prediction output. """ # preprocess decoded = Image.open(io.BytesIO(request_body)) preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize( mean=[ 0.485, 0.456, 0.406], std=[ 0.229, 0.224, 0.225]), ]) normalized = preprocess(decoded) batchified = normalized.unsqueeze(0) # predict device = torch.device("cuda" if torch.cuda.is_available() else "cpu") batchified = batchified.to(device) output = model.forward(batchified) return json.dumps(output.cpu().numpy().tolist()), response_content_type ``` ------ 1. **Para instancias inf1 o imágenes de contenedor onnx, xgboost o keras** Para todos los demás tipos de instancias de inferencia o imágenes de contenedor optimizadas para inferencias de Neo, el guión de punto de entrada debe implementar las siguientes funciones para tiempo de ejecución de aprendizaje profundo de Neo: + `neo_preprocess`: Convierte la carga útil de la solicitud entrante en una matriz numpy. + `neo_postprocess`: Convierte el resultado de la predicción de tiempo de ejecución de aprendizaje profundo de Neo en el cuerpo de la respuesta. **nota** Las dos funciones anteriores no utilizan ninguna de las funcionalidades de MXNet, PyTorch, o TensorFlow. Para ver ejemplos de cómo utilizar estas funciones, consulte los [cuadernos de ejemplo de compilación de modelos de Neo](https://docs.aws.amazon.com//sagemaker/latest/dg/neo.html#neo-sample-notebooks). 1. **Para TensorFlow modelos** Si su modelo requiere una lógica personalizada de preprocesamiento y posprocesamiento antes de enviar los datos al modelo, debe especificar un archivo `inference.py` de guión de punto de entrada que pueda usarse en el momento de la inferencia. El script debe implementar un par de funciones `input_handler` y `output_handler` o una función de controlador único. **nota** Tenga en cuenta que si la función de controlador está implementada `input_handler` y `output_handler` se ignoran. El siguiente es un ejemplo de código de un guión `inference.py` que se puede combinar con el modelo de compilación para realizar un procesamiento previo y posterior personalizado en un modelo de clasificación de imágenes. El cliente de SageMaker IA envía el archivo de imagen como un tipo de `application/x-image` contenido a la `input_handler` función, donde se convierte a JSON. A continuación, el archivo de imagen convertido se envía al [servidor de modelos de Tensorflow (TFX)](https://www.tensorflow.org/tfx/serving/api_rest) mediante la API de REST. ``` import json import numpy as np import json import io from PIL import Image def input_handler(data, context): """ Pre-process request input before it is sent to TensorFlow Serving REST API Args: data (obj): the request data, in format of dict or string context (Context): an object containing request and configuration details Returns: (dict): a JSON-serializable dict that contains request body and headers """ f = data.read() f = io.BytesIO(f) image = Image.open(f).convert('RGB') batch_size = 1 image = np.asarray(image.resize((512, 512))) image = np.concatenate([image[np.newaxis, :, :]] * batch_size) body = json.dumps({"signature_name": "serving_default", "instances": image.tolist()}) return body def output_handler(data, context): """Post-process TensorFlow Serving output before it is returned to the client. Args: data (obj): the TensorFlow serving response context (Context): an object containing request and configuration details Returns: (bytes, string): data to return to client, response content type """ if data.status_code != 200: raise ValueError(data.content.decode('utf-8')) response_content_type = context.accept_header prediction = data.content return prediction, response_content_type ``` Si no se realiza un procesamiento previo o posterior personalizado, el cliente de SageMaker IA convierte la imagen del archivo a JSON de forma similar antes de enviarla al punto final de la SageMaker IA. Para obtener más información, consulte [Implementación en puntos finales de TensorFlow servicio en el SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#providing-python-scripts-for-pre-pos-processing). 1. El URI del bucket de Amazon S3 que contiene los artefactos del modelo compilado. # Implemente un modelo compilado mediante el SDK SageMaker Debe cumplir con la sección de [requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si el modelo se compiló con AWS SDK para Python (Boto3) AWS CLI, o la consola Amazon SageMaker AI. Siga uno de los siguientes casos de uso para implementar un modelo compilado con SageMaker Neo en función de cómo compiló el modelo. **Topics** + [Si compilaste tu modelo con el SageMaker SDK](#neo-deployment-hosting-services-sdk-deploy-sm-sdk) + [Si compiló el modelo utilizando MXNet o PyTorch](#neo-deployment-hosting-services-sdk-deploy-sm-boto3) + [Si compiló el modelo mediante Boto3, la SageMaker consola o la CLI para TensorFlow](#neo-deployment-hosting-services-sdk-deploy-sm-boto3-tensorflow) ## Si compilaste tu modelo con el SageMaker SDK El identificador de objeto [sagemaker.Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model) del modelo compilado proporciona la función [deploy()](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model#sagemaker.model.Model.deploy), que le permite crear un punto de conexión para atender solicitudes de inferencia. La función le permite establecer el número y el tipo de instancias que se utilizan para el punto de conexión. Tiene que elegir una instancia para la que haya compilado su modelo. Por ejemplo, en el trabajo compilado en la sección [Compilar un modelo (Amazon SageMaker SDK)](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation-sagemaker-sdk.html), esto es`ml_c5`. ``` predictor = compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.c5.4xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ## Si compiló el modelo utilizando MXNet o PyTorch Cree el modelo de SageMaker IA e impleméntelo mediante la API deploy () en el modelo específico del marco. APIs Para MXNet, es [MXNetModelo](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html?highlight=MXNetModel#mxnet-model) y para PyTorch, es. [ PyTorchModel](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html?highlight=PyTorchModel#sagemaker.pytorch.model.PyTorchModel) Al crear e implementar un modelo de SageMaker IA, debe establecer la variable de `MMS_DEFAULT_RESPONSE_TIMEOUT` entorno `500` y especificar el `entry_point` parámetro como el script de inferencia (`inference.py`) y el `source_dir` parámetro como la ubicación del directorio (`code`) del script de inferencia. Para preparar el script de inferencia (`inference.py`), siga el paso de Requisitos previos. El siguiente ejemplo muestra cómo utilizar estas funciones para implementar un modelo compilado mediante el SDK de SageMaker IA para Python: ------ #### [ MXNet ] ``` from sagemaker.mxnet import MXNetModel # Create SageMaker model and deploy an endpoint sm_mxnet_compiled_model = MXNetModel( model_data='insert S3 path of compiled MXNet model archive', role='AmazonSageMaker-ExecutionRole', entry_point='inference.py', source_dir='code', framework_version='1.8.0', py_version='py3', image_uri='insert appropriate ECR Image URI for MXNet', env={'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'}, ) # Replace the example instance_type below to your preferred instance_type predictor = sm_mxnet_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ------ #### [ PyTorch 1.4 and Older ] ``` from sagemaker.pytorch import PyTorchModel # Create SageMaker model and deploy an endpoint sm_pytorch_compiled_model = PyTorchModel( model_data='insert S3 path of compiled PyTorch model archive', role='AmazonSageMaker-ExecutionRole', entry_point='inference.py', source_dir='code', framework_version='1.4.0', py_version='py3', image_uri='insert appropriate ECR Image URI for PyTorch', env={'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'}, ) # Replace the example instance_type below to your preferred instance_type predictor = sm_pytorch_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ------ #### [ PyTorch 1.5 and Newer ] ``` from sagemaker.pytorch import PyTorchModel # Create SageMaker model and deploy an endpoint sm_pytorch_compiled_model = PyTorchModel( model_data='insert S3 path of compiled PyTorch model archive', role='AmazonSageMaker-ExecutionRole', entry_point='inference.py', source_dir='code', framework_version='1.5', py_version='py3', image_uri='insert appropriate ECR Image URI for PyTorch', ) # Replace the example instance_type below to your preferred instance_type predictor = sm_pytorch_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ------ **nota** Las políticas `AmazonSageMakerFullAccess` y `AmazonS3ReadOnlyAccess` deben asociarse al rol de IAM `AmazonSageMaker-ExecutionRole`. ## Si compiló el modelo mediante Boto3, la SageMaker consola o la CLI para TensorFlow Construya un objeto `TensorFlowModel` y, a continuación, llame a deploy: ``` role='AmazonSageMaker-ExecutionRole' model_path='S3 path for model file' framework_image='inference container arn' tf_model = TensorFlowModel(model_data=model_path, framework_version='1.15.3', role=role, image_uri=framework_image) instance_type='ml.c5.xlarge' predictor = tf_model.deploy(instance_type=instance_type, initial_instance_count=1) ``` Consulte [Implementación directa a partir de artefactos del modelo](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#deploying-directly-from-model-artifacts) para obtener más información. De [esta lista](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), puede seleccionar un URI de Amazon ECR de imagen de Docker que se adapte a sus necesidades. [Para obtener más información sobre cómo construir un `TensorFlowModel` objeto, consulte el SageMaker SDK.](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-serving-model) **nota** Su primera solicitud de inferencia puede tener una latencia alta si implementa el modelo en una GPU. Esto se debe a que en la primera solicitud de inferencia se crea un kernel de procesamiento optimizado. Le recomendamos que cree un archivo de calentamiento de las solicitudes de inferencia y lo almacene junto con el archivo de modelo antes de enviarlo a un TFX. Esto se conoce como “calentar” el modelo. El siguiente fragmento de código muestra cómo producir el archivo de calentamiento para el ejemplo de clasificación de imágenes de la sección de [requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites): ``` import tensorflow as tf from tensorflow_serving.apis import classification_pb2 from tensorflow_serving.apis import inference_pb2 from tensorflow_serving.apis import model_pb2 from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_log_pb2 from tensorflow_serving.apis import regression_pb2 import numpy as np with tf.python_io.TFRecordWriter("tf_serving_warmup_requests") as writer: img = np.random.uniform(0, 1, size=[224, 224, 3]).astype(np.float32) img = np.expand_dims(img, axis=0) test_data = np.repeat(img, 1, axis=0) request = predict_pb2.PredictRequest() request.model_spec.name = 'compiled_models' request.model_spec.signature_name = 'serving_default' request.inputs['Placeholder:0'].CopyFrom(tf.compat.v1.make_tensor_proto(test_data, shape=test_data.shape, dtype=tf.float32)) log = prediction_log_pb2.PredictionLog( predict_log=prediction_log_pb2.PredictLog(request=request)) writer.write(log.SerializeToString()) ``` Para obtener más información sobre cómo «calentar» su modelo, consulte la [página TensorFlow TFX](https://www.tensorflow.org/tfx/serving/saved_model_warmup). # Implementa un modelo compilado con Boto3 Debe cumplir con la sección de [requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si el modelo se compiló con AWS SDK para Python (Boto3) AWS CLI, o la consola Amazon SageMaker AI. Siga los pasos que se indican a continuación para crear e implementar un modelo SageMaker compilado en NEO mediante el [SDK de Amazon Web Services para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html). **Topics** + [Implementar el modelo](#neo-deployment-hosting-services-boto3-steps) ## Implementar el modelo Una vez que haya cumplido con los [requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), utilice las `create_model` teclas, y. `create_enpoint_config` `create_endpoint` APIs El siguiente ejemplo muestra cómo utilizarlos APIs para implementar un modelo compilado con Neo: ``` import boto3 client = boto3.client('sagemaker') # create sagemaker model create_model_api_response = client.create_model( ModelName='my-sagemaker-model', PrimaryContainer={ 'Image': , 'ModelDataUrl': 's3://path/to/model/artifact/model.tar.gz', 'Environment': {} }, ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole' ) print ("create_model API response", create_model_api_response) # create sagemaker endpoint config create_endpoint_config_api_response = client.create_endpoint_config( EndpointConfigName='sagemaker-neomxnet-endpoint-configuration', ProductionVariants=[ { 'VariantName': , 'ModelName': 'my-sagemaker-model', 'InitialInstanceCount': 1, 'InstanceType': }, ] ) print ("create_endpoint_config API response", create_endpoint_config_api_response) # create sagemaker endpoint create_endpoint_api_response = client.create_endpoint( EndpointName='provide your endpoint name', EndpointConfigName=, ) print ("create_endpoint API response", create_endpoint_api_response) ``` **nota** Las políticas `AmazonSageMakerFullAccess` y `AmazonS3ReadOnlyAccess` deben asociarse al rol de IAM `AmazonSageMaker-ExecutionRole`. Para ver la sintaxis completa de `create_model` `create_endpoint_config` `create_endpoint` APIs, y [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), consulte [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config), y [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint), respectivamente. Si no entrenó el modelo con SageMaker IA, especifique las siguientes variables de entorno: ------ #### [ MXNet and PyTorch ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region", "MMS_DEFAULT_RESPONSE_TIMEOUT": "500" } ``` ------ #### [ TensorFlow ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region" } ``` ------ Si entrenó su modelo mediante SageMaker IA, especifique la variable de entorno `SAGEMAKER_SUBMIT_DIRECTORY` como el URI completo del bucket de Amazon S3 que contiene el script de entrenamiento. # Implemente un modelo compilado mediante AWS CLI Debe cumplir con la sección de [requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si el modelo se compiló con AWS SDK para Python (Boto3) AWS CLI, o la consola Amazon SageMaker AI. Siga los pasos que se indican a continuación para crear e implementar un modelo SageMaker compilado en NEO mediante. [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/) **Topics** + [Implementar el modelo](#neo-deploy-cli) ## Implementar el modelo Una vez que haya cumplido los [requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), utilice los comandos `create-model``create-enpoint-config`, y `create-endpoint` AWS CLI . Los siguientes pasos muestran cómo usar estos comandos para implementar un modelo compilado con Neo: ### Creación de un modelo En [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), seleccione el URI de la imagen de inferencia y, a continuación, utilice la `create-model` API para crear un SageMaker modelo de IA. Para hacerlo, siga estos pasos: 1. Cree un archivo `create_model.json`. En el archivo, especifique el nombre del modelo, el URI de la imagen, la ruta al `model.tar.gz` archivo en su bucket de Amazon S3 y su función de ejecución de SageMaker IA: ``` { "ModelName": "insert model name", "PrimaryContainer": { "Image": "insert the ECR Image URI", "ModelDataUrl": "insert S3 archive URL", "Environment": {"See details below"} }, "ExecutionRoleArn": "ARN for AmazonSageMaker-ExecutionRole" } ``` Si entrenó su modelo con SageMaker IA, especifique la siguiente variable de entorno: ``` "Environment": { "SAGEMAKER_SUBMIT_DIRECTORY" : "[Full S3 path for *.tar.gz file containing the training script]" } ``` Si no entrenó el modelo con SageMaker IA, especifique las siguientes variables de entorno: ------ #### [ MXNet and PyTorch ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region", "MMS_DEFAULT_RESPONSE_TIMEOUT": "500" } ``` ------ #### [ TensorFlow ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region" } ``` ------ **nota** Las políticas `AmazonSageMakerFullAccess` y `AmazonS3ReadOnlyAccess` deben asociarse al rol de IAM `AmazonSageMaker-ExecutionRole`. 1. Use el siguiente comando: ``` aws sagemaker create-model --cli-input-json file://create_model.json ``` Para informarse de la sintaxis completa de la API de `create-model`, consulte [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html). ### Crear una configuración de punto de conexión Tras crear un modelo de SageMaker IA, cree la configuración del punto final mediante la `create-endpoint-config` API. Para ello, cree un archivo JSON con las especificaciones de configuración de su punto de conexión. Por ejemplo, puede usar la siguiente plantilla de código y guardarla como `create_config.json`: ``` { "EndpointConfigName": "", "ProductionVariants": [ { "VariantName": "", "ModelName": "my-sagemaker-model", "InitialInstanceCount": 1, "InstanceType": "", "InitialVariantWeight": 1.0 } ] } ``` Ahora ejecute el siguiente AWS CLI comando para crear la configuración de su punto final: ``` aws sagemaker create-endpoint-config --cli-input-json file://create_config.json ``` Para informarse de la sintaxis completa de la API de `create-endpoint-config`, consulte [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html). ### Creación de un punto de conexión Una vez que haya creado la configuración de su punto de conexión, cree un punto de conexión mediante la API `create-endpoint`: ``` aws sagemaker create-endpoint --endpoint-name '' --endpoint-config-name '' ``` Para informarse de la sintaxis completa de la API de `create-endpoint`, consulte [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html). # Implementar un modelo compilado con la Consola Debe cumplir con la sección de [requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si el modelo se compiló utilizando AWS SDK para Python (Boto3) la AWS CLI consola Amazon AI o la consola Amazon SageMaker AI. Siga los pasos que se indican a continuación para crear e implementar un modelo compilado con SageMaker IA NEO utilizando la consola de SageMaker IA o la IA [https://console.aws.amazon.com. SageMaker ](https://console.aws.amazon.com/sagemaker/) **Topics** + [Implementar el modelo](#deploy-the-model-console-steps) ## Implementar el modelo Una vez que haya cumplido los [ requisitos previos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), siga los siguientes pasos para implementar un modelo compilado con Neo: 1. Elija **Modelos** y, a continuación, seleccione **Crear modelos** en el grupo **Inferencia**. En la página **Crear modelo**, cumplimente los campos **Nombre del modelo**,** Rol de IAM** y, si es preciso, **VPC** (opcional). ![\[Creación de un modelo de Neo para inferencia\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/create-pipeline-model.png) 1. Para agregar información sobre el contenedor utilizado para implementar el modelo, seleccione **Agregar contenedor** y haga clic en **Siguiente**. Complete los campos **Opciones de entrada del contenedor**, **Ubicación de la imagen del código de inferencia** y **Ubicación de los artefactos del modelo**; opcionalmente, también puede completar los campos **Nombre del host contenedor** y **Variables de entorno**. ![\[Creación de un modelo de Neo para inferencia\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo-deploy-console-container-definition.png) 1. Para implementar modelos compilados por Neo, elija las opciones siguientes: + **Opciones de entrada del contenedor**: seleccione **Proporcionar artefactos de modelo e imágenes de inferencia**. + **Ubicación de la imagen del código de inferencia**: elija el URI de la imagen de inferencia de [Imágenes de contenedor de inferencias de Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), según la AWS región y el tipo de aplicación. + **Ubicación de los artefactos del modelo**: introduzca el URI del bucket de S3 del artefacto del modelo compilado generado por la API de compilación de Neo. + **Variables de entorno**: + Deje este campo en blanco durante **SageMaker XGBoost**. + Si entrenó su modelo mediante SageMaker IA, especifique la variable de entorno `SAGEMAKER_SUBMIT_DIRECTORY` como el URI del bucket de Amazon S3 que contiene el script de entrenamiento. + Si no entrenó el modelo con SageMaker IA, especifique las siguientes variables de entorno: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/neo-deployment-hosting-services-console.html) 1. Confirme que la información para los contenedores es precisa y, a continuación, seleccione **Crear modelo**. **En la página de inicio para crear un modelo**, elija **Crear punto de conexión**. ![\[Página de inicio de creación de modelos\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo-deploy-console-create-model-land-page.png) 1. En el diagrama **Crear y configurar punto de enlace**, especifique el **Nombre del punto de enlace**. Para **Asociar configuración de punto de conexión**, seleccione **Crear una nueva configuración de punto de conexión**. ![\[Interfaz de usuario Crear y configurar punto de conexión de la consola de Neo.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo-deploy-console-config-endpoint.png) 1. En la página **Nueva configuración del punto de conexión**, especifique el **Nombre de configuración de punto de conexión**. ![\[Interfaz de usuario de Nueva configuración de punto de conexión de la consola de Neo.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo-deploy-console-new-endpoint-config.png) 1. Seleccione **Editar** junto al nombre del modelo y especifique el **Tipo de instancia** correcto en la página **Editar variante de producción**. Es imprescindible que el valor del **Tipo de instancia** coincida con el valor especificado en el trabajo de compilación. ![\[Interfaz de usuario de Nueva configuración de punto de conexión de la consola de Neo.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo-deploy-console-edit-production-variant.png) 1. Seleccione **Save**. 1. En la página de **Configuración de nuevo punto de conexión**, elija **Crear configuración de punto de conexión** y, a continuación, elija **Crear punto de conexión**.