0.0.1 🎯 Objectifs d’apprentissage
- Comprendre FastAPI et ses avantages pour la data science
- Créer des endpoints GET et POST
- Valider les données d’entrée avec Pydantic
- Servir un modèle ML via une API REST
- Documenter automatiquement avec Swagger/OpenAPI
📚 Prérequis : Python, Docker, scikit-learn
⏱️ Temps estimé : 3 heures
1 Pourquoi FastAPI ?
FastAPI combine performance (async), validation automatique (Pydantic) et documentation (Swagger). C’est le framework idéal pour servir des modèles ML en production.
| Framework | Performance | Validation | Doc auto | Async |
|---|---|---|---|---|
| Flask | Moyenne | Non | Non | Non |
| Django | Moyenne | Non | Plugins | Non |
| FastAPI | Excellente | Oui | Oui | Oui |
💡 Point clé
Pydantic valide automatiquement les entrées. Si un utilisateur envoie {"age": "abc"}, FastAPI retourne une erreur 422 avec un message clair — pas besoin d’écrire la validation manuellement.
2 Créer des endpoints
2.1 Première API
from fastapi import FastAPI
from pydantic import BaseModel, Field
app = FastAPI(title="API Tarification Assurance")
@app.get("/health")
def health():
return {"status": "ok"}
class ProfilAssure(BaseModel):
age: int = Field(..., ge=18, le=99)
zone: str
crm: float = Field(default=1.0, ge=0.5, le=3.5)
class PrimeResponse(BaseModel):
prime_pure: float
prime_commerciale: float
@app.post("/predict", response_model=PrimeResponse)
def predict(profil: ProfilAssure):
rel_age = 1.85 if profil.age < 26 else 1.0
rel_zone = {"paris": 1.45, "rural": 0.75}.get(profil.zone, 1.0)
prime_pure = 180 * rel_age * rel_zone * profil.crm
return PrimeResponse(
prime_pure=round(prime_pure, 2),
prime_commerciale=round(prime_pure / 0.70, 2)
)$ uvicorn main:app –reload –port 8000
INFO: Uvicorn running on http://127.0.0.1:8000
3 Servir un modèle ML
Charger le modèle au démarrage (pas à chaque requête) :
import pickle
# Chargé une seule fois
with open("models/glm.pkl", "rb") as f:
model = pickle.load(f)
@app.post("/predict")
def predict(profil: ProfilAssure):
features = [[profil.age, profil.puissance]]
pred = model.predict(features)[0]
return {"prime": round(float(pred), 2)}⚠️ Attention
Ne jamais charger le modèle à chaque requête — un fichier pickle de 50 Mo ajouterait 1-2 secondes de latence à chaque appel.
4 Dockeriser l’API
FROM python:3.10-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]\(</span> docker build -t api-scoring:v1 .<br> <span class="prompt">\) docker run -p 8000:8000 api-scoring:v1
5 Documentation Swagger
FastAPI génère automatiquement :
- Swagger UI à
/docs— interface interactive pour tester - ReDoc à
/redoc— documentation lisible - OpenAPI JSON à
/openapi.json— spécification standard
📝 Avantage clé : les équipes front-office peuvent tester l’API sans lire le code Python. Le format OpenAPI est reconnu par tous les outils d’intégration.
Synthèse
5.0.1 🎯 Les 5 points essentiels
- FastAPI = performance + validation + docs — Le framework idéal pour les APIs ML
- Pydantic valide automatiquement — Types, plages, champs obligatoires
- Charger le modèle au démarrage — Pas à chaque requête
- POST /predict — Envoyer un profil, recevoir une prime
- Docker pour déployer — Même API partout
Auto-évaluation
Réponse : Validation Pydantic automatique, documentation Swagger auto, support async, type hints natifs. Flask nécessite des plugins pour tout ça.
Réponse : Charger un pickle (10-100 Mo) à chaque requête ajouterait 0.5-2s de latence. Au démarrage, c’est fait une seule fois.
Réponse : HTTPException avec codes appropriés (400 données invalides, 500 erreur interne). Logger côté serveur, ne pas exposer les détails au client.
Réponse : Préfixer les routes (/v1/predict, /v2/predict). Permet de maintenir l’ancienne version pendant la transition.