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.
# Préparation de votre produit grâce à l' SageMaker IA
Avant de pouvoir publier votre produit dans AWS Marketplace, vous devez le préparer dans Amazon SageMaker AI. Il existe deux types de produits d' SageMaker intelligence artificielle répertoriés dans AWS Marketplace : les packages de modèles et les algorithmes. Pour de plus amples informations, veuillez consulter [Produits d'apprentissage automatique dans AWS Marketplace](machine-learning-products.md). Cette rubrique fournit un aperçu des trois étapes nécessaires à la préparation de votre produit :
1. [Regrouper votre code sous forme d'images pour les produits d'apprentissage automatique dans AWS Marketplace](ml-packaging-your-code-into-images.md)— Pour préparer un package modèle ou un produit algorithmique, vous devez créer les images du conteneur Docker pour votre produit.
1. [Téléchargement de vos images sur Amazon Elastic Container Registry](ml-uploading-your-images.md)— Après avoir empaqueté votre code dans des images de conteneur et les avoir testées localement, téléchargez les images et scannez-les pour détecter les vulnérabilités connues. Corrigez les vulnérabilités éventuelles avant de continuer.
1. [Création de votre ressource Amazon SageMaker AI](ml-creating-your-amazon-sagemaker-resource.md)— Une fois vos images numérisées avec succès, vous pouvez les utiliser pour créer un package de modèles ou une ressource d'algorithme dans SageMaker AI.
# Regrouper votre code sous forme d'images pour les produits d'apprentissage automatique dans AWS Marketplace
Les produits de machine learning AWS Marketplace utilisent Amazon SageMaker AI pour créer et exécuter la logique d'apprentissage automatique que vous proposez aux acheteurs. SageMaker L'IA exécute des images de conteneurs Docker qui contiennent votre logique. SageMaker L'IA gère ces conteneurs dans une infrastructure sécurisée et évolutive. Pour de plus amples informations, veuillez consulter [Sécurité et propriété intellectuelle avec Amazon SageMaker AI](ml-security-and-intellectual-property.md). Les sections suivantes fournissent des informations sur la façon d'empaqueter votre code dans des images de conteneur Docker pour l' SageMaker IA.
**Topics**
+ [Quel type d'image de conteneur dois-je créer ?](#ml-which-type-of-container-image-do-i-create)
+ [Création d'images de paquets-modèles](ml-model-package-images.md)
+ [Création d'images d'algorithmes](ml-algorithm-images.md)
## Quel type d'image de conteneur dois-je créer ?
Les deux types d'images de conteneur sont une image d'inférence et une image d'apprentissage.
Pour créer un produit d'emballage modèle, vous n'avez besoin que d'une image d'inférence. Pour obtenir des instructions complètes, consultez [Création d'images de paquets-modèles](ml-model-package-images.md).
Pour créer un produit algorithmique, vous avez besoin à la fois d'images d'entraînement et d'inférence. Pour obtenir des instructions complètes, consultez [Création d'images d'algorithmes](ml-algorithm-images.md).
Pour empaqueter correctement le code dans une image de conteneur, le conteneur doit respecter la structure du fichier SageMaker AI. Le conteneur doit exposer les points de terminaison appropriés pour garantir que le service puisse transmettre des données vers et depuis votre conteneur. Les sections suivantes expliquent les détails de ce processus.
**Important**
Pour des raisons de sécurité, lorsqu'un acheteur s'abonne à votre produit conteneurisé, les conteneurs Docker s'exécutent dans un environnement isolé sans connexion Internet. Lorsque vous créez vos conteneurs, ne vous fiez pas aux appels sortants sur Internet, car ils échoueront. Les appels vers Services AWS échoueront également. Pour plus d’informations, consultez la section [Sécurité et propriété intellectuelle avec Amazon SageMaker AI](ml-security-and-intellectual-property.md).
Si vous le souhaitez, lorsque vous créez vos images d'inférence et d'entraînement, utilisez un conteneur d'[Available Deep Learning Containers Images](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/) comme point de départ. Les images sont déjà correctement emballées avec différents frameworks d'apprentissage automatique.
# Création d'images de paquets-modèles
Un package de modèles Amazon SageMaker AI est un modèle préentraîné qui fait des prédictions et ne nécessite aucune formation supplémentaire de la part de l'acheteur. Vous pouvez créer un package modèle dans SageMaker AI 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.
**Topics**
+ [Présentation de](#ml-model-package-images-overview)
+ [Création d'une image d'inférence pour les packages modèles](#ml-creating-an-inference-image-for-model-packages)
## Présentation de
Un modèle de package inclut les composants suivants :
+ Une image d'inférence stockée dans [Amazon Elastic Container Registry](https://aws.amazon.com/ecr/) (Amazon ECR)
+ (Facultatif) Artefacts du modèle, stockés séparément dans [Amazon S3](https://aws.amazon.com/s3/)
**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 packages modèles, ils peuvent être regroupés dans votre image d'inférence ou stockés séparément dans Amazon SageMaker AI. 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 PyTorch, TensorFlow TensorFlow -Lite ou ONNX, pensez à utiliser Amazon AI 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 que`ml.c4`,`ml.p2`, et autres. Pour plus d'informations, consultez [Optimiser les performances des modèles à l'aide de Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) dans le manuel *Amazon SageMaker AI 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.\]](http://docs.aws.amazon.com/fr_fr/marketplace/latest/userguide/images/ml-model-package-images.png)
Le processus de création d'un package de modèles d' SageMaker IA 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 Amazon ECR.
Les artefacts du modèle peuvent être regroupés dans l'image d'inférence ou stockés séparément dans S3.
1. Le vendeur crée ensuite une ressource de package modèle dans Amazon SageMaker AI et publie son produit ML sur AWS Marketplace.
1. 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 à des fins d'inférence](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html).
1. SageMaker L'IA 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.
1. SageMaker L'IA transmet les données d'inférence de l'acheteur au conteneur en utilisant les points de terminaison HTTP du conteneur et renvoie les résultats des prédictions.
## 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 :
**Topics**
+ [Étape 1 : Création de l'image du conteneur](#ml-step-1-creating-the-container-image)
+ [Étape 2 : Création et test de l'image localement](#ml-step-2-building-and-testing-the-image-locally)
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 permettre à l' SageMaker IA de transmettre des 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 l' SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html) et les [exemples d'AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) sur GitHub.
L'exemple suivant utilise un service Web, [Flask](https://pypi.org/project/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 l' SageMaker IA, l'image Docker doit exposer les points de terminaison HTTP. Pendant le fonctionnement de votre conteneur, l'SageMaker IA transmet les données de l'acheteur au point de terminaison HTTP du conteneur à des fins d'inférence. Les résultats de l'inférence sont renvoyés dans le corps de la réponse HTTP.
La procédure pas à pas suivante utilise la CLI Docker dans un environnement de développement utilisant une distribution Linux Ubuntu.
+ [Création du script du serveur Web](#ml-create-the-web-server-script)
+ [Créez le script pour l'exécution du conteneur](#ml-create-the-script-for-the-container-run)
+ [Créer le `Dockerfile`](#ml-create-the-dockerfile)
+ [Package ou téléchargement des artefacts du modèle](#ml-package-or-upload-the-model-artifacts)
#### Création du script du serveur Web
Cet exemple utilise un serveur Python appelé [Flask](https://pypi.org/project/Flask/), mais vous pouvez utiliser n'importe quel serveur Web adapté à votre framework.
**Note**
[Le flacon](https://pypi.org/project/Flask/) 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 points de terminaison HTTP sur le port TCP 8080 utilisé par AI. SageMaker Les deux paramètres attendus sont les suivants :
+ `/ping`— SageMaker L'IA 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`— SageMaker L'IA envoie 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. Pour plus de détails sur les délais d'expiration, consultez[Exigences et meilleures pratiques pour créer des produits d'apprentissage automatique](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)
```
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` que l' SageMaker IA exécute lorsqu'elle exécute l'image du conteneur Docker. Le script suivant démarre 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 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}
```
`Dockerfile`Ajoute 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.
#### 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 le`Dockerfile`.
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é, et SageMaker AI extrait et copie 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éation et test de 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 balise`my-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 \
--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 SageMaker AI envoie des requêtes HTTP.
+ `--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écutez le même script que celui que SageMaker l'IA exécute 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 terminaison HTTP ping
Lorsque SageMaker l'IA gère votre conteneur, elle 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 à l' SageMaker IA 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 HTTP d'inférence
Lorsque le conteneur indique qu'il est prêt en renvoyant un code d'état 200 à votre ping, SageMaker AI transmet les données d'inférence au point de terminaison `/invocations` HTTP via une `POST` requête. 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 points de terminaison HTTP fonctionnant, l'image d'inférence est désormais compatible avec SageMaker l'IA.
**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, l' SageMaker IA 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
```
Lorsque votre image d'inférence est prête et testée, vous pouvez continuer[Téléchargement de vos images sur Amazon Elastic Container Registry](ml-uploading-your-images.md).
# Création d'images d'algorithmes
Un algorithme d' SageMaker intelligence artificielle d'Amazon exige que l'acheteur apporte ses propres données pour s'entraîner avant de faire des prédictions. En tant que AWS Marketplace vendeur, vous pouvez utiliser l' SageMaker IA pour créer des algorithmes et des modèles d'apprentissage automatique (ML) dans lesquels vos acheteurs peuvent les déployer AWS. Les sections suivantes expliquent comment créer des images d'algorithmes pour AWS Marketplace. Cela inclut la création de l'image d'entraînement Docker pour entraîner votre algorithme et de l'image d'inférence contenant votre logique d'inférence. Les images d'apprentissage et d'inférence sont requises lors de la publication d'un produit algorithmique.
**Topics**
+ [Présentation de](#ml-algorithm-images-overview)
+ [Création d'une image d'entraînement pour les algorithmes](#ml-creating-a-training-image-for-algorithms)
+ [Création d'une image d'inférence pour les algorithmes](#ml-creating-an-inference-image-for-algorithms)
## Présentation de
Un algorithme comprend les composants suivants :
+ Une image d'entraînement stockée dans [Amazon ECR](https://aws.amazon.com/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.\]](http://docs.aws.amazon.com/fr_fr/marketplace/latest/userguide/images/ml-algorithm-package-images.png)
Le processus de création d'un algorithme d' SageMaker IA pour AWS Marketplace inclut les étapes suivantes :
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.
1. Le vendeur crée ensuite une ressource d'algorithme dans Amazon SageMaker AI et publie son produit ML sur AWS Marketplace.
1. L'acheteur souscrit au produit ML.
1. 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 L'IA 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](https://aws.amazon.com/s3/) de l'acheteur.
1. 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.
1. SageMaker L'IA 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.
1. Que le modèle soit déployé en tant que point de terminaison ou en tant que tâche de transformation par lots, l' SageMaker IA transmet les données au conteneur à des fins d'inférence pour le compte de l'acheteur 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](https://docs.aws.amazon.com/sagemaker/latest/dg/train-model.html).
## 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 à l' SageMaker IA 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 et modèles avec les AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) [exemples d'AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) ci-dessous GitHub.
**Topics**
+ [Étape 1 : Création de l'image du conteneur](#ml-step-1-creating-the-container-image-1)
+ [Étape 2 : Création et test de l'image localement](#ml-step-2-building-and-testing-the-image-locally-1)
### Étape 1 : Création de l'image du conteneur
Pour que l'image d'entraînement soit compatible avec Amazon SageMaker AI, elle doit respecter une structure de fichier spécifique afin de permettre à SageMaker AI de copier les données d'entraînement et les entrées de configuration vers des chemins spécifiques de votre conteneur. Une fois la formation 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 à partir duquel SageMaker AI copie.
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](#ml-prepare-your-program-to-read-configuration-inputs)
+ [Préparez votre programme pour lire les entrées de données](#ml-prepare-your-program-to-read-data-inputs)
+ [Préparez votre programme pour rédiger des résultats de formation](#ml-prepare-your-program-to-write-training-outputs)
+ [Créez le script pour l'exécution du conteneur](#ml-create-the-script-for-the-container-run-1)
+ [Créer le `Dockerfile`](#ml-create-the-dockerfile-1)
#### 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 ces chemins de fichiers spécifiques.
+ `/opt/ml/input/config`est le répertoire qui contient les informations qui contrôlent le mode d'exécution de votre programme.
+ `hyperparameters.json`est un dictionnaire au format JSON contenant les noms et les valeurs des hyperparamètres. Les valeurs étant des chaînes, vous devrez peut-être les convertir.
+ `resourceConfig.json`[est un fichier au format JSON qui décrit la structure du réseau utilisée pour la formation distribuée.](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training) Si votre image d'entraînement ne prend pas en charge l'entraînement distribué, vous pouvez ignorer ce fichier.
**Note**
Pour plus d'informations sur les entrées de configuration, consultez [Comment Amazon SageMaker AI fournit des informations de formation](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html).
#### 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//`contient les données d'entrée pour ce canal. Les canaux sont créés en fonction de l'appel à l'`CreateTrainingJob`opé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](https://aws.amazon.com/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/_`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 AI 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 que l' SageMaker IA exécute lorsqu'elle 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 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}
```
`Dockerfile`Ajoute 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 et modèles avec les AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) [exemples d'AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) 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 balise`my-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 ':/opt/ml/input:ro' \
--volume ':/opt/ml/model' \
--volume ':/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 ':/opt/ml/input:ro'`— Rend le répertoire d'entrée de test disponible pour le conteneur en lecture seule.
+ `--volume ':/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 ':/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`— Exécutez le même script que celui que SageMaker l'IA exécute 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](#ml-creating-an-inference-image-for-algorithms).
## 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 permettre à l' SageMaker IA de transmettre 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. Si ce n'est pas déjà fait, consultez la section précédente à propos de[Création d'une image d'entraînement pour les algorithmes](#ml-creating-a-training-image-for-algorithms). 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 et modèles avec les AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) [exemples d'AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) ci-dessous GitHub.
L'exemple suivant utilise un service Web, [Flask](https://pypi.org/project/Flask/), pour des raisons de simplicité, et n'est pas considéré comme prêt pour la production.
**Topics**
+ [Étape 1 : Création de l'image d'inférence](#ml-step-1-creating-the-inference-image)
+ [Étape 2 : Création et test de l'image localement](#ml-step-2-building-and-testing-the-image-locally-2)
### Étape 1 : Création de l'image d'inférence
Pour que l'image d'inférence soit compatible avec l' SageMaker IA, l'image Docker doit exposer les points de terminaison HTTP. Pendant le fonctionnement de votre conteneur, l'SageMaker IA 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](#ml-create-the-web-server-script-1)
+ [Créez le script pour l'exécution du conteneur](#ml-create-the-script-for-the-container-run-2)
+ [Créer le `Dockerfile`](#ml-create-the-dockerfile-2)
+ [Préparation de votre programme pour le chargement dynamique des artefacts du modèle](#ml-preparing-your-program-to-dynamically-load-model-artifacts)
#### Création du script du serveur Web
Cet exemple utilise un serveur Python appelé [Flask](https://pypi.org/project/Flask/), mais vous pouvez utiliser n'importe quel serveur Web adapté à votre framework.
**Note**
[Le flacon](https://pypi.org/project/Flask/) 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é par AI. SageMaker Les deux paramètres attendus sont les suivants :
+ `/ping`— SageMaker L'IA 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`— SageMaker L'IA envoie 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` que l' SageMaker IA exécute lorsqu'elle 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 AI
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 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}
```
`Dockerfile`Ajoute 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 L'IA compresse le contenu de ce répertoire dans un fichier .tar.gz et le stocke dans celui de l'acheteur sur Compte AWS Amazon S3.
Lorsque le modèle est déployé, l' SageMaker IA 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 de plus amples informations, veuillez consulter [Sécurité et propriété intellectuelle avec Amazon SageMaker AI](ml-security-and-intellectual-property.md).
### É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 balise`my-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 ':/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 SageMaker auquel AI envoie des requêtes HTTP.
+ `--volume ':/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`— Exécutez le même script que celui que SageMaker l'IA exécute 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 SageMaker l'IA gère votre conteneur, elle 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 à l' SageMaker IA 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, l' SageMaker IA 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 l'IA.
**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 AI 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 sur Amazon Elastic Container Registry](ml-uploading-your-images.md)
# Téléchargement de vos images sur Amazon Elastic Container Registry
Après avoir créé vos images d'inférence et d'entraînement, vous pouvez les télécharger sur Amazon Elastic Container Registry. [Amazon ECR](https://aws.amazon.com/ecr/) est un registre Docker entièrement géré. Amazon SageMaker AI extrait des images d'Amazon ECR pour créer un package modèle à des fins d'inférence ou un algorithme pour les tâches de formation. AWS Marketplace récupère également ces images sur Amazon ECR pour publier votre package de modèles et vos produits d'algorithmes. Cette rubrique fournit une procédure pas à pas pour télécharger vos images d'inférence et de formation sur Amazon ECR.
**Topics**
+ [Quelles images dois-je télécharger ?](#ml-which-images-must-i-upload)
+ [Quelles sont les autorisations IAM requises ?](#ml-what-iam-permissions-are-required)
+ [Connectez votre client Docker à AWS](#ml-log-in-your-docker-client)
+ [Création d'un référentiel et téléchargement d'une image](#ml-create-repository-and-upload-image)
+ [Scannez l'image que vous avez téléchargée](#ml-scan-your-uploaded-image)
## Quelles images dois-je télécharger ?
Si vous publiez un modèle de package, téléchargez uniquement une image d'inférence. Si vous publiez un algorithme, téléchargez à la fois une image d'inférence et une image d'entraînement. Si les images d'inférence et d'entraînement sont combinées, téléchargez l'image combinée une seule fois.
## Quelles sont les autorisations IAM requises ?
Les étapes suivantes supposent que la machine locale possède les AWS informations d'identification correctes pour un rôle ou un utilisateur Gestion des identités et des accès AWS (IAM) chez le vendeur Compte AWS. Le rôle ou l'utilisateur doit disposer des politiques appropriées à la fois pour Amazon ECR AWS Marketplace et pour Amazon ECR. Par exemple, vous pouvez utiliser les politiques AWS gérées suivantes :
+ [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSMarketplaceSellerProductsFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSMarketplaceSellerProductsFullAccess.html)— Pour accéder à 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)— Pour accéder à Amazon ECR
**Note**
Les liens vous redirigent vers le *AWS Managed Policy Reference*.
## Connectez votre client Docker à AWS
Définissez une variable pour le Région AWS document à partir duquel vous souhaitez publier (voir[Supporté Régions AWS pour la publication](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing)). Pour cet exemple, utilisez la région USA Est (Ohio).
```
region=us-east-2
```
Exécutez la commande suivante pour définir une variable avec votre Compte AWS identifiant. Cet exemple suppose que les informations d'identification actuelles AWS Command Line Interface (AWS CLI) appartiennent à celles du vendeur Compte AWS.
```
account=$(aws sts get-caller-identity --query Account --output text)
```
Pour authentifier votre client Docker CLI auprès de votre registre Docker Compte AWS Amazon ECR pour votre région, exécutez la commande suivante.
```
aws ecr get-login-password \
--region ${region} \
| sudo docker login \
--username AWS \
--password-stdin \
${account}.dkr.ecr.${region}.amazonaws.com
```
## Création d'un référentiel et téléchargement d'une image
Définissez une variable pour le tag de l'image téléchargée et une autre variable pour le nom du référentiel d'images téléchargé.
```
image=my-inference-image
repo=my-inference-image
```
**Note**
Dans les sections précédentes de ce guide où les images d'inférence et d'entraînement ont été créées, elles ont été étiquetées comme **my-inference-image**et **my-training-image**, respectivement. Pour cet exemple, créez et téléchargez l'image d'inférence dans un référentiel portant le même nom.
Exécutez la commande suivante pour créer le référentiel d'images dans Amazon ECR.
```
aws ecr --region ${region} create-repository --repository-name "${repo}"
```
Le nom complet de l'emplacement du référentiel Amazon ECR est composé des éléments suivants : ` .dkr.ecr..amazonaws.com/`
Pour transférer l'image vers le référentiel, vous devez l'étiqueter avec le nom complet de l'emplacement du référentiel.
Définissez une variable pour le nom complet de l'emplacement du référentiel d'images ainsi que le `latest` tag.
```
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${repo}:latest"
```
Marquez l'image avec le nom complet.
```
sudo docker tag ${image} ${fullname}
```
Enfin, transférez l'image d'inférence vers le référentiel d'Amazon ECR.
```
sudo docker push ${fullname}
```
Une fois le chargement terminé, l'image apparaît dans la [liste des référentiels de la console Amazon ECR](https://console.aws.amazon.com/ecr/repositories?region=us-east-2) de la région à partir de laquelle vous publiez. Dans l'exemple précédent, l'image a été transférée vers un référentiel de la région USA Est (Ohio).
## Scannez l'image que vous avez téléchargée
Dans la [console Amazon ECR](https://console.aws.amazon.com/ecr/repositories?region=us-east-2), choisissez Région AWS celui à partir duquel vous publiez et ouvrez le référentiel dans lequel l'image a été téléchargée. Sélectionnez l'image que vous avez téléchargée et lancez une analyse pour détecter les vulnérabilités connues. AWS Marketplace vérifie les résultats du scan Amazon ECR des images de conteneurs utilisées dans votre ressource Amazon SageMaker AI avant de les publier. Avant de créer votre produit, vous devez corriger les images de conteneur présentant des vulnérabilités de gravité critique ou élevée.
Une fois que vos images ont été numérisées avec succès, elles peuvent être utilisées pour créer un paquetage modèle ou une ressource d'algorithme.
Si vous pensez que le scan de votre produit contient des erreurs qui sont des faux positifs, contactez l'équipe chargée [des opérations avec les AWS Marketplace vendeurs](https://aws.amazon.com/marketplace/management/contact-us) pour obtenir des informations sur l'erreur.
**Étapes suivantes**
+ Voir les limites de taille dans [Exigences et meilleures pratiques pour créer des produits d'apprentissage automatique](ml-listing-requirements-and-best-practices.md)
+ Continuez vers [Création de votre ressource Amazon SageMaker AI](ml-creating-your-amazon-sagemaker-resource.md)
# Création de votre ressource Amazon SageMaker AI
Pour publier un package modèle ou un produit d'algorithme, vous devez créer la ressource de [package de modèle ou la ressource](https://docs.aws.amazon.com/marketplace/latest/userguide/ml-creating-your-amazon-sagemaker-resource.html#ml-creating-your-model-package-product) d'[algorithme](https://docs.aws.amazon.com/marketplace/latest/userguide/ml-creating-your-amazon-sagemaker-resource.html#ml-creating-your-algorithm-product) correspondante dans Amazon SageMaker AI. Lorsque vous créez votre ressource pour un AWS Marketplace produit, celle-ci doit être certifiée par le biais d'une étape de validation. L'étape de validation nécessite que vous fournissiez des données pour tester votre paquetage de modèles ou votre ressource d'algorithme avant de pouvoir les publier. Les sections suivantes vous montrent comment créer votre ressource d' SageMaker IA, qu'il s'agisse d'une ressource de package modèle ou d'une ressource d'algorithme. Cela inclut la définition des spécifications de validation qui indiquent à l' SageMaker IA comment effectuer la validation.
**Note**
Si vous n'avez pas encore créé les images de votre produit et ne les avez pas chargées sur Amazon Elastic Container Registry (Amazon ECR), [Regrouper votre code sous forme d'images pour les produits d'apprentissage automatique dans AWS Marketplace](ml-packaging-your-code-into-images.md) consultez [Téléchargement de vos images sur Amazon Elastic Container Registry](ml-uploading-your-images.md) et pour obtenir des informations sur la procédure à suivre.
**Topics**
+ [Création de votre modèle de package](#ml-creating-your-model-package-product)
+ [Création de votre algorithme](#ml-creating-your-algorithm-product)
## Création de votre modèle de package
Les conditions suivantes sont requises pour créer un modèle de package pour AWS Marketplace :
+ Une image d'inférence stockée dans [Amazon ECR](https://aws.amazon.com/ecr/)
+ (Facultatif) Artefacts du modèle, stockés séparément dans [Amazon S3](https://aws.amazon.com/s3/)
+ Vos données de test utilisées pour les inférences, stockées dans Amazon Simple Storage Service
**Note**
Ce qui suit concerne la création d'un modèle de produit d'emballage. Pour plus d'informations sur les packages de modèles dans l' SageMaker IA, consultez la section [Créer une ressource de packages de modèles](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-mkt-create-model-package.html).
### Création des ressources du package modèle
Les procédures suivantes vous guident dans la création des ressources du package modèle.
**Étape 1 : Pour créer les ressources du package modèle**
1. Ouvrez la [console Amazon SageMaker AI](https://us-east-2.console.aws.amazon.com/sagemaker/home).
1. Vérifiez que vous vous trouvez dans la AWS région à partir de laquelle vous souhaitez publier en regardant en haut à droite de la page. Pour la publication, consultez la [Supporté Régions AWS pour la publication](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing) section. L'image d'inférence que vous avez chargée sur Amazon ECR lors des étapes précédentes doit se trouver dans la même région.
1. Dans le menu de navigation de gauche, choisissez **Model packages**.
1. Sélectionnez **Create model package (Créer un package de modèle)**.
Après avoir créé le package, vous devez définir les spécifications du package d'inférence.
**Étape 2 : Pour définir les spécifications d'inférence**
1. Entrez un **nom** pour votre modèle de package (par exemple,*my-model-package*).
1. Pour **Emplacement de l'image d'inférence**, entrez l'URI de votre image d'inférence qui a été téléchargée sur Amazon ECR. Vous pouvez récupérer l'URI en localisant votre image dans la [console Amazon ECR.](https://us-east-2.console.aws.amazon.com/ecr/repositories)
1. Si les artefacts de votre modèle issus de l'entraînement sont intégrés à votre logique dans votre image d'inférence, laissez le champ **Emplacement des artefacts de données du modèle vide**. Sinon, spécifiez l'emplacement complet sur Amazon S3 du fichier compressé (.tar.gz) des artefacts de votre modèle.
1. À l'aide de la liste déroulante, choisissez les types d'instance pris en charge pour votre image d'inférence en temps réel (également appelée point de *terminaison*) et pour les tâches de transformation par lots.
1. Choisissez **Suivant**.
Avant que votre modèle de package puisse être créé et publié, une validation est nécessaire pour garantir qu'il fonctionne comme prévu. Cela nécessite que vous exécutiez une tâche de transformation par lots avec les données de test que vous fournissez à des fins d'inférence. Les spécifications de validation indiquent à SageMaker AI comment effectuer la validation.
**Étape 3 : Pour définir les spécifications de validation**
1. Définissez **Publier ce modèle de package AWS Marketplace** sur **Oui**. Si vous définissez ce paramètre sur **Non**, vous ne pourrez pas publier ce modèle de package ultérieurement. Le fait de choisir **Oui** [certifie](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-CertifyForMarketplace) votre modèle de package AWS Marketplace et nécessite l'étape de validation.
1. Si c'est la première fois que ce processus est terminé, choisissez **Create a new role** for the **IAM role**. Amazon SageMaker AI utilise ce rôle lorsqu'il déploie votre modèle de package. Cela inclut des actions, telles que l'extraction d'images depuis Amazon ECR et d'artefacts depuis Amazon S3. Vérifiez les paramètres, puis choisissez **Create role**. La création d'un rôle ici accorde les autorisations décrites par la politique [ AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)IAM au rôle que vous créez.
1. Modifiez le **JSON** dans le profil de validation. Pour plus de détails sur les valeurs autorisées, consultez [TransformJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformJobDefinition.html).
1. `TransformInput.DataSource.S3Uri`: Définissez l'endroit où vos données de test pour inférence sont stockées.
1. `TransformInput.ContentType`: Spécifiez le type de contenu de vos données de test (par exemple `application/json``text/plain`,`image/png `,, ou toute autre valeur). SageMaker L'IA ne valide pas les données d'entrée réelles. Cette valeur est transmise au point de terminaison HTTP de votre conteneur dans la valeur `Content-type` d'en-tête.
1. `TransformInput.CompressionType`: défini sur `None` si vos données de test à des fins d'inférence dans Amazon S3 ne sont pas compressées.
1. `TransformInput.SplitType`: défini sur pour `None` transmettre chaque objet d'Amazon S3 dans son ensemble à des fins d'inférence.
1. `TransformOutput.S3OutputPath`: défini sur l'emplacement où la sortie d'inférence est stockée.
1. `TransformOutput.AssembleWith`: défini sur `None` pour générer chaque inférence sous forme d'objets distincts dans Amazon S3.
1. Sélectionnez **Create model package (Créer un package de modèle)**.
SageMaker L'IA extrait l'image d'inférence d'Amazon ECR, copie tous les artefacts dans le conteneur d'inférence et exécute une tâche de transformation par lots en utilisant vos données de test à des fins d'inférence. Une fois la validation réussie, le statut passe à **Terminé**.
**Note**
L'étape de validation n'évalue pas la précision du modèle à l'aide de vos données de test. L'étape de validation vérifie si le conteneur fonctionne et répond comme prévu.
Vous avez terminé de créer les ressources de votre modèle de produit. Passez au [Mettre en vente votre produit dans AWS Marketplace](ml-publishing-your-product-in-aws-marketplace.md).
## Création de votre algorithme
Les conditions suivantes sont requises pour créer un algorithme pour AWS Marketplace :
+ Une image d'inférence, stockée dans Amazon ECR
+ Une image d'entraînement, stockée dans Amazon ECR
+ Vos données de test pour l'entraînement, stockées dans Amazon S3
+ Vos données de test à des fins d'inférence, stockées dans Amazon S3
**Note**
La procédure pas à pas suivante permet de créer un produit algorithmique. Pour plus d'informations, voir [Création d'une ressource d'algorithme](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-mkt-create-algo.html).
### Création des ressources de l'algorithme
Les procédures suivantes vous permettent de créer les ressources de votre package d'algorithmes.
**Étape 1 : Pour créer les ressources de l'algorithme**
1. Ouvrez la [console Amazon SageMaker AI](https://us-east-2.console.aws.amazon.com/sagemaker/home).
1. Vérifiez que vous vous trouvez dans la AWS région à partir de laquelle vous souhaitez publier en regardant en haut à droite de la page (voir[Supporté Régions AWS pour la publication](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing)). Les images d'entraînement et d'inférence que vous avez chargées sur Amazon ECR lors des étapes précédentes doivent se trouver dans cette même région.
1. Dans le menu de navigation de gauche, sélectionnez **Algorithmes**.
1. Choisissez **Create algorithm (Créer un algorithme)**.
Après avoir créé le package d'algorithmes, vous devez définir les spécifications pour l'entraînement et le réglage de votre modèle.
**Étape 2 : Pour définir les spécifications d'entraînement et de réglage**
1. Entrez le **nom** de votre algorithme (par exemple,*my-algorithm*).
1. Pour **l'image d'entraînement**, collez l'adresse URI complète de votre image d'entraînement qui a été téléchargée sur Amazon ECR. Vous pouvez récupérer l'URI en localisant votre image dans la [console Amazon ECR.](https://us-east-2.console.aws.amazon.com/ecr/repositories)
1. À l'aide de la liste déroulante, choisissez les **types d'instances d'entraînement compatibles** avec votre image d'entraînement.
1. Dans la section **Spécification du canal**, ajoutez un canal pour chaque jeu de données d'entrée pris en charge par votre algorithme, jusqu'à 20 canaux de sources d'entrée. Pour plus d'informations, consultez la section [Configuration des données d'entrée](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-inputdataconfig).
1. Choisissez **Suivant**.
1. Si votre algorithme prend en charge les hyperparamètres et le réglage des hyperparamètres, vous devez spécifier les paramètres de réglage.
1. Choisissez **Suivant**.
**Note**
Nous recommandons vivement que votre algorithme prenne en charge le réglage des hyperparamètres et rende les paramètres appropriés réglables. Cela permet aux data scientists d'ajuster les modèles pour obtenir les meilleurs résultats.
Après avoir défini les paramètres de réglage, le cas échéant, vous devez définir les spécifications de votre image d'inférence.
**Étape 3 : Pour définir les spécifications de l'image d'inférence**
1. Pour **Emplacement de l'image d'inférence**, collez l'URI de l'image d'inférence qui a été téléchargée sur Amazon ECR. Vous pouvez récupérer l'URI en localisant votre image dans la [console Amazon ECR.](https://us-east-2.console.aws.amazon.com/ecr/repositories)
1. À l'aide de la liste déroulante, choisissez les types d'instance pris en charge pour votre image d'inférence à la fois pour les tâches d'inférence en temps réel (également appelées *endpoints) et de transformation* par lots.
1. Choisissez **Suivant**.
Avant que votre algorithme puisse être créé et publié, une validation est nécessaire pour garantir qu'il fonctionne comme prévu. Cela nécessite que vous exécutiez à la fois une tâche d'entraînement avec des données de test pour l'entraînement et une tâche de transformation par lots avec les données de test à des fins d'inférence que vous fournissez. Les spécifications de validation indiquent à SageMaker AI comment effectuer la validation.
**Étape 4 : Pour définir les spécifications de validation**
1. Définissez **Publier cet algorithme AWS Marketplace** sur **Oui**. Si vous définissez ce paramètre sur **Non**, vous ne pourrez pas publier cet algorithme ultérieurement. **Si vous choisissez Oui,** [votre algorithme est certifié](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAlgorithm.html#sagemaker-CreateAlgorithm-request-CertifyForMarketplace) AWS Marketplace et nécessite la spécification de validation.
1. Si c'est la première fois que vous créez un package de machine learning pour AWS Marketplace, choisissez **Create a new role** for the **IAM role**. Amazon SageMaker AI utilise ce rôle lors de l'entraînement de votre algorithme et du déploiement du package modèle suivant. Cela inclut des actions telles que l'extraction d'images depuis Amazon ECR, le stockage d'artefacts dans Amazon S3 et la copie de données de formation depuis Amazon S3. Vérifiez les paramètres, puis choisissez **Create role**. La création d'un rôle ici accorde les autorisations décrites par la politique [ AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)IAM au rôle que vous créez.
1. Modifiez le fichier **JSON** dans le profil de validation pour la **définition des tâches de formation**. Pour plus d'informations sur les valeurs autorisées, consultez [ TrainingJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TrainingJobDefinition.html).
1. `InputDataConfig`: Dans ce tableau JSON, ajoutez un [objet Channel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html) pour chaque canal que vous avez spécifié lors de l'étape de spécification de formation. Pour chaque canal, spécifiez où sont stockées vos données de test pour l'entraînement.
1. `OutputDataConfig`: Une fois la formation terminée, les artefacts du modèle figurant dans le chemin du répertoire du conteneur de formation `/opt/ml/model/` sont compressés et copiés sur Amazon S3. Spécifiez l'emplacement Amazon S3 où le fichier compressé (.tar.gz) est stocké.
1. Modifiez le fichier JSON dans le profil de validation pour la **définition de la tâche de transformation**. Pour plus d'informations sur les valeurs autorisées, consultez [ TransformJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformJobDefinition.html).
1. `TransformInput.DataSource.S3Uri`: Définissez l'endroit où vos données de test pour inférence sont stockées.
1. `TransformInput.ContentType`: Spécifiez le type de contenu de vos données de test. Par exemple,`application/json`, `text/plain``image/png`, ou toute autre valeur. Amazon SageMaker AI ne valide pas les données d'entrée réelles. Cette valeur est transmise au point de terminaison HTTP de votre conteneur dans la valeur `Content-type` d'en-tête.
1. `TransformInput.CompressionType`: défini sur `None` si vos données de test à des fins d'inférence dans Amazon S3 ne sont pas compressées.
1. `TransformInput.SplitType`: Choisissez la manière dont vous souhaitez que les objets soient divisés dans S3. Par exemple, `None` transmet chaque objet d'Amazon S3 dans son ensemble à des fins d'inférence. Pour plus de détails, consultez [ SplitType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#sagemaker-Type-TransformInput-SplitType)le manuel Amazon SageMaker AI API Reference.
1. `TransformOutput.S3OutputPath`: défini sur l'emplacement où la sortie d'inférence est stockée.
1. `TransformOutput.AssembleWith`: défini sur `None` pour générer chaque inférence sous forme d'objets distincts dans Amazon S3.
1. Choisissez **Créer un package d'algorithmes**.
SageMaker L'IA extrait l'image d'entraînement d'Amazon ECR, exécute une tâche d'entraînement de test en utilisant vos données et stocke les artefacts du modèle dans Amazon S3. Il extrait ensuite l'image d'inférence d'Amazon ECR, copie les artefacts d'Amazon S3 dans le conteneur d'inférence et exécute une tâche de transformation par lots en utilisant vos données de test à des fins d'inférence. Une fois la validation réussie, le statut passe à **Terminé**.
**Note**
L'étape de validation n'évalue pas la précision de l'entraînement ou du modèle à l'aide de vos données de test. L'étape de validation vérifie si les conteneurs fonctionnent et répondent comme prévu.
L'étape de validation valide uniquement le traitement par lots. C'est à vous de valider que le traitement en temps réel fonctionne avec votre produit.
Vous avez terminé de créer les ressources de votre produit algorithmique. Passez au [Mettre en vente votre produit dans AWS Marketplace](ml-publishing-your-product-in-aws-marketplace.md).