Qu'est-ce qui rend une API intelligente ?

Je pratique le Machine Learning depuis près de 3-4 ans maintenant. Au cours de cette période, j'ai formé de nombreux modèles, mis en œuvre de nombreux pipelines de données, et bien plus encore. Remarque : J'ai définitivement collecté et nettoyé beaucoup plus de données que le nombre de modèles que j'ai pu construire .

L'un des aspects cruciaux de l'appartenance au spectre ML est de pouvoir rendre vos pensées ou vos implémentations facilement accessibles aux autres .

Laissez-moi vous expliquer cela.

Il peut s'agir d'expliquer à une personne non technique comment un algorithme fonctionne en termes simples, comment servir vos modèles dans une API, ou même documenter votre travail afin qu'une personne nouvelle dans vos projets puisse facilement se mettre au courant de ce que vous avez fait. loin, et bien d'autres encore. Dans cet article, nous allons nous concentrer sur les API .

L'API (Application Programming Interface) n'est rien d'autre qu'un moyen qui facilite la communication entre la source et l'utilisateur final . Presque toutes les applications que nous utilisons dans notre vie quotidienne comprennent des centaines (sinon plus) d'API effectuant le travail lourd dans le back-end afin que vous puissiez utiliser l'application à l'aise. Une API se comporte de manière requête-réponse . Cela peut varier entre quelques millisecondes et bien plus de quelques minutes.

Imaginez que vous allez chez Starbucks et que vous commandez un Frappuccino au caramel avec de la crème supplémentaire (mon préféré ) juste avant d'assister à cette très longue réunion

Que se passe-t-il ensuite ? Hé bien,

Vous attendriez probablement les 4 à 5 prochaines minutes au cours desquelles votre commande serait passée, puis elle serait préparée dans la cuisine et le serveur vous livrerait votre délicieux Frappuccino. Dans ce cas, vous êtes l' utilisateur final, la cuisine devient la source et le serveur qui vous apporte le Frappuccino de la cuisine agit comme une API .

Cela semble assez clair ?

Supposons maintenant que cela fait plus de 30 minutes et que votre Frappuccino ne vous a pas encore été donné. Ne perdriez-vous pas patience ? Ou du moins ne partiriez-vous pas pour assister à cette réunion que vous avez dans 10 minutes tout en vous sentant très déçu ?

C'est exactement ce que ressentirait l'utilisateur final de votre application s'il y avait beaucoup de retard pour renvoyer la réponse. La latence est essentielle lorsqu'il s'agit de concevoir l'application parfaite.

Supposons maintenant que même avec le meilleur artiste du café, préparer un Frappuccino au caramel ne prendrait rien de moins que 30 minutes. Souhaitez-vous toujours commander le Frappuccino ou opter pour une autre option qui a un temps de préparation moindre ? Dans la plupart des cas, vous opterez pour l'autre option, n'est-ce pas ?

Mais que se passe-t-il si le barista dit, comme je le cite, allez simplement à cette réunion, je m'assurerai que le Frappuccino est dans votre salle de conférence avant que vous n'y arriviez !

Sonne comme une affaire intéressante n'est-ce pas?

Pourquoi ne pouvons-nous pas créer une API qui pourrait se comporter de la même manière ?

Laisse-moi expliquer.

Vous pouvez créer une API qui renverra une réponse instantanément lorsque l'utilisateur envoie une requête à une API. Mais le travail lourd est effectué en arrière -plan ( cela peut/peut ne pas prendre un certain temps ). Avec une telle API, vous pouvez vous assurer que le temps d'exécution n'a jamais d'incidence sur le temps total nécessaire pour renvoyer une réponse.

Celery et FastAPI fournissent un mécanisme de messagerie optimisé. Dans cet article, nous allons nous concentrer uniquement sur FastAPI (merci à Sebastián Ramírez pour la création de ce GEM), qui est également mon framework d'API python préféré. Il prend en charge les tâches en arrière-plan, ce qui correspond parfaitement à ce dont nous avons discuté maintenant.

Si vous êtes nouveau sur FastAPI, veuillez consulter ce blog sur FastAPI pour obtenir un tremplin pour comprendre ce que je suis sur le point d'expliquer dans cet article.

Premiers pas avec FastAPI

À partir de là, je supposerai que vous savez comment construire une API de base à l'aide de FastAPI.

Allons-nous commencer?

Créons une API qui renverra "Hello world" après 10s.

from fastapi import FastAPI
import time

app = FastAPI()

@app.post("/myApp/timer")
def read_item():
    
    start = time.time() # start time
    time.sleep(10)
    end = time.time() # end time
    
    print(end - start) # print the time taken to return the response
    
    return {"response": "Hello world!"}

Vous pouvez remarquer que la réponse de l'API est renvoyée après 10.0037s et que l'instruction d'impression est également à peu près au même moment

Vous trouverez ci-dessous le temps nécessaire pour 10 appels API que j'ai effectués

Le temps moyen pris est d'environ 10.002s

Ajoutons maintenant la capacité de tâches en arrière-plan sur la même API. Pour ce faire, vous pouvez utiliser la fonctionnalité Tâches en arrière-plan dans FastAPI. Créez simplement une fonction appelée return_response qui affiche "Hello world!" en l'appelant. Appelez cette fonction en utilisant la méthode BackgroundTasks dans l'API et c'est tout !

from fastapi import BackgroundTasks, FastAPI
import time

app = FastAPI()

def return_response():
    start = time.time() # start time
    time.sleep(10)
    end = time.time() # end time
    
    print({
        "response": "Hello world!", 
        "time_taken": end - start
        })

@app.post("/myApp/timer")
def read_item(background_tasks: BackgroundTasks):
    start = time.time() # start time
    background_tasks.add_task(return_response) # background processing the function
    end = time.time() # end time
    
    return {
        "status": "processing in background",
        "time_taken": end - start
        }

Alors que la déclaration d'impression peut être vue dans le terminal après 10 secondes

Vous pouvez voir ici que le temps pris par l'API pour renvoyer la réponse est passé de 10,002 s à seulement 0,00034 s alors que l'instruction d'impression est donnée après 10,0043 s

La création d'une API de cette manière garantit que votre réponse est donnée presque instantanément en déplaçant le travail lourd en arrière-plan.

N'oubliez pas que la fonctionnalité BackgroundTasks ne fonctionnera mieux que dans les cas où votre application peut stocker la réponse de l'API dans une source externe (MySQL, DynamoDB, etc.) et n'exige pas que l'utilisateur final la visualise au moment de recevoir la réponse.

J'espère que cela vous aidera à restructurer votre API avec un temps de traitement beaucoup plus court. Je vous dis à bientôt avec des articles plus intéressants.