Recherche de site Web

Tutoriel FastAPI : Créez des API avec Python en quelques minutes

Vous souhaitez créer des API avec Python ? Apprenez à le faire à l'aide de FastAPI avec ce didacticiel étape par étape.

FastAPI est un framework Web populaire pour créer des API avec Python. C'est très simple à apprendre et il est apprécié des développeurs.

FastAPI exploite les astuces de type Python et est basé sur Pydantic. Cela simplifie la définition de modèles de données et de schémas de requête/réponse. Le framework valide automatiquement les données de demande par rapport à ces schémas, réduisant ainsi les erreurs potentielles. Il prend également en charge de manière native les points de terminaison asynchrones, ce qui facilite la création d'API performantes capables de gérer efficacement les opérations liées aux E/S.

Ce tutoriel vous apprendra comment créer votre première API avec FastAPI. De la configuration de votre environnement de développement à la création d'une API pour une simple application d'apprentissage automatique, ce didacticiel vous guide à travers toutes les étapes : définition des modèles de données, des points de terminaison de l'API, gestion des requêtes, etc. À la fin de ce didacticiel, vous comprendrez bien comment utiliser FastAPI pour créer des API rapidement et efficacement. Alors commençons.

Étape 1 : configurer l'environnement

FastAPI nécessite Python 3.7 ou version ultérieure. Assurez-vous donc d’avoir installé une version récente de Python. Dans le répertoire du projet, créez et activez un environnement virtuel dédié au projet :

$ python3 -m venv v1
$ source v1/bin/activate

La commande ci-dessus pour activer l'environnement virtuel fonctionne si vous êtes sous Linux ou MacOS. Si vous êtes un utilisateur Windows, consultez la documentation pour créer et activer des environnements virtuels.

Ensuite, installez les packages requis. Vous pouvez installer FastAPI et uvicorn en utilisant pip :

$ pip3 install fastapi uvicorn

Cela installe FastAPI et toutes les dépendances requises ainsi que uvicorn, le serveur que nous utiliserons pour exécuter et tester l'API que nous construisons. Étant donné que nous allons créer un modèle d'apprentissage automatique simple à l'aide de scikit-learn, installez-le également dans l'environnement de votre projet :

$ pip3 install scikit-learn

Une fois les installations terminées, nous pouvons passer au codage ! Vous pouvez trouver le code sur GitHub.

Étape 2 : Créer une application FastAPI

Créez un fichier main.py dans le répertoire du projet. La première étape consiste à créer une instance d'application FastAPI comme ceci :

# Create a FastAPI app
# Root endpoint returns the app description

from fastapi import FastAPI

app = FastAPI()

L'ensemble de données Iris est l'un des ensembles de données de jouets avec lesquels vous travaillez lorsque vous débutez en science des données. Il contient 150 enregistrements de données, 4 fonctionnalités et une étiquette cible (espèces de fleurs d'iris). Pour simplifier les choses, créons une API pour prédire les espèces d'iris.

Dans les étapes à venir, nous allons créer un modèle de régression logistique et créer un point de terminaison d'API pour la prédiction. Après avoir construit le modèle et défini le point de terminaison de l'API /predict/, vous devriez pouvoir envoyer une requête POST à l'API avec les fonctionnalités d'entrée et recevoir les espèces prédites en réponse.

Pour que cela soit utile, définissons également un point de terminaison racine qui renvoie la description de l'application que nous construisons. Pour ce faire, nous définissons la fonction get_app_description et créons le point de terminaison racine avec le décorateur @app comme ceci :

# Define a function to return a description of the app
def get_app_description():
	return (
    	"Welcome to the Iris Species Prediction API!"
    	"This API allows you to predict the species of an iris flower based on its sepal and petal measurements."
    	"Use the '/predict/' endpoint with a POST request to make predictions."
    	"Example usage: POST to '/predict/' with JSON data containing sepal_length, sepal_width, petal_length, and petal_width."
	)

# Define the root endpoint to return the app description
@app.get("/")
async def root():
	return {"message": get_app_description()}

L'envoi d'une requête GET au point de terminaison racine renvoie la description.

Étape 3 : Créer un classificateur de régression logistique

Jusqu'à présent, nous avons instancié une application FastAPI et défini un point de terminaison racine. Il est maintenant temps de faire ce qui suit :

  • Créez un modèle d'apprentissage automatique. Nous utiliserons un classificateur de régression logistique. Si vous souhaitez en savoir plus sur la régression logistique, lisez Création de modèles prédictifs : régression logistique en Python.
  • Définissez une fonction de prédiction qui reçoit les caractéristiques d'entrée et utilise le modèle d'apprentissage automatique pour effectuer une prédiction pour l'espèce (une parmi setosa, versicolor et virginica).

Nous construisons un classificateur de régression logistique simple à partir de scikit-learn et définissons la fonction predict_species comme indiqué :

# Build a logistic regression classifier
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression

# Load the Iris dataset
iris = load_iris()
X, y = iris.data, iris.target

# Train a logistic regression model
model = LogisticRegression()
model.fit(X, y)

# Define a function to predict the species
def predict_species(sepal_length, sepal_width, petal_length, petal_width):
	features = [[sepal_length, sepal_width, petal_length, petal_width]]
	prediction = model.predict(features)
	return iris.target_names[prediction[0]]

Étape 4 : Définir le modèle Pydantic pour les données d'entrée

Ensuite, nous devons modéliser les données que nous envoyons dans la requête POST. Ici, les caractéristiques en entrée sont la longueur et la largeur des sépales et des pétales, toutes des valeurs à virgule flottante. Pour modéliser cela, nous créons une classe IrisData qui hérite de la classe BaseModel de Pydantic comme ceci :

# Define the Pydantic model for your input data
from pydantic import BaseModel

class IrisData(BaseModel):
	sepal_length: float
	sepal_width: float
	petal_length: float
	petal_width: float

Si vous avez besoin d'un didacticiel rapide sur l'utilisation de Pydantic pour la modélisation et la validation des données, lisez Tutoriel Pydantic : La validation des données en Python rendue super simple.

Étape 5 : Créer un point de terminaison d'API

Maintenant que nous avons construit le classificateur et défini la fonction predict_species, nous pouvons créer le point de terminaison de l'API pour la prédiction. Comme précédemment, nous pouvons utiliser le décorateur @app pour définir le point de terminaison /predict/ qui accepte une requête POST et renvoie les espèces prédites :

# Create API endpoint
@app.post("/predict/")
async def predict_species_api(iris_data: IrisData):
	species = predict_species(iris_data.sepal_length, iris_data.sepal_width, iris_data.petal_length, iris_data.petal_width)
	return {"species": species}

Et il est temps d'exécuter l'application !

Étape 6 : Exécutez l'application

Vous pouvez exécuter l'application avec la commande suivante :

$ uvicorn main:app --reload

Ici, main est le nom du module et app est l'instance FastAPI. L'indicateur --reload garantit que l'application se recharge en cas de modification du code source.

Lors de l'exécution de la commande, vous devriez voir des messages INFO similaires :

INFO: 	Will watch for changes in these directories: ['/home/balapriya/fastapi-tutorial']
INFO: 	Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: 	Started reloader process [11243] using WatchFiles
INFO: 	Started server process [11245]
INFO: 	Waiting for application startup.
INFO: 	Application startup complete.
…
…

Si vous accédez à « http://127.0.0.1:8000 » (localhost), vous devriez voir la description de l'application :

Étape 7 : testez l'API

Vous pouvez désormais envoyer des requêtes POST au point de terminaison /predict/ avec les mesures des sépales et des pétales (avec des valeurs valides) et obtenir les espèces prédites. Vous pouvez utiliser un utilitaire de ligne de commande comme cURL. Voici un exemple :

curl -X 'POST' \
  'http://localhost:8000/predict/' \
  -H 'Content-Type: application/json' \
  -d '{
  "sepal_length": 5.1,
  "sepal_width": 3.5,
  "petal_length": 1.4,
  "petal_width": 0.2
}'

Pour cet exemple de requête, voici le résultat attendu :

{"species":"setosa"}

Conclusion

Dans ce didacticiel, nous avons expliqué la création d'une API avec FastAPI pour un modèle de classification simple. Nous avons modélisé les données d'entrée à utiliser dans les requêtes, défini les points de terminaison de l'API, exécuté l'application et interrogé l'API.

À titre d'exercice, prenez un modèle d'apprentissage automatique existant et créez une API dessus à l'aide de FastAPI. Bon codage !

Articles connexes