Déployer un modèle de Machine Learning avec Flask

C’est bien d’implémenter un modèle de machine learning performant. Mais ce dernier n’aura pas grand intérêt s’il ne peut être utilisé dans « une application ». En effet, après l’entraînement d’un modèle, ce dernier n’est pas tout à fait prêt à être utilisé. Il nous faut le écrire du code supplémentaire afin qu’il puisse effectivement servir. Dans cet article nous montrerons, à travers un exemple simple, comment déployer un modèle de machine learning sur un serveur web en utilisant Flask.

Le modèle utilisé

Dans ce tuto, nous utiliserons le modèle d’analyse de sentiments entraîné dans cet article. Ce modèle est un fine-tuning de CamemBERT et a été entraîné sur des reviews de films laissés sur allociné. Pour chaque avis donnée sous forme de texte écrit en français, le modèle est capable de nous dire s’il s’agit d’un avis « plutôt positif » ou « plutôt négatif ».

Objetctif de ce tuto

Notre but aujourd’hui est de pouvoir exposer le modèle entraîné afin qu’il soit utilisable. Pour celà, nous allons créer une application web qui donne la possibilité à un utilisateur (ou une autre application) de faire une « prédiction » avec le modèle via une simple requête web.

Architecture

Notre application ressemble à :

Les différents éléments de l’application sont :

• Le modèle : Il s’agit du modèle que l’on a entraîné. En vérité, il s’agit de l’état du modèle. Qui n’est rien d’autre qu’un fichier .pt, qui est en fait, un dictionnaire qui contient tous les paramètres du modèle entraîné.
• Le pipeline ML : Il s’agit d’un ensemble fonctions permettant de faire des traitements sur la donnée brute afin de pouvoir prédire avec le modèle. Le pipeline servira donc d’interface entre la donnée brute et le format à l’entrée du modèle.
• Le serveur web : Serveur Flask qui expose l’application et donne donc la possibilité au client de faire une prédiction via une requête web.

Les flux d’utilisation de notre application est tout ce qu’il y a de plus simple :

• Étape 1 – Requête du client : Le client fait une requête avec sont texte à analysé en valeur d’un paramètre qu’on va appeler text. Example : GET http://serveur.ml?text= »ce film est excellent ».
• Étape 2 – Prédiction : Le serveur appelle la fonction predict du pipeline avec pour paramètre le text « ce film est excellent ». Le pipeline va encoder ce texte et le passer à l’entrée du modèle.
• Étape 3 – Envoi de la prédiction au serveur : Le pipeline décode les vecteurs rendus par le modèle de sorte à ce que les résultats soient compréhensible par l’utilisateur. En pratique, il va juste remplacer les 0 par « négatif » et les 1 par « positif ». Ce résultat intélligible est ensuite envoyé au serveur.
• Étape 4 – Envoi du résultat au client : Le serveur envoie le résultat (« positif » ou « négatif ») au client.

Implémentation

1. Bibliothèques

Les bibliothèques utilisées pour notre appli sont les suivantes :

• Transformers : La bibliothèque utilisée pour fine-tuner notre CamemBERT lors de l’implémentation du modèle. On la réutilise pour charger notre modèle entraîné.
• Pytorch : La bibliothèque de deep learning avec laquelle on a entraîné notre modèle. Elle va également nous permettre de charger notre modèle et de faire des opération sur celui-ci.
• Flask : Le célèbre framework va nous permettre de créer notre serveur web et d’y exposer notre modèle.

2. Pipeline

Le pipeline est un module qui contient les fonction pour, charger le modèle, encoder le texte brut, prédire avec le modèle et décoder les prédictions du modèle.

import torch
from transformers import CamembertForSequenceClassification, CamembertTokenizer


# Chargement du model
state_dict = torch.load("./sentiments.pt")
MODEL = CamembertForSequenceClassification.from_pretrained(
                'camembert-base',
                state_dict=state_dict)

# Chargement du tokenizer
TOKENIZER = CamembertTokenizer.from_pretrained(
                'camembert-base',
                do_lower_case=True)

def encode(reviews, tokenizer=TOKENIZER):
    encoded_batch = tokenizer.encode_plus([reviews],
                                        add_special_tokens=True,
                                        pad_to_max_length=True,
                                        return_attention_mask=True,
                                        return_tensors = 'pt')

    return encoded_batch['input_ids'], encoded_batch['attention_mask']

def decode(encoded_results):
    """
    Transforme 0 et 1 respectivement en "negatif" et "positif"
    """
    # On récupère le scalair contenu dans le tensor
    encoded_results = encoded_results.item()
    if encoded_results == 1:
        return "Positif"
    return "Négatif"

def predict(reviews, model=MODEL, tokenizer=TOKENIZER):
    with torch.no_grad():
        model.eval()
        input_ids, attention_mask = encode(reviews)
        output = model(input_ids, attention_mask=attention_mask)
        
        return decode(torch.argmax(output[0], dim=1))

Il suffit donc d’appeler predict avec un texte en paramètre pour obtenir la polarité de ce dernier.

3. Serveur Flask

Notre serveur consiste en un unique endpoint qu’on va appeler « predict ».

import pipeline
from flask import Flask, jsonify, request


app = Flask(__name__)

@app.route("/predict", methods=['GET'])
def get_prediction():
    text = request.args.get('text')
    polarity = pipeline.predict(text)

    return jsonify(polarity=polarity)

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

On lance notre serveur en faisant python serveur.py

Vous pouvez tester dans votre navigateur ou juste faire :

GET http://localhost:5000/predict?text=ce%20film%20est%20excellent

{
  "polarity": "Positif"
}

Conclusion

On vient de voir comment exposer son modèle de machine learning après entraînement. On a utilisé un Flask comme serveur web. Être capable de déployer son modèle est une compétence indispensable aujourd’hui. Il faut au minimum être capable de créer une API REST pour exposer le modèle.

J’espère que cet article vous aura plu. N’hésitez pas à laisser un commentaire.