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.
# Preparación del producto en SageMaker AI
Antes de publicar el producto en AWS Marketplace, debe prepararlo en Amazon SageMaker AI. Hay dos tipos de productos de SageMaker AI que se muestran en AWS Marketplace: paquetes de modelos y algoritmos. Para obtener más información, consulte [Productos de machine learning en AWS Marketplace](machine-learning-products.md). En este tema se proporciona una descripción general de los tres pasos que se requieren para preparar el producto:
1. [Empaquetar su código en imágenes para productos de aprendizaje automático en AWS Marketplace](ml-packaging-your-code-into-images.md): para preparar un paquete modelo o un producto de algoritmo, debe crear las imágenes del contenedor de Docker para su producto.
1. [Carga de las imágenes a Amazon Elastic Container Registry](ml-uploading-your-images.md): tras empaquetar el código en imágenes de contenedores y probarlas localmente, cargue las imágenes y escanéelas en busca de vulnerabilidades conocidas. Corrija cualquier vulnerabilidad antes de continuar.
1. [Cómo crear tu recurso de Amazon SageMaker AI](ml-creating-your-amazon-sagemaker-resource.md): una vez escaneadas correctamente las imágenes, puede utilizarlas para crear un paquete de modelos o un recurso de algoritmo en SageMaker AI.
# Empaquetar su código en imágenes para productos de aprendizaje automático en AWS Marketplace
Los productos de aprendizaje automático AWS Marketplace utilizan Amazon SageMaker AI para crear y ejecutar la lógica de aprendizaje automático que usted proporciona a los compradores. SageMaker La IA ejecuta imágenes de contenedores de Docker que contienen tu lógica. SageMaker La IA ejecuta estos contenedores en una infraestructura segura y escalable. Para obtener más información, consulte [Seguridad y propiedad intelectual con Amazon SageMaker AI](ml-security-and-intellectual-property.md). En las siguientes secciones, se proporciona información sobre cómo empaquetar el código en imágenes de contenedores de Docker para SageMaker IA.
**Topics**
+ [¿Qué tipo de imagen de contenedor debo crear?](#ml-which-type-of-container-image-do-i-create)
+ [Creación de imágenes de paquetes de modelos](ml-model-package-images.md)
+ [Creación de imágenes de algoritmos](ml-algorithm-images.md)
## ¿Qué tipo de imagen de contenedor debo crear?
Los dos tipos de imágenes de contenedor son una imagen de inferencia y una imagen de entrenamiento.
Para crear un producto de paquete modelo, solo necesita una imagen de inferencia. Para obtener instrucciones detalladas, consulte [Creación de imágenes de paquetes de modelos](ml-model-package-images.md).
Para crear un producto de algoritmo, se necesitan imágenes de entrenamiento y de inferencia. Para obtener instrucciones detalladas, consulte [Creación de imágenes de algoritmos](ml-algorithm-images.md).
Para empaquetar el código correctamente en una imagen de contenedor, el contenedor debe cumplir con la estructura de archivos de SageMaker AI. El contenedor debe exponer los puntos finales correctos para garantizar que el servicio pueda transferir datos hacia y desde su contenedor. En las siguientes secciones se explican los detalles de este proceso.
**importante**
Por motivos de seguridad, cuando un comprador se suscribe a su producto en contenedores, los contenedores de Docker se ejecutan en un entorno aislado sin conexión a Internet. Cuando cree sus contenedores, no confíe en que podrá realizar llamadas salientes a través de Internet, ya que fallarán. Las llamadas a también Servicios de AWS fallarán. Para obtener más información, consulte la sección [Seguridad y propiedad intelectual con Amazon SageMaker AI](ml-security-and-intellectual-property.md).
Si lo desea, al crear sus imágenes de inferencia y entrenamiento, utilice un contenedor de [Imágenes de contenedores de aprendizaje profundo disponibles](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/) como punto de partida. Las imágenes ya vienen empaquetadas correctamente con diferentes marcos de machine learning.
# Creación de imágenes de paquetes de modelos
Un paquete de modelos de Amazon SageMaker AI es un modelo previamente entrenado que hace predicciones y no requiere ninguna formación adicional por parte del comprador. Puedes crear un paquete modelo en SageMaker IA y publicar tu producto de aprendizaje automático en AWS Marketplaceél. En las siguientes secciones se explica cómo crear un paquete modelo AWS Marketplace. Esto incluye la creación de la imagen del contenedor y la creación y prueba de la imagen localmente.
**Topics**
+ [Descripción general de](#ml-model-package-images-overview)
+ [Creación de una imagen de inferencia para paquetes de modelos](#ml-creating-an-inference-image-for-model-packages)
## Descripción general de
Un paquete de modelos incluye los siguientes componentes:
+ Imagen de inferencia almacenada en [Amazon Elastic Container Registry](https://aws.amazon.com/ecr/) (Amazon ECR)
+ (Opcional) Artefactos del modelo, almacenados por separado en [Amazon S3](https://aws.amazon.com/s3/)
**nota**
Los artefactos del modelo son archivos que su modelo utiliza para realizar predicciones y, por lo general, son el resultado de sus propios procesos de entrenamiento. Los artefactos pueden ser de cualquier tipo de archivo que necesite el modelo, pero deben comprimirse con el archivo use.tar.gz. En el caso de los paquetes modelo, pueden agruparse en la imagen de inferencia o almacenarse por separado en Amazon SageMaker AI. Los artefactos del modelo almacenados en Amazon S3 se cargan en el contenedor de inferencias durante el tiempo de ejecución. Al publicar su paquete modelo, esos artefactos se publican y almacenan en depósitos de Amazon S3 AWS Marketplace propios a los que el comprador no puede acceder directamente.
**sugerencia**
Si su modelo de inferencia se ha creado con un marco de aprendizaje profundo como Gluon, Keras,,, TensorFlow -Lite u TensorFlow ONNX PyTorch, considere la posibilidad de utilizar Amazon AI Neo. MXNet SageMaker Neo puede optimizar automáticamente los modelos de inferencia que se implementan en una familia específica de tipos de instancias en la nube, como, etc. `ml.c4` `ml.p2` Para obtener más información, consulte [Optimizar el rendimiento de los modelos con Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) en la *Guía para desarrolladores de Amazon SageMaker AI*.
En el siguiente diagrama se muestra el flujo de trabajo para publicar y usar productos de paquetes de modelos.
![\[Diagrama de cómo un vendedor crea una imagen de paquete de modelos con un algoritmo y cómo la usa un comprador.\]](http://docs.aws.amazon.com/es_es/marketplace/latest/userguide/images/ml-model-package-images.png)
El flujo de trabajo para crear un paquete de modelos de SageMaker IA AWS Marketplace incluye los siguientes pasos:
1. El vendedor crea una imagen de inferencia (no tiene acceso a la red cuando está implementada) y la envía al registro ECR de Amazon.
Los artefactos del modelo pueden agruparse en la imagen de inferencia o almacenarse por separado en S3.
1. A continuación, el vendedor crea un recurso de paquete modelo en Amazon SageMaker AI y publica su producto de aprendizaje automático en él AWS Marketplace.
1. El comprador se suscribe al producto de ML e implementa el modelo.
**nota**
El modelo se puede implementar como punto de conexión para inferencias en tiempo real o como un trabajo por lotes para obtener predicciones para todo un conjunto de datos de una sola vez. Para obtener más información, consulte [Implementar modelos para inferencia](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html).
1. SageMaker La IA ejecuta la imagen de inferencia. Todos los artefactos del modelo proporcionados por el vendedor que no estén incluidos en la imagen de inferencia se cargan dinámicamente en tiempo de ejecución.
1. SageMaker La IA pasa los datos de inferencia del comprador al contenedor mediante los puntos finales HTTP del contenedor y devuelve los resultados de la predicción.
## Creación de una imagen de inferencia para paquetes de modelos
En esta sección se proporciona un tutorial para empaquetar el código de inferencia en una imagen de inferencia para el producto de paquete de modelos. El proceso consta de los siguientes pasos:
**Topics**
+ [Paso 1: creación de la imagen del contenedor](#ml-step-1-creating-the-container-image)
+ [Paso 2: creación y prueba de la imagen localmente](#ml-step-2-building-and-testing-the-image-locally)
La imagen de inferencia es una imagen de Docker que contiene la lógica de inferencia. En tiempo de ejecución, el contenedor expone los puntos de enlace HTTP para permitir que la SageMaker IA pase datos hacia y desde el contenedor.
**nota**
El siguiente es solo un ejemplo de código de empaquetado para una imagen de inferencia. [Para obtener más información, consulte [Uso de contenedores Docker con SageMaker IA y los ejemplos de IA](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html) que aparecen más abajo AWS Marketplace SageMaker .](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) GitHub
En el siguiente ejemplo se utiliza un servicio web, [Flask](https://pypi.org/project/Flask/), por motivos de simplicidad, y no se considera listo para la producción.
### Paso 1: creación de la imagen del contenedor
Para que la imagen de inferencia sea compatible con la SageMaker IA, la imagen de Docker debe exponer los puntos finales HTTP. Mientras el contenedor está en ejecución, la SageMaker IA pasa las entradas del comprador para su inferencia al punto final HTTP del contenedor. Los resultados de la inferencia se devuelven en el cuerpo de la respuesta HTTP.
En el siguiente tutorial se utiliza la CLI de Docker en un entorno de desarrollo utilizando una distribución Linux Ubuntu.
+ [Crear el script del servidor web](#ml-create-the-web-server-script)
+ [Crear el script para la ejecución del contenedor](#ml-create-the-script-for-the-container-run)
+ [Creación del `Dockerfile`](#ml-create-the-dockerfile)
+ [Empaqueta o cargar los artefactos del modelo](#ml-package-or-upload-the-model-artifacts)
#### Crear el script del servidor web
Este ejemplo usa un servidor de Python llamado [Flask](https://pypi.org/project/Flask/), pero puede usar cualquier servidor web que funcione para su marco.
**nota**
Aquí se usa [Flask](https://pypi.org/project/Flask/) por motivos de simplicidad. No se considera un servidor web listo para producción.
Crea un script para el servidor web de Flask que sirva a los dos puntos finales HTTP del puerto TCP 8080 que utiliza AI. SageMaker Los dos puntos de conexión esperados son los siguientes:
+ `/ping`— SageMaker AI realiza solicitudes HTTP GET a este punto final para comprobar si su contenedor está listo. Cuando el contenedor esté listo, responderá a las solicitudes HTTP GET en este punto de conexión con un código de respuesta HTTP 200.
+ `/invocations`— SageMaker La IA realiza solicitudes HTTP POST a este punto final para realizar inferencias. Los datos de entrada para la inferencia se envían en el cuerpo de la solicitud. El tipo de contenido especificado por el usuario se pasa en el encabezado HTTP. El cuerpo de la respuesta es el resultado de la inferencia. Para obtener más información sobre los tiempos de espera, consulte [Requisitos y prácticas recomendadas para crear productos de machine learning](ml-listing-requirements-and-best-practices.md).
**`./web_app_serve.py`**
```
# Import modules
import json
import re
from flask import Flask
from flask import request
app = Flask(__name__)
# Create a path for health checks
@app.route("/ping")
def endpoint_ping():
return ""
# Create a path for inference
@app.route("/invocations", methods=["POST"])
def endpoint_invocations():
# Read the input
input_str = request.get_data().decode("utf8")
# Add your inference code between these comments.
#
#
#
#
#
# Add your inference code above this comment.
# Return a response with a prediction
response = {"prediction":"a","text":input_str}
return json.dumps(response)
```
En el ejemplo anterior, no existe una lógica de inferencia real. Para la imagen de inferencia real, añada la lógica de inferencia a la aplicación web para que procese la entrada y devuelva la predicción real.
La imagen de inferencia debe contener todas las dependencias requeridas, ya que no tendrá acceso a Internet ni podrá realizar llamadas a ninguna de ellas. Servicios de AWS
**nota**
Este mismo código se utiliza tanto para las inferencias en tiempo real como para las inferencias por lotes
#### Crear el script para la ejecución del contenedor
Cree un script con el nombre de `serve` que SageMaker AI ejecute cuando ejecute la imagen del contenedor de Docker. El siguiente script inicia el servidor web HTTP.
**`./serve`**
```
#!/bin/bash
# Run flask server on port 8080 for SageMaker
flask run --host 0.0.0.0 --port 8080
```
#### Creación del `Dockerfile`
Cree un `Dockerfile` en su contexto de compilación. En este ejemplo se usa Ubuntu 18.04, pero puede empezar desde cualquier imagen base que funcione para su framework.
`./Dockerfile`
```
FROM ubuntu:18.04
# Specify encoding
ENV LC_ALL=C.UTF-8
ENV LANG=C.UTF-8
# Install python-pip
RUN apt-get update \
&& apt-get install -y python3.6 python3-pip \
&& ln -s /usr/bin/python3.6 /usr/bin/python \
&& ln -s /usr/bin/pip3 /usr/bin/pip;
# Install flask server
RUN pip install -U Flask;
# Add a web server script to the image
# Set an environment to tell flask the script to run
COPY /web_app_serve.py /web_app_serve.py
ENV FLASK_APP=/web_app_serve.py
# Add a script that Amazon SageMaker AI will run
# Set run permissions
# Prepend program directory to $PATH
COPY /serve /opt/program/serve
RUN chmod 755 /opt/program/serve
ENV PATH=/opt/program:${PATH}
```
El `Dockerfile` añade a la imagen los dos scripts creados anteriormente. El directorio del script `serve` se agrega a PATH para que pueda ejecutarse cuando se ejecute el contenedor.
#### Empaqueta o cargar los artefactos del modelo
Las dos formas de proporcionar los artefactos del modelo, desde el entrenamiento del modelo hasta la imagen de inferencia, son las siguientes:
+ Se empaqueta estáticamente con la imagen de inferencia.
+ Se carga dinámicamente en tiempo de ejecución. Como se carga de forma dinámica, puede usar la misma imagen para empaquetar diferentes modelos de machine learning.
Si desea empaquetar los artefactos del modelo con la imagen de inferencia, inclúyalos en el `Dockerfile`.
Si desea cargar los artefactos del modelo de forma dinámica, almacénelos por separado en un archivo comprimido (.tar.gz) en Amazon S3. Al crear el paquete modelo, especifique la ubicación del archivo comprimido y SageMaker AI extraerá y copiará el contenido en el directorio del contenedor `/opt/ml/model/` cuando ejecute el contenedor. Al publicar su paquete de modelos, esos artefactos se publican y almacenan en buckets de Amazon S3 propiedad de AWS Marketplace a los que el comprador no puede acceder directamente.
### Paso 2: creación y prueba de la imagen localmente
En el contexto de la compilación, ahora existen los siguientes archivos:
+ `./Dockerfile`
+ `./web_app_serve.py`
+ `./serve`
+ Su lógica de inferencia y sus dependencias (opcionales)
A continuación, compile, ejecute y pruebe la imagen del contenedor.
#### Compilar la imagen
Ejecute el comando Docker en el contexto de compilación para crear y etiquetar la imagen. En este ejemplo se utiliza la etiqueta `my-inference-image`.
```
sudo docker build --tag my-inference-image ./
```
Tras ejecutar este comando de Docker para crear la imagen, debería ver el resultado a medida que Docker cree la imagen en función de cada línea de su `Dockerfile`. Cuando termine, debería ver algo similar a lo siguiente.
```
Successfully built abcdef123456
Successfully tagged my-inference-image:latest
```
#### Ejecutar localmente
Una vez completada la compilación, puede probar la imagen localmente.
```
sudo docker run \
--rm \
--publish 8080:8080/tcp \
--detach \
--name my-inference-container \
my-inference-image \
serve
```
A continuación se muestran los detalles del comando:
+ `--rm`: eliminar automáticamente el contenedor una vez que se detenga.
+ `--publish 8080:8080/tcp`— Exponga el puerto 8080 para simular el puerto al que SageMaker AI envía las solicitudes HTTP.
+ `--detach`: ejecuta el contenedor en segundo plano.
+ `--name my-inference-container`: asigna un nombre a este contenedor en ejecución.
+ `my-inference-image`: ejecuta la imagen creada.
+ `serve`— Ejecute el mismo script que ejecuta SageMaker AI al ejecutar el contenedor.
Tras ejecutar este comando, Docker crea un contenedor a partir de la imagen de inferencia compilada y la ejecuta en segundo plano. El contenedor ejecuta el script `serve`, que lanza el servidor web con fines de prueba.
#### Probar el ping de punto de conexión HTTP
Cuando la SageMaker IA ejecuta el contenedor, hace ping periódicamente al punto final. Cuando el punto final devuelve una respuesta HTTP con el código de estado 200, indica a la SageMaker IA que el contenedor está listo para la inferencia. Para comprobarlo, ejecute el siguiente comando, que comprueba el punto de conexión e incluye el encabezado de respuesta.
```
curl --include http://127.0.0.1:8080/ping
```
A continuación, se muestra un ejemplo de resultado.
```
HTTP/1.0 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 0
Server: MyServer/0.16.0 Python/3.6.8
Date: Mon, 21 Oct 2019 06:58:54 GMT
```
#### Probar el punto de conexión HTTP de inferencia
Cuando el contenedor indica que está listo devolviendo un código de estado 200 a tu ping, la SageMaker IA pasa los datos de inferencia al punto final `/invocations` HTTP mediante una `POST` solicitud. Pruebe el punto de inferencia ejecutando el siguiente comando.
```
curl \
--request POST \
--data "hello world" \
http://127.0.0.1:8080/invocations
```
A continuación, se muestra un ejemplo de resultado.
`{"prediction": "a", "text": "hello world"}`
Con estos dos puntos finales HTTP funcionando, la imagen de inferencia ahora es compatible con la IA. SageMaker
**nota**
El modelo de su producto de paquete de modelos se puede implementar de dos maneras: en tiempo real y por lotes. En ambas implementaciones, la SageMaker IA utiliza los mismos puntos de enlace HTTP mientras ejecuta el contenedor de Docker.
Para detener el contenedor, ejecute el siguiente comando.
```
sudo docker container stop my-inference-container
```
Cuando la imagen de inferencia esté lista y probada, podrá continuar con [Carga de las imágenes a Amazon Elastic Container Registry](ml-uploading-your-images.md).
# Creación de imágenes de algoritmos
Un algoritmo de SageMaker IA de Amazon requiere que el comprador traiga sus propios datos para entrenarse antes de hacer predicciones. Como AWS Marketplace vendedor, puedes usar la SageMaker IA para crear algoritmos y modelos de aprendizaje automático (ML) que tus compradores puedan utilizar AWS. En las siguientes secciones se explica cómo crear imágenes de algoritmos AWS Marketplace. Esto incluye la creación de la imagen de entrenamiento de Docker para entrenar el algoritmo y la imagen de inferencia que contiene la lógica de inferencia. Tanto las imágenes de entrenamiento como las de inferencia son obligatorias para publicar un producto de algoritmo.
**Topics**
+ [Descripción general de](#ml-algorithm-images-overview)
+ [Crear una imagen de entrenamiento para algoritmos](#ml-creating-a-training-image-for-algorithms)
+ [Crear una imagen de inferencia para algoritmos](#ml-creating-an-inference-image-for-algorithms)
## Descripción general de
Un algoritmo incluye los siguientes componentes:
+ Una imagen de entrenamiento almacenada en [Amazon ECR](https://aws.amazon.com/ecr/)
+ Imagen de inferencia almacenada en Amazon Elastic Container Registry (Amazon ECR)
**nota**
En el caso de los productos de algoritmos, el contenedor de entrenamiento genera artefactos del modelo que se cargan en el contenedor de inferencias al implementar el modelo.
En el siguiente diagrama se muestra el flujo de trabajo de publicación y uso de productos de algoritmos.
![\[Diagrama de cómo un vendedor crea una imagen de paquete con un algoritmo y cómo la usa un comprador.\]](http://docs.aws.amazon.com/es_es/marketplace/latest/userguide/images/ml-algorithm-package-images.png)
El flujo de trabajo para crear un algoritmo de SageMaker IA AWS Marketplace incluye los siguientes pasos:
1. El vendedor crea una imagen de formación y una imagen de inferencia (no hay acceso a la red cuando está implementada) y las carga en el registro ECR de Amazon.
1. A continuación, el vendedor crea un recurso de algoritmo en Amazon SageMaker AI y publica su producto de aprendizaje automático en él AWS Marketplace.
1. El comprador se suscribe al producto de ML.
1. El comprador crea un trabajo de formación con un conjunto de datos compatible y los valores de hiperparámetros adecuados. SageMaker La IA ejecuta la imagen de entrenamiento y carga los datos de entrenamiento y los hiperparámetros en el contenedor de entrenamiento. Cuando se completa el trabajo de entrenamiento, los artefactos del modelo que se encuentran en `/opt/ml/model/` se comprimen y se copian en el bucket de [Amazon S3](https://aws.amazon.com/s3/) del comprador.
1. El comprador crea un paquete de modelos con los artefactos del modelo de entrenamiento almacenado en Amazon S3 e implementa el modelo.
1. SageMaker La IA ejecuta la imagen de inferencia, extrae los artefactos comprimidos del modelo y carga los archivos en la ruta del directorio del contenedor de inferencias, `/opt/ml/model/` donde son consumidos por el código que sirve para la inferencia.
1. Ya sea que el modelo se despliegue como un punto final o como un trabajo de transformación por lotes, la SageMaker IA pasa los datos para su inferencia en nombre del comprador al contenedor a través del punto final HTTP del contenedor y devuelve los resultados de la predicción.
**nota**
Para obtener más información, consulte [Entrenar modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/train-model.html).
## Crear una imagen de entrenamiento para algoritmos
En esta sección se proporciona un tutorial para empaquetar el código de entrenamiento en una imagen de entrenamiento. Se necesita una imagen de entrenamiento para crear un producto de algoritmo.
Una *imagen de entrenamiento* es una imagen de Docker que contiene su algoritmo de entrenamiento. El contenedor se adhiere a una estructura de archivos específica para que la SageMaker IA pueda copiar los datos hacia y desde el contenedor.
Tanto las imágenes de entrenamiento como las de inferencia son obligatorias para publicar un producto de algoritmo. Tras crear la imagen de entrenamiento, debe crear una imagen de inferencia. Las dos imágenes se pueden combinar en una sola imagen o permanecer como imágenes independientes. Usted decide si desea combinar las imágenes o separarlas. Por lo general, la inferencia es más sencilla que el entrenamiento, y es posible que desee separar las imágenes para mejorar el rendimiento de la inferencia.
**nota**
El siguiente es solo un ejemplo de código de empaquetado para una imagen de entrenamiento. Para obtener más información, consulte [Utilice sus propios algoritmos y modelos con los AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) [ejemplos de AWS Marketplace SageMaker IA puestos](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace). GitHub
**Topics**
+ [Paso 1: Creación de la imagen del contenedor](#ml-step-1-creating-the-container-image-1)
+ [Paso 2: Crear y probar la imagen localmente](#ml-step-2-building-and-testing-the-image-locally-1)
### Paso 1: Creación de la imagen del contenedor
Para que la imagen de entrenamiento sea compatible con Amazon SageMaker AI, debe cumplir con una estructura de archivos específica para permitir que SageMaker AI copie los datos de entrenamiento y las entradas de configuración en rutas específicas de su contenedor. Cuando se completa el entrenamiento, los artefactos del modelo generados se almacenan en una ruta de directorio específica en el contenedor desde el que SageMaker AI copia.
A continuación, se utiliza la CLI de Docker instalada en un entorno de desarrollo en una distribución Ubuntu de Linux.
+ [Preparar el programa para leer las entradas de configuración](#ml-prepare-your-program-to-read-configuration-inputs)
+ [Preparar el programa para leer entradas de datos](#ml-prepare-your-program-to-read-data-inputs)
+ [Prepare su programa para escribir los resultados del entrenamiento](#ml-prepare-your-program-to-write-training-outputs)
+ [Crear el script para la ejecución del contenedor](#ml-create-the-script-for-the-container-run-1)
+ [Creación del `Dockerfile`](#ml-create-the-dockerfile-1)
#### Preparar el programa para leer las entradas de configuración
Si su programa de entrenamiento requiere alguna entrada de configuración proporcionada por el comprador, la siguiente es la ubicación en la que se copian dentro del contenedor cuando se ejecuta. Si es necesario, el programa debe leer esas rutas de archivo específicas.
+ `/opt/ml/input/config` es el directorio que contiene la información que controla el funcionamiento del programa.
+ `hyperparameters.json` es un diccionario de nombres y valores de hiperparámetros con formato JSON. Los valores son cadenas, por lo que puede que necesite convertirlos.
+ `resourceConfig.json` es un archivo con formato JSON que describe el diseño de red utilizado para el [entrenamiento distribuido](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training). Si su imagen de formación no admite el entrenamiento distribuido, puede omitir este archivo.
**nota**
Para obtener más información sobre las entradas de configuración, consulte [Cómo Amazon SageMaker AI proporciona información de formación](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html).
#### Preparar el programa para leer entradas de datos
Los datos de entrenamiento se pueden pasar al contenedor en uno de los dos modos siguientes. El programa de entrenamiento que se ejecuta en el contenedor digiere los datos de entrenamiento en uno de esos dos modos.
**Modo de archivo**
+ `/opt/ml/input/data//` contiene los datos de entrada de ese canal. Los canales se crean en función de la llamada a la operación `CreateTrainingJob`, pero generalmente es importante que los canales coincidan con lo que espera el algoritmo. Los archivos de cada canal se copian de [Amazon S3](https://aws.amazon.com/s3/) a este directorio, conservando la estructura de árbol indicada por la estructura de claves de Amazon S3.
**Modo de canalización**
+ `/opt/ml/input/data/_` es la canalización de una fecha de inicio determinada. Las fechas de inicio (epochs) comienzan en cero y aumentan en una cada vez que las lees. No hay límite en cuanto al número de épocas que puede recorrer, pero debe cerrar cada canalización antes de leer la siguiente.
#### Prepare su programa para escribir los resultados del entrenamiento
El resultado del entrenamiento se escribe en los siguientes directorios de contenedores:
+ `/opt/ml/model/` es el directorio en el que se escribe el modelo o los artefactos del modelo que genera su algoritmo de entrenamiento. El modelo puede estar en el formato que desee. Puede ser un único archivo o un árbol de directorios completo. SageMaker AI empaqueta todos los archivos de este directorio en un archivo comprimido (.tar.gz). Este archivo está disponible en la ubicación de Amazon S3 devuelta por la operación de la API `DescribeTrainingJob`.
+ `/opt/ml/output/` es un directorio en el que el algoritmo puede escribir un archivo `failure` que describa el motivo del error en la tarea. El contenido de este archivo se devuelve en el campo `FailureReason` del resultado `DescribeTrainingJob`. En el caso de los trabajos que se realicen correctamente, no hay motivo para escribir este archivo porque se omite.
#### Crear el script para la ejecución del contenedor
Cree un script de `train` shell que SageMaker AI ejecute cuando ejecute la imagen del contenedor de Docker. Cuando finalice el entrenamiento y los artefactos del modelo estén escritos en sus directorios respectivos, salga del script.
**`./train`**
```
#!/bin/bash
# Run your training program here
#
#
#
#
```
#### Creación del `Dockerfile`
Cree un `Dockerfile` en su contexto de compilación. En este ejemplo se usa Ubuntu 18.04 como imagen base, pero puede empezar desde cualquier imagen base que funcione para su framework.
**`./Dockerfile`**
```
FROM ubuntu:18.04
# Add training dependencies and programs
#
#
#
#
#
# Add a script that SageMaker AI will run
# Set run permissions
# Prepend program directory to $PATH
COPY /train /opt/program/train
RUN chmod 755 /opt/program/train
ENV PATH=/opt/program:${PATH}
```
El `Dockerfile` añade el script `train` creado anteriormente a la imagen. El directorio del script se agrega a PATH para que pueda ejecutarse cuando se ejecute el contenedor.
En el ejemplo anterior, no existe una lógica de entrenamiento real. Para su imagen de entrenamiento real, añada las dependencias de entrenamiento al `Dockerfile` y añada la lógica para leer las entradas de entrenamiento para entrenar y generar los artefactos del modelo.
La imagen de entrenamiento debe contener todas las dependencias necesarias, ya que no tendrá acceso a Internet.
Para obtener más información, consulte [Utilice sus propios algoritmos y modelos con los AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) [ejemplos de AWS Marketplace SageMaker IA incluidos](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace). GitHub
### Paso 2: Crear y probar la imagen localmente
En el contexto de la compilación, ahora existen los siguientes archivos:
+ `./Dockerfile`
+ `./train`
+ Su lógica y dependencias de entrenamiento
A continuación, puede crear, ejecutar y probar esta imagen de contenedor.
#### Compilar la imagen
Ejecute el comando Docker en el contexto de compilación para crear y etiquetar la imagen. En este ejemplo se utiliza la etiqueta `my-training-image`.
```
sudo docker build --tag my-training-image ./
```
Tras ejecutar este comando de Docker para crear la imagen, debería ver el resultado a medida que Docker cree la imagen en función de cada línea de su `Dockerfile`. Cuando termine, debería ver algo similar a lo siguiente.
```
Successfully built abcdef123456
Successfully tagged my-training-image:latest
```
#### Ejecutar localmente
Una vez finalizado, pruebe la imagen de forma local, como se muestra en el siguiente ejemplo.
```
sudo docker run \
--rm \
--volume ':/opt/ml/input:ro' \
--volume ':/opt/ml/model' \
--volume ':/opt/ml/output' \
--name my-training-container \
my-training-image \
train
```
A continuación se muestran los detalles del comando:
+ `--rm`: eliminar automáticamente el contenedor una vez que se detenga.
+ `--volume ':/opt/ml/input:ro'`: hacer que el directorio de entrada de prueba esté disponible para el contenedor como de solo lectura.
+ `--volume ':/opt/ml/model'`: monta de forma vinculada la ruta en la que se almacenan los artefactos del modelo en la máquina host una vez finalizada la prueba de entrenamiento.
+ `--volume ':/opt/ml/output'`: monta de forma vinculada la ruta en la que se escribe el motivo del error en un archivo `failure` en la máquina host.
+ `--name my-training-container`: asigna un nombre a este contenedor en ejecución.
+ `my-training-image`: ejecuta la imagen creada.
+ `train`— Ejecute el mismo script que ejecuta SageMaker AI al ejecutar el contenedor.
Tras ejecutar este comando, Docker crea un contenedor a partir de la imagen de entrenamiento creada y lo ejecuta. El contenedor ejecuta el script `train`, que inicia el programa de entrenamiento.
Cuando el programa de entrenamiento finalice y el contenedor salga, comprueba que los artefactos del modelo de salida sean correctos. Además, comprueba los resultados del registro para confirmar que no están produciendo registros no deseados y, al mismo tiempo, asegurarse de que se proporcione suficiente información sobre el trabajo de entrenamiento.
Esto completa el empaquetado del código de entrenamiento para un producto algorítmico. Como un producto de algoritmo también incluye una imagen de inferencia, continúe con la siguiente sección, [Crear una imagen de inferencia para algoritmos](#ml-creating-an-inference-image-for-algorithms).
## Crear una imagen de inferencia para algoritmos
En esta sección se proporciona un tutorial para empaquetar el código de inferencia en una imagen de inferencia para el producto de su algoritmo.
La imagen de inferencia es una imagen de Docker que contiene la lógica de inferencia. En tiempo de ejecución, el contenedor expone los puntos finales HTTP para permitir que la SageMaker IA pase datos hacia y desde el contenedor.
Tanto las imágenes de entrenamiento como las de inferencia son obligatorias para publicar un producto de algoritmo. Si aún no lo ha hecho, consulte la sección anterior sobre [Crear una imagen de entrenamiento para algoritmos](#ml-creating-a-training-image-for-algorithms). Las dos imágenes se pueden combinar en una sola imagen o permanecer como imágenes separadas. Usted decide si desea combinar las imágenes o separarlas. Por lo general, la inferencia es más sencilla que el entrenamiento, y es posible que desee separar las imágenes para mejorar el rendimiento de la inferencia.
**nota**
El siguiente es solo un ejemplo de código de empaquetado para una imagen de inferencia. Para obtener más información, consulte [Utilice sus propios algoritmos y modelos con los AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) [ejemplos de AWS Marketplace SageMaker IA puestos](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace). GitHub
En el siguiente ejemplo se utiliza un servicio web, [Flask](https://pypi.org/project/Flask/), por motivos de simplicidad, y no se considera listo para la producción.
**Topics**
+ [Paso 1: Creación de la imagen de inferencia](#ml-step-1-creating-the-inference-image)
+ [Paso 2: Crear y probar la imagen localmente](#ml-step-2-building-and-testing-the-image-locally-2)
### Paso 1: Creación de la imagen de inferencia
Para que la imagen de inferencia sea compatible con la SageMaker IA, la imagen de Docker debe exponer los puntos finales HTTP. Mientras el contenedor está en ejecución, la SageMaker IA transfiere los datos de inferencia proporcionados por el comprador al punto de enlace HTTP del contenedor. El resultado de la inferencia se muestra en el cuerpo de la respuesta HTTP.
A continuación, se utiliza la CLI de Docker instalada en un entorno de desarrollo en una distribución Ubuntu de Linux.
+ [Crear el script del servidor web](#ml-create-the-web-server-script-1)
+ [Crear el script para la ejecución del contenedor](#ml-create-the-script-for-the-container-run-2)
+ [Creación del `Dockerfile`](#ml-create-the-dockerfile-2)
+ [Preparar el programa para cargar dinámicamente los artefactos del modelo](#ml-preparing-your-program-to-dynamically-load-model-artifacts)
#### Crear el script del servidor web
Este ejemplo usa un servidor de Python llamado [Flask](https://pypi.org/project/Flask/), pero puede usar cualquier servidor web que funcione para su marco.
**nota**
Aquí se usa [Flask](https://pypi.org/project/Flask/) por motivos de simplicidad. No se considera un servidor web listo para producción.
Cree el script del servidor web Flask que sirva a los dos puntos finales HTTP del puerto TCP 8080 que utiliza AI. SageMaker Los dos puntos de conexión esperados son los siguientes:
+ `/ping`— SageMaker AI realiza solicitudes HTTP GET a este punto final para comprobar si su contenedor está listo. Cuando el contenedor esté listo, responderá a las solicitudes HTTP GET en este punto de conexión con un código de respuesta HTTP 200.
+ `/invocations`— SageMaker La IA realiza solicitudes HTTP POST a este punto final para realizar inferencias. Los datos de entrada para la inferencia se envían en el cuerpo de la solicitud. El tipo de contenido especificado por el usuario se pasa en el encabezado HTTP. El cuerpo de la respuesta es el resultado de la inferencia.
**`./web_app_serve.py`**
```
# Import modules
import json
import re
from flask import Flask
from flask import request
app = Flask(__name__)
# Create a path for health checks
@app.route("/ping")
def endpoint_ping():
return ""
# Create a path for inference
@app.route("/invocations", methods=["POST"])
def endpoint_invocations():
# Read the input
input_str = request.get_data().decode("utf8")
# Add your inference code here.
#
#
#
#
#
# Add your inference code here.
# Return a response with a prediction
response = {"prediction":"a","text":input_str}
return json.dumps(response)
```
En el ejemplo anterior, no existe una lógica de inferencia real. Para la imagen de inferencia real, añada la lógica de inferencia a la aplicación web para que procese la entrada y devuelva la predicción.
La imagen de inferencia debe contener todas las dependencias necesarias, ya que no tendrá acceso a Internet.
#### Crear el script para la ejecución del contenedor
Cree un script con el nombre de `serve` que SageMaker AI ejecute cuando ejecute la imagen del contenedor de Docker. En este script, inicie el servidor web HTTP.
**`./serve`**
```
#!/bin/bash
# Run flask server on port 8080 for SageMaker AI
flask run --host 0.0.0.0 --port 8080
```
#### Creación del `Dockerfile`
Cree un `Dockerfile` en su contexto de compilación. En este ejemplo se usa Ubuntu 18.04, pero puede empezar desde cualquier imagen base que funcione para su framework.
**`./Dockerfile`**
```
FROM ubuntu:18.04
# Specify encoding
ENV LC_ALL=C.UTF-8
ENV LANG=C.UTF-8
# Install python-pip
RUN apt-get update \
&& apt-get install -y python3.6 python3-pip \
&& ln -s /usr/bin/python3.6 /usr/bin/python \
&& ln -s /usr/bin/pip3 /usr/bin/pip;
# Install flask server
RUN pip install -U Flask;
# Add a web server script to the image
# Set an environment to tell flask the script to run
COPY /web_app_serve.py /web_app_serve.py
ENV FLASK_APP=/web_app_serve.py
# Add a script that Amazon SageMaker AI will run
# Set run permissions
# Prepend program directory to $PATH
COPY /serve /opt/program/serve
RUN chmod 755 /opt/program/serve
ENV PATH=/opt/program:${PATH}
```
El `Dockerfile` añade los dos scripts creados anteriormente a la imagen. El directorio del script `serve` se agrega a PATH para que pueda ejecutarse cuando se ejecute el contenedor.
#### Preparar el programa para cargar dinámicamente los artefactos del modelo
En el caso de los productos algorítmicos, el comprador utiliza sus propios conjuntos de datos con la imagen de entrenamiento para generar artefactos de modelo únicos. Cuando se complete el proceso de entrenamiento, el contenedor de entrenamiento envía los artefactos del modelo al directorio ` /opt/ml/model/` del contenedor. SageMaker La IA comprime el contenido de ese directorio en un archivo.tar.gz y lo almacena en Amazon S3 del comprador. Cuenta de AWS
Cuando el modelo se implementa, la SageMaker IA ejecuta la imagen de inferencia, extrae los artefactos del modelo del archivo .tar.gz almacenado en la cuenta del comprador en Amazon S3 y los carga en el contenedor de inferencia del directorio. `/opt/ml/model/` En tiempo de ejecución, el código del contenedor de inferencias utiliza los datos del modelo.
**nota**
Para proteger cualquier propiedad intelectual que pueda contener los archivos del artefacto, puede elegir cifrarlos antes de publicarlos. Para obtener más información, consulte [Seguridad y propiedad intelectual con Amazon SageMaker AI](ml-security-and-intellectual-property.md).
### Paso 2: Crear y probar la imagen localmente
En el contexto de la compilación, ahora existen los siguientes archivos:
+ `./Dockerfile`
+ `./web_app_serve.py`
+ `./serve`
A continuación, puede crear, ejecutar y probar esta imagen de contenedor.
#### Compilar la imagen
Ejecuta el comando de Docker para compilar y etiquetar la imagen. En este ejemplo se utiliza la etiqueta `my-inference-image`.
```
sudo docker build --tag my-inference-image ./
```
Tras ejecutar este comando de Docker para crear la imagen, debería ver el resultado a medida que Docker cree la imagen en función de cada línea de su `Dockerfile`. Cuando termine, debería ver algo similar a lo siguiente.
```
Successfully built abcdef123456
Successfully tagged my-inference-image:latest
```
#### Ejecutar localmente
Una vez completada la compilación, puede probar la imagen localmente.
```
sudo docker run \
--rm \
--publish 8080:8080/tcp \
--volume ':/opt/ml/model:ro' \
--detach \
--name my-inference-container \
my-inference-image \
serve
```
A continuación se muestran los detalles del comando:
+ `--rm`: eliminar automáticamente el contenedor una vez que se detenga.
+ `--publish 8080:8080/tcp`— Exponga el puerto 8080 para simular el puerto al que AI envía las solicitudes HTTP. SageMaker
+ `--volume ':/opt/ml/model:ro'`: monta de forma vinculada la ruta donde se almacenan los artefactos del modelo de prueba en la máquina host como de solo lectura para que estén disponibles en el código de inferencia en el contenedor.
+ `--detach`: ejecuta el contenedor en segundo plano.
+ `--name my-inference-container`: asigna un nombre a este contenedor en ejecución.
+ `my-inference-image`: ejecuta la imagen creada.
+ `serve`— Ejecute el mismo script que SageMaker AI ejecuta al ejecutar el contenedor.
Tras ejecutar este comando, Docker crea un contenedor a partir de la imagen de inferencia y lo ejecuta en segundo plano. El contenedor ejecuta el script `serve`, que inicia el servidor web con fines de prueba.
#### Probar el ping de punto de conexión HTTP
Cuando la SageMaker IA ejecuta tu contenedor, hace ping periódicamente al punto final. Cuando el punto final devuelve una respuesta HTTP con el código de estado 200, indica a la SageMaker IA que el contenedor está listo para la inferencia.
Ejecute el siguiente comando para probar el punto de conexión e incluir el encabezado de respuesta.
```
curl --include http://127.0.0.1:8080/ping
```
Por ejemplo, en el ejemplo siguiente se muestra el resultado.
```
HTTP/1.0 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 0
Server: MyServer/0.16.0 Python/3.6.8
Date: Mon, 21 Oct 2019 06:58:54 GMT
```
#### Probar el punto de conexión HTTP de inferencia
Cuando el contenedor indica que está listo devolviendo un código de estado 200, la SageMaker IA pasa los datos de inferencia al punto final `/invocations` HTTP mediante una `POST` solicitud.
Ejecute el siguiente comando para probar el punto de conexión de inferencia.
```
curl \
--request POST \
--data "hello world" \
http://127.0.0.1:8080/invocations
```
Por ejemplo, en el ejemplo siguiente se muestra el resultado.
```
{"prediction": "a", "text": "hello world"}
```
Con estos dos puntos finales HTTP funcionando, la imagen de inferencia ahora es compatible con la IA. SageMaker
**nota**
El modelo de su producto de algoritmo se puede implementar de dos maneras: en tiempo real y por lotes. Para ambas implementaciones, la SageMaker IA utiliza los mismos puntos de enlace HTTP mientras ejecuta el contenedor de Docker.
Para detener el contenedor, ejecute el siguiente comando.
```
sudo docker container stop my-inference-container
```
Una vez que las imágenes de entrenamiento e inferencia del producto de algoritmo estén listas y probadas, continúe con [Carga de las imágenes a Amazon Elastic Container Registry](ml-uploading-your-images.md).
# Carga de las imágenes a Amazon Elastic Container Registry
Después de crear las imágenes de inferencia y entrenamiento, puede cargarlas en Amazon Elastic Container Registry. [Amazon ECR](https://aws.amazon.com/ecr/) es un registro de Docker totalmente gestionado. Amazon SageMaker AI extrae imágenes de Amazon ECR para crear un paquete modelo para realizar inferencias o un algoritmo para tareas de formación. AWS Marketplace también recupera estas imágenes de Amazon ECR para publicar sus productos de algoritmos y paquetes de modelos. En esta sección se proporciona un tutorial para cargar las imágenes de inferencia y entrenamiento en Amazon ECR
**Topics**
+ [¿Qué imágenes debo subir?](#ml-which-images-must-i-upload)
+ [¿Qué permisos de IAM son necesarios?](#ml-what-iam-permissions-are-required)
+ [Inicie sesión en su cliente de Docker AWS](#ml-log-in-your-docker-client)
+ [Crear un repositorio y cargar la imagen](#ml-create-repository-and-upload-image)
+ [Escanea la imagen que ha cargado](#ml-scan-your-uploaded-image)
## ¿Qué imágenes debo subir?
Si va a publicar un paquete modelo, suba solo una imagen de inferencia. Si va a publicar un algoritmo, cargue una imagen de inferencia y una imagen de formación. Si las imágenes de inferencia y de formación están combinadas, cargue la imagen combinada solo una vez.
## ¿Qué permisos de IAM son necesarios?
En los siguientes pasos se parte del supuesto de que la máquina local tiene AWS las credenciales correctas para un rol o usuario AWS Identity and Access Management (IAM) del vendedor. Cuenta de AWS El rol o el usuario deben contar con las políticas correctas tanto AWS Marketplace para Amazon ECR como para Amazon. Por ejemplo, puede usar las siguientes políticas AWS administradas:
+ [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSMarketplaceSellerProductsFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSMarketplaceSellerProductsFullAccess.html)— Para acceder a AWS Marketplace
+ [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ContainerRegistryFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ContainerRegistryFullAccess.html): para acceder a Amazon ECR
**nota**
Los enlaces lo llevan a la *Referencia de políticas administradas de AWS *.
## Inicie sesión en su cliente de Docker AWS
Defina una variable para la Región de AWS que desee publicar (consulte[Compatible con Regiones de AWS la publicación](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing)). Para este ejemplo, use la región Este de EE. UU. (Ohio).
```
region=us-east-2
```
Ejecuta el siguiente comando para establecer una variable con tu Cuenta de AWS ID. En este ejemplo se supone que las credenciales actuales AWS Command Line Interface (AWS CLI) pertenecen a las del vendedor Cuenta de AWS.
```
account=$(aws sts get-caller-identity --query Account --output text)
```
Para autenticar su cliente CLI de Docker con el registro de Docker de Cuenta de AWS Amazon ECR de su región, ejecute el siguiente comando.
```
aws ecr get-login-password \
--region ${region} \
| sudo docker login \
--username AWS \
--password-stdin \
${account}.dkr.ecr.${region}.amazonaws.com
```
## Crear un repositorio y cargar la imagen
Establezca una variable para la etiqueta de la imagen cargada y otra variable para el nombre del repositorio de imágenes cargado.
```
image=my-inference-image
repo=my-inference-image
```
**nota**
En las secciones anteriores de esta guía, en las que se crearon las imágenes de inferencia y entrenamiento, se etiquetaron como y, respectivamente. **my-inference-image**my-training-image**** Para este ejemplo, cree y cargue la imagen de inferencia en un repositorio con el mismo nombre.
Ejecute el siguiente comando para crear un repositorio de imágenes en Amazon ECR.
```
aws ecr --region ${region} create-repository --repository-name "${repo}"
```
El nombre completo de la ubicación del repositorio de Amazon ECR se compone de las siguientes partes: ` .dkr.ecr..amazonaws.com/`
Para enviar la imagen al repositorio, debe etiquetarla con el nombre completo de la ubicación del repositorio.
Establezca una variable para el nombre completo de la ubicación del repositorio de imágenes junto con la etiqueta `latest`.
```
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${repo}:latest"
```
Etiquete la imagen con el nombre completo.
```
sudo docker tag ${image} ${fullname}
```
Por último, inserte la imagen de inferencia en el repositorio de Amazon ECR.
```
sudo docker push ${fullname}
```
Una vez finalizada la carga, la imagen aparece en la [lista de repositorios de la consola de Amazon ECR](https://console.aws.amazon.com/ecr/repositories?region=us-east-2) en la región desde la que está publicando. En el ejemplo anterior, la imagen se envió a un repositorio en la región Este de EE. UU. (Ohio).
## Escanea la imagen que ha cargado
En la [consola de Amazon ECR](https://console.aws.amazon.com/ecr/repositories?region=us-east-2), elija el repositorio desde el Región de AWS que va a publicar y abra el repositorio en el que se cargó la imagen. Seleccione la imagen cargada e inicie un análisis para comprobar si hay vulnerabilidades conocidas. AWS Marketplace comprueba los resultados del escaneo de Amazon ECR de las imágenes del contenedor utilizadas en tu recurso de Amazon SageMaker AI antes de publicarlo. Antes de poder crear su producto, debe corregir las imágenes de los contenedores que tengan vulnerabilidades de gravedad Crítica o Alta.
Una vez que las imágenes se hayan escaneado correctamente, se pueden utilizar para crear un paquete modelo o un recurso de algoritmo.
Si cree que su producto contiene errores en el escaneo que son falsos positivos, póngase en contacto con el equipo de [operaciones de vendedores de AWS Marketplace](https://aws.amazon.com/marketplace/management/contact-us) para informar sobre el error.
**Pasos siguientes**
+ Consulte los límites de tamaño en [Requisitos y prácticas recomendadas para crear productos de machine learning](ml-listing-requirements-and-best-practices.md)
+ Continuar con [Cómo crear tu recurso de Amazon SageMaker AI](ml-creating-your-amazon-sagemaker-resource.md)
# Cómo crear tu recurso de Amazon SageMaker AI
Para publicar un paquete de modelos o un producto de algoritmos, debe crear el recurso de [paquete de modelo o recurso](https://docs.aws.amazon.com/marketplace/latest/userguide/ml-creating-your-amazon-sagemaker-resource.html#ml-creating-your-model-package-product) de [algoritmo](https://docs.aws.amazon.com/marketplace/latest/userguide/ml-creating-your-amazon-sagemaker-resource.html#ml-creating-your-algorithm-product) correspondiente en Amazon SageMaker AI. Al crear el recurso para un producto de AWS Marketplace , debe certificarse mediante un paso de validación. El paso de validación requiere que proporcione datos para probar el paquete de modelos o el recurso de algoritmo antes de que se pueda publicar. En las siguientes secciones, se muestra cómo crear un recurso de SageMaker IA, ya sea un recurso de paquete de modelo o un recurso de algoritmo. Esto incluye establecer las especificaciones de validación que indican a la SageMaker IA cómo realizar la validación.
**nota**
Si aún no ha creado las imágenes de su producto y las ha subido a Amazon Elastic Container Registry (Amazon ECR), consulte [Empaquetar su código en imágenes para productos de aprendizaje automático en AWS Marketplace](ml-packaging-your-code-into-images.md) y [Carga de las imágenes a Amazon Elastic Container Registry](ml-uploading-your-images.md) para obtener información sobre cómo hacerlo.
**Topics**
+ [Creación de su paquete de modelos](#ml-creating-your-model-package-product)
+ [Creación de un algoritmo](#ml-creating-your-algorithm-product)
## Creación de su paquete de modelos
Los siguientes son requisitos para crear un paquete de modelos para AWS Marketplace:
+ Una imagen de inferencia almacenada en [Amazon ECR](https://aws.amazon.com/ecr/)
+ (Opcional) Artefactos del modelo, almacenados por separado en [Amazon S3](https://aws.amazon.com/s3/)
+ Los datos de prueba utilizados para realizar inferencias y almacenados en Amazon Simple Storage Service.
**nota**
A continuación, se aborda la creación de un producto de paquete de modelos. Para obtener más información sobre los paquetes de modelos en SageMaker AI, consulte [Create a Model Package Resource](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-mkt-create-model-package.html).
### Creación de los recursos del paquete de modelos
Los siguientes procedimientos le guiarán en la creación de los recursos del paquete de modelos.
**Paso 1: Crear los recursos del paquete de modelos**
1. Abre la [consola Amazon SageMaker AI](https://us-east-2.console.aws.amazon.com/sagemaker/home).
1. Comprueba que te encuentras en la AWS región desde la que quieres publicar consultando la parte superior derecha de la página. Para publicar, consulte la sección [Compatible con Regiones de AWS la publicación](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing). La imagen de inferencia que cargó en Amazon ECR en los pasos anteriores debe estar en la misma región.
1. En el menú de navegación izquierdo, elija **Paquetes de modelos**.
1. Seleccione **Create model package (Crear paquete de modelos)**.
Tras crear el paquete, debe establecer las especificaciones del paquete de inferencia.
**Paso 2: Establecer las especificaciones de inferencia**
1. Proporcione un **nombre** para el paquete modelo (por ejemplo,*my-model-package*).
1. En **Ubicación de la imagen de inferencia**, introduzca el URI de la imagen de inferencia que se cargó en Amazon ECR. Para recuperar el URI, busque la imagen en la [consola de Amazon ECR](https://us-east-2.console.aws.amazon.com/ecr/repositories).
1. Si los artefactos del modelo del entrenamiento se incluyen con la lógica en la imagen de inferencia, deje en blanco el campo **Ubicación de los artefactos de datos del modelo**. De lo contrario, especifique la ubicación completa en Amazon S3 del archivo comprimido (.tar.gz) de los artefactos del modelo.
1. En el cuadro desplegable, elija los tipos de instancia compatibles de la imagen de inferencia para los trabajos de inferencia en tiempo real (también denominados *puntos de conexión*) y de transformación por lotes.
1. Elija **Siguiente**.
Antes de poder crear y publicar el paquete de modelos, es necesario validarlo para garantizar que funcione según lo esperado. Esto requiere que ejecute un trabajo de transformación por lotes con los datos de prueba que proporcione para la inferencia. Las especificaciones de validación indican a SageMaker AI cómo realizar la validación.
**Paso 3: Establecer las especificaciones de validación**
1. Establezca **Publicar este paquete de modelos en AWS Marketplace** **Sí**. Si lo establece en **No**, no podrá publicar este paquete de modelos más adelante. **Si selecciona Sí,** [se certifica el](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-CertifyForMarketplace) paquete modelo AWS Marketplace y se requiere el paso de validación.
1. Si es la primera vez que completa este proceso, elija **Crear un nuevo rol** para el **rol de IAM**. Amazon SageMaker AI utiliza esta función cuando despliega su paquete de modelos. Esto incluye acciones, como extraer imágenes de Amazon ECR y artefactos de Amazon S3. Revise la configuración y elija **Crear rol**. Al crear un rol aquí, se otorgan los permisos descritos en la política de [ AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)IAM al rol que se cree.
1. Edita el **JSON** en el perfil de validación. Para obtener más información sobre los valores permitidos, consulte [TransformJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformJobDefinition.html).
1. `TransformInput.DataSource.S3Uri`: establece el lugar donde se almacenan los datos de las pruebas para la inferencia.
1. `TransformInput.ContentType`: especifique el tipo de contenido de los datos de la prueba (por ejemplo `application/json``text/plain`,`image/png `,, o cualquier otro valor). SageMaker La IA no valida los datos de entrada reales. Este valor se transfiere al punto de conexión HTTP del contenedor en el valor de encabezado `Content-type`.
1. `TransformInput.CompressionType`: se establece en `None` si los datos de prueba para la inferencia en Amazon S3 no están comprimidos.
1. `TransformInput.SplitType`: se establece en `None` para pasar cada objeto en Amazon S3 como un todo a efectos de inferencia.
1. `TransformOutput.S3OutputPath`: se establece en la ubicación en la que se almacena el resultado de la inferencia.
1. `TransformOutput.AssembleWith`: se establece en `None` para generar cada inferencia como objetos independientes en Amazon S3.
1. Seleccione **Create model package (Crear paquete de modelos)**.
SageMaker La IA extrae la imagen de inferencia de Amazon ECR, copia cualquier artefacto en el contenedor de inferencias y ejecuta un trabajo de transformación por lotes utilizando los datos de prueba para la inferencia. Una vez finalizada la validación, el estado cambia a **Completado**.
**nota**
El paso de validación no evalúa la precisión del modelo con los datos de la prueba. El paso de validación comprueba si el contenedor funciona y responde según lo esperado.
Ha terminado de crear los recursos de su producto de modelo. Siga en [Publicar tu producto en AWS Marketplace](ml-publishing-your-product-in-aws-marketplace.md).
## Creación de un algoritmo
Los siguientes son requisitos para crear un algoritmo para AWS Marketplace:
+ Una imagen de inferencia almacenada en Amazon ECR
+ Una imagen de entrenamiento almacenada en Amazon ECR
+ Sus datos de prueba para el entrenamiento, almacenados en Amazon S3
+ Sus datos de prueba para la inferencia, almacenados en Amazon S3
**nota**
En el siguiente tutorial se crea un producto de algoritmo. Para obtener más información, consulte [Crear un recurso de algoritmo](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-mkt-create-algo.html).
### Creación de recursos de algoritmo
Los siguientes procedimientos le guiarán por la creación de los recursos en su paquete de algoritmos.
**Paso 1: Crear los recursos del algoritmo**
1. Abre la [consola Amazon SageMaker AI](https://us-east-2.console.aws.amazon.com/sagemaker/home).
1. Asegúrese de que se encuentra en la AWS región desde la que desea publicar consultando la parte superior derecha de la página (consulte[Compatible con Regiones de AWS la publicación](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing)). La imagen de entrenamiento e inferencia que cargó en Amazon ECR en los pasos anteriores debe estar en esta misma región.
1. En el panel de navegación izquierdo, elija **Algoritmos**.
1. Elija **Create algorithm (Crear algoritmo)**.
Una vez creado el paquete de algoritmos, debe establecer las especificaciones para el entrenamiento y el ajuste del modelo.
**Paso 2: Configurar las especificaciones de entrenamiento y ajuste**
1. Introduce el **nombre del** algoritmo (por ejemplo,*my-algorithm*).
1. En **Imagen de entrenamiento**, pegue la ubicación URI completa de la imagen de entrenamiento que se cargó en Amazon ECR. Para recuperar el URI, busque la imagen en la [consola de Amazon ECR](https://us-east-2.console.aws.amazon.com/ecr/repositories).
1. En el cuadro desplegable, elija los **tipos de instancias de formación compatibles** con la imagen de formación.
1. En la sección **Especificaciones del canal**, agregue un canal para cada conjunto de datos de entrada que admita su algoritmo, hasta 20 canales de fuentes de entrada. Para obtener más información, consulte [Configuración de datos de entrada](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-inputdataconfig).
1. Elija **Siguiente**.
1. Si el algoritmo admite hiperparámetros y el ajuste de hiperparámetros, debe especificar los parámetros de ajuste.
1. Elija **Siguiente**.
**nota**
Se recomienda encarecidamente que el algoritmo admita el ajuste de hiperparámetros y que permita ajustar los parámetros adecuados. Esto permite a los científicos de datos ajustar los modelos para obtener los mejores resultados.
Una vez establecidos los parámetros de ajuste, si los hay, debe establecer las especificaciones de la imagen de inferencia.
**Paso 3: Establecer la especificación de la imagen de inferencia**
1. En **Ubicación de la imagen de inferencia**, pegue el URI de la imagen de inferencia cargada en Amazon ECR. Para recuperar el URI, busque la imagen en la [consola de Amazon ECR](https://us-east-2.console.aws.amazon.com/ecr/repositories).
1. En el cuadro desplegable, elija los tipos de instancia compatibles para su imagen de inferencia, tanto para los trabajos de inferencia en tiempo real (también conocido como *punto de conexión*) como para los de transformación por lotes.
1. Elija **Siguiente**.
Antes de poder crear y publicar el algoritmo, es necesario validarlo para garantizar que funcione según lo esperado. Esto requiere que ejecute un trabajo de entrenamiento con los datos de prueba para el entrenamiento y un trabajo de transformación por lotes con los datos de prueba que proporcione para la inferencia. Las especificaciones de validación indican a SageMaker AI cómo realizar la validación.
**Paso 4: Establecer las especificaciones de validación**
1. Establezca **Publicar este algoritmo en AWS Marketplace** en **Sí**. Si lo establece en **No**, no podrá publicar este algoritmo más adelante. **Si selecciona Sí,** [se certifica el](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAlgorithm.html#sagemaker-CreateAlgorithm-request-CertifyForMarketplace) algoritmo AWS Marketplace y se requiere la especificación de validación.
1. Si es la primera vez que crea un paquete de aprendizaje automático para AWS Marketplace, elija **Crear un nuevo rol para el rol** de **IAM**. Amazon SageMaker AI utiliza esta función cuando entrena el algoritmo y despliega el paquete de modelos subsiguiente. Esto incluye acciones como extraer imágenes de Amazon ECR, almacenar artefactos en Amazon S3 y copiar datos de entrenamiento de Amazon S3. Revise la configuración y elija **Crear rol**. Al crear un rol aquí, se otorgan los permisos descritos en la política de [ AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)IAM al rol que se cree.
1. Edite el archivo **JSON** en el perfil de validación para **Definición de trabajo de entrenamiento.** Para obtener más información sobre los valores permitidos, consulte [ TrainingJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TrainingJobDefinition.html).
1. `InputDataConfig`: en esta matriz JSON, añada un [objeto de canal](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html) para cada canal especificado en el paso de especificación del entrenamiento. Para cada canal, especifique dónde se almacenan los datos de las pruebas para el entrenamiento.
1. `OutputDataConfig`: una vez finalizado el entrenamiento, los artefactos del modelo de la ruta del directorio del contenedor de formación `/opt/ml/model/` se comprimen y se copian en Amazon S3. Especifique la ubicación de Amazon S3 en la que se almacena el archivo comprimido (.tar.gz).
1. Edite el archivo JSON en el perfil de validación para **Definición de trabajo de transformación**. Para obtener más información sobre los valores permitidos, consulte [ TransformJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformJobDefinition.html).
1. `TransformInput.DataSource.S3Uri`: establece el lugar donde se almacenan los datos de las pruebas para la inferencia.
1. `TransformInput.ContentType`: especifique el tipo de contenido de los datos de la prueba. Por ejemplo,`application/json`, `text/plain`, `image/png` o cualquier otro valor. Amazon SageMaker AI no valida los datos de entrada reales. Este valor se transfiere al punto de conexión HTTP del contenedor en el valor de encabezado `Content-type`.
1. `TransformInput.CompressionType`: se establece en `None` si los datos de prueba para la inferencia en Amazon S3 no están comprimidos.
1. `TransformInput.SplitType`: elija cómo quiere dividir los objetos de S3. Por ejemplo, `None` pasa cada objeto en Amazon S3 como un todo a efectos de inferencia. Para obtener más información, consulta [ SplitType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#sagemaker-Type-TransformInput-SplitType)la referencia de la API de Amazon SageMaker AI.
1. `TransformOutput.S3OutputPath`: se establece en la ubicación donde se almacena el resultado de la inferencia.
1. `TransformOutput.AssembleWith`: se establece en `None` para generar cada inferencia como objetos independientes en Amazon S3.
1. Elija **Crear paquete de algoritmos**.
SageMaker La IA extrae la imagen de entrenamiento de Amazon ECR, ejecuta un trabajo de entrenamiento de prueba con sus datos y almacena los artefactos del modelo en Amazon S3. Luego extrae la imagen de inferencia de Amazon ECR, copia cualquier artefacto de Amazon S3 en el contenedor de inferencias y ejecuta un trabajo de transformación por lotes utilizando los datos de prueba para la inferencia. Una vez finalizada la validación, el estado cambia a **Completado**.
**nota**
El paso de validación no evalúa la precisión del entrenamiento o el modelo con los datos de la prueba. El paso de validación comprueba si los contenedores funcionan y responden según lo esperado.
El paso de validación solo valida el procesamiento por lotes. Depende de usted validar que el procesamiento en tiempo real funcione con su producto.
Ha terminado de crear los recursos de su producto de algoritmo. Siga en [Publicar tu producto en AWS Marketplace](ml-publishing-your-product-in-aws-marketplace.md).