**Aidez à améliorer cette page**
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.
Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.
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.
# Utiliser des instances AWS Inferentia avec Amazon EKS pour le Machine Learning
Cette rubrique décrit comment créer un cluster Amazon EKS avec des nœuds de travail exécutant des instances [Amazon EC2 Inf1](https://aws.amazon.com/ec2/instance-types/inf1/) et (éventuellement) déployer un exemple d'application. Les instances Amazon EC2 Inf1 sont alimentées par des puces [AWS Inferentia](https://aws.amazon.com/machine-learning/inferentia/), conçues sur mesure AWS pour fournir des performances élevées et une inférence à moindre coût dans le cloud. Les modèles d'apprentissage automatique sont déployés sur des conteneurs à l'aide de [AWS Neuron](https://aws.amazon.com/machine-learning/neuron/), un kit de développement logiciel (SDK) spécialisé composé d'un compilateur, d'un environnement d'exécution et d'outils de profilage qui optimisent les performances d'inférence par apprentissage automatique des puces Inferentia. AWS Neuron prend en charge les frameworks d'apprentissage automatique populaires tels que TensorFlow PyTorch, et MXNet.
**Note**
La logique du dispositif neuronal IDs doit être contiguë. Si un pod demandant plusieurs appareils Neuron est planifié sur un type d'`inf1.24xlarge`instance `inf1.6xlarge` ou (qui possède plusieurs appareils Neuron), ce pod ne démarrera pas si le planificateur Kubernetes sélectionne un appareil non contigu. IDs Pour plus d'informations, consultez la section [Le périphérique logique IDs doit être contigu](https://github.com/aws/aws-neuron-sdk/issues/110). GitHub
## Conditions préalables
+ Installez `eksctl` sur votre ordinateur. Si vous ne l’avez pas installé, consultez [Installation](https://eksctl.io/installation) dans la documentation `eksctl`.
+ Installez `kubectl` sur votre ordinateur. Pour de plus amples informations, veuillez consulter [Configuration de `kubectl` et `eksctl`](install-kubectl.md).
+ (Facultatif) Installez `python3` sur votre ordinateur. S’il n’est pas installé, consultez les [téléchargements Python](https://www.python.org/downloads/) pour obtenir des instructions d’installation.
## Créer un cluster
1. Créez un cluster avec des nœuds d'instances Amazon EC2 Inf1. Vous pouvez remplacer {{inf1.2xlarge}} par n'importe quel [type d'instance Inf1](https://aws.amazon.com/ec2/instance-types/inf1/). L'`eksctl`utilitaire détecte que vous lancez un groupe de nœuds avec un type d'`Inf1`instance et démarrera vos nœuds à l'aide de l'un des systèmes accélérés optimisés pour Amazon EKS d'Amazon Linux AMIs.
**Note**
Vous ne pouvez pas utiliser de [rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md) avec TensorFlow Serving.
```
eksctl create cluster \
--name inferentia \
--region region-code \
--nodegroup-name ng-inf1 \
--node-type inf1.2xlarge \
--nodes 2 \
--nodes-min 1 \
--nodes-max 4 \
--ssh-access \
--ssh-public-key your-key \
--with-oidc
```
**Note**
Notez la valeur de la ligne suivante de la sortie. Elle est utilisée lors d’une étape ultérieure (facultative).
```
[9] adding identity "arn:aws: iam::111122223333:role/eksctl-inferentia-nodegroup-ng-in-NodeInstanceRole-FI7HIYS3BS09" to auth ConfigMap
```
Lorsque vous lancez un groupe de nœuds avec des `Inf1` instances, le plug-in d'appareil AWS Neuron Kubernetes est `eksctl` automatiquement installé. Ce plug-in annonce les appareils Neuron comme une ressource système au planificateur Kubernetes, qui peut être demandé par un conteneur. Outre les stratégies IAM de nœud Amazon EKS par défaut, la stratégie d'accès en lecture seule Amazon S3 est ajoutée afin que l'exemple d'application, traité dans une étape ultérieure, puisse charger un modèle formé à partir d'Amazon S3.
1. Assurez-vous que tous les pods ont démarré correctement.
```
kubectl get pods -n kube-system
```
Sortie abrégée :
```
NAME READY STATUS RESTARTS AGE
[...]
neuron-device-plugin-daemonset-6djhp 1/1 Running 0 5m
neuron-device-plugin-daemonset-hwjsj 1/1 Running 0 5m
```
## (Facultatif) Déployez une image d'application TensorFlow Serving
Un modèle formé doit être compilé sur une cible Inferentia avant de pouvoir être déployé sur des instances Inferentia. Pour continuer, vous aurez besoin d'un TensorFlow modèle [optimisé pour Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html) enregistré dans Amazon S3. Si vous n'en avez pas encore SavedModel, veuillez suivre le didacticiel pour [créer un modèle ResNet 50 compatible avec Neuron](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-tf-neuron.html) et télécharger le résultat SavedModel sur S3. ResNet-50 est un modèle d'apprentissage automatique populaire utilisé pour les tâches de reconnaissance d'images. Pour plus d'informations sur la compilation de modèles Neuron, consultez [The AWS Inferentia Chip with DLAMI dans le Deep Learning Developer Guide](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia.html). AWS AMIs
L'exemple de manifeste de déploiement gère un conteneur de service d'inférence prédéfini TensorFlow fourni par AWS Deep Learning Containers. À l'intérieur du conteneur se trouvent le AWS Neuron Runtime et l'application TensorFlow Serving. Une liste complète des Deep Learning Containers prédéfinis optimisés pour Neuron est disponible GitHub sous Images [disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-inference-containers). Au démarrage, le DLC récupérera votre modèle sur Amazon S3, lancera Neuron TensorFlow Serving avec le modèle enregistré et attendra les demandes de prédiction.
Le nombre d'appareils Neuron alloués à votre application de service peut être ajusté en changeant la ressource `aws.amazon.com/neuron` dans le yaml de déploiement. Veuillez noter que la communication entre TensorFlow Serving et le runtime Neuron se fait via GRPC, ce qui nécessite de transmettre la `IPC_LOCK` capacité au conteneur.
1. Ajoutez la politique IAM `AmazonS3ReadOnlyAccess` au rôle d’instance de nœud créé à l’étape 1 de la section [Créer un cluster](#create-cluster-inferentia). Ceci est nécessaire pour que l'application exemple puisse charger un modèle formé à partir de Amazon S3.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::aws:policy/AmazonS3ReadOnlyAccess \
--role-name eksctl-inferentia-nodegroup-ng-in-NodeInstanceRole-FI7HIYS3BS09
```
1. Créez un fichier nommé `rn50_deployment.yaml` avec les contenus suivants. Mettez à jour le code régional et le chemin du modèle pour correspondre aux paramètres souhaités. Le nom du modèle est utilisé à des fins d'identification lorsqu'un client fait une demande au TensorFlow serveur. Cet exemple utilise un nom de modèle correspondant à un exemple de ResNet 50 scripts client qui sera utilisé ultérieurement pour envoyer des demandes de prédiction.
```
aws ecr list-images --repository-name neuron-rtd --registry-id 790709498068 --region us-west-2
```
```
kind: Deployment
apiVersion: apps/v1
metadata:
name: eks-neuron-test
labels:
app: eks-neuron-test
role: master
spec:
replicas: 2
selector:
matchLabels:
app: eks-neuron-test
role: master
template:
metadata:
labels:
app: eks-neuron-test
role: master
spec:
containers:
- name: eks-neuron-test
image: 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04
command:
- /usr/local/bin/entrypoint.sh
args:
- --port=8500
- --rest_api_port=9000
- --model_name=resnet50_neuron
- --model_base_path=s3://${your-bucket-of-models}/resnet50_neuron/
ports:
- containerPort: 8500
- containerPort: 9000
imagePullPolicy: IfNotPresent
env:
- name: AWS_REGION
value: "us-east-1"
- name: S3_USE_HTTPS
value: "1"
- name: S3_VERIFY_SSL
value: "0"
- name: S3_ENDPOINT
value: s3.us-east-1.amazonaws.com
- name: AWS_LOG_LEVEL
value: "3"
resources:
limits:
cpu: 4
memory: 4Gi
aws.amazon.com/neuron: 1
requests:
cpu: "1"
memory: 1Gi
securityContext:
capabilities:
add:
- IPC_LOCK
```
1. Déployez le modèle.
```
kubectl apply -f rn50_deployment.yaml
```
1. Créez un fichier nommé `rn50_service.yaml` avec les contenus suivants. Les ports HTTP et gRPC sont ouverts pour accepter les demandes de prédiction.
```
kind: Service
apiVersion: v1
metadata:
name: eks-neuron-test
labels:
app: eks-neuron-test
spec:
type: ClusterIP
ports:
- name: http-tf-serving
port: 8500
targetPort: 8500
- name: grpc-tf-serving
port: 9000
targetPort: 9000
selector:
app: eks-neuron-test
role: master
```
1. Créez un service Kubernetes pour votre application TensorFlow Model Serving.
```
kubectl apply -f rn50_service.yaml
```
## (Facultatif) Faites des prédictions par rapport à votre TensorFlow service de service
1. Pour tester localement, transférez le port gRPC au service `eks-neuron-test`.
```
kubectl port-forward service/eks-neuron-test 8500:8500 &
```
1. Créez un script Python appelé `tensorflow-model-server-infer.py` avec le contenu suivant. Ce script exécute l'inférence via gRPC, qui est un framework de service.
```
import numpy as np
import grpc
import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.resnet50 import preprocess_input
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc
from tensorflow.keras.applications.resnet50 import decode_predictions
if __name__ == '__main__':
channel = grpc.insecure_channel('localhost:8500')
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
img_file = tf.keras.utils.get_file(
"./kitten_small.jpg",
"https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg")
img = image.load_img(img_file, target_size=(224, 224))
img_array = preprocess_input(image.img_to_array(img)[None, ...])
request = predict_pb2.PredictRequest()
request.model_spec.name = 'resnet50_inf1'
request.inputs['input'].CopyFrom(
tf.make_tensor_proto(img_array, shape=img_array.shape))
result = stub.Predict(request)
prediction = tf.make_ndarray(result.outputs['output'])
print(decode_predictions(prediction))
```
1. Exécutez le script pour soumettre des prédictions à votre service.
```
python3 tensorflow-model-server-infer.py
```
L'exemple qui suit illustre un résultat.
```
[[(u'n02123045', u'tabby', 0.68817204), (u'n02127052', u'lynx', 0.12701613), (u'n02123159', u'tiger_cat', 0.08736559), (u'n02124075', u'Egyptian_cat', 0.063844085), (u'n02128757', u'snow_leopard', 0.009240591)]]
```