Kurs
FastAPI Tutorial: Eine Einführung in die Verwendung von FastAPI
API (Application Programming Interface) sind das Rückgrat der modernen Architektur, weil sie es ermöglichen, Anwendungen modular und entkoppelt zu gestalten. Das bedeutet, dass du schnell und einfach Anwendungen erstellen kannst, die sich leicht warten und aktualisieren lassen.
APIs sind auch beim maschinellen Lernen sehr wichtig, weil sie es verschiedenen Anwendungen ermöglichen, Daten auszutauschen und zusammenzuarbeiten, was Zeit und Mühe spart. Es gibt viele verschiedene Frameworks für die Erstellung von APIs in Python. Einige der beliebtesten Frameworks für die Erstellung von APIs in Python sind Django, Flask und FastAPI. Dieses Tutorial ist ein tiefer Einblick in eines der Frameworks namens FastAPI.
Was ist eine API?
API steht für Application Programming Interface. Eine API ist ein Software-Vermittler, der es zwei Anwendungen ermöglicht, miteinander zu kommunizieren. Wenn du eine Anwendung auf deinem Telefon verwendest, verbindet sich die Anwendung mit dem Internet und sendet Daten an einen Server. Der Server verarbeitet dann die Daten und sendet sie zurück an dein Telefon. Die Anwendung auf deinem Handy interpretiert dann die Daten und präsentiert sie dir in einer lesbaren Form.
Eine API ist wie ein Kellner in einem Restaurant. Der Kellner nimmt deine Bestellung auf und schickt sie an die Küche. Die Küche bereitet dann das Essen zu und schickt es an den Kellner zurück. Der Kellner bringt dann das Essen zu dir.
Auf die gleiche Weise nimmt eine API eine Anfrage von einer Anwendung entgegen und sendet sie an einen Server. Der Server verarbeitet dann die Anfrage und sendet die Daten zurück an die Anwendung. Die Anwendung interpretiert dann die Daten und präsentiert sie dem/der Nutzer/in.
Image Source: https://www.techfunnel.com/wp-content/uploads/2021/07/api.png
Wenn du mehr über Pipelines für maschinelles Lernen, APIs und MLOps erfahren möchtest, kannst du dir unser Tutorial zu maschinellem Lernen, Pipelines, Bereitstellung und MLOps ansehen.
Was ist FastAPI?
FastAPI ist ein leistungsfähiges Web-Framework für die Erstellung von APIs mit Python 3.7+, das auf Standard-Python-Typ-Hinweisen basiert. Es hilft Entwicklern, Anwendungen schnell und effizient zu erstellen. FastAPI baut auf dem Starlette-Webserver auf und enthält Funktionen, die das Erstellen von Webanwendungen erleichtern, z. B. automatische Datenvalidierung, Fehlerbehandlung und interaktive API-Dokumente.
In diesem Abschnitt werden wir alle diese Funktionen einzeln betrachten. Schauen wir uns zunächst die wichtigsten Funktionen an, die in der Originaldokumentation von FastAPI beschrieben sind.
- Leistung: Auf Augenhöhe mit NodeJS und der Sprache Go.
- Geschwindigkeit: Erhöhe die Entwicklungsgeschwindigkeit um das 2-3-fache.
- Einfach: Großartige Unterstützung für Redakteure. Vollendung überall. Leicht zu erlernen und anzuwenden.
- Robust: Serienreifer Code mit automatischer interaktiver Dokumentation.
- OpenAPI basiert: Vollständig kompatibel mit OpenAPI und JSON Schema.
Installing FastAPI
FastAPI erfordert Python 3.7+. Es kann mit pip installiert werden. Du musst FastAPI und den ASGI-Server `uvicorn` installieren.
``
# install fastapi
pip install fastapi
# install uvicorn
pip install uvicorn
``
Eine einfache API erstellen
Lass uns direkt mit der Erstellung einer sehr einfachen Spielzeug-API beginnen. Ich verwende VS Code, um dies zu implementieren, aber du kannst jeden beliebigen Editor verwenden.
```
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}
```
(Das Beispiel stammt aus der Originaldokumentation). Danke an @tiangolo.
Führe diese API mit folgendem Befehl in einem Terminal aus:
```
uvicorn main:app –reload
```
main" ist der Name der Python-Datei und "app" ist die Variable, in der die FastAPI-Klasse gespeichert ist. Du kannst sie nennen, wie du willst. Wenn du den obigen Befehl ausführst, siehst du in deinem Terminal etwas wie das hier:
Wenn du den Link in deinem Browser aufrufst und eine Seite mit der Aufschrift "Hallo Welt" siehst, ist die API betriebsbereit.
Bild vom Autor
Herzlichen Glückwunsch zur Erstellung deiner ersten API.
Interaktive API-Dokumente
FastAPI erstellt ein "Schema" mit all deinen APIs und verwendet dabei den OpenAPI-Standard zur Definition von APIs. Ein "Schema" ist eine Definition oder Beschreibung von etwas. Nicht den Code, der ihn implementiert, sondern nur eine abstrakte Beschreibung. Das OpenAPI-Schema ist die Grundlage für die beiden interaktiven Dokumentationssysteme, die in FastAPI enthalten sind.
Um die Dokumentation zu sehen, füge einfach `/docs` an die URL (`http://127.0.0.1:8000/docs`) an. Dieser Link zeigt die automatische interaktive API-Dokumentation an.
Bild vom Autor
Klicke auf die Schaltfläche "Ausprobieren" in der oberen rechten Ecke, um die API zu testen.
Bild vom Autor
Du kannst sehen, dass der Antwortkörper ein Wörterbuch ist. Dies ist der Rückruf der Funktion `read_item`, die in der Datei `main.py` definiert ist. Du kannst auch die Anfrage-Url `http://127.0.0.1:8000/items/1?q=orange` sehen. 1" und "Orange" waren unsere Eingaben an die API.
In FastAPI gibt es eine alternative interaktive automatische Dokumentation. Um das zu überprüfen, gehe auf http://127.0.0.1:8000/redoc`. So sieht es aus:
Bild vom Autor
Fortgeschrittene Beispiele
Bei der Erstellung einer API definiert der "Pfad" den Weg oder Endpunkt der Anfrage. Es gibt jedoch noch eine weitere Wahl, die wir treffen müssen, nämlich "Operation". Das Wort "Operation" bezieht sich hier auf eine der HTTP-"Methoden". Wenn du eine (oder mehrere) dieser sogenannten "Methoden" verwendest, kannst du mit jedem der verschiedenen Pfade kommunizieren, die das HTTP-Protokoll unterstützt. Normalerweise würdest du das verwenden:
- POST: um Daten zu erstellen.
- GET: um Daten zu lesen.
- PUT: um Daten zu aktualisieren.
- LÖSCHEN: um Daten zu löschen.
- Und ein paar andere fortgeschrittene
FastAPI unterstützt alle http-Methoden.
Die Tatsache, dass FastAPI auf Python-Typ-Hinweisen basiert, ist ein weiterer wichtiger Aspekt dieses Frameworks. Typ-Hinweise werden in Python 3.6 und höher unterstützt. Die Typ-Hinweise sind eine spezielle Art der Syntax, die es ermöglicht, den Typ einer Variablen zu deklarieren.
Wenn du Typen für deine Variablen deklarierst, können dir Editoren und andere Tools bessere Unterstützung bieten. Schauen wir uns ein fortgeschrittenes Beispiel an.
Wir werden unsere Datei `main.py` ändern, um eine neue `PUT`-Anfrage einzufügen, die mehrere Eingaben unterschiedlicher Datentypen entgegennimmt.
```
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}
```
(Das Beispiel stammt aus der Originaldokumentation). Danke an @tiangolo.
Die Veränderung:
Es wird eine Anfrage "put" hinzugefügt, die zwei Eingaben benötigt. item_id" ist eine ganze Zahl und der Typ "item" verweist auf die benutzerdefinierte Klasse "item", die von "pydantic" das "BaseModel" geerbt hat. Die Klasse `Item` enthält drei Attribute: `Name`, `Preis`, `Angebot`, und alle haben unterschiedliche Datentypen.
Die FastAPI prüft das:
- Name" ist ein "Str".
- Preis" ist eine "Fließkommazahl".
- is_offer" ist ein bool, falls vorhanden.
Der Vorteil der Verwendung von Typ-Hinweisen ist, dass du die Typen von Parametern, Körper usw. als Funktionsparameter mit Standard-Python (3.6+) einmal deklarierst. Du bekommst:
- Editor-Unterstützung, einschließlich Autovervollständigung, Typüberprüfung
- Datenvalidierung
- Umwandlung von Eingabedaten
- Konvertierung der Ausgabedaten
- Fehler, die leicht zu verstehen sind.
Vergleich von FastAPI mit Django und Flask
Alle drei Frameworks sind Python-Webframeworks, die du für die Entwicklung von Webanwendungen nutzen kannst. Sie haben alle ihre eigenen Stärken und Schwächen.
Django ist ein voll funktionsfähiges Framework, das alles enthält, was du für den Einstieg brauchst, einschließlich eines eingebauten ORM und eines Admin-Panels. Für Anfänger kann es ein bisschen überwältigend sein, aber dank der umfassenden Dokumentation ist es leicht zu erlernen.
Flask ist ein Mikroframework, das leichtgewichtig ist und mit dem du einfach loslegen kannst. Es enthält nicht so viele Funktionen wie Django, ist aber perfekt für einfache Projekte.
FastAPI ist ein neues Framework, das schnell und einfach zu bedienen sein soll. Es enthält Funktionen wie automatische Datenvalidierung und Dokumentation.
Django |
Flachmann |
FastAPI |
|
Community |
Big. 66K GitHub-Sterne |
Big. 61K GitHub-Sterne |
Big. 50K GitHub-Sterne |
Leistung |
Django ist riesig. Es ist nicht das Beste, was die Leistung angeht. |
Flask ist ein Mikro-Webframework. Es funktioniert besser als Django. |
FastAPI ist eines der schnellsten Web-Frameworks mit nativer asynchroner Unterstützung, die zur Effizienz des Frameworks beiträgt. |
Async-Unterstützung |
Ja, mit begrenzter Latenzzeit. |
Nein. Braucht Asyncio |
FastAPI bietet native async-Unterstützung. |
Einfachheit der Nutzung |
Django ist sehr umfangreich und daher ein bisschen kompliziert zu lernen. |
Flask ist einfach zu erlernen und ziemlich unkompliziert in der Anwendung. |
FastAPI ist die einfachste von allen dreien. |
Interaktive Dokumentation |
Nicht interaktiv |
Nein |
Ja (OpenAI, Redoc) |
Datenüberprüfung |
Nein |
Nein |
Ja |
FastAPI Leistungsvergleiche
Nach den Ergebnissen der von techempower durchgeführten Tests ist FastAPI allen anderen Frameworks in Bezug auf die Gesamtleistung überlegen.
Source: https://www.techempower.com/benchmarks/
Beispiel: Aufbau einer End-to-End-Pipeline für maschinelles Lernen mit PyCaret und Bereitstellung mit FastAPI
In diesem Abschnitt werden wir schnell eine Pipeline für maschinelles Lernen aufbauen und dann eine API erstellen, um das Modell zu bedienen. Wir werden die Python-Bibliothek PyCaret verwenden, um eine Pipeline zu erstellen und eine API zu entwickeln. PyCaret verfügt über eine Integration mit FastAPI, die es extrem einfach macht, Machine Learning-Modelle als API zu erstellen und bereitzustellen.
PyCaret
PyCaret ist eine Open-Source-Bibliothek für maschinelles Lernen in Python, die Workflows für maschinelles Lernen automatisiert. Es ist ein End-to-End-Tool für maschinelles Lernen und Modellmanagement, das den Experimentierzyklus exponentiell beschleunigt und dich produktiver macht.
```
pip install pycaret
```
```
import pycaret
pycaret.__version__
>>> 2.3.10
```
In diesem Beispiel werden wir den Datensatz "Versicherungen" verwenden. Es handelt sich um einen Regressionsanwendungsfall zur Vorhersage von medizinischen Kosten auf der Grundlage von Alter, Geschlecht, BMI und Region.
```
from pycaret.datasets import get_data
data = get_data(‘insurance’)
```
Bild vom Autor
Als Nächstes werden wir die Funktion `setup` von pycaret initialisieren. Diese Funktion initialisiert das Experiment in PyCaret und erstellt die Transformationspipeline basierend auf allen in der Funktion übergebenen Parametern.
Die Funktion `setup` muss vor allen anderen Funktionen ausgeführt werden. Sie benötigt zwei Parameter, um zu funktionieren: "Daten" und "Ziel". Alle anderen Argumente in `setup` sind optional. Die Funktion `setup` ist für die Steuerung der gesamten Datenvorverarbeitung zuständig. In der PyCaret-Dokumentation findest du eine umfassende Übersicht über alle Vorverarbeitungsprozesse, die in PyCaret unterstützt werden.
```
from pycaret.regression import *
s = setup(data, target = 'charges')
```
Bild vom Autor Ausgabe gekürzt.
Sobald die Einrichtung abgeschlossen ist, können wir mit nur einer Zeile Code mit dem Training und der Auswahl der Modelle beginnen: `compare_models`. Mit Hilfe der Kreuzvalidierung trainiert und bewertet diese Funktion die Modellleistung aller Schätzer in der Modellbibliothek. Das Ergebnis dieser Funktion ist ein Bewertungsraster, das die durchschnittliche Punktzahl aus der Kreuzvalidierung enthält.
Preprocessing für maschinelles Lernen in Python
Willst du mehr darüber erfahren, wie du deine bereinigten Daten für die Modellierung bereit machst? Besuche unseren Kurs Preprocessing for Machine Learning in Python.
```
best = compare_models()
```
Bild vom Autor
Das beste Modell ist der "Gradient Boosting Regressor". Wenn wir wollen, können wir das Modell mithilfe der Visualisierung analysieren und versuchen, die Leistung durch die Abstimmung der Hyperparameter oder die Zusammenstellung von Modellen zu verbessern, aber das werden wir in diesem Tutorial nicht tun.
Wir werden direkt mit dem Aufbau der API des besten Modells beginnen, um mit FastAPI Vorhersagen in der Produktion zu erstellen. Vergiss nicht, dass PyCaret eine Integration mit FastAPI hat, so dass es mit der Funktion `create_api` automatisch eine REST-API aus dem Modell erstellen kann.
```
create_api (best, 'insurance_prediction_model')
```
Um diese API auszuführen, öffnest du die Eingabeaufforderung, navigierst zu dem Ordner, in dem sich dein Notebook befindet, und führst den folgenden Befehl aus: "Python insurance_prediction_model.py".
Gehe zu `http://127.0.0.1:8000/docs` und du wirst die gleiche Benutzeroberfläche sehen, die du bereits in diesem Tutorial gesehen hast
Bild vom Autor
Bild vom Autor
Du kannst auch eine alternative interaktive Dokumentation sehen, indem du `http://127.0.0.1:8000/redoc'aufrufst.
Bild vom Autor
Denke daran, dass sowohl die Standard- als auch die interaktive redoc-Dokumentation auf OpenAPI-Standards basieren.
Wenn du die Datei sehen willst, die PyCaret erstellt hat, als du die Funktion `create_api` benutzt hast, kannst du die Datei im gleichen Ordner wie dein Notebook auschecken. Das sieht so aus:
```
import pandas as pd
from pycaret.regression import load_model, predict_model
from fastapi import FastAPI
import uvicorn
# Create the app
app = FastAPI()
# Load trained Pipeline
model = load_model('my_lr_api')
# Define predict function
@app.post('/predict')
def predict(age, sex, bmi, children, smoker, region):
data = pd.DataFrame([[age, sex, bmi, children, smoker, region]])
data.columns = ['age', 'sex', 'bmi', 'children', 'smoker', 'region']
predictions = predict_model(model, data=data)
return {'prediction': list(predictions['Label'])}
if __name__ == '__main__':
uvicorn.run(app, host='127.0.0.1', port=8000)
```
Fazit
In dem Artikel wurde die Idee der API diskutiert und warum sie verwendet werden. API ist in der modernen Architektur wichtig, weil sie es verschiedenen Softwareprogrammen ermöglicht, Daten und Funktionen gemeinsam zu nutzen. So können komplexe Systeme geschaffen werden, die zuverlässiger und leichter zu warten sind.
Dann tauchen wir tief in ein relativ neues Framework in Python namens FastAPI ein. FastAPI ist eine neuere API, die einfach zu bedienen und effizient sein soll. Es ist eine großartige Option für Entwickler, die schnell und einfach eine API erstellen wollen.
GitHub Sterngeschichte - erstellt mit star-history.com
Wenn du außerdem lernen willst, wie du mit Flask eine einfache API aus einem Machine Learning-Modell in Python erstellst, dann schau dir das leicht verständliche Tutorial "Turning Machine Learning Models into APIs in Python" an.
FastAPI FAQs
Ist die FastAPI asynchron?
FastAPI unterstützt von Haus aus asynchronen Code mit den Python-Schlüsselwörtern async/await.
Ist FastAPI produktionsreif?
FastAPI ist vollständig produktionsreif und verfügt über eine hervorragende Dokumentation, Support und eine benutzerfreundliche Oberfläche.
Wie unterscheidet sich die FastAPI von Flask?
FastAPI unterstützt asynchrone Aufrufe. Es ist leichtgewichtig, schneller und einfacher zu erlernen als Flask. Sowohl Flask als auch FastAPI haben eine große Community.
Verfügt FastAPI auch über einen integrierten Entwicklungsserver?
Nein, FastAPI hat keinen eingebauten Entwicklungsserver. Dafür musst du `uvicorn` verwenden.
Wird FastAPI von Python 2 unterstützt?
Nein, FastAPI ist nur in Python 3.6+ verfügbar.
Ist FastAPI nur in Python verfügbar?
Ja
Ist FastAPI schneller als die Programmiersprache Go?
Nein. Laut techempower ist Golang Fiber die 50. schnellste API der Welt. FastAPI liegt auf Platz 183.
Ist FastAPI mit Pydantic kompatibel?
FastAPI ist vollständig kompatibel mit (und basiert auf) Pydantic.
Python-Kurse
Kurs
Zwischendurch Daten in Python importieren
Kurs