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.
# Contenedores Docker personalizados con IA SageMaker
Puede adaptar una imagen de Docker existente para que funcione con IA. SageMaker Es posible que necesites usar una imagen de Docker externa existente con SageMaker IA si tienes un contenedor que cumple requisitos de características o seguridad que actualmente no son compatibles con una imagen de IA SageMaker prediseñada. Hay dos kits de herramientas que te permiten traer tu propio contenedor y adaptarlo para que funcione con la IA: SageMaker
+ [SageMaker Kit de herramientas de formación](https://github.com/aws/sagemaker-training-toolkit): utilice este kit de herramientas para entrenar modelos con IA. SageMaker
+ SageMaker Kit de [herramientas de inferencia de IA: utilice este kit](https://github.com/aws/sagemaker-inference-toolkit) de herramientas para implementar modelos con IA. SageMaker
En los siguientes temas, se muestra cómo adaptar la imagen existente mediante los kits de herramientas de SageMaker formación e inferencia:
**Topics**
+ [Bibliotecas de marcos individuales](#docker-containers-adapt-your-own-frameworks)
+ [SageMaker Kits de herramientas de formación e inferencia](amazon-sagemaker-toolkits.md)
+ [Adaptación del contenedor de entrenamiento propio](adapt-training-container.md)
+ [Adapte su propio contenedor de inferencias para Amazon AI SageMaker](adapt-inference-container.md)
## Bibliotecas de marcos individuales
Además del kit de herramientas de SageMaker formación y el kit de herramientas de inferencia de SageMaker IA, la SageMaker IA también proporciona kits de herramientas especializados para TensorFlow, y Chainer. MXNet PyTorch En la siguiente tabla se proporcionan enlaces a los GitHub repositorios que contienen el código fuente de cada marco y sus respectivos conjuntos de herramientas de servicio. Las instrucciones enlazadas son para usar el SDK de Python para ejecutar algoritmos de entrenamiento y alojar modelos en SageMaker IA. La funcionalidad de estas bibliotecas individuales está incluida en el kit de herramientas de formación sobre SageMaker IA y el kit de herramientas de inferencia de SageMaker IA.
| Marcos | Código fuente del Toolkit |
| --- | --- |
| TensorFlow | [SageMaker Formación en IA TensorFlow ](https://github.com/aws/sagemaker-tensorflow-training-toolkit) [SageMaker Servicio de TensorFlow IA](https://github.com/aws/sagemaker-tensorflow-serving-container) |
| MXNet | [SageMaker MXNet Entrenamiento de IA](https://github.com/aws/sagemaker-mxnet-training-toolkit) [SageMaker MXNet Inferencia de IA](https://github.com/aws/sagemaker-mxnet-inference-toolkit) |
| PyTorch | [SageMaker Entrenamiento de IA PyTorch ](https://github.com/aws/sagemaker-pytorch-training-toolkit) [SageMaker PyTorch Inferencia de IA](https://github.com/aws/sagemaker-pytorch-inference-toolkit) |
| Chainer | [SageMaker Contenedores AI Chainer SageMaker AI](https://github.com/aws/sagemaker-chainer-container) |
# SageMaker Kits de herramientas de formación e inferencia
Los kits de herramientas de [SageMaker formación](https://github.com/aws/sagemaker-training-toolkit) e [inferencia de SageMaker IA](https://github.com/aws/sagemaker-inference-toolkit) implementan la funcionalidad que necesita para adaptar sus contenedores a fin de ejecutar scripts, entrenar algoritmos e implementar modelos en IA. SageMaker Cuando se instala, la biblioteca define lo siguiente para los usuarios:
+ Las ubicaciones para almacenar código y otros recursos.
+ El punto de entrada que contiene el código que se ejecutará al iniciarse el contenedor. Su Dockerfile debe copiar el código que debe ejecutarse en la ubicación esperada por un contenedor que sea compatible con la IA. SageMaker
+ Otra información que un contenedor necesita para gestionar implementaciones para entrenamiento e inferencia.
## SageMaker Estructura de contenedores de kits de herramientas de IA
Cuando la SageMaker IA entrena un modelo, crea la siguiente estructura de carpetas de archivos en el `/opt/ml` directorio del contenedor.
```
/opt/ml
├── input
│ ├── config
│ │ ├── hyperparameters.json
│ │ └── resourceConfig.json
│ └── data
│ └──
│ └──
├── model
│
├── code
│
├── output
│
└── failure
```
Cuando ejecutas un trabajo de *entrenamiento* de modelos, el contenedor de SageMaker IA usa el `/opt/ml/input/` directorio, que contiene los archivos JSON que configuran los hiperparámetros del algoritmo y el diseño de red utilizado para el entrenamiento distribuido. El `/opt/ml/input/` directorio también contiene archivos que especifican los canales a través de los cuales la SageMaker IA accede a los datos, que se almacenan en Amazon Simple Storage Service (Amazon S3). La biblioteca de contenedores de SageMaker IA coloca los scripts que el contenedor ejecutará en el `/opt/ml/code/` directorio. Su script debe escribir el modelo generado por su algoritmo en el directorio `/opt/ml/model/`. Para obtener más información, consulte [Contenedores con algoritmos de entrenamiento personalizados](your-algorithms-training-algo.md).
Cuando *alojas* un modelo entrenado en SageMaker IA para hacer inferencias, implementas el modelo en un punto final HTTP. El modelo hace predicciones en tiempo real en respuesta a solicitudes de inferencia. El contenedor debe contener una pila de distribución para procesar estas solicitudes.
En un contenedor de transformación por lotes o alojamiento, los archivos del modelo se encuentran en la misma carpeta en la que se escribieron durante la entrenamiento.
```
/opt/ml/model
│
└──
```
Para obtener más información, consulte [Contenedores con código de inferencia personalizado](your-algorithms-inference-main.md).
## Contenedores individuales frente a contenedores múltiples
Puede proporcionar imágenes de Docker independientes para el algoritmo de entrenamiento y código de inferencia, o puede utilizar una única imagen de Docker para ambos. Al crear imágenes de Docker para usarlas con SageMaker IA, tenga en cuenta lo siguiente:
+ Proporcionar dos imágenes de Docker puede aumentar los requisitos de almacenamiento y el costo, ya que las bibliotecas comunes pueden duplicarse.
+ Por regla general, los contenedores más pequeños se inician más rápido para el alojamiento y la capacitación. Los modelos realizan una capacitación más rápida y el servicio de alojamiento puede reaccionar a los aumentos de tráfico mediante un escalado automático más rápido.
+ Es posible que pueda escribir un contenedor de inferencias que sea significativamente más pequeño que el contenedor de capacitación. Esto es especialmente común cuando se utiliza GPUs para entrenamiento, pero el código de inferencia está optimizado para ello. CPUs
+ SageMaker La IA requiere que los contenedores Docker se ejecuten sin acceso privilegiado.
+ Tanto los contenedores Docker que usted cree como los que proporciona la SageMaker IA pueden enviar mensajes a los archivos `Stdout` y`Stderr`. SageMaker La IA envía estos mensajes a CloudWatch los registros de Amazon de tu AWS cuenta.
Para obtener más información sobre cómo crear contenedores de SageMaker IA y cómo se ejecutan los scripts en ellos, consulte los repositorios del kit de herramientas de [formación sobre SageMaker IA y del kit de herramientas](https://github.com/aws/sagemaker-training-toolkit) de [inferencia de SageMaker IA](https://github.com/aws/sagemaker-inference-toolkit) en. GitHub También proporcionan listas de variables ambientales importantes y de las variables ambientales que proporcionan los contenedores de IA. SageMaker
# Adaptación del contenedor de entrenamiento propio
Para ejecutar tu propio modelo de entrenamiento, crea un contenedor de Docker con el [Amazon SageMaker Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) a través de una instancia de Amazon SageMaker Notebook.
## Paso 1: Crea una instancia de bloc de notas SageMaker
1. Abre la consola Amazon SageMaker AI en [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. En el panel de navegación, elija **Notebook Cuaderno)**, seleccione **Notebook instances (Instancias de cuaderno)** y, a continuación, seleccione **Create notebook instance (Crear instancia de cuaderno)**.
1. En la página **Crear instancia de bloc de notas**, proporcione la siguiente información:
1. En **Notebook instance name (Nombre de instancia del bloc de notas)**, escriba **RunScriptNotebookInstance**.
1. En **Tipo de instancia de bloc de notas**, elija **ml.t2.medium**.
1. En la sección **Permissions and encryption (Permisos y cifrado)**, haga lo siguiente:
1. En **Rol de IAM**, elija **Crear un nuevo rol**. Se abre una nueva ventana.
1. En la página **Create an IAM role (Crear un rol de IAM)**, elija **Buckets de S3 específicos**, especifique un bucket de Amazon S3 denominado **sagemaker-run-script** y, a continuación, elija **Create role (Crear rol)**.
SageMaker AI crea un rol de IAM denominado`AmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS`. Por ejemplo, `AmazonSageMaker-ExecutionRole-20190429T110788`. Tenga en cuenta que la convención de nomenclatura de rol de ejecución utiliza la fecha y la hora en que se creó el rol, separadas por una `T`.
1. En **Root Access (Acceso raíz)**, elija **Enable (Habilitar)**.
1. Elija **Crear instancia de bloc de notas**.
1. **En la página **Notebook instances (Instancias de cuaderno)**, **Status (Estado)** es Pemnding (Pendiente)**. Amazon SageMaker AI puede tardar unos minutos en lanzar una instancia de procesamiento de aprendizaje automático (en este caso, lanza una instancia de notebook) y adjuntarle un volumen de almacenamiento de aprendizaje automático. La instancia de cuaderno cuenta con un servidor de cuaderno de Jupyter configurado previamente y un conjunto de bibliotecas de Anaconda. Para obtener más información, consulte [ CreateNotebookInstance](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateNotebookInstance.html).
1. Haga clic en el **Name (Nombre)** del cuaderno que acaba de crear. Se abre una nueva página.
1. En la sección **Permissions and encryption (Permisos y cifrado)**, copie el **número de ARN del rol de IAM** y péguelo en un archivo de cuaderno para guardarlo temporalmente. Este número ARN del rol de IAM se utiliza más adelante para configurar un estimador de entrenamiento local en la instancia del cuaderno. **El número de ARN de rol de IAM** tiene el siguiente aspecto: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`.
1. Cuando el estado de la instancia del bloc de notas cambie a **InService**, seleccione **Abrir JupyterLab**.
## Paso 2: Crear y cargar scripts de entrenamiento de Dockerfile y Python
1. Cuando JupyterLab se abra, cree una nueva carpeta en el directorio principal de su JupyterLab. En la esquina superior izquierda, elija el icono de **nueva carpeta** y, a continuación, escriba el nombre de la carpeta `docker_test_folder`.
1. Cree un archivo de texto `Dockerfile` en el directorio `docker_test_folder`.
1. Seleccione el icono del **nuevo lanzador** (\$1) en la esquina superior izquierda.
1. En el panel derecho, en la sección **Other (Otro)**, seleccione **Text file (Archivo de texto)**.
1. Pegue el siguiente código de ejemplo `Dockerfile` en el archivo de texto.
```
#Download an open source TensorFlow Docker image
FROM tensorflow/tensorflow:latest-gpu-jupyter
# Install sagemaker-training toolkit that contains the common functionality necessary to create a container compatible with SageMaker AI and the Python SDK.
RUN pip3 install sagemaker-training
# Copies the training code inside the container
COPY train.py /opt/ml/code/train.py
# Defines train.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```
El script Dockerfile realiza las siguientes tareas:
+ `FROM tensorflow/tensorflow:latest-gpu-jupyter`— Descarga la última imagen base de TensorFlow Docker. Puede sustituirla por cualquier imagen base de Docker que desee utilizar para crear contenedores, así como por imágenes base de contenedores AWS prediseñadas.
+ `RUN pip install sagemaker-training`— Instala un [kit de herramientas de formación en SageMaker IA](https://github.com/aws/sagemaker-training-toolkit) que contiene la funcionalidad común necesaria para crear un contenedor compatible con la IA. SageMaker
+ `COPY train.py /opt/ml/code/train.py`— Copia el script en la ubicación prevista por SageMaker la IA dentro del contenedor. El script debe estar ubicado en esta carpeta.
+ `ENV SAGEMAKER_PROGRAM train.py`— Toma el script de entrenamiento `train.py` como script de punto de entrada copiado en la carpeta `/opt/ml/code` del contenedor. Esta es la única variable de entorno que debe especificar cuando crea su propio contenedor.
1. En la navegación del directorio izquierdo, el nombre del archivo de texto se establece automáticamente como `untitled.txt`. Para cambiar el nombre del archivo, haga clic con el botón derecho en el archivo, seleccione **Rename (Cambiar nombre)**, cámbiele el nombre a `Dockerfile` sin la extensión `.txt` y, a continuación, pulse `Ctrl+s` o `Command+s` para guardar el archivo.
1. Cargue un script de entrenamiento `train.py` en la `docker_test_folder`. Para este ejercicio, puede usar el siguiente script de ejemplo para crear un modelo que lea dígitos manuscritos entrenados en el [conjunto de datos MNIST](https://en.wikipedia.org/wiki/MNIST_database).
```
import tensorflow as tf
import os
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=1)
model_save_dir = f"{os.environ.get('SM_MODEL_DIR')}/1"
model.evaluate(x_test, y_test)
tf.saved_model.save(model, model_save_dir)
```
## Paso 3: Compilar el contenedor
1. En el directorio JupyterLab principal, abre un cuaderno de Jupyter. Para abrir un cuaderno nuevo, seleccione el icono de **nuevo lanzamiento** y, a continuación, seleccione la última versión de **conda\$1tensorflow2** en la sección **Notebook (Cuaderno)**.
1. Ejecute el siguiente comando en la primera celda del cuaderno para cambiar al directorio `docker_test_folder`:
```
cd ~/SageMaker/docker_test_folder
```
Esto devuelve su directorio actual como se indica a continuación:
```
! pwd
```
`output: /home/ec2-user/SageMaker/docker_test_folder`
1. Para crear el contenedor de Docker, ejecute el siguiente comando de compilación de Docker, incluyendo el espacio seguido del punto final:
```
! docker build -t tf-custom-container-test .
```
El comando de compilación de Docker debe ejecutarse desde el directorio creado, en este caso `docker_test_folder`.
**nota**
Si aparece el siguiente mensaje de error que indica que Docker no puede encontrar el Dockerfile, asegúrese de que el Dockerfile tenga el nombre correcto y se haya guardado en el directorio.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker/Dockerfile: no such file or directory
```
Recuerde que `docker` busca un archivo llamado específicamente `Dockerfile` sin ninguna extensión en el directorio actual. Si lo nombró de otra manera, puede pasar el nombre de archivo manualmente con la marca `-f`. Por ejemplo, si asignó el nombre `Dockerfile-text.txt` a su Dockerfile, ejecute el siguiente comando:
```
! docker build -t tf-custom-container-test -f Dockerfile-text.txt .
```
## Paso 4: Probar el contenedor
1. Para probar el contenedor localmente en la instancia de cuaderno, abra un cuaderno de Jupyter. Seleccione el icono de **nuevo lanzamiento** y, a continuación, seleccione la última versión de **conda\$1tensorflow2** en la sección **Notebook (Cuaderno)**.
1. Pegue el siguiente script de ejemplo en la celda de código del cuaderno para configurar un SageMaker AI Estimator.
```
import sagemaker
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri='tf-custom-container-test',
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='local')
estimator.fit()
```
En el ejemplo de código anterior, `sagemaker.get_execution_role()` se especifica el `role` argumento para recuperar automáticamente el rol configurado para la sesión de SageMaker IA. También puede sustituirlo por el valor de cadena del **número de ARN del rol de IAM** que utilizó al configurar la instancia de cuaderno. El ARN debería tener el aspecto siguiente: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`.
1. Ejecute la celda de código. Esta prueba devuelve la configuración del entorno de capacitación, los valores utilizados en las variables de entorno, el origen de los datos y la pérdida y precisión obtenidas durante la capacitación.
## Paso 5: Insertar el contenedor en Amazon Elastic Container Registry (Amazon ECR)
1. Después de ejecutar correctamente la prueba de modo local, puede insertar el contenedor de Docker en [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) para utilizarlo para ejecutar trabajos de entrenamiento. Si desea utilizar un registro privado de Docker en lugar de Amazon ECR, consulte [Insertar un contenedor de entrenamiento en un registro privado](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry.html).
Puede ejecutar manualmente comandos de Git como los siguientes en una celda del cuaderno.
```
%%sh
# Specify an algorithm name
algorithm_name=tf-custom-container-test
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
**nota**
Este script de intérprete de comandos bash puede provocar un problema de permisos similar al siguiente mensaje de error:
```
"denied: User: [ARN] is not authorized to perform: ecr:InitiateLayerUpload on resource:
arn:aws:ecr:us-east-1:[id]:repository/tf-custom-container-test"
```
Si se produce este error, tendrás que adjuntar la EC2 ContainerRegistryFullAccess política de **Amazon** a tu función de IAM. Ve a la [consola de IAM](https://console.aws.amazon.com/iam/home), selecciona **Roles** en el panel de navegación izquierdo y busca el IAMrole que usaste para la instancia de Notebook. En la pestaña **Permiso**, pulsa el botón **Adjuntar políticas** y busca la EC2 ContainerRegistryFullAccess política de **Amazon**. marque la casilla de verificación de la política y, a continuación, elija **Add permissions (Añadir permisos)** para finalizar.
1. Ejecute el siguiente código en una celda de un cuaderno de Studio para llamar a la imagen de Amazon ECR de su contenedor de entrenamiento.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'tf-custom-container-test'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/sagemaker-byoc-test:latest
```
1. Utilice lo `ecr_image` obtenido en el paso anterior para configurar un objeto estimador de SageMaker IA. El siguiente ejemplo de código configura un estimador de SageMaker IA con `byoc_image_uri` e inicia un trabajo de formación en una instancia de Amazon EC2.
------
#### [ SageMaker Python SDK v1 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
#### [ SageMaker Python SDK v2 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
1. [Si desea implementar el modelo con su propio contenedor, consulte Adaptación del contenedor de inferencias propio](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-inference-container.html). También puede usar un contenedor AWS marco que pueda implementar un modelo. TensorFlow Para implementar el modelo de ejemplo para leer dígitos escritos a mano, introduzca el siguiente script de ejemplo en el mismo bloc de notas que utilizó para entrenar el modelo en el subpaso anterior para obtener la imagen URIs (identificadores de recursos universales) necesaria para el despliegue e implementar el modelo.
```
import boto3
import sagemaker
#obtain image uris
from sagemaker import image_uris
container = image_uris.retrieve(framework='tensorflow',region='us-west-2',version='2.11.0',
image_scope='inference',instance_type='ml.g4dn.xlarge')
#create the model entity, endpoint configuration and endpoint
predictor = estimator.deploy(1,instance_type='ml.g4dn.xlarge',image_uri=container)
```
Pruebe el modelo con un ejemplo de dígito manuscrito del conjunto de datos MNIST mediante el siguiente ejemplo de código.
```
#Retrieve an example test dataset to test
import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
# Load the MNIST dataset and split it into training and testing sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Select a random example from the training set
example_index = np.random.randint(0, x_train.shape[0])
example_image = x_train[example_index]
example_label = y_train[example_index]
# Print the label and show the image
print(f"Label: {example_label}")
plt.imshow(example_image, cmap='gray')
plt.show()
```
Convierta el dígito manuscrito de prueba en un formulario que TensorFlow pueda asimilar y hacer una predicción de prueba.
```
from sagemaker.serializers import JSONSerializer
data = {"instances": example_image.tolist()}
predictor.serializer=JSONSerializer() #update the predictor to use the JSONSerializer
predictor.predict(data) #make the prediction
```
Para ver un ejemplo completo que muestra cómo probar un contenedor personalizado localmente y subirlo a una imagen de Amazon ECR, consulte el cuaderno de ejemplo [Building Your Own TensorFlow Container](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/tensorflow_bring_your_own/tensorflow_bring_your_own.html).
**sugerencia**
Para perfilar y depurar los trabajos de formación a fin de supervisar los problemas de utilización del sistema (como los cuellos de botella de la CPU y la infrautilización de la GPU) e identificar los problemas de formación (como el sobreajuste, el sobreentrenamiento, la explosión de los tensores y la desaparición de los gradientes), utilice Amazon Debugger. SageMaker Para obtener más información, consulte [Uso del depurador con contenedores de entrenamiento personalizados](debugger-bring-your-own-container.md).
## Paso 6: Eliminar recursos
**Para limpiar los recursos una vez que haya terminado con el ejemplo de inicio**
1. ****Abra la [consola de SageMaker IA, elija la instancia del bloc de notas](https://console.aws.amazon.com/sagemaker/), elija Actions y elija Stop. **RunScriptNotebookInstance****** Puede que transcurran unos minutos hasta que la instancia se detenga.
1. Cuando **State (Estado)** de la instancia cambie a **Stopped (Detenida)**, elija **Actions (Acciones)**, elija **Delete (Eliminar)** y, a continuación, elija **Delete (Eliminar)** en el cuadro de diálogo. Puede que transcurran unos minutos hasta que la instancia se elimine. La instancia del cuaderno desaparece de la tabla cuando se elimina.
1. Abra la [consola de Amazon S3](https://console.aws.amazon.com/s3/) y elimine el bucket que creó para almacenar los artefactos del modelo y los conjuntos de datos de entrenamiento.
1. Abra la [consola de IAM](https://console.aws.amazon.com/iam/) y elimine el rol de IAM. Si ha creado políticas de permisos, puede eliminarlas también.
**nota**
El contenedor de Docker se cierra automáticamente después de que se haya ejecutado. No es necesario eliminarlo.
## Blogs y casos prácticos
En los siguientes blogs se analizan casos prácticos sobre el uso de contenedores de formación personalizados en Amazon SageMaker AI.
+ [Por qué llevar tu propio contenedor a Amazon SageMaker AI y cómo hacerlo bien](https://medium.com/@pandey.vikesh/why-bring-your-own-container-to-amazon-sagemaker-and-how-to-do-it-right-bc158fe41ed1), *Medium* (20 de enero de 2023)
# Adaptar el trabajo de entrenamiento para acceder a las imágenes de un registro privado de Docker
Puedes usar un [registro de Docker](https://docs.docker.com/registry/) privado en lugar de un Amazon Elastic Container Registry (Amazon ECR) para alojar tus imágenes para AI Training. SageMaker Las siguientes instrucciones le muestran cómo crear un registro de Docker, configurar su nube privada virtual (VPC) y el trabajo de formación, almacenar imágenes y SageMaker dar acceso a la IA a la imagen de entrenamiento en el registro de Docker privado. Estas instrucciones también le muestran cómo utilizar un registro de Docker que requiera autenticación para un trabajo de formación. SageMaker
## Crear y almacenar imágenes en un registro privado de Docker
Cree un registro privado de Docker para almacenar las imágenes. Su registro debe:
+ utilizar el protocolo [Docker Registry HTTP API](https://docs.docker.com/registry/spec/api/)
+ ser accesible desde la misma VPC especificada en el [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)parámetro de la API. `CreateTrainingJob` Introdúzcala `VpcConfig` cuando cree su trabajo de entrenamiento.
+ protegerse con un [certificado TLS](https://aws.amazon.com/what-is/ssl-certificate/) de una autoridad de certificación pública conocida.
Para obtener más información sobre la creación de un registro de Docker, consulte [Implementar un servidor de registro](https://docs.docker.com/registry/deploying/).
## Configure su VPC y SageMaker su trabajo de formación
SageMaker La IA utiliza una conexión de red dentro de la VPC para acceder a las imágenes del registro de Docker. Para utilizar las imágenes de su registro de Docker con fines de entrenamiento, debe poder acceder al registro desde una VPC de Amazon de su cuenta. Para obtener más información, consulte [Utilizar un registro de Docker que requiera autenticación para el entrenamiento](docker-containers-adapt-your-own-private-registry-authentication.md).
También debe configurar su trabajo de entrenamiento para conectarse a la misma VPC a la que tiene acceso su registro de Docker. Para obtener más información, consulte [Configurar un trabajo de entrenamiento para Amazon VPC Access](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure).
## Crear un trabajo de entrenamiento con una imagen del registro privado de Docker
Para usar una imagen de su registro privado de Docker con fines de entrenamiento, utilice la siguiente guía para configurar su imagen, as´çi como configurar y crear un trabajo de entrenamiento. Los ejemplos de código que aparecen a continuación utilizan el AWS SDK para Python (Boto3) cliente.
1. Cree un objeto de configuración de imagen de entrenamiento e introduzca `Vpc` en el campo `TrainingRepositoryAccessMode` de la siguiente manera.
```
training_image_config = {
'TrainingRepositoryAccessMode': 'Vpc'
}
```
**nota**
Si su registro privado de Docker requiere autenticación, debe añadir un objeto `TrainingRepositoryAuthConfig` al objeto de configuración de la imagen de entrenamiento. También debe especificar el nombre de recurso de Amazon (ARN) de una AWS Lambda función que proporcione credenciales de acceso a la SageMaker IA mediante el `TrainingRepositoryCredentialsProviderArn` campo del `TrainingRepositoryAuthConfig` objeto. Para obtener más información, consulte la estructura del código de ejemplo que se incluye a continuación.
```
training_image_config = {
'TrainingRepositoryAccessMode': 'Vpc',
'TrainingRepositoryAuthConfig': {
'TrainingRepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName'
}
}
```
Para obtener información acerca de cómo crear la función de Lambda para proporcionar autenticación, consulte [Utilizar un registro de Docker que requiera autenticación para el entrenamiento](docker-containers-adapt-your-own-private-registry-authentication.md).
1. Utilice un cliente Boto3 para crear un trabajo de entrenamiento y pase la configuración correcta a la API [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). En las siguientes instrucciones se muestra cómo configurar los componentes y crear un trabajo de entrenamiento.
1. Cree el objeto `AlgorithmSpecification` que desea pasar a `create_training_job`. Utilice el objeto de configuración de imagen de entrenamiento que creó en el paso anterior, tal y como se muestra en el siguiente ejemplo de código.
```
algorithm_specification = {
'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:',
'TrainingImageConfig': training_image_config,
'TrainingInputMode': 'File'
}
```
**nota**
Para utilizar una versión fija de una imagen en lugar de una versión actualizada, consulte el [resumen](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) de la imagen en lugar de utilizar el nombre o la etiqueta.
1. Especifique el nombre del puesto de entrenamiento y el rol que desea pasar a `create_training_job`, tal y como se muestra en el siguiente ejemplo de código.
```
training_job_name = 'private-registry-job'
execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole'
```
1. Especifique un grupo de seguridad y una subred para la configuración de VPC para su trabajo de entrenamiento. Su registro privado de Docker debe permitir el tráfico entrante de los grupos de seguridad que especifique, como se muestra en el siguiente ejemplo de código.
```
vpc_config = {
'SecurityGroupIds': ['sg-0123456789abcdef0'],
'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
}
```
**nota**
Si su subred no está en la misma VPC que su registro privado de Docker, debe configurar una conexión de red entre ambas. VPCs SeeConnect VPCs utilizando el [peering de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) para obtener más información.
1. Especifique la configuración de los recursos, incluidas las instancias de computación de machine learning y los volúmenes de almacenamiento, que se utilizarán para el entrenamiento, como se muestra en el siguiente ejemplo de código.
```
resource_config = {
'InstanceType': 'ml.m4.xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 10,
}
```
1. Especifique la configuración de los datos de entrada y salida, dónde se almacena el conjunto de datos de entrenamiento y dónde desea almacenar los artefactos del modelo, como se muestra en el siguiente ejemplo de código.
```
input_data_config = [
{
"ChannelName": "training",
"DataSource":
{
"S3DataSource":
{
"S3DataDistributionType": "FullyReplicated",
"S3DataType": "S3Prefix",
"S3Uri": "s3://your-training-data-bucket/training-data-folder"
}
}
}
]
output_data_config = {
'S3OutputPath': 's3://your-output-data-bucket/model-folder'
}
```
1. Especifique el número máximo de segundos que puede ejecutar un trabajo de entrenamiento de modelos, como se muestra en el siguiente ejemplo de código.
```
stopping_condition = {
'MaxRuntimeInSeconds': 1800
}
```
1. Por último, cree el trabajo de entrenamiento con los parámetros que especificó en los pasos anteriores, tal y como se muestra en el siguiente ejemplo de código.
```
import boto3
sm = boto3.client('sagemaker')
try:
resp = sm.create_training_job(
TrainingJobName=training_job_name,
AlgorithmSpecification=algorithm_specification,
RoleArn=execution_role_arn,
InputDataConfig=input_data_config,
OutputDataConfig=output_data_config,
ResourceConfig=resource_config,
VpcConfig=vpc_config,
StoppingCondition=stopping_condition
)
except Exception as e:
print(f'error calling CreateTrainingJob operation: {e}')
else:
print(resp)
```
# Utilice un estimador de SageMaker IA para realizar un trabajo de formación
También puedes usar un [estimador](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) del SDK de SageMaker Python para gestionar la configuración y la ejecución de tu trabajo de SageMaker entrenamiento. En los siguientes ejemplos de código, se muestra cómo configurar y ejecutar un estimador con imágenes de un registro privado de Docker.
1. Importe las bibliotecas y dependencias necesarias, tal y como se muestra en el siguiente ejemplo de código.
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
session = sagemaker.Session()
role = sagemaker.get_execution_role()
```
1. Proporcione un identificador uniforme de recursos (URI) a su imagen de entrenamiento, grupos de seguridad y subredes para la configuración de VPC para su trabajo de entrenamiento, como se muestra en el siguiente ejemplo de código.
```
image_uri = "myteam.myorg.com/docker-local/my-training-image:"
security_groups = ["sg-0123456789abcdef0"]
subnets = ["subnet-0123456789abcdef0", "subnet-0123456789abcdef0"]
```
Para obtener más información sobre `security_group_ids` y`subnets`, consulte la descripción del parámetro correspondiente en la sección [Estimadores](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) del SDK de SageMaker Python.
**nota**
SageMaker La IA utiliza una conexión de red dentro de la VPC para acceder a las imágenes del registro de Docker. Para utilizar las imágenes de su registro de Docker con fines de entrenamiento, debe poder acceder al registro desde una VPC de Amazon de su cuenta.
1. Si lo desea, si su registro de Docker requiere autenticación, también debe especificar el nombre de recurso de Amazon (ARN) de AWS Lambda una función que proporcione credenciales SageMaker de acceso a la IA. En el siguiente ejemplo, se muestra cómo especificar el ARN.
```
training_repository_credentials_provider_arn = "arn:aws:lambda:us-west-2:1234567890:function:test"
```
Para obtener más información sobre el uso de imágenes en un registro de Docker que requiera autenticación, consulte **Uso de un registro de Docker que requiera autenticación con fines de entrenamiento**, a continuación.
1. Use los ejemplos de código de los pasos anteriores para configurar un estimador, como se muestra en el siguiente ejemplo de código.
```
# The training repository access mode must be 'Vpc' for private docker registry jobs
training_repository_access_mode = "Vpc"
# Specify the instance type, instance count you want to use
instance_type="ml.m5.xlarge"
instance_count=1
# Specify the maximum number of seconds that a model training job can run
max_run_time = 1800
# Specify the output path for the model artifacts
output_path = "s3://your-output-bucket/your-output-path"
estimator = Estimator(
image_uri=image_uri,
role=role,
subnets=subnets,
security_group_ids=security_groups,
training_repository_access_mode=training_repository_access_mode,
training_repository_credentials_provider_arn=training_repository_credentials_provider_arn, # remove this line if auth is not needed
instance_type=instance_type,
instance_count=instance_count,
output_path=output_path,
max_run=max_run_time
)
```
1. Comience su trabajo de entrenamiento llamando a `estimator.fit` con el nombre del trabajo y la ruta de entrada como parámetros, tal y como se muestra en el siguiente ejemplo de código.
```
input_path = "s3://your-input-bucket/your-input-path"
job_name = "your-job-name"
estimator.fit(
inputs=input_path,
job_name=job_name
)
```
# Utilizar un registro de Docker que requiera autenticación para el entrenamiento
Si su registro de Docker requiere autenticación, debe crear una AWS Lambda función que proporcione credenciales de acceso a la IA. SageMaker A continuación, cree un trabajo de entrenamiento y proporcione el ARN de esta función de Lambda dentro de la API [create\$1training\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job). Por último, si lo desea, puede crear un punto de conexión de VPC de interfaz para que su VPC pueda comunicarse con su función de Lambda sin enviar tráfico a través de Internet. En la siguiente guía se muestra cómo crear una función de Lambda, asignarle la función correcta y crear un punto de conexión de VPC de interfaz.
## Crear la función de Lambda
Cree una AWS Lambda función que pase las credenciales de acceso a la SageMaker IA y devuelva una respuesta. En el siguiente ejemplo de código se crea el controlador de funciones de Lambda, de la siguiente manera.
```
def handler(event, context):
response = {
"Credentials": {"Username": "username", "Password": "password"}
}
return response
```
El tipo de autenticación utilizado para configurar el registro privado de Docker determina el contenido de la respuesta que devuelve la función de Lambda como se muestra a continuación.
+ Si su registro privado de Docker utiliza la autenticación básica, la función de Lambda devolverá el nombre de usuario y la contraseña necesarios para autenticarse en el registro.
+ Si su registro privado de Docker utiliza la [autenticación por token de portador](https://docs.docker.com/registry/spec/auth/token/), el nombre de usuario y la contraseña se envían a su servidor de autorización, que luego devuelve un token de portador. Luego, este token se usa para autenticarse en su registro privado de Docker.
**nota**
Si tiene más de una función de Lambda para sus registros en la misma cuenta y el rol de ejecución es el mismo para sus trabajos de entrenamiento, los trabajos de entrenamiento para el registro uno tendrían acceso a las funciones de Lambda de los demás registros.
## Conceda el permiso de rol correcto a la función de Lambda.
La [IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)que utilices en la `create_training_job` API debe tener permiso para llamar a una AWS Lambda función. En el siguiente ejemplo de código, se muestra cómo asociar una política de un rol de IAM para llamar a `myLambdaFunction`.
```
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:*myLambdaFunction*"
]
}
```
Para obtener más información acerca de cómo editar la política de permisos de un rol, consulte [Modificación de una política de permisos de rol (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) en la *Guía del usuario de AWS Identity and Access Management*.
**nota**
Un rol de IAM con una política **AmazonSageMakerFullAccess**gestionada adjunta tiene permiso para llamar a cualquier función de Lambda cuyo nombre SageMaker incluya «AI».
## Crear un punto de conexión de VPC de la interfaz para Lambda
Si crea un punto de conexión de interfaz, su VPC de Amazon puede comunicarse con su función de Lambda sin enviar tráfico a través de Internet. Para obtener más información, consulte [Configuración de puntos de conexión de VPC de interfaz para Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) en la *AWS Lambda Guía para desarrolladores*.
Una vez creado el punto final de la interfaz, la SageMaker formación llamará a la función Lambda enviando una solicitud a través de la VPC a. `lambda.region.amazonaws.com` Si selecciona **Enable DNS Name (Habilitar nombre de DNS)** al crear el punto de conexión de la interfaz, [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) dirige la llamada al punto de conexión de la interfaz de Lambda. Si utiliza un proveedor de DNS diferente, debe asignar `lambda.region.amazonaws.co`m al punto de conexión de la interfaz de Lambda.
# Adapte su propio contenedor de inferencias para Amazon AI SageMaker
Si no puede usar ninguna de las imágenes incluidas en [Imágenes de Docker de IA prediseñadas SageMaker](docker-containers-prebuilt.md) Amazon SageMaker AI para su caso de uso, puede crear su propio contenedor de Docker y usarlo dentro de la SageMaker IA para el entrenamiento y la inferencia. Para ser compatible con la SageMaker IA, el contenedor debe tener las siguientes características:
+ El contenedor debe tener un servidor web mostrado en el puerto `8080`.
+ El contenedor debe aceptar solicitudes de `POST` dirigidas a los puntos de conexión de `/invocations` y en tiempo real `/ping`. Las solicitudes que envíe a estos puntos de conexión deben devolverse en un plazo de 60 segundos para respuestas regulares y 8 minutos para respuestas de transmisión y tener un tamaño máximo de 25 MB.
Para obtener más información y un ejemplo de cómo crear tu propio contenedor de Docker para el entrenamiento y la inferencia con SageMaker IA, consulta Cómo [crear tu propio contenedor de algoritmos](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/scikit_bring_your_own/scikit_bring_your_own.ipynb).
En la siguiente guía, se muestra cómo utilizar un `JupyterLab` espacio con Amazon SageMaker Studio Classic para adaptar un contenedor de inferencias para que funcione con el alojamiento de SageMaker IA. En el ejemplo se utiliza un servidor web NGINX, Gunicorn como interfaz de puerta de enlace de servidor web Python y Flask como marco de aplicación web. Puede utilizar diferentes aplicaciones para adaptar el contenedor siempre que cumpla los requisitos enumerados anteriormente. Para obtener más información sobre el uso de su propio código de inferencia, consulte [Código de inferencia personalizado con los servicios de alojamiento](your-algorithms-inference-code.md).
**Adaptación de su contenedor de inferencias**
Siga los siguientes pasos para adaptar su propio contenedor de inferencias para que funcione con el alojamiento de SageMaker IA. El ejemplo que se muestra en los pasos siguientes utiliza un [modelo de Reconocimiento de entidades nombradas (NER)](https://spacy.io/universe/project/video-spacys-ner-model-alt) anteriormente entrenado que utiliza la biblioteca de procesamiento de lenguaje natural (NLP) [spaCy](https://spacy.io/) para `Python` y lo siguiente:
+ Un Dockerfile para crear el contenedor que contiene el modelo de NER.
+ Scripts de inferencia para servir al modelo de NER
Si adapta este ejemplo a su caso de uso, debe usar un Dockerfile y los scripts de inferencia necesarios para implementar y servir su modelo.
1. Crea JupyterLab espacio con Amazon SageMaker Studio Classic (opcional).
Puede usar cualquier bloc de notas para ejecutar scripts y adaptar su contenedor de inferencias con alojamiento de SageMaker IA. En este ejemplo, se muestra cómo utilizar un JupyterLab espacio de Amazon SageMaker Studio Classic para lanzar una JupyterLab aplicación que incluye una imagen de SageMaker AI Distribution. Para obtener más información, consulte [SageMaker JupyterLab](studio-updated-jl.md).
1. Cargue un archivo Docker y scripts de inferencia.
1. Cree una carpeta en el directorio principal. Si está utilizando JupyterLab, en la esquina superior izquierda, elija el icono de **Nueva carpeta** e introduzca un nombre de carpeta que contenga el Dockerfile. En este ejemplo, la carpeta se llama `docker_test_folder`.
1. Cargue un archivo de texto Dockerfile a su nueva carpeta. A continuación se muestra un Dockerfile de ejemplo que crea un contenedor de Docker con un [modelo de Reconocimiento de entidades nombradas (NER)](https://spacy.io/universe/project/video-spacys-ner-model) previamente entrenado de [spaCy](https://spacy.io/), con las aplicaciones y variables de entorno necesarias para ejecutar el ejemplo:
```
FROM python:3.8
RUN apt-get -y update && apt-get install -y --no-install-recommends \
wget \
python3 \
nginx \
ca-certificates \
&& rm -rf /var/lib/apt/lists/*
RUN wget https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && \
pip install flask gevent gunicorn && \
rm -rf /root/.cache
#pre-trained model package installation
RUN pip install spacy
RUN python -m spacy download en
# Set environment variables
ENV PYTHONUNBUFFERED=TRUE
ENV PYTHONDONTWRITEBYTECODE=TRUE
ENV PATH="/opt/program:${PATH}"
COPY NER /opt/program
WORKDIR /opt/program
```
En el ejemplo de código anterior, la variable de entorno `PYTHONUNBUFFERED` evita que Python almacene en búfer el flujo de salida estándar, lo que permite una entrega más rápida de los registros al usuario. La variable de entorno `PYTHONDONTWRITEBYTECODE` impide que Python escriba archivos `.pyc` de código de bytes compilados, lo que no es necesario en este caso de uso. La variable de entorno `PATH` se utiliza para identificar la ubicación de los programas `train` y `serve` cuando se invoca el contenedor.
1. Cree un nuevo directorio dentro de la nueva carpeta para que contengan los scripts que sirvan su modelo. En este ejemplo se utiliza un directorio llamado `NER`, que contiene los siguientes scripts necesarios para ejecutar este ejemplo:
+ `predictor.py`: un script de Python que contiene la lógica para cargar y realizar inferencias con el modelo.
+ `nginx.conf`: un script para configurar un servidor web.
+ `serve`: un script que inicia un servidor de inferencias.
+ `wsgi.py`: un script auxiliar para servir un modelo.
**importante**
Si copia los scripts de inferencia en un cuaderno que termina en `.ipynb` y les cambia el nombre, es posible que el script contenga caracteres de formato que impidan que se implemente el punto de conexión. En su lugar, cree un archivo de texto y cámbiele el nombre.
1. Cargue un script para que su modelo esté disponible para inferencia. El siguiente es un script de ejemplo llamado `predictor.py` que utiliza Flask para proporcionar los puntos de conexión `/invocations` y `/ping`:
```
from flask import Flask
import flask
import spacy
import os
import json
import logging
#Load in model
nlp = spacy.load('en_core_web_sm')
#If you plan to use a your own model artifacts,
#your model artifacts should be stored in /opt/ml/model/
# The flask app for serving predictions
app = Flask(__name__)
@app.route('/ping', methods=['GET'])
def ping():
# Check if the classifier was loaded correctly
health = nlp is not None
status = 200 if health else 404
return flask.Response(response= '\n', status=status, mimetype='application/json')
@app.route('/invocations', methods=['POST'])
def transformation():
#Process input
input_json = flask.request.get_json()
resp = input_json['input']
#NER
doc = nlp(resp)
entities = [(X.text, X.label_) for X in doc.ents]
# Transform predictions to JSON
result = {
'output': entities
}
resultjson = json.dumps(result)
return flask.Response(response=resultjson, status=200, mimetype='application/json')
```
El punto de conexión `/ping` del ejemplo de script anterior devuelve un código de estado de `200` si el modelo se ha cargado correctamente y `404` si se ha cargado de forma incorrecta. El punto de conexión `/invocations` procesa una solicitud con formato en JSON, extrae el campo de entrada y utiliza el modelo NER para identificar y almacenar las entidades en las entidades variables. La aplicación Flask devuelve la respuesta que contiene estas entidades. Para obtener más información sobre estas solicitudes de estado obligatorias, consulte [Cómo debe responder su contenedor a las solicitudes de comprobación de estado (ping)](your-algorithms-inference-code.md#your-algorithms-inference-algo-ping-requests).
1. Cargue un script para iniciar un servidor de inferencias. En el siguiente ejemplo de script, se llama a `serve` usando Gunicorn como servidor de aplicaciones y Nginx como servidor web:
```
#!/usr/bin/env python
# This file implements the scoring service shell. You don't necessarily need to modify it for various
# algorithms. It starts nginx and gunicorn with the correct configurations and then simply waits until
# gunicorn exits.
#
# The flask server is specified to be the app object in wsgi.py
#
# We set the following parameters:
#
# Parameter Environment Variable Default Value
# --------- -------------------- -------------
# number of workers MODEL_SERVER_WORKERS the number of CPU cores
# timeout MODEL_SERVER_TIMEOUT 60 seconds
import multiprocessing
import os
import signal
import subprocess
import sys
cpu_count = multiprocessing.cpu_count()
model_server_timeout = os.environ.get('MODEL_SERVER_TIMEOUT', 60)
model_server_workers = int(os.environ.get('MODEL_SERVER_WORKERS', cpu_count))
def sigterm_handler(nginx_pid, gunicorn_pid):
try:
os.kill(nginx_pid, signal.SIGQUIT)
except OSError:
pass
try:
os.kill(gunicorn_pid, signal.SIGTERM)
except OSError:
pass
sys.exit(0)
def start_server():
print('Starting the inference server with {} workers.'.format(model_server_workers))
# link the log streams to stdout/err so they will be logged to the container logs
subprocess.check_call(['ln', '-sf', '/dev/stdout', '/var/log/nginx/access.log'])
subprocess.check_call(['ln', '-sf', '/dev/stderr', '/var/log/nginx/error.log'])
nginx = subprocess.Popen(['nginx', '-c', '/opt/program/nginx.conf'])
gunicorn = subprocess.Popen(['gunicorn',
'--timeout', str(model_server_timeout),
'-k', 'sync',
'-b', 'unix:/tmp/gunicorn.sock',
'-w', str(model_server_workers),
'wsgi:app'])
signal.signal(signal.SIGTERM, lambda a, b: sigterm_handler(nginx.pid, gunicorn.pid))
# Exit the inference server upon exit of either subprocess
pids = set([nginx.pid, gunicorn.pid])
while True:
pid, _ = os.wait()
if pid in pids:
break
sigterm_handler(nginx.pid, gunicorn.pid)
print('Inference server exiting')
# The main routine to invoke the start function.
if __name__ == '__main__':
start_server()
```
En el ejemplo de script anterior, se define una función de controlador de señales `sigterm_handler`, que cierra los subprocesos Nginx y Gunicorn al recibir una señal `SIGTERM`. Una función `start_server` inicia el controlador de señales, inicia y supervisa los subprocesos Nginx y Gunicorn, y captura los flujos de registro.
1. Cargue un script para configurar su servidor web. El siguiente ejemplo de script llamado `nginx.conf`, configura un servidor web Nginx usando Gunicorn como servidor de aplicaciones para servir su modelo para inferencia:
```
worker_processes 1;
daemon off; # Prevent forking
pid /tmp/nginx.pid;
error_log /var/log/nginx/error.log;
events {
# defaults
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
access_log /var/log/nginx/access.log combined;
upstream gunicorn {
server unix:/tmp/gunicorn.sock;
}
server {
listen 8080 deferred;
client_max_body_size 5m;
keepalive_timeout 5;
proxy_read_timeout 1200s;
location ~ ^/(ping|invocations) {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;
proxy_pass http://gunicorn;
}
location / {
return 404 "{}";
}
}
}
```
El ejemplo de script anterior configura Nginx para ejecutarse en primer plano, establece la ubicación para capturar el `error_log` y define `upstream` como el sock socket del servidor Gunicorn. El servidor configura el bloque de servidores para que escuche en el puerto `8080`, y establece límites en el tamaño del cuerpo de la solicitud del cliente y los valores de tiempo de espera. El bloque de servidores reenvía las solicitudes que contienen las rutas `/ping` o `/invocations` a `server http://gunicorn` de Gunicorn y devuelve un error `404` para las demás rutas.
1. Cargue cualquier otro script necesario para entregar el modelo. Este ejemplo necesita el siguiente script de ejemplo llamado `wsgi.py` para ayudar a Gunicorn a encontrar la aplicación:
```
import predictor as myapp
# This is just a simple wrapper for gunicorn to find your app.
# If you want to change the algorithm file, simply change "predictor" above to the
# new file.
app = myapp.app
```
Desde la carpeta `docker_test_folder`, la estructura de directorios debe contener un Dockerfile y la carpeta NER. La carpeta NER debe contener los archivos `nginx.conf`, `predictor.py`, `serve` y `wsgi.py` de la siguiente manera:
![\[The Dockerfile structure has inference scripts under the NER directory next to the Dockerfile.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/docker-file-struct-adapt-ex.png)
1. Cree su propio contenedor.
Desde la carpeta `docker_test_folder`, cree el contenedor de Docker. El siguiente comando de ejemplo creará el contenedor de Docker que está configurado en el Dockerfile:
```
! docker build -t byo-container-test .
```
El comando anterior creará un contenedor llamado `byo-container-test` en el directorio de trabajo actual. Para obtener más información sobre los parámetros de compilación de Docker, consulte [Build arguments](https://docs.docker.com/build/guide/build-args/).
**nota**
Si aparece el siguiente mensaje de error que indica que Docker no encuentra el Dockerfile, asegúrese de que el Dockerfile tenga el nombre correcto y se haya guardado en el directorio.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker_test_folder/Dockerfile: no such file or directory
```
Docker busca un archivo llamado específicamente Dockerfile sin ninguna extensión en el directorio actual. Si le ha asignado otro nombre, puede pasar el nombre de archivo manualmente con la marca -f. Por ejemplo, si has asignado un nombre a su Dockerfile como Dockerfile-text.txt, cree el contenedor de Docker con la marca `-f` seguida del archivo, de la siguiente manera:
```
! docker build -t byo-container-test -f Dockerfile-text.txt .
```
1. Envío de la imagen de Docker a un Amazon Elastic Container Registry (Amazon ECR)
En una celda del cuaderno, envíe la imagen de Docker a un ECR. En el siguiente ejemplo de código, se muestra cómo se crea el contenedor localmente, se inicia sesión y se envía a un ECR:
```
%%sh
# Name of algo -> ECR
algorithm_name=sm-pretrained-spacy
#make serve executable
chmod +x NER/serve
account=$(aws sts get-caller-identity --query Account --output text)
# Region, defaults to us-west-2
region=$(aws configure get region)
region=${region:-us-east-1}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/nullfi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
En el ejemplo anterior, se muestra cómo realizar los siguientes pasos necesarios para enviar el contenedor de Docker de ejemplo a un ECR:
1. Defina el nombre del algoritmo como `sm-pretrained-spacy`.
1. Haga que el archivo `serve` de la carpeta NER sea ejecutable.
1. Configure el Región de AWS.
1. Cree un ECR si no existe todavía.
1. Inicie sesión en el ECR.
1. Compilación del contenedor de Docker de forma local
1. Inserte la imagen de Docker en ECR.
1. Configure el cliente de SageMaker IA
Si desea utilizar los servicios de alojamiento de SageMaker IA para realizar inferencias, debe [crear un modelo](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html), crear una [configuración de punto final](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#) y [crear un punto final](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html#). Para obtener inferencias de su punto final, puede usar el cliente SageMaker AI boto3 Runtime para invocar su punto final. En el siguiente código se muestra cómo configurar tanto el cliente SageMaker AI como el cliente SageMaker Runtime mediante el cliente [SageMaker AI boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html):
```
import boto3
from sagemaker import get_execution_role
sm_client = boto3.client(service_name='sagemaker')
runtime_sm_client = boto3.client(service_name='sagemaker-runtime')
account_id = boto3.client('sts').get_caller_identity()['Account']
region = boto3.Session().region_name
#used to store model artifacts which SageMaker AI will extract to /opt/ml/model in the container,
#in this example case we will not be making use of S3 to store the model artifacts
#s3_bucket = ''
role = get_execution_role()
```
En el ejemplo de código anterior, no se usa el bucket de Amazon S3, sino que se inserta como comentario para mostrar la manera de almacenar los artefactos del modelo.
Si recibe un error de permiso tras la ejecución del ejemplo de código anterior, es posible que tenga que agregar permisos a su rol de IAM. Para más información acerca de los roles de IAM, consulte [Gestor de SageMaker funciones de Amazon](role-manager.md). Para obtener más información sobre cómo agregar permisos al rol actual, consulte [AWS políticas gestionadas para Amazon SageMaker AI](security-iam-awsmanpol.md).
1. Cree el modelo
Si desea utilizar los servicios de alojamiento de SageMaker IA para realizar inferencias, debe crear un modelo en IA. SageMaker El siguiente ejemplo de código muestra cómo crear el spaCy NER modelo dentro de la SageMaker IA:
```
from time import gmtime, strftime
model_name = 'spacy-nermodel-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
# MODEL S3 URL containing model atrifacts as either model.tar.gz or extracted artifacts.
# Here we are not
#model_url = 's3://{}/spacy/'.format(s3_bucket)
container = '{}.dkr.ecr.{}.amazonaws.com/sm-pretrained-spacy:latest'.format(account_id, region)
instance_type = 'ml.c5d.18xlarge'
print('Model name: ' + model_name)
#print('Model data Url: ' + model_url)
print('Container image: ' + container)
container = {
'Image': container
}
create_model_response = sm_client.create_model(
ModelName = model_name,
ExecutionRoleArn = role,
Containers = [container])
print("Model Arn: " + create_model_response['ModelArn'])
```
En el ejemplo de código anterior, se muestra cómo definir una `model_url` con el `s3_bucket` si tuviera que utilizar el bucket de Amazon S3 de los comentarios del paso 5 y define el URI de ECR para la imagen del contenedor. En los ejemplos de código anteriores, se define `ml.c5d.18xlarge` como el tipo de instancia. También puede elegir un tipo de instancia diferente. Para obtener más información sobre los tipos de instancia disponibles, consulte [Tipos de instancias de Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
En el ejemplo de código anterior, la clave `Image` apunta al URI de la imagen del contenedor. La definición de `create_model_response` utiliza el `create_model method` para crear un modelo y devolver el nombre del modelo, el rol y una lista que contiene la información del contenedor.
A continuación, se muestra una salida de ejemplo del script anterior:
```
Model name: spacy-nermodel-YYYY-MM-DD-HH-MM-SS
Model data Url: s3://spacy-sagemaker-us-east-1-bucket/spacy/
Container image: 123456789012.dkr.ecr.us-east-2.amazonaws.com/sm-pretrained-spacy:latest
Model Arn: arn:aws:sagemaker:us-east-2:123456789012:model/spacy-nermodel-YYYY-MM-DD-HH-MM-SS
```
1.
1.
**Configuración y creación de un punto de conexión**
Para utilizar el alojamiento de SageMaker IA con fines de inferencia, también debe configurar y crear un punto final. SageMaker La IA utilizará este punto final para la inferencia. En el siguiente ejemplo de configuración, se muestra cómo generar y configurar un punto de conexión con el tipo de instancia y el nombre de modelo que ha definido anteriormente:
```
endpoint_config_name = 'spacy-ner-config' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint config name: ' + endpoint_config_name)
create_endpoint_config_response = sm_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ProductionVariants=[{
'InstanceType': instance_type,
'InitialInstanceCount': 1,
'InitialVariantWeight': 1,
'ModelName': model_name,
'VariantName': 'AllTraffic'}])
print("Endpoint config Arn: " + create_endpoint_config_response['EndpointConfigArn'])
```
En el ejemplo de configuración anterior, `create_endpoint_config_response` asocia el `model_name` a un nombre de configuración de punto de conexión único `endpoint_config_name` que se crea con una marca de tiempo.
A continuación, se muestra una salida de ejemplo del script anterior:
```
Endpoint config name: spacy-ner-configYYYY-MM-DD-HH-MM-SS
Endpoint config Arn: arn:aws:sagemaker:us-east-2:123456789012:endpoint-config/spacy-ner-config-MM-DD-HH-MM-SS
```
Para obtener más información sobre los errores de punto final, consulte [¿Por qué mi punto de enlace de Amazon SageMaker AI pasa a un estado de error cuando creo o actualizo un punto de enlace?](https://repost.aws/knowledge-center/sagemaker-endpoint-creation-fail)
1.
**Cree un punto de conexión y espere a que el punto de conexión esté en servicio.**
El siguiente ejemplo de código crea el punto de conexión con la configuración del ejemplo de configuración anterior e implementa el modelo:
```
%%time
import time
endpoint_name = 'spacy-ner-endpoint' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint name: ' + endpoint_name)
create_endpoint_response = sm_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
print('Endpoint Arn: ' + create_endpoint_response['EndpointArn'])
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp['EndpointStatus']
print("Endpoint Status: " + status)
print('Waiting for {} endpoint to be in service...'.format(endpoint_name))
waiter = sm_client.get_waiter('endpoint_in_service')
waiter.wait(EndpointName=endpoint_name)
```
En el ejemplo de código anterior, el método `create_endpoint` crea el punto de conexión con el nombre del punto de conexión generado en el ejemplo de código anterior e imprime el nombre de recurso de Amazon del punto de conexión. El método `describe_endpoint` devuelve información sobre el punto de conexión y su estado. Un camarero de SageMaker IA espera a que el punto final esté en servicio.
1. Pruebe el punto de conexión.
Una vez que su punto de conexión esté en servicio, envíe una [solicitud de invocación](https://boto3.amazonaws.com/v1/documentation/api/1.9.42/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) a su punto de conexión. En el siguiente ejemplo de código, se muestra cómo enviar una solicitud de prueba a su punto de conexión:
```
import json
content_type = "application/json"
request_body = {"input": "This is a test with NER in America with \
Amazon and Microsoft in Seattle, writing random stuff."}
#Serialize data for endpoint
#data = json.loads(json.dumps(request_body))
payload = json.dumps(request_body)
#Endpoint invocation
response = runtime_sm_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload)
#Parse results
result = json.loads(response['Body'].read().decode())['output']
result
```
En el ejemplo de código anterior, el método `json.dumps` serializa el `request_body` en una cadena con formato en JSON y la guarda en la carga útil de la variable. A continuación, el cliente SageMaker AI Runtime utiliza el método [invocar punto final](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) para enviar la carga útil a su punto final. El resultado contiene la respuesta del punto de conexión tras extraer el campo de salida.
El ejemplo de código anterior debe devolver la siguiente salida:
```
[['NER', 'ORG'],
['America', 'GPE'],
['Amazon', 'ORG'],
['Microsoft', 'ORG'],
['Seattle', 'GPE']]
```
1. Eliminación de su punto de conexión
Una vez que haya completado las invocaciones, elimine el punto de conexión para conservar los recursos. En el siguiente ejemplo de código, se muestra cómo eliminar un punto de conexión:
```
sm_client.delete_endpoint(EndpointName=endpoint_name)
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)
```
Para ver un cuaderno completo que contenga el código de este ejemplo, consulte [BYOC-Single-Model](https://github.com/aws-samples/sagemaker-hosting/tree/main/Bring-Your-Own-Container/BYOC-Single-Model).