Images d'algorithmes - AWS Marketplace
Création d'une image d'entraînement pour les algorithmes Création d'une image d'inférence pour les algorithmes

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.

Images d'algorithmes

Un SageMaker algorithme Amazon exige que l'acheteur apporte ses propres données pour s'entraîner avant de faire des prédictions.

Un algorithme comprend les composants suivants :

  • Une image d'entraînement stockée dans Amazon ECR

  • Une image d'inférence stockée dans Amazon Elastic Container Registry (Amazon ECR)

Note

Pour les produits d'algorithmes, le conteneur de formation génère des artefacts de modèle qui sont chargés dans le conteneur d'inférence lors du déploiement du modèle.

Le schéma suivant montre le flux de travail pour la publication et l'utilisation de produits algorithmiques.

Schéma illustrant comment un vendeur crée une image de package algorithmique et comment l'acheteur l'utilise.

  1. Le vendeur crée une image de formation et une image d'inférence (aucun accès réseau lors du déploiement) et les télécharge dans le registre Amazon ECR.

  2. Le vendeur crée ensuite une ressource d'algorithme sur Amazon SageMaker et publie son produit ML sur AWS Marketplace.

  3. L'acheteur souscrit au produit ML.

  4. L'acheteur crée une tâche de formation avec un ensemble de données compatible et des valeurs d'hyperparamètres appropriées. SageMaker exécute l'image d'entraînement et charge les données d'entraînement et les hyperparamètres dans le conteneur d'entraînement. Une fois la tâche de formation terminée, les artefacts du modèle qui s'/opt/ml/model/y trouvent sont compressés et copiés dans le compartiment Amazon S3 de l'acheteur.

  5. L'acheteur crée un package modèle avec les artefacts du modèle issus de la formation stockés dans Amazon S3 et déploie le modèle.

  6. SageMaker exécute l'image d'inférence, extrait les artefacts du modèle compressé et charge les fichiers dans le chemin du répertoire du conteneur d'inférence /opt/ml/model/ où ils sont consommés par le code servant à l'inférence.

  7. Que le modèle soit déployé en tant que point de terminaison ou en tant que tâche de transformation par lots, il SageMaker transmet les données à des fins d'inférence pour le compte de l'acheteur au conteneur via le point de terminaison HTTP du conteneur et renvoie les résultats de la prédiction.

Note

Pour plus d'informations, consultez la section Modèles de train.

Création d'une image d'entraînement pour les algorithmes

Cette section fournit une procédure pas à pas pour intégrer votre code d'entraînement dans une image d'entraînement. Une image d'apprentissage est requise pour créer un produit algorithmique.

Une image d'entraînement est une image Docker contenant votre algorithme d'entraînement. Le conteneur adhère à une structure de fichier spécifique pour permettre SageMaker de copier des données vers et depuis votre conteneur.

Les images d'apprentissage et d'inférence sont requises lors de la publication d'un produit algorithmique. Après avoir créé votre image d'entraînement, vous devez créer une image d'inférence. Les deux images peuvent être combinées en une seule image ou rester sous forme d'images distinctes. C'est à vous de décider de combiner les images ou de les séparer. En général, l'inférence est plus simple que l'entraînement, et vous pouvez avoir besoin d'images distinctes pour améliorer les performances d'inférence.

Note

Ce qui suit n'est qu'un exemple de code d'emballage pour une image d'entraînement. Pour plus d'informations, consultez la section Utiliser vos propres algorithmes AWS Marketplace et modèles avec les AWS Marketplace SageMaker exemples ci-dessous GitHub.

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

Pour que l'image d'entraînement soit compatible avec Amazon SageMaker, elle doit respecter une structure de fichier spécifique afin de SageMaker permettre de copier les données de formation et les entrées de configuration vers des chemins spécifiques de votre conteneur. Lorsque la formation est terminée, les artefacts du modèle générés sont stockés dans un chemin de répertoire spécifique dans le conteneur d'où SageMaker proviennent les copies.

Ce qui suit utilise la CLI Docker installée dans un environnement de développement sur une distribution Ubuntu de Linux.

Préparez votre programme pour lire les entrées de configuration

Si votre programme de formation nécessite des entrées de configuration fournies par l'acheteur, celles-ci sont copiées ci-dessous dans votre conteneur lors de leur exécution. Le cas échéant, votre programme doit lire à partir de ces chemins de fichiers spécifiques.

  • /opt/ml/input/configest le répertoire qui contient les informations qui contrôlent le mode d'exécution de votre programme.

Note

Pour plus d'informations sur les entrées de configuration, consultez Comment Amazon SageMaker fournit des informations de formation.

Préparez votre programme pour lire les entrées de données

Les données d'entraînement peuvent être transmises au conteneur dans l'un des deux modes suivants. Votre programme d'entraînement qui s'exécute dans le conteneur digère les données d'entraînement dans l'un de ces deux modes.

Mode fichier

  • /opt/ml/input/data/<channel_name>/contient les données d'entrée pour ce canal. Les canaux sont créés en fonction de l'appel à l'CreateTrainingJobopération, mais il est généralement important que les canaux correspondent aux attentes de l'algorithme. Les fichiers de chaque canal sont copiés depuis Amazon S3 vers ce répertoire, en préservant la structure arborescente indiquée par la structure clé d'Amazon S3.

Mode tuyau

  • /opt/ml/input/data/<channel_name>_<epoch_number>est le tube pour une époque donnée. Les époques commencent à zéro et augmentent d'un à chaque fois que vous les lisez. Il n'y a pas de limite au nombre d'époques que vous pouvez exécuter, mais vous devez fermer chaque tube avant de lire l'époque suivante.

Préparez votre programme pour rédiger des résultats de formation

Le résultat de la formation est écrit dans les répertoires de conteneurs suivants :

  • /opt/ml/model/est le répertoire dans lequel vous écrivez le modèle ou les artefacts du modèle générés par votre algorithme d'apprentissage. Votre modèle peut être dans le format de votre choix. Il peut s'agir d'un seul fichier ou d'une arborescence de répertoires complète. SageMaker regroupe tous les fichiers de ce répertoire dans un fichier compressé (.tar.gz). Ce fichier est disponible à l'emplacement Amazon S3 renvoyé par l'opération DescribeTrainingJob d'API.

  • /opt/ml/output/est un répertoire dans lequel l'algorithme peut écrire un failure fichier décrivant les raisons de l'échec de la tâche. Le contenu de ce fichier est renvoyé dans le FailureReason champ du DescribeTrainingJob résultat. Pour les tâches qui réussissent, il n'y a aucune raison d'écrire ce fichier car il est ignoré.

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

Créez un script train shell qui SageMaker s'exécute lorsqu'il exécute l'image du conteneur Docker. Lorsque la formation est terminée et que les artefacts du modèle sont écrits dans leurs répertoires respectifs, quittez le script.

./train 

#!/bin/bash

# Run your training program here
#
#
#
#

Créer le Dockerfile

Créez un Dockerfile dans votre contexte de construction. Cet exemple utilise Ubuntu 18.04 comme image de base, mais vous pouvez commencer à partir de n'importe quelle image de base adaptée à votre infrastructure.

./Dockerfile 

FROM ubuntu:18.04

# Add training dependencies and programs
#
#
#
#
#
# Add a script that SageMaker 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}

DockerfileAjoute le train script créé précédemment à l'image. Le répertoire du script est ajouté au PATH afin qu'il puisse s'exécuter lorsque le conteneur s'exécute.

Dans l'exemple précédent, il n'existe pas de véritable logique d'entraînement. Pour votre image d'entraînement réelle, ajoutez les dépendances d'entraînement au et ajoutez la Dockerfile logique permettant de lire les entrées d'entraînement afin d'entraîner et de générer les artefacts du modèle.

Votre image d'entraînement doit contenir toutes les dépendances requises, car elle n'aura pas accès à Internet.

Pour plus d'informations, consultez la section Utiliser vos propres algorithmes AWS Marketplace et modèles avec les AWS Marketplace SageMaker exemples ci-dessous GitHub.

Étape 2 : Création et test de l'image localement

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

  • ./Dockerfile

  • ./train

  • Vos dépendances et votre logique d'entraînement

Vous pouvez ensuite créer, exécuter et tester cette image de 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-training-image. 

sudo docker build --tag my-training-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 l'opération terminée, vous devriez voir quelque chose de similaire à ce qui suit. 

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

Exécuter localement

Une fois cette opération terminée, testez l'image localement, comme indiqué dans l'exemple suivant. 

sudo docker run \
  --rm \
  --volume '<path_to_input>:/opt/ml/input:ro' \
  --volume '<path_to_model>:/opt/ml/model' \
  --volume '<path_to_output>:/opt/ml/output' \
  --name my-training-container \
  my-training-image \
  train

Les détails de la commande sont les suivants :

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

  • --volume '<path_to_input>:/opt/ml/input:ro'— Rend le répertoire d'entrée de test disponible pour le conteneur en lecture seule.

  • --volume '<path_to_model>:/opt/ml/model'— Fixez le chemin où les artefacts du modèle sont stockés sur la machine hôte une fois le test d'entraînement terminé.

  • --volume '<path_to_output>:/opt/ml/output'— Lind mount le chemin où la raison de l'échec d'un failure fichier est écrite sur la machine hôte.

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

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

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

Après avoir exécuté cette commande, Docker crée un conteneur à partir de l'image d'entraînement que vous avez créée et l'exécute. Le conteneur exécute le train script, qui démarre votre programme d'entraînement.

Une fois que votre programme d'entraînement est terminé et que le conteneur est sorti, vérifiez que les artefacts du modèle de sortie sont corrects. En outre, vérifiez les résultats des journaux pour vous assurer qu'ils ne produisent pas des journaux indésirables, tout en vous assurant que suffisamment d'informations sont fournies sur le poste de formation.

Ceci termine le packaging de votre code d'entraînement pour un produit algorithmique. Étant donné qu'un produit algorithmique inclut également une image d'inférence, passez à la section suivante, Création d'une image d'inférence pour les algorithmes.

Création d'une image d'inférence pour les algorithmes

Cette section fournit une procédure pas à pas pour intégrer votre code d'inférence dans une image d'inférence pour votre produit algorithmique.

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 points de terminaison HTTP pour SageMaker permettre le transfert de données vers et depuis votre conteneur.

Les images d'apprentissage et d'inférence sont requises lors de la publication d'un produit algorithmique. Si ce n'est pas déjà fait, consultez la section précédente à propos deCréation d'une image d'entraînement pour les algorithmes. Les deux images peuvent être combinées en une seule image ou rester sous forme d'images distinctes. C'est à vous de décider de combiner les images ou de les séparer. En général, l'inférence est plus simple que l'entraînement, et vous pouvez avoir besoin d'images distinctes pour améliorer les performances d'inférence.

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 Utiliser vos propres algorithmes AWS Marketplace et modèles avec 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 d'inférence

Pour que l'image d'inférence soit compatible avec SageMaker, l'image Docker doit exposer les points de terminaison HTTP. Pendant le fonctionnement de votre conteneur, SageMaker transmet les entrées à des fins d'inférence fournies par l'acheteur au point de terminaison HTTP de votre conteneur. Le résultat de l'inférence est renvoyé dans le corps de la réponse HTTP.

Ce qui suit utilise la CLI Docker installée dans un environnement de développement sur une distribution Ubuntu de Linux.

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 le script du serveur Web Flask qui dessert les deux points de terminaison HTTP sur le port TCP 8080 utilisé. SageMaker Les deux paramètres attendus sont les suivants :

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

  • /invocations— envoie SageMaker des requêtes HTTP POST à ce point de terminaison à des fins d'inférence. 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'en-tête HTTP. Le corps de la réponse est le résultat d'inférence.

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

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.

Votre image d'inférence doit contenir toutes les dépendances requises car elle n'aura pas accès à Internet.

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. Dans ce script, démarrez le serveur Web HTTP.

./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 commencer à 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 PATH afin qu'il puisse s'exécuter lorsque le conteneur s'exécute.

Préparation de votre programme pour le chargement dynamique des artefacts du modèle

Pour les produits algorithmiques, l'acheteur utilise ses propres ensembles de données avec votre image d'apprentissage pour générer des artefacts de modèle uniques. Lorsque le processus de formation est terminé, votre conteneur de formation génère les artefacts du modèle dans le répertoire des conteneurs /opt/ml/model/. SageMaker compresse le contenu de ce répertoire dans un fichier .tar.gz et le stocke dans le répertoire de l'acheteur sur Compte AWS Amazon S3.

Lorsque le modèle est déployé, SageMaker exécute votre image d'inférence, extrait les artefacts du modèle du fichier .tar.gz stocké dans le compte de l'acheteur sur Amazon S3 et les charge dans le conteneur d'inférence du répertoire. /opt/ml/model/ Au moment de l'exécution, le code de votre conteneur d'inférence utilise les données du modèle.

Note

Pour protéger toute propriété intellectuelle susceptible d'être contenue dans les fichiers d'artefacts modèles, vous pouvez choisir de chiffrer les fichiers avant de les générer. Pour plus d’informations, consultez Sécurité et propriété intellectuelle.

Étape 2 : Création et test de l'image localement

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

  • ./Dockerfile

  • ./web_app_serve.py

  • ./serve

Vous pouvez ensuite créer, exécuter et tester cette image de conteneur.

Construisez l'image

Exécutez la commande Docker 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 l'opération terminée, 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 \
  --volume '<path_to_model>:/opt/ml/model:ro' \
  --detach \
  --name my-inference-container \
  my-inference-image \
  serve

Les détails de la commande sont les suivants :

  • --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 il SageMaker envoie des requêtes HTTP.

  • --volume '<path_to_model>:/opt/ml/model:ro'— Fixez le chemin vers lequel les artefacts du modèle de test sont stockés sur la machine hôte en lecture seule afin de les mettre à la disposition de votre code d'inférence dans le conteneur.

  • --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— SageMaker Exécute le même script que 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 et l'exécute en arrière-plan. Le conteneur exécute le serve script, qui démarre votre serveur Web à des fins de test.

Testez le point de terminaison HTTP 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 réponse HTTP avec le code d'état 200, il indique SageMaker que le conteneur est prêt pour l'inférence.

Exécutez la commande suivante pour tester le point de terminaison et inclure l'en-tête de réponse. 

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

Un exemple de sortie est illustré dans l'exemple 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 HTTP d'inférence

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

Exécutez la commande suivante pour tester le point de terminaison d'inférence. 

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

Un exemple de sortie est illustré dans l'exemple suivant. 

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

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

Note

Le modèle de votre produit algorithmique peut être déployé de deux manières : en temps réel et par lots. Pour les deux déploiements, SageMaker utilise les mêmes points de terminaison HTTP 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

Une fois que vos images d'entraînement et d'inférence pour votre produit algorithmique sont prêtes et testées, continuez. Téléchargement de vos images