Tutoriel FastAPI : Introduction à l'utilisation de FastAPI

Les API (interfaces de programmation d'applications) sont l'épine dorsale de l'architecture moderne car elles permettent aux applications d'être modulaires et découplées. Cela signifie que vous pouvez créer des applications rapidement et facilement, ce qui vous permet de les maintenir et de les mettre à jour aisément. 

Les API sont également très importantes pour l'apprentissage automatique car elles permettent à différentes applications de partager des données et de travailler ensemble, ce qui permet d'économiser du temps et des efforts. Il existe de nombreux frameworks différents pour construire des API en Python. Parmi les frameworks les plus populaires pour la création d'API en Python, on trouve Django, Flask et FastAPI. Ce tutoriel est une plongée en profondeur dans l'un des frameworks appelé FastAPI.

Qu'est-ce qu'une API ?

API est l'abréviation de Application Programming Interface (interface de programmation d'applications). Une API est un intermédiaire logiciel qui permet à deux applications de communiquer entre elles. Lorsque vous utilisez une application sur votre téléphone, celle-ci se connecte à Internet et envoie des données à un serveur. Le serveur traite ensuite les données et les renvoie à votre téléphone. L'application sur votre téléphone interprète alors les données et vous les présente de manière lisible. 

Une API est comme un serveur dans un restaurant. Le serveur prend votre commande et la transmet à la cuisine. La cuisine prépare ensuite les plats et les renvoie au serveur. Le serveur vous apporte ensuite la nourriture. 

De la même manière, une API reçoit une requête d'une application et l'envoie à un serveur. Le serveur traite ensuite la demande et renvoie les données à l'application. L'application interprète ensuite les données et les présente à l'utilisateur.

Source de l'image : https://www.techfunnel.com/wp-content/uploads/2021/07/api.png

Si vous souhaitez en savoir plus sur les pipelines d'apprentissage automatique, les API et les MLOps, vous pouvez consulter notre tutoriel sur l'apprentissage automatique, les pipelines, le déploiement et les MLOps.

Qu'est-ce que FastAPI ?

FastAPI est un framework web performant pour la construction d'API avec Python 3.7+, basé sur les indices de type standard de Python. Il aide les développeurs à créer des applications rapidement et efficacement. FastAPI est construit au-dessus du serveur web Starlette et comprend des fonctionnalités qui facilitent la création d'applications web, telles que la validation automatique des données, la gestion des erreurs et des documents interactifs sur les API. 

Nous examinerons toutes ces caractéristiques individuellement dans cette section. Tout d'abord, examinons les principales caractéristiques, telles qu'elles figurent dans la documentation originale de FastAPI.

• Performance: Au même titre que NodeJS et le langage Go.
• La vitesse: Augmentez la vitesse de développement de 2 à 3 fois.
• Facile: Excellente prise en charge de l'éditeur. Achèvement partout. Facile à apprendre et à utiliser.
• Robuste: Code prêt à la production avec documentation interactive automatique.
• Basé sur OpenAPI: Entièrement compatible avec OpenAPI et JSON Schema.

Installation de FastAPI

FastAPI nécessite Python 3.7+. Il peut être installé à l'aide de pip. Vous devrez installer FastAPI et le serveur ASGI `uvicorn`.

``

# install fastapi

pip install fastapi




# install uvicorn
pip install uvicorn

``

Créer une API simple

Passons directement à la création d'une API jouet très simple. J'utilise VS Code pour réaliser cette opération, mais vous pouvez utiliser l'éditeur de votre choix.

```

from typing import Union

from fastapi import FastAPI




app = FastAPI()




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}

```

(Exemple reproduit à partir de la documentation originale). Merci à @tiangolo.

Maintenant, en utilisant un terminal de ligne de commande, exécutez cette API avec la commande suivante :

```

uvicorn main:app –reload

```

`main` est le nom du fichier Python, et `app` est la variable qui stocke la classe FastAPI. Vous pouvez leur donner le nom que vous voulez. Une fois que vous aurez exécuté la commande ci-dessus, vous verrez quelque chose comme ceci dans votre terminal :

Allez sur le lien dans votre navigateur, et si vous voyez une page qui affiche "Hello World", l'API est opérationnelle.

Image par l'auteur

Félicitations pour la création de votre première API. 

Documents interactifs sur l'API

FastAPI génère un "schéma" avec toutes vos API en utilisant le standard OpenAPI pour définir les API. Un "schéma" est une définition ou une description de quelque chose. Il ne s'agit pas du code qui le met en œuvre, mais d'une description abstraite. Le schéma OpenAPI est le moteur des deux systèmes de documentation interactive inclus dans FastAPI.

Pour voir la documentation, ajoutez simplement `/docs` à l'url (`http://127.0.0.1:8000/docs`). Ce lien vous permettra d'accéder à la documentation interactive automatique de l'API.

Image par l'auteur

Cliquez sur le bouton "Try it out" dans le coin supérieur droit pour tester l'API.

Image par l'auteur

Vous pouvez voir que le corps de la réponse est un dictionnaire. C'est l'appel de retour de la fonction `read_item` définie dans le fichier `main.py`. Vous pouvez également voir l'url de la requête `http://127.0.0.1:8000/items/1?q=orange`. `1` et `orange` sont nos entrées dans l'API.

Une documentation automatique interactive alternative est disponible dans FastAPI. Pour le vérifier, rendez-vous sur http://127.0.0.1:8000/redoc`. Voici à quoi cela ressemble :

Image par l'auteur

Exemples plus avancés

Lors de la création d'une API, le "chemin" définit l'itinéraire ou le point d'arrivée de la demande. Cependant, il y a encore un choix à faire, celui de l'opération. Le mot "opération" fait ici référence à l'une des "méthodes" HTTP. En utilisant une (ou plusieurs) de ces "méthodes", vous pouvez communiquer avec chacun des différents chemins pris en charge par le protocole HTTP. En règle générale, vous utiliserez :

• POST: pour créer des données.
• GET: pour lire des données.
• PUT: pour mettre à jour les données.
• DELETE: pour supprimer les données.
• Et quelques autres avancées 

FastAPI supporte toutes les méthodes http. 

Le fait que FastAPI s'appuie sur les indices de type de Python est encore un autre aspect clé de ce cadre. Les indications de type sont prises en charge dans les versions de Python 3.6 et ultérieures. Les indications de type sont un type de syntaxe spécialisé qui permet de déclarer le type d'une variable. 

Déclarer des types pour vos variables permet aux éditeurs et autres outils de vous fournir une assistance améliorée. Voyons un exemple avancé.

Nous allons modifier notre fichier `main.py` pour inclure une nouvelle requête `PUT` qui acceptera plusieurs entrées de différents types de données. 

```

from typing import Union




from fastapi import FastAPI

from pydantic import BaseModel




app = FastAPI()




class Item(BaseModel):

    name: str

    price: float

    is_offer: Union[bool, None] = None




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}




@app.put("/items/{item_id}")

def update_item(item_id: int, item: Item):

    return {"item_name": item.name, "item_id": item_id}

```

(Exemple reproduit à partir de la documentation originale). Merci à @tiangolo.

Le changement :

Une requête `put` est ajoutée qui prend deux entrées. `item_id` est un entier et `item` type pointe vers la classe personnalisée `Item` créée et héritant du `BaseModel` de `pydantic`. La classe `Item` contient trois attributs : `name`, `price`, `is_offer`, et tous ont des types de données différents.

FastAPI vérifiera : 

• `name` est une `str`.
• `price` est un `float`.
• `is_offer` est un bool, s'il est présent.

L'avantage d'utiliser des indices de type est que vous déclarez une seule fois les types des paramètres, du corps, etc. en tant que paramètres de fonction avec Python standard (3.6+). Vous recevrez :

• Prise en charge de l'éditeur, y compris l'autocomplétion, les vérifications de type
• Validation des données
• Conversion des données d'entrée
• Conversion des données de sortie
• Des erreurs faciles à comprendre.

Comparaison de FastAPI avec Django et Flask

Ces trois frameworks sont des frameworks web Python que vous pouvez utiliser pour développer des applications web. Ils ont chacun leurs forces et leurs faiblesses.

Django est un framework complet qui inclut tout ce dont vous avez besoin pour démarrer, y compris un ORM intégré et un panneau d'administration. Il peut être un peu difficile à comprendre pour les débutants, mais sa documentation complète facilite son apprentissage.

Flask est un microframework léger et facile à utiliser. Il ne comprend pas autant de fonctionnalités que Django, mais il est parfait pour les projets simples.

FastAPI est un nouveau cadre conçu pour être rapide et facile à utiliser. Il comprend des fonctionnalités telles que la validation automatique des données et la documentation. 

Performances de l'interface FastAPI

Selon les résultats des tests effectués par techempower, FastAPI est supérieur à tous les autres frameworks en termes de performances globales. 

Source : https://www.techempower.com/benchmarks/

Exemple : Construire un pipeline d'apprentissage automatique de bout en bout avec PyCaret et le déployer avec FastAPI 

Dans cette section, nous allons rapidement construire un pipeline d'apprentissage automatique, puis créer une API pour servir le modèle. Nous utiliserons une bibliothèque Python low-code , PyCaret, pour construire un pipeline et créer une API. PyCaret est intégré à FastAPI, ce qui facilite grandement la création et l'utilisation de modèles d'apprentissage automatique en tant qu'API.

PyCaret

PyCaret est une bibliothèque d'apprentissage automatique open-source et low-code en Python qui automatise les flux de travail d'apprentissage automatique. Il s'agit d'un outil d'apprentissage automatique et de gestion de modèles de bout en bout qui accélère le cycle d'expérimentation de manière exponentielle et vous rend plus productif.

```

pip install pycaret

```




```

import pycaret

pycaret.__version__

>>> 2.3.10

```

Dans cet exemple, nous utiliserons l'ensemble de données `insurance`. Il s'agit d'un cas d'utilisation de régression pour prédire les frais médicaux en fonction de l'âge, du sexe, de l'IMC et de la région. 

```

from pycaret.datasets import get_data

data = get_data(‘insurance’)

```

Image par l'auteur

Ensuite, nous allons initialiser la fonction `setup` de pycaret. Cette fonction initialise l'expérience dans PyCaret et crée le pipeline de transformation sur la base de tous les paramètres passés dans la fonction. 

La fonction `setup` doit être exécutée avant toute autre fonction. Il a besoin de deux paramètres pour fonctionner : `data` et `target`. Tous les autres arguments de `setup` sont optionnels. La fonction `setup` est responsable du contrôle de l'ensemble des procédures de prétraitement des données. Consultez la documentation de PyCaret pour un aperçu complet de toutes les procédures de prétraitement prises en charge par PyCaret.

```

from pycaret.regression import *

s = setup(data, target = 'charges')

```

Image par l'auteur Sortie tronquée.

Une fois la configuration terminée, nous pouvons commencer l'apprentissage et la sélection des modèles avec une seule ligne de code : `compare_models`. Grâce à la validation croisée, cette fonction entraîne et évalue les performances de tous les estimateurs de la bibliothèque de modèles. Le résultat de cette fonction est une grille de notation qui contient les notes moyennes obtenues lors de la validation croisée.