AI Deploy - Tutoriel - Déployer et appeler un classificateur de spam avec FastAPI

Objectif

L’objectif de ce tutoriel est de déployer une API de classification de spam.

Le cas d’usage est le Spam Ham Collection Dataset.

L’objectif de ce tutoriel est de montrer comment il est possible de créer, déployer et appeler une API avec AI Deploy.

Pour cela, nous utiliserons FastAPI, un framework web pour développer des API RESTful en Python. Vous apprendrez également à construire et utiliser une image Docker personnalisée pour une API FastAPI.

Prérequis

• Un projet AI Deploy créé au sein d’un projet Public Cloud dans votre compte OVHcloud ;
• Un utilisateur pour AI Deploy ;
• Docker installé sur votre ordinateur local ;
• Quelques connaissances sur la construction d’image et de Dockerfile ;
• Vous devez également avoir suivi le tutoriel AI Notebooks - Tutoriel - Construire votre classificateur de spam. Retrouvez le code sur le dépôt GitHub. Vous pourrez y comprendre la création du modèle de classification de spam.

En pratique

Vous allez suivre différentes étapes pour construire votre app FastAPI.

• Plus d’informations sur les capacités de FastAPI sont disponibles ici.
• Le lien direct vers le code complet est disponible ici.

Nous verrons ici principalement comment écrire les codes model.py et app.py, le fichier requirements.txt et le Dockerfile. Si vous souhaitez consulter le code complet, veuillez vous référer au dépôt GitHub.

Créer l’API

Deux fichiers Python sont créés pour définir le modèle et construire l’API.

Définir le fichier model.py

Ce fichier Python est dédié à la construction et à la définition du modèle de régression logistique. Vous trouverez le code complet ici.

D’abord, nous devons charger le Spam Ham Collection Dataset.

def load_data():

    PATH = 'SMSSpamCollection'
    df = pd.read_csv(PATH, delimiter = "\t", names=["classe", "message"])
    X = df['message']
    y = df['classe']

    return X, y

Ensuite, nous créons la fonction permettant de diviser le jeu de données pour l’entraînement et le test.

def split_data(X, y):

    ntest = 2000/(3572+2000)
    X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=ntest, random_state=0)

    return X_train, y_train

La dernière fonction nous permet de construire le modèle.

def spam_classifier_model(Xtrain, ytrain):

    model_logistic_regression = LogisticRegression()
    model_logistic_regression = model_logistic_regression.fit(Xtrain, ytrain)

    coeff = model_logistic_regression.coef_
    coef_abs = np.abs(coeff)

    quantiles = np.quantile(coef_abs,[0, 0.25, 0.5, 0.75, 0.9, 1])

    index = np.where(coeff[0] > quantiles[1])
    newXtrain = Xtrain[:, index[0]]

    model_logistic_regression = LogisticRegression()

    model_logistic_regression.fit(newXtrain, ytrain)

    return model_logistic_regression, index

# extract input and output data
data_input, data_output = load_data()

# split data
X_train, ytrain = split_data(data_input, data_output)

# transform and fit training set
vectorizer = CountVectorizer(stop_words='english', binary=True, min_df=10)
Xtrain = vectorizer.fit_transform(X_train.tolist())
Xtrain = Xtrain.toarray()

# use the model and index for prediction
model_logistic_regression, index = spam_classifier_model(Xtrain, ytrain)

Écrire le fichier app.py

Initialisez une instance de FastAPI.

app = FastAPI()

Définissez le format des données.

class request_body(BaseModel):
    message : str

Traitez le message envoyé par l’utilisateur.

def process_message(message):

    desc = vectorizer.transform(message)
    dense_desc = desc.toarray()
    dense_select = dense_desc[:, index[0]]

    return dense_select

Définissez la méthode GET.

@app.get('/')
def root():
    return {'message': 'Welcome to the SPAM classifier API'}

Créez la méthode POST.

@app.post('/spam_detection_path')
def classify_message(data : request_body):

    message = [
        data.message
    ]

    if (not (message)):
        raise HTTPException(status_code=400, detail="Please Provide a valid text message")

    dense_select = process_message(message)
    label = model_logistic_regression.predict(dense_select)
    proba = model_logistic_regression.predict_proba(dense_select)

    if label[0]=='ham':
        label_proba = proba[0][0]
    else:
        label_proba = proba[0][1]

    return {'label': label[0], 'label_probability': label_proba}

Écrire le fichier requirements.txt pour l’API

Le fichier requirements.txt nous permettra d’indiquer tous les modules nécessaires au fonctionnement de notre application. Ce fichier sera utile lors de l’écriture du Dockerfile.

fastapi==0.87.0
pydantic==1.10.2
uvicorn==0.20.0
pandas==1.5.1
scikit-learn==1.1.3

Écrire le Dockerfile de l’application

Votre Dockerfile doit commencer par l’instruction FROM indiquant l’image parente à utiliser. Dans notre cas, nous choisissons de partir de l’image python:3.8 :

python:3.8

Créez le répertoire d’accueil et ajoutez-y vos fichiers :

WORKDIR /workspace
ADD . /workspace

Installez le fichier requirements.txt qui contient les modules Python nécessaires à l’aide d’une commande pip install ... :

RUN pip install -r requirements.txt

Définissez le port d’écoute du container :

EXPOSE 8000

Définissez le point d’entrée et la commande de lancement par défaut pour démarrer l’application :

ENTRYPOINT ["uvicorn"]
CMD ["app:app", "--host", "0.0.0.0"]

Donnez les droits d’accès corrects à un utilisateur ovhcloud (42420:42420) :

RUN chown -R 42420:42420 /workspace
ENV HOME=/workspace

Construire l’image Docker depuis le Dockerfile

Depuis le répertoire contenant votre Dockerfile, exécutez l’une des commandes suivantes pour construire l’image de votre application :

# Build the image using your machine's default architecture
docker build . -t fastapi-spam-classification:latest

# Build image targeting the linux/amd64 architecture
docker buildx build --platform linux/amd64 -t fastapi-spam-classification:latest .

• La première commande construit l’image en utilisant l’architecture par défaut de votre système. Cela peut fonctionner si votre machine utilise déjà l’architecture linux/amd64, requise pour exécuter des containers avec nos produits AI. Cependant, sur des systèmes avec une architecture différente (par exemple ARM64 sur Apple Silicon), l’image résultante ne sera pas compatible et ne pourra pas être déployée.

• La seconde commande cible explicitement l’architecture linux/amd64 afin de garantir la compatibilité avec nos services AI. Elle nécessite buildx, qui n’est pas installé par défaut. Si vous n’avez jamais utilisé buildx, vous pouvez l’installer en exécutant : docker buildx install

Tester en local (optionnel)

Lancez la commande Docker suivante pour exécuter votre application localement sur votre ordinateur :

docker run --rm -it -p 8000:8000 --user=42420:42420 fastapi-spam-classification:latest

Une fois démarrée, votre application devrait être disponible sur http://localhost:8000.

Envoyer l’image vers le registre partagé

Trouvez l’adresse de votre registre partagé en lançant cette commande :

ovhai registry list

Connectez-vous au registre partagé avec vos identifiants habituels d’utilisateur de la plateforme AI :

docker login -u <user> -p <password> <shared-registry-address>

Envoyez l’image compilée vers le registre partagé :

docker tag fastapi-spam-classification:latest <shared-registry-address>/fastapi-spam-classification:latest
docker push <shared-registry-address>/fastapi-spam-classification:latest

Lancer l’app AI Deploy

La commande suivante démarre une nouvelle app exécutant votre application FastAPI :

ovhai app run \
      --default-http-port 8000 \
      --cpu 4 \
      <shared-registry-address>/fastapi-spam-classification:latest

Interagir avec l’API déployée via le dashboard

En cliquant sur le lien de votre app AI Deploy, vous arriverez sur la page suivante.

Comment interagir avec votre API ?

Vous pouvez ajouter /docs à la fin de l’URL de votre app.

Elle fournit un dashboard complet pour interagir avec l’API !

Pour pouvoir envoyer un message à classifier, sélectionnez /spam_detection_path dans l’encadré vert. Cliquez sur Try it out et saisissez le message de votre choix dans la zone dédiée.

Pour obtenir le résultat de la prédiction, cliquez sur le bouton Execute.

Félicitations ! Vous avez obtenu le résultat de la prédiction avec le label et le score de confiance.

Aller plus loin

• Vous pouvez imaginer déployer un modèle IA avec un autre outil : Gradio. Lisez ce tutoriel.
• Une autre façon de créer une app AI Deploy consiste à utiliser Streamlit ! Suivez ce tutoriel.

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page Professional Services pour obtenir un devis et faire analyser votre projet par nos experts.

Votre avis nous intéresse !

N’hésitez pas à nous faire part de vos questions, retours et suggestions pour améliorer le service :

• Sur le serveur Discord OVHcloud