Comment déployer un modèle de deep learning sur Kubernetes

Découvrez comment déployer, mettre à l'échelle et gérer un modèle d'apprentissage profond qui sert des prédictions de reconnaissance d'images avec Kubermatic Kubernetes Platform.

À mesure que les entreprises utilisent de plus en plus l’intelligence artificielle (IA), l’apprentissage automatique (ML) et l’apprentissage profond (DL), une question cruciale se pose : comment peuvent-elles faire évoluer et industrialiser le développement du ML ? Ces conversations se concentrent souvent sur le modèle ML ; cependant, il ne s’agit là que d’une étape vers une solution complète. Pour parvenir à une application et une mise à l'échelle en production, le développement du modèle doit inclure un processus reproductible qui prend en compte les activités critiques qui précèdent et suivent le développement, y compris le déploiement du modèle auprès du public.

Cet article montre comment déployer, mettre à l'échelle et gérer un modèle d'apprentissage profond qui sert des prédictions de reconnaissance d'images à l'aide de la plateforme Kubermatic Kubernetes.

Kubermatic Kubernetes Platform est un outil de gestion de cluster Kubernetes open source de qualité production qui offre flexibilité et automatisation pour s'intégrer aux flux de travail ML/DL avec une gestion complète du cycle de vie du cluster.

Commencer

Cet exemple déploie un modèle d'apprentissage profond pour la reconnaissance d'images. Il utilise l'ensemble de données CIFAR-10 composé de 60 000 images couleur 32 x 32 réparties en 10 classes avec la bibliothèque Gluon dans Apache MXNet et les GPU NVIDIA pour accélérer la charge de travail. Si vous souhaitez utiliser un modèle pré-entraîné sur l'ensemble de données CIFAR-10, consultez le guide de démarrage.

Le modèle a été formé sur une période de 200 époques, à condition que l'erreur de validation continue de diminuer lentement sans entraîner de surajustement du modèle. Ce graphique montre le processus de formation :

^{(Chaimaa Zyami, CC BY-SA 4.0)}

Après l'entraînement, il est essentiel de sauvegarder les paramètres du modèle afin de pouvoir les charger ultérieurement :

file_name = "net.params"
net.save_parameters(file_name)

Une fois le modèle prêt, enveloppez votre code de prédiction dans un serveur Flask. Cela permet au serveur d'accepter une image comme argument de sa requête et de renvoyer la prédiction du modèle dans la réponse :

from gluoncv.model_zoo import get_model
import matplotlib.pyplot as plt
from mxnet import gluon, nd, image
from mxnet.gluon.data.vision import transforms
from gluoncv import utils
from PIL import Image
import io
import flask 
app = flask.Flask(__name__)

@app.route("/predict",methods=["POST"])
def predict():
    if flask.request.method == "POST":
        if flask.request.files.get("img"):
            img = Image.open(io.BytesIO(flask.request.files["img"].read()))
            transform_fn = transforms.Compose([
            transforms.Resize(32),
            transforms.CenterCrop(32),
            transforms.ToTensor(),
            transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])])
            img = transform_fn(nd.array(img))
            net = get_model('cifar_resnet20_v1', classes=10)
            net.load_parameters('net.params')
            pred = net(img.expand_dims(axis=0))
            class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
                       'dog', 'frog', 'horse', 'ship', 'truck']
            ind = nd.argmax(pred, axis=1).astype('int')
            prediction = 'The input picture is classified as [%s], with probability %.3f.'%
                         (class_names[ind.asscalar()], nd.softmax(pred)[0][ind].asscalar())
    return prediction

if __name__ == '__main__':
    app.run(host='0.0.0.0')

Conteneuriser le modèle

Avant de pouvoir déployer votre modèle sur Kubernetes, vous devez installer Docker et créer une image de conteneur avec votre modèle.

Téléchargez, installez et démarrez Docker :

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

sudo yum install docker-ce

sudo systemctl start docker

Créez un répertoire dans lequel vous pouvez organiser votre code et vos dépendances :
```
mkdir kubermatic-dl
cd kubermatic-dl
```
Créez un fichier requirements.txt pour contenir les packages dont le code a besoin pour s'exécuter :
```
flask
gluoncv
matplotlib
mxnet
requests
Pillow
```
Créez le fichier Docker que Docker lira pour créer et exécuter le modèle :
```
FROM python:3.6
WORKDIR /app
COPY requirements.txt /app
RUN pip install -r ./requirements.txt
COPY app.py /app
CMD ["python", "app.py"]~
```
Ce Dockerfile peut être décomposé en trois étapes. Tout d'abord, il crée le Dockerfile et demande à Docker de télécharger une image de base de Python 3. Ensuite, il demande à Docker d'utiliser le gestionnaire de packages Python pip pour installer les packages dans requirements.txt. Enfin, il indique à Docker d'exécuter votre script via python app.py.
Créez le conteneur Docker :
```
sudo docker build -t kubermatic-dl:latest .
```
Cela demande à Docker de créer un conteneur pour le code dans votre répertoire de travail actuel, kubermatic-dl.
Vérifiez que votre conteneur fonctionne en l'exécutant sur votre ordinateur local :
```
sudo docker run -d -p 5000:5000 kubermatic-dl
```
Vérifiez l'état de votre conteneur en exécutant sudo docker ps -a :

^{(Chaimaa Zyami, CC BY-SA 4.0)}

Téléchargez le modèle sur Docker Hub

Avant de pouvoir déployer le modèle sur Kubernetes, il doit être accessible au public. Faites-le en l'ajoutant à Docker Hub. (Vous devrez créer un compte Docker Hub si vous n'en avez pas.)

Connectez-vous à votre compte Docker Hub :
```
sudo docker login
```
Marquez l'image afin de pouvoir vous y référer pour la gestion des versions lorsque vous la téléchargez sur Docker Hub :
```
sudo docker tag <your-image-id> <your-docker-hub-name>/<your-app-name>

sudo docker push <your-docker-hub-name>/<your-app-name>
```
^{(Chaimaa Zyami, CC BY-SA 4.0)}
Vérifiez l'ID de votre image en exécutant sudo docker images.

Déployer le modèle sur un cluster Kubernetes

Créez un projet sur la plate-forme Kubermatic Kubernetes, puis créez un cluster Kubernetes à l'aide du didacticiel de démarrage rapide.

^{(Chaimaa Zyami, CC BY-SA 4.0)}
Téléchargez le kubeconfig utilisé pour configurer l'accès à votre cluster, remplacez-le dans le répertoire de téléchargement et exportez-le dans votre environnement :

^{(Chaimaa Zyami, CC BY-SA 4.0)}
À l'aide de kubectl, vérifiez les informations du cluster, telles que les services que kube-system démarre sur votre cluster :
```
kubectl cluster-info
```
^{(Chaimaa Zyami, CC BY-SA 4.0)}

Pour exécuter le conteneur dans le cluster, vous devez créer un déploiement (deployment.yaml) et l'appliquer au cluster :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubermatic-dl-deployment
spec:
  selector:
    matchLabels:
      app: kubermatic-dl
  replicas: 3
  template:
    metadata:
      labels:
        app: kubermatic-dl
    spec:
     containers:
     - name: kubermatic-dl
       image: kubermatic00/kubermatic-dl:latest
       imagePullPolicy: Always
       ports:
       - containerPort: 8080

kubectl apply -f deployment.yaml

Pour exposer votre déploiement au monde extérieur, vous avez besoin d'un objet de service qui créera une adresse IP accessible de l'extérieur pour votre conteneur :
```
kubectl expose deployment kubermatic-dl-deployment  --type=LoadBalancer --port 80 --target-port 5000
```
Tu y es presque! Vérifiez vos services pour déterminer l'état de votre déploiement et obtenez l'adresse IP permettant d'appeler votre API de reconnaissance d'image :
```
kubectl get service
```
^{(Chaimaa Zyami, CC BY-SA 4.0)}
Testez votre API avec ces deux images en utilisant l'IP externe :

^{(Chaimaa Zyami, CC BY-SA 4.0)}
^{(Chaimaa Zyami, CC BY-SA 4.0)}
^{(Chaimaa Zyami, CC BY-SA 4.0)}

Résumé

Dans ce didacticiel, vous avez créé un modèle d'apprentissage profond destiné à servir d'API REST à l'aide de Flask. Il a placé l'application dans un conteneur Docker, a téléchargé le conteneur sur Docker Hub et l'a déployé avec Kubernetes. Ensuite, avec seulement quelques commandes, Kubermatic Kubernetes Platform a déployé l'application et l'a exposée au monde.