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.

Creación de imágenes de paquetes modelo

Un paquete SageMaker modelo de Amazon es un modelo previamente entrenado que hace predicciones y no requiere ninguna formación adicional por parte del comprador. Puedes crear un paquete modelo SageMaker 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.

Información general

Un paquete de modelos incluye los siguientes componentes:

En el siguiente diagrama se muestra el flujo de trabajo para publicar y usar productos de paquetes de modelos.

El flujo de trabajo para crear un paquete de SageMaker modelos AWS Marketplace incluye los siguientes pasos:

Cree una imagen de inferencia para los paquetes modelo

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:

La imagen de inferencia es una imagen de Docker que contiene la lógica de inferencia. En tiempo de ejecución, el contenedor expone HTTP los puntos finales para permitir SageMaker el paso de datos hacia y desde el contenedor.

Paso 1: Crear la imagen del contenedor

Para que la imagen de inferencia sea compatible SageMaker, la imagen de Docker debe exponer HTTP los puntos finales. Mientras el contenedor está en funcionamiento, SageMaker transfiere las entradas del comprador para su inferencia al punto final del contenedor. HTTP Los resultados de la inferencia se devuelven en el cuerpo de la HTTP respuesta.

El siguiente tutorial utiliza el Docker CLI en un entorno de desarrollo que utiliza una distribución de Linux Ubuntu.

Crear el script del servidor web

Este ejemplo usa un servidor de Python llamado Flask, pero puede usar cualquier servidor web que funcione para su marco.

Cree un script de servidor web Flask que sirva a los dos HTTP puntos finales del TCP puerto 8080 que utiliza. SageMaker Los dos puntos de conexión esperados son los siguientes:

./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

Crear el script para la ejecución del contenedor

Cree un script con el nombre serve que SageMaker se ejecute cuando ejecute la imagen del contenedor de Docker. El siguiente script inicia el servidor HTTP web.

./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 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 serve script se agrega al para PATH 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:

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 extraiga y copie 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: Cree y pruebe la imagen localmente

En el contexto de la compilación, ahora existen los siguientes archivos:

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:

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.

Pruebe el HTTP punto final del ping

Cuando SageMaker ejecuta el contenedor, hace ping periódicamente al punto final. Cuando el punto final devuelve una HTTP respuesta con el código de estado 200, indica SageMaker 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

Pruebe el punto final de la inferencia HTTP

Cuando el contenedor indique que está listo devolviendo un código de estado 200 a tu ping, SageMaker pasa los datos de inferencia al /invocations HTTP punto final 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 HTTP puntos finales en funcionamiento, la imagen de inferencia ahora es compatible con ellos. SageMaker

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 tus imágenes a Amazon Elastic Container Registry.