Création d'images de packages modèles - AWS Marketplace
PrésentationCréation d'une image d'inférence pour les packages modèles

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Création d'images de packages modèles

Un SageMaker modèle de package Amazon est un modèle préentraîné qui établit des prévisions et ne nécessite aucune formation supplémentaire de la part de l'acheteur. Vous pouvez créer un package modèle dans SageMaker et publier votre produit d'apprentissage automatique sur AWS Marketplace. Les sections suivantes expliquent comment créer un modèle de package pour AWS Marketplace. Cela inclut la création de l'image du conteneur ainsi que la création et le test de l'image localement.

Présentation

Un modèle de package inclut les composants suivants :

Note

Les artefacts du modèle sont des fichiers que votre modèle utilise pour faire des prédictions et sont généralement le résultat de vos propres processus de formation. Les artefacts peuvent être n'importe quel type de fichier requis par votre modèle, mais ils doivent être compressés par use.tar.gz. Pour les modèles de packages, ils peuvent être regroupés dans votre image d'inférence ou stockés séparément sur Amazon. SageMaker Les artefacts du modèle stockés dans Amazon S3 sont chargés dans le conteneur d'inférence lors de l'exécution. Lorsque vous publiez votre modèle de package, ces artefacts sont publiés et stockés dans des compartiments Amazon S3 AWS Marketplace détenus, auxquels l'acheteur ne peut accéder directement.

Astuce

Si votre modèle d'inférence est construit avec un framework d'apprentissage profond tel que Gluon, Keras,,,MXNet, TensorFlow -Lite PyTorch TensorFlow, ou ONNX envisagez d'utiliser Amazon Neo. SageMaker Neo peut optimiser automatiquement les modèles d'inférence déployés sur une famille spécifique de types d'instances cloud tels queml.c4,ml.p2, et autres. Pour plus d'informations, consultez Optimiser les performances des modèles à l'aide de Neo dans le manuel Amazon SageMaker Developer Guide.

Le schéma suivant montre le flux de travail pour la publication et l'utilisation de modèles de packages.

Schéma illustrant comment un vendeur crée une image de colis modèle et comment l'acheteur l'utilise.

Le processus de création d'un SageMaker modèle de package pour AWS Marketplace inclut les étapes suivantes :

  1. Le vendeur crée une image d'inférence (aucun accès au réseau lors du déploiement) et l'envoie dans le registre AmazonECR.

    Les artefacts du modèle peuvent être regroupés dans l'image d'inférence ou stockés séparément dans S3.

  2. Le vendeur crée ensuite une ressource de package modèle sur Amazon SageMaker et publie son produit ML sur AWS Marketplace.

  3. L'acheteur souscrit au produit ML et déploie le modèle.

    Note

    Le modèle peut être déployé en tant que point de terminaison pour des inférences en temps réel ou en tant que traitement par lots pour obtenir des prédictions pour un ensemble de données complet en une seule fois. Pour plus d'informations, voir Déployer des modèles pour l'inférence.

  4. SageMaker exécute l'image d'inférence. Tous les artefacts de modèle fournis par le vendeur qui ne sont pas regroupés dans l'image d'inférence sont chargés dynamiquement lors de l'exécution.

  5. SageMaker transmet les données d'inférence de l'acheteur au conteneur en utilisant les HTTP points de terminaison du conteneur et renvoie les résultats de la prédiction.

Création d'une image d'inférence pour les packages modèles

Cette section fournit une procédure pas à pas pour intégrer votre code d'inférence dans une image d'inférence pour votre modèle de produit. Le processus comprend les étapes suivantes :

L'image d'inférence est une image Docker contenant votre logique d'inférence. Au moment de l'exécution, le conteneur expose les HTTP points de terminaison pour SageMaker permettre le transfert de données vers et depuis votre conteneur.

Note

Ce qui suit n'est qu'un exemple de code d'emballage pour une image d'inférence. Pour plus d'informations, consultez la section Utilisation de conteneurs Docker avec SageMaker et les AWS Marketplace SageMaker exemples ci-dessous. GitHub

L'exemple suivant utilise un service Web, Flask, pour des raisons de simplicité, et n'est pas considéré comme prêt pour la production.

Étape 1 : Création de l'image du conteneur

Pour que l'image d'inférence soit compatible avec SageMaker, l'image Docker doit exposer HTTP les points de terminaison. Pendant que votre conteneur fonctionne, SageMaker transmet les données de l'acheteur à des fins d'inférence au HTTP terminal du conteneur. Les résultats de l'inférence sont renvoyés dans le corps de la HTTP réponse.

La procédure pas à pas suivante utilise le Docker CLI dans un environnement de développement utilisant une distribution Linux Ubuntu.

Création du script du serveur Web

Cet exemple utilise un serveur Python appelé Flask, mais vous pouvez utiliser n'importe quel serveur Web adapté à votre framework.

Note

Le flacon est utilisé ici pour des raisons de simplicité. Il n'est pas considéré comme un serveur Web prêt pour la production.

Créez un script de serveur Web Flask qui dessert les deux HTTP points de terminaison du TCP port 8080 qui l'utilise. SageMaker Les deux paramètres attendus sont les suivants :

  • /ping— SageMaker envoie des HTTP GET demandes à ce point de terminaison pour vérifier si votre conteneur est prêt. Lorsque votre conteneur est prêt, il répond aux HTTP GET demandes de ce point de terminaison avec un code de réponse HTTP 200.

  • /invocations— envoie SageMaker des HTTP POST demandes d'inférence à ce point de terminaison. Les données d'entrée à des fins d'inférence sont envoyées dans le corps de la demande. Le type de contenu spécifié par l'utilisateur est transmis dans l'HTTPen-tête. Le corps de la réponse est le résultat d'inférence. Pour plus de détails sur les délais d'expiration, consultezExigences et meilleures pratiques pour créer des produits d'apprentissage automatique.

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

Dans l'exemple précédent, il n'existe aucune logique d'inférence réelle. Pour votre image d'inférence réelle, ajoutez la logique d'inférence dans l'application Web afin qu'elle traite l'entrée et renvoie la prédiction réelle.

Votre image d'inférence doit contenir toutes les dépendances requises, car elle n'aura pas accès à Internet et ne pourra pas passer d'appels vers aucune Services AWS d'entre elles.

Note

Ce même code est utilisé pour les inférences en temps réel et par lots

Créez le script pour l'exécution du conteneur

Créez un script nommé serve qui SageMaker s'exécute lorsqu'il exécute l'image du conteneur Docker. Le script suivant démarre le serveur HTTP Web.

./serve 

#!/bin/bash

# Run flask server on port 8080 for SageMaker
flask run --host 0.0.0.0 --port 8080

Créer le Dockerfile

Créez un Dockerfile dans votre contexte de construction. Cet exemple utilise Ubuntu 18.04, mais vous pouvez partir de n'importe quelle image de base adaptée à votre 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}

DockerfileAjoute les deux scripts créés précédemment à l'image. Le répertoire du serve script est ajouté au afin qu'il PATH puisse s'exécuter lors de l'exécution du conteneur.

Package ou téléchargement des artefacts du modèle

Les deux manières de fournir les artefacts du modèle depuis l'entraînement du modèle jusqu'à l'image d'inférence sont les suivantes :

  • Emballé statiquement avec l'image d'inférence.

  • Chargé dynamiquement au moment de l'exécution. Comme elle est chargée dynamiquement, vous pouvez utiliser la même image pour empaqueter différents modèles de machine learning.

Si vous souhaitez empaqueter les artefacts de votre modèle avec l'image d'inférence, incluez-les dans leDockerfile.

Si vous souhaitez charger les artefacts de votre modèle de manière dynamique, stockez-les séparément dans un fichier compressé (.tar.gz) dans Amazon S3. Lors de la création du package modèle, spécifiez l'emplacement du fichier compressé, puis SageMaker extrayez et copiez le contenu dans le répertoire du conteneur /opt/ml/model/ lors de l'exécution de votre conteneur. Lorsque vous publiez votre modèle de package, ces artefacts sont publiés et stockés dans des compartiments Amazon S3 AWS Marketplace détenus, auxquels l'acheteur ne peut accéder directement.

Étape 2 : créer et tester l'image localement

Dans le contexte de construction, les fichiers suivants existent désormais :

  • ./Dockerfile

  • ./web_app_serve.py

  • ./serve

  • Votre logique d'inférence et vos dépendances (facultatives)

Créez, exécutez et testez ensuite l'image du conteneur.

Construisez l'image

Exécutez la commande Docker dans le contexte de construction pour créer et étiqueter l'image. Cet exemple utilise la balisemy-inference-image. 

sudo docker build --tag my-inference-image ./

Après avoir exécuté cette commande Docker pour créer l'image, vous devriez voir une sortie car Docker crée l'image en fonction de chaque ligne de votre. Dockerfile Une fois terminé, vous devriez voir quelque chose de similaire à ce qui suit. 

Successfully built abcdef123456
Successfully tagged my-inference-image:latest

Exécuter localement

Une fois votre compilation terminée, vous pouvez tester l'image localement. 

sudo docker run \
  --rm \
  --publish 8080:8080/tcp \
  --detach \
  --name my-inference-container \
  my-inference-image \
  serve

Vous trouverez ci-dessous des informations sur la commande :

  • --rm— Retirez automatiquement le contenant une fois qu'il s'est arrêté.

  • --publish 8080:8080/tcp— Exposez le port 8080 pour simuler le port auquel les HTTP demandes sont SageMaker envoyées.

  • --detach— Lancez le conteneur en arrière-plan.

  • --name my-inference-container— Donnez un nom à ce conteneur en cours d'exécution.

  • my-inference-image— Exécute l'image créée.

  • serve— Exécute le même script que celui SageMaker exécuté lors de l'exécution du conteneur.

Après avoir exécuté cette commande, Docker crée un conteneur à partir de l'image d'inférence que vous avez créée et l'exécute en arrière-plan. Le conteneur exécute le serve script, qui lance votre serveur Web à des fins de test.

Testez le point de HTTP terminaison ping

Lorsque votre conteneur SageMaker exécute, il envoie régulièrement un ping au point de terminaison. Lorsque le point de terminaison renvoie une HTTP réponse avec le code d'état 200, il indique SageMaker que le conteneur est prêt pour l'inférence. Vous pouvez le tester en exécutant la commande suivante, qui teste le point de terminaison et inclut l'en-tête de réponse. 

curl --include http://127.0.0.1:8080/ping

L'exemple de sortie est le suivant.

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

Tester le point de terminaison d'inférence HTTP

Lorsque le conteneur indique qu'il est prêt en renvoyant un code d'état 200 à votre ping, il SageMaker transmet les données d'inférence au /invocations HTTP point de terminaison via une POST demande. Testez le point d'inférence en exécutant la commande suivante. 

curl \
  --request POST \
  --data "hello world" \
  http://127.0.0.1:8080/invocations

L'exemple de sortie est le suivant.

{"prediction": "a", "text": "hello world"}

Ces deux HTTP points de terminaison fonctionnant, l'image d'inférence est désormais compatible avec. SageMaker

Note

Le modèle de votre modèle de package peut être déployé de deux manières : en temps réel et par lots. Dans les deux déploiements, SageMaker utilise les mêmes HTTP points de terminaison lors de l'exécution du conteneur Docker.

Pour arrêter le conteneur, exécutez la commande suivante.

sudo docker container stop my-inference-container

Lorsque votre image d'inférence est prête et testée, vous pouvez continuerTéléchargement de vos images sur Amazon Elastic Container Registry.