FastAPI-tutorial: een introductie tot het gebruik van FastAPI

API’s (Application Programming Interfaces) zijn de ruggengraat van moderne architectuur omdat ze applicaties modulair en losjes gekoppeld maken. Hierdoor kun je applicaties snel en eenvoudig bouwen, wat het onderhoud en updaten gemakkelijk maakt. 

API’s zijn ook heel belangrijk in machine learning omdat ze verschillende applicaties in staat stellen om data te delen en samen te werken, wat tijd en moeite bespaart. Er zijn veel verschillende frameworks voor het bouwen van API’s in Python. Enkele van de populairste frameworks voor het maken van API’s in Python zijn Django, Flask en FastAPI. Deze tutorial is een deep dive in een van die frameworks: FastAPI.

Als je dieper in dit onderwerp wilt duiken, raad ik deze cursus aan: Deploying AI Into Production With FastAPI.

Wat is een API?

API staat voor Application Programming Interface. Een API is een software-tussenlaag die twee applicaties met elkaar laat communiceren. Wanneer je een app op je telefoon gebruikt, maakt de app verbinding met internet en stuurt data naar een server. De server verwerkt vervolgens de data en stuurt die terug naar je telefoon. De app op je telefoon interpreteert de data en presenteert die op een leesbare manier aan jou. 

Een API is als een ober in een restaurant. De ober neemt je bestelling op en brengt die naar de keuken. De keuken bereidt het eten en geeft het terug aan de ober. De ober brengt het eten vervolgens naar je tafel. 

Op dezelfde manier neemt een API een verzoek van een applicatie aan en stuurt dat naar een server. De server verwerkt het verzoek en stuurt de data terug naar de applicatie. De applicatie interpreteert de data en presenteert die aan de gebruiker.

Beeldbron: https://www.techfunnel.com/wp-content/uploads/2021/07/api.png

Als je meer wilt leren over machine learning-pijplijnen, API’s en MLOps, bekijk dan onze Machine Learning, Pipelines, Deployment and MLOps Tutorial.

Wat is FastAPI

FastAPI is een high-performance webframework voor het bouwen van API’s met Python 3.7+, gebaseerd op standaard Python type hints. Het helpt ontwikkelaars om snel en efficiënt applicaties te bouwen. FastAPI is gebouwd bovenop de Starlette-webserver en bevat functies die het bouwen van webapplicaties eenvoudiger maken, zoals automatische datavalidatie, foutafhandeling en interactieve API-documentatie. 

We bekijken al deze features afzonderlijk in deze sectie. Laten we eerst de belangrijkste kenmerken bekijken zoals genoemd in de originele documentatie van FastAPI.

• Performance: Vergelijkbaar met NodeJS en de programmeertaal Go.
• Snelheid: Verhoogt de ontwikkelsnelheid 2-3x.
• Eenvoudig: Uitstekende editorondersteuning. Overal autocompletion. Makkelijk te leren en te gebruiken.
• Robuust: Productierijpe code met automatische interactieve documentatie.
• Gebaseerd op OpenAPI: Volledig compatibel met OpenAPI en JSON Schema.

FastAPI installeren

FastAPI vereist Python 3.7+. Je kunt het installeren met pip. Je moet FastAPI en de ASGI-server `uvicorn` installeren.

``

# install fastapi

pip install fastapi




# install uvicorn
pip install uvicorn

``

Maak een eenvoudige API

Laten we meteen beginnen met het maken van een heel simpele toy-API. Ik gebruik VS Code om dit te implementeren, maar je kunt elke editor gebruiken die je fijn vindt.

```

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}

```

(Voorbeeld gereproduceerd uit de originele documentatie). Dank aan @tiangolo.

Voer deze API nu uit via een commandoregelterminal met het volgende commando:

```

uvicorn main:app –reload

```

`main` is de naam van het Python-bestand, en `app` is de variabele die de FastAPI-klasse bewaart. Je kunt ze noemen zoals je wilt. Zodra je het bovenstaande commando uitvoert, zie je iets als dit in je terminal:

Ga in je browser naar de link, en als je een pagina ziet met `Hello World,` dan draait de API.

Afbeelding door de auteur

Gefeliciteerd met het bouwen van je eerste API. 

Interactieve API-docs

FastAPI genereert een "schema" met al je API’s via de OpenAPI-standaard voor het definiëren van API’s. Een "schema" is een definitie of beschrijving van iets. Niet de code die het implementeert, maar een abstracte beschrijving. Het OpenAPI-schema voedt de twee interactieve documentatiesystemen die in FastAPI zijn inbegrepen.

Om de documentatie te zien, voeg je gewoon `/docs` toe aan de URL (`http://127.0.0.1:8000/docs`). Deze link toont automatische interactieve API-documentatie.

Afbeelding door de auteur

Klik op de knop `Try it out` rechtsboven om de API te testen.

Afbeelding door de auteur

Je ziet dat de response body een dictionary is. Dit is de return-call van de functie `read_item` gedefinieerd in `main.py`. Je ziet ook de request-URL `http://127.0.0.1:8000/items/1?q=orange`. `1` en `orange` waren onze inputs voor de API.

Er is een alternatief voor de interactieve automatische documentatie in FastAPI. Ga hiervoor naar http://127.0.0.1:8000/redoc`. Zo ziet dat eruit:

Afbeelding door de auteur

Meer geavanceerde voorbeelden

Bij het bouwen van een API definieert het "pad" de route of endpoint van het verzoek. Er is hier echter nog een keuze, namelijk de “operatie”. Het woord `operation` verwijst hier naar een van de HTTP-"methoden". Door een (of meer) van deze zogenaamde "methoden" te gebruiken, kun je communiceren met elk van de verschillende paden die door het HTTP-protocol worden ondersteund. Meestal gebruik je:

• POST: om data te creëren.
• GET: om data te lezen.
• PUT: om data te updaten.
• DELETE: om data te verwijderen.
• En nog een paar geavanceerde 

FastAPI ondersteunt al deze HTTP-methoden. 

Dat FastAPI is gebouwd op Python type hints is nog een belangrijk aspect van dit framework. Type hints worden ondersteund in Python 3.6 en later. Type hints zijn een speciale soort syntax waarmee je het type van een variabele kunt declareren. 

Het declareren van types voor je variabelen stelt editors en andere tools in staat je beter te helpen. Laten we een geavanceerd voorbeeld bekijken.

We wijzigen ons `main.py`-bestand om een nieuw `PUT`-verzoek toe te voegen dat meerdere inputs van verschillende datatypes accepteert. 

```

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}

```

(Voorbeeld gereproduceerd uit de originele documentatie). Dank aan @tiangolo.

De wijziging:

Er is een `put`-verzoek toegevoegd dat twee inputs neemt. `item_id` is een integer en het type `item` verwijst naar de custom class `Item` die is gemaakt en `BaseModel` van `pydantic` erft. De klasse `Item` bevat drie attributen: `name`, `price`, `is_offer`, en ze hebben elk een ander datatype.

FastAPI controleert: 

• `name` is een `str`.
• `price` is een `float`.
• `is_offer` is een bool, indien aanwezig.

Het voordeel van het gebruik van type hints is dat je één keer de types van parameters, body, enz. declareert als functieparameters met standaard Python (3.6+). Je krijgt:

• Editorondersteuning, inclusief autocompletion en typechecks
• Datavalidatie
• Conversie van invoergegevens
• Conversie van uitvoergegevens
• Fouten die makkelijk te begrijpen zijn.

Vergelijking van FastAPI met Django en Flask

Alle drie deze frameworks zijn Python-webframeworks die je kunt gebruiken om webapplicaties te ontwikkelen. Ze hebben elk hun eigen sterke en zwakke punten.

Django is een full-featured framework dat alles bevat wat je nodig hebt om te starten, waaronder een ingebouwde ORM en een adminpaneel. Het kan wat overweldigend zijn voor beginners, maar de uitgebreide documentatie maakt het makkelijk te leren.

Flask is een microframework dat lichtgewicht is en makkelijk om mee te beginnen. Het bevat niet zoveel features als Django, maar is perfect voor eenvoudige projecten.

FastAPI is een nieuw framework dat is ontworpen om snel en gebruiksvriendelijk te zijn. Het bevat functies zoals automatische datavalidatie en documentatie. 

Prestatiebenchmarks van FastAPI

Volgens de resultaten van tests uitgevoerd door techempower is FastAPI superieur aan alle andere frameworks qua algehele performance. 

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

Voorbeeld: een end-to-end machine learning-pijplijn bouwen met PyCaret en deployen met FastAPI 

In deze sectie bouwen we snel een machine learning-pijplijn en maken daarna een API om het model te serveren. We gebruiken de low-code Python-bibliotheek PyCaret om een pijplijn te bouwen en een API te maken. PyCaret heeft integratie met FastAPI, waardoor het extreem eenvoudig wordt om machine learning-modellen als een API te maken en te serveren.

PyCaret

PyCaret is een open-source, low-code machine learning-bibliotheek in Python die ML-workflows automatiseert. Het is een end-to-end tool voor machine learning en modelbeheer die de experimenteercyclus exponentieel versnelt en je productiever maakt.

```

pip install pycaret

```




```

import pycaret

pycaret.__version__

>>> 2.3.10

```

We gebruiken de dataset `insurance` in dit voorbeeld. Het is een regressiecasus voor het voorspellen van medische kosten op basis van leeftijd, geslacht, BMI en regio. 

```

from pycaret.datasets import get_data

data = get_data(‘insurance’)

```

Afbeelding door de auteur

Vervolgens initialiseren we de functie `setup` van pycaret. Deze functie initialiseert het experiment in PyCaret en maakt de transformatiepijplijn op basis van alle parameters die aan de functie zijn doorgegeven. 

De `setup` moet eerst worden uitgevoerd voordat je andere functies gebruikt. Er zijn twee parameters nodig: `data` en `target`. Alle overige argumenten in `setup` zijn optioneel. De `setup`-functie is verantwoordelijk voor het aansturen van het volledige datapreprocessing-proces. Bekijk de PyCaret-documentatie voor een volledig overzicht van alle preprocessing-procedures die in PyCaret worden ondersteund.

```

from pycaret.regression import *

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

```

Afbeelding door de auteur Output ingekort.

Zodra de setup klaar is, kunnen we met één regel code starten met modeltraining en -selectie: `compare_models`. Met cross-validatie traint en evalueert deze functie de modelprestaties van alle estimators binnen de modellibrary. Het resultaat is een scoretabel met de gemiddelde scores verkregen uit cross-validatie.