Voorspellingen aanbieden met een FastAPI-endpoint
Cursisten verpakken een joblib-model in een FastAPI POST-route die een JSON-payload accepteert en een voorspelling retourneert, en testen deze daarna met een curl-verzoek.
Voorspellingen aanbieden met een FastAPI-endpoint is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Van notebook naar productie-API
Een Jupyter-notebook is een uitstekende ontwikkelomgeving, maar een slecht systeem voor het aanbieden van modellen in productie. De gebruikelijke route van notebook naar productie is: een model trainen en opslaan met joblib, het verpakken in een REST API en die API implementeren als een dienst in een container. De API accepteert onbewerkte kenmerkwaarden als JSON, verwerkt ze via de getrainde verwerkingspijplijn en retourneert binnen milliseconden voorspellingen.
Waarom FastAPI voor het aanbieden van ML-modellen?
FastAPI is een modern Python-webframework dat is gebaseerd op Pydantic en Starlette. Het genereert automatisch interactieve documentatie (Swagger UI), valideert aanvraaglichamen met type hints en verwerkt asynchrone I/O efficiënt. FastAPI is populair voor het aanbieden van ML-modellen omdat je maar weinig standaardcode nodig hebt, het gelijktijdige aanvragen via asynchrone workers ondersteunt en natuurlijk samenwerkt met de Python-gegevenstypen die in sklearn en pandas worden gebruikt.
FastAPI en Uvicorn installeren
FastAPI heeft uvicorn nodig als ASGI-server om te kunnen draaien. Installeer beide met één opdracht. uvicorn is een asynchrone server met hoge prestaties die HTTP-verbindingen afhandelt en aanvragen doorstuurt naar de FastAPI-toepassing. In productie voer je uvicorn doorgaans uit achter een nginx-reverse-proxy met meerdere workerprocessen.
# pip install fastapi uvicorn[standard]
# Verify installation
from fastapi import FastAPI
from pydantic import BaseModel
import uvicorn
print('FastAPI ready')Het aanvraagschema definiëren met Pydantic
Pydantic-BaseModel-klassen definiëren de structuur van binnenkomende aanvragen. FastAPI gebruikt deze modellen om JSON-lichamen automatisch te valideren. Als een verplicht veld ontbreekt of het verkeerde type heeft, retourneert FastAPI een duidelijke 422-fout voordat je code überhaupt wordt uitgevoerd. Elk veld in het Pydantic-model komt overeen met één invoerkenmerk voor het model.
from pydantic import BaseModel
from typing import Optional
class IrisFeatures(BaseModel):
sepal_length: float
sepal_width: float
petal_length: float
petal_width: float
class PredictionResponse(BaseModel):
predicted_class: int
class_name: str
confidence: float
# Example input (FastAPI will validate this automatically)
input_data = IrisFeatures(sepal_length=5.1, sepal_width=3.5,
petal_length=1.4, petal_width=0.2)
print('Input:', input_data)Het model bij het opstarten laden
Laad het model eenmalig bij het opstarten, niet bij elke aanvraag. Een joblib-bestand bij elke voorspelling laden zou per aanvraag honderden milliseconden vertraging toevoegen. Gebruik een variabele op moduleniveau of een FastAPI-gebeurtenisafhandelaar voor lifespan om het model te laden wanneer de server start en het voor alle volgende aanvragen in het geheugen te houden.
import joblib
from contextlib import asynccontextmanager
from fastapi import FastAPI
ml_models = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# Startup: load model once
ml_models['iris'] = joblib.load('/tmp/iris_pipeline.joblib')
print('Model loaded at startup')
yield
# Shutdown: cleanup if needed
ml_models.clear()
app = FastAPI(title='Iris Predictor API', lifespan=lifespan)Het voorspellings-eindpunt maken
Definieer een POST-route die het Pydantic-invoermodel accepteert, dit omzet naar een NumPy-array, pipeline.predict en predict_proba aanroept en de voorspelling als een gestructureerd JSON-antwoord retourneert. FastAPI serialiseert Pydantic-antwoordmodellen automatisch.
import numpy as np
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
app = FastAPI()
model = None
@app.on_event('startup')
def load_model():
global model
model = joblib.load('/tmp/iris_pipeline.joblib')
CLASS_NAMES = ['setosa', 'versicolor', 'virginica']
@app.post('/predict')
def predict(features: IrisFeatures):
X = np.array([[features.sepal_length, features.sepal_width,
features.petal_length, features.petal_width]])
pred = int(model.predict(X)[0])
proba = float(model.predict_proba(X)[0].max())
return {
'predicted_class': pred,
'class_name': CLASS_NAMES[pred],
'confidence': round(proba, 4)
}Een eindpunt voor statuscontrole toevoegen
Een /health- of /ping-eindpunt is essentieel voor productiediensten. Load balancers en orkestratiesystemen (Kubernetes, ECS) roepen dit eindpunt periodiek aan om te controleren of de service actief is. Een gezonde reactie betekent dat de server draait EN dat het model is geladen. Retourneer 503 als het model niet kon worden geladen.
from fastapi import FastAPI
from fastapi.responses import JSONResponse
app = FastAPI()
@app.get('/health')
def health():
if model is None:
return JSONResponse(status_code=503,
content={'status': 'unhealthy', 'reason': 'model not loaded'})
return {'status': 'ok', 'model': 'iris_pipeline', 'version': '1.0.0'}
@app.get('/')
def root():
return {'message': 'Iris Predictor API — POST /predict to get a classification'}De server lokaal uitvoeren
Sla de FastAPI-app op in main.py en start deze met uvicorn main:app --reload. De vlag --reload start de server automatisch opnieuw bij wijzigingen in bestanden (alleen voor ontwikkeling). Ga naar http://localhost:8000/docs om de automatisch gegenereerde Swagger UI te bekijken, waarin je interactief voorspellingen kunt testen.
# Save to main.py then run:
# uvicorn main:app --host 0.0.0.0 --port 8000 --reload
# Test with curl:
# 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}'
#
# Expected response:
# {"predicted_class": 0, "class_name": "setosa", "confidence": 0.9981}
print('Command to start: uvicorn main:app --reload --port 8000')Het eindpunt testen met de requests-bibliotheek
Gebruik in een testscript of notebook requests.post om je actieve API aan te roepen. Zo gebruiken ook clienttoepassingen (mobiele apps, dashboards en andere microservices) de voorspellings-API. Dezelfde aanvraagindeling werkt vanuit elke taal, bijvoorbeeld curl, JavaScript fetch en de http.Client van Go.
import requests
url = 'http://localhost:8000/predict'
payload = {
'sepal_length': 6.3,
'sepal_width': 3.3,
'petal_length': 6.0,
'petal_width': 2.5
}
response = requests.post(url, json=payload)
if response.status_code == 200:
result = response.json()
print('Predicted class:', result['class_name'])
print('Confidence:', result['confidence'])
else:
print('Error:', response.status_code, response.text)Invoervalidatie en foutafhandeling
De Pydantic-validatie van FastAPI onderschept typefouten automatisch, maar je moet ook fouten op modelniveau afhandelen (bijvoorbeeld onverwachte NaN-waarden of invoer buiten het toegestane bereik). Gebruik try/except in de routefunctie en retourneer een 400- of 500-status met een betekenisvolle foutmelding. Voorkom dat je in productie interne foutdetails (stacktraces) aan API-aanroepers bekendmaakt.
from fastapi import FastAPI, HTTPException
import numpy as np
app = FastAPI()
@app.post('/predict')
def predict(features: IrisFeatures):
try:
X = np.array([[features.sepal_length, features.sepal_width,
features.petal_length, features.petal_width]])
if np.any(np.isnan(X)) or np.any(X < 0):
raise HTTPException(status_code=400,
detail='Input contains invalid values (NaN or negative)')
pred = int(model.predict(X)[0])
proba = float(model.predict_proba(X)[0].max())
return {'predicted_class': pred, 'confidence': round(proba, 4)}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail='Internal prediction error')Eindpunt voor batchvoorspellingen
Voeg voor toepassingen met een hoge verwerkingscapaciteit een batch-eindpunt toe dat een lijst met kenmerkverzamelingen accepteert en in één API-aanroep een lijst met voorspellingen retourneert. Batchverwerking vermindert netwerkoverhead en stelt het model in staat voorspellingen efficiënt te vectoriseren (sklearn predict verwerkt matrices).
from typing import List
from pydantic import BaseModel
import numpy as np
class BatchRequest(BaseModel):
instances: List[IrisFeatures]
@app.post('/predict/batch')
def predict_batch(batch: BatchRequest):
X = np.array([[f.sepal_length, f.sepal_width, f.petal_length, f.petal_width]
for f in batch.instances])
preds = model.predict(X).tolist()
probas = model.predict_proba(X).max(axis=1).tolist()
return {'predictions': [{'class': p, 'confidence': round(c, 4)}
for p, c in zip(preds, probas)]}Korte controle
Test je begrip van het aanbieden van ML-voorspellingen met FastAPI uit deze les.
Samenvatting van de les
In deze les heb je geleerd: FastAPI verpakt een met joblib geladen pipeline in een getypeerd REST-eindpunt met automatische JSON-validatie en Swagger-documentatie, laad het model eenmaal bij het opstarten om latentie door schijf-I/O per verzoek te voorkomen, en voeg altijd een /health-eindpunt toe zodat load balancers en orchestrators kunnen controleren of de service actief is. Hierna voegen we logging van voorspellingen toe aan de API en bespreken we datadrift en triggers voor het opnieuw trainen van het model.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Voorspellingen aanbieden met een FastAPI-endpoint” gratis?
Ja — de volledige tekst van “Voorspellingen aanbieden met een FastAPI-endpoint” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “Voorspellingen aanbieden met een FastAPI-endpoint”?
Cursisten verpakken een joblib-model in een FastAPI POST-route die een JSON-payload accepteert en een voorspelling retourneert, en testen deze daarna met een curl-verzoek. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Voorspellingen aanbieden met een FastAPI-endpoint”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Modellen opslaan met joblib en pickle
- Modellen versiebeheer geven: waarom bestandsnamen en metadata belangrijk zijn
- Voorspellingen aanbieden met een FastAPI-endpoint
- Voorspellingen monitoren: invoer en uitvoer loggen