Tutorial FastAPI: Introduzione all'uso di FastAPI

Le API (Application Programming Interface) sono la spina dorsale dell’architettura moderna perché permettono di creare applicazioni modulari e disaccoppiate. Questo significa che puoi sviluppare applicazioni in modo rapido e semplice, rendendole facili da mantenere e aggiornare. 

Le API sono fondamentali anche nel machine learning perché permettono a diverse applicazioni di condividere dati e collaborare, risparmiando tempo e fatica. Esistono molti framework diversi per creare API in Python. Alcuni dei più popolari sono Django, Flask e FastAPI. Questo tutorial approfondisce uno di questi framework: FastAPI.

Se vuoi approfondire l’argomento, ti consiglio questo corso: Deploying AI Into Production With FastAPI.

Che cos’è un’API?

API sta per Application Programming Interface. Un’API è un intermediario software che consente a due applicazioni di comunicare tra loro. Quando usi un’app sul tuo telefono, l’app si connette a Internet e invia dati a un server. Il server elabora i dati e li rinvia al tuo telefono. L’app sul telefono interpreta i dati e te li presenta in modo leggibile. 

Un’API è come un cameriere in un ristorante. Il cameriere prende l’ordine e lo porta in cucina. La cucina prepara il cibo e lo rimanda al cameriere. Il cameriere poi porta il piatto al tavolo. 

Allo stesso modo, un’API riceve una richiesta da un’applicazione e la invia a un server. Il server elabora la richiesta e rimanda i dati all’applicazione. L’applicazione poi interpreta i dati e li presenta all’utente.

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

Se vuoi saperne di più su pipeline di machine learning, API e MLOps, dai un’occhiata al nostro Tutorial su Machine Learning, Pipeline, Deployment e MLOps.

Che cos’è FastAPI

FastAPI è un web framework ad alte prestazioni per creare API con Python 3.7+ basato sui type hints standard di Python. Aiuta gli sviluppatori a costruire applicazioni in modo rapido ed efficiente. FastAPI è costruito sopra il web server Starlette e include funzionalità che semplificano lo sviluppo di applicazioni web, come la validazione automatica dei dati, la gestione degli errori e la documentazione interattiva delle API. 

In questa sezione vedremo singolarmente tutte queste funzionalità. Per prima cosa, diamo un’occhiata alle caratteristiche chiave evidenziate nella documentazione originale di FastAPI.

• Performance: Paragonabile a NodeJS e al linguaggio Go.
• Speed: Aumenta la velocità di sviluppo di 2-3 volte.
• Easy: Ottimo supporto dell’editor. Completamento ovunque. Facile da imparare e usare.
• Robust: Codice pronto per la produzione con documentazione interattiva automatica.
• Basato su OpenAPI: Pienamente compatibile con OpenAPI e JSON Schema.

Installare FastAPI

FastAPI richiede Python 3.7+. Può essere installato con pip. Dovrai installare FastAPI e il server ASGI `uvicorn`.

``

# install fastapi

pip install fastapi




# install uvicorn
pip install uvicorn

``

Crea una semplice API

Passiamo subito a creare una semplicissima API di esempio. Io uso VS Code per implementarla, ma puoi usare qualunque editor preferisci.

```

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}

```

(Esempio riprodotto dalla documentazione originale). Grazie a @tiangolo.

Ora, usando un terminale a riga di comando, esegui questa API con il seguente comando:

```

uvicorn main:app –reload

```

`main` è il nome del file Python e `app` è la variabile che contiene la classe FastAPI. Puoi chiamarli come vuoi. Una volta eseguito il comando, vedrai qualcosa di simile nel terminale:

Apri il link nel browser e, se vedi una pagina che mostra `Hello World,` significa che l’API è attiva e funzionante.

Immagine dell’autore

Congratulazioni per aver creato la tua prima API. 

Documentazione API interattiva

FastAPI genera uno "schema" con tutte le tue API usando lo standard OpenAPI per la definizione delle API. Uno "schema" è una definizione o descrizione di qualcosa. Non il codice che lo implementa, ma una descrizione astratta. Lo schema OpenAPI alimenta i due sistemi di documentazione interattiva inclusi in FastAPI.

Per vedere la documentazione, aggiungi semplicemente `/docs` all’URL (`http://127.0.0.1:8000/docs`). Questo link mostra la documentazione interattiva automatica delle API.

Immagine dell’autore

Clicca sul pulsante `Try it out` in alto a destra per testare l’API.

Immagine dell’autore

Puoi vedere che il body della risposta è un dizionario. Questa è la return della funzione `read_item` definita in `main.py`. Puoi anche vedere l’URL della richiesta `http://127.0.0.1:8000/items/1?q=orange`. `1` e `orange` erano i nostri input all’API.

In FastAPI è disponibile un’alternativa di documentazione interattiva automatica. Per vederla, vai su http://127.0.0.1:8000/redoc`. Si presenta così:

Immagine dell’autore

Esempi più avanzati

Nella creazione di un’API, il "percorso" definisce la route o l’endpoint della richiesta. Tuttavia, c’è un’altra scelta da fare, ossia l’“Operazione”. La parola `operation` qui si riferisce a uno dei "metodi" HTTP. Usando uno (o più) di questi cosiddetti "metodi", puoi comunicare con ciascuno dei diversi percorsi supportati dal protocollo HTTP. In genere useresti:

• POST: per creare dati.
• GET: per leggere dati.
• PUT: per aggiornare dati.
• DELETE: per eliminare dati.
• E qualche altro metodo avanzato 

FastAPI supporta tutti i metodi HTTP. 

Un altro aspetto fondamentale di questo framework è che FastAPI si basa sui type hints di Python. I type hints sono supportati da Python 3.6 e versioni successive. I type hints sono una sintassi specifica che consente di dichiarare il tipo di una variabile. 

Dichiarare i tipi delle variabili permette agli editor e ad altri strumenti di offrirti un supporto migliore. Vediamo un esempio avanzato.

Modificheremo il file `main.py` per includere una nuova richiesta `PUT` che accetterà più input di tipi di dato diversi. 

```

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}

```

(Esempio riprodotto dalla documentazione originale). Grazie a @tiangolo.

La modifica:

È stato aggiunto un `put` che accetta due input. `item_id` è un intero e il tipo di `item` punta alla classe personalizzata `Item` creata ed erede di `BaseModel` di `pydantic`. La classe `Item` contiene tre attributi: `name`, `price`, `is_offer`, e hanno tutti tipi di dato diversi.

FastAPI controllerà: 

• che `name` sia una `str`.
• che `price` sia un `float`.
• che `is_offer` sia un bool, se presente.

Il vantaggio di usare i type hints è che dichiari una sola volta i tipi dei parametri, del body, ecc. come parametri di funzione con Python standard (3.6+). Otterrai:

• Supporto dell’editor, inclusi completamento automatico e controlli di tipo
• Validazione dei dati
• Conversione dei dati in input
• Conversione dei dati in output
• Errori facili da capire.

Confronto tra FastAPI, Django e Flask

Tutti e tre questi framework sono web framework Python che puoi usare per sviluppare applicazioni web. Ognuno ha punti di forza e debolezza.

Django è un framework completo che include tutto ciò che serve per iniziare, incluso un ORM integrato e un pannello di amministrazione. Può risultare un po’ impegnativo per i principianti, ma la sua documentazione completa lo rende facile da imparare.

Flask è un microframework leggero e facile da iniziare a usare. Non include tante funzionalità quante Django, ma è perfetto per progetti semplici.

FastAPI è un framework nuovo progettato per essere veloce e facile da usare. Include funzionalità come la validazione automatica dei dati e la documentazione. 

Benchmark delle prestazioni di FastAPI

Secondo i risultati dei test eseguiti da techempower, FastAPI è superiore agli altri framework in termini di prestazioni complessive. 

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

Esempio: costruire una pipeline di machine learning end-to-end con PyCaret e fare il deploy con FastAPI 

In questa sezione costruiremo rapidamente una pipeline di machine learning e poi creeremo un’API per servire il modello. Useremo una libreria Python low-code, PyCaret, per creare la pipeline e l’API. PyCaret ha un’integrazione con FastAPI, che rende estremamente semplice creare e servire modelli di machine learning come API.

PyCaret

PyCaret è una libreria di machine learning open source e low-code in Python che automatizza i flussi di lavoro di ML. È uno strumento end-to-end per il machine learning e la gestione dei modelli che accelera in modo esponenziale il ciclo di sperimentazione e ti rende più produttivo.

```

pip install pycaret

```




```

import pycaret

pycaret.__version__

>>> 2.3.10

```

In questo esempio useremo il dataset `insurance`. È un caso di regressione per prevedere i costi sanitari in base a età, sesso, BMI e regione. 

```

from pycaret.datasets import get_data

data = get_data(‘insurance’)

```

Immagine dell’autore

Successivamente inizializzeremo la funzione `setup` di pycaret. Questa funzione avvia l’esperimento in PyCaret e crea la pipeline di trasformazione in base a tutti i parametri passati nella funzione. 

`setup` deve essere eseguito per primo, prima di qualsiasi altra funzione. Richiede due parametri per funzionare: `data` e `target`. Tutti gli altri argomenti in `setup` sono opzionali. La funzione `setup` è responsabile del controllo di tutte le procedure di preprocessing dei dati. Consulta la documentazione di PyCaret per una panoramica completa di tutte le procedure di preprocessing supportate in PyCaret.

```

from pycaret.regression import *

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

```

Immagine dell’autore Output troncato.

Una volta terminato il setup, possiamo iniziare addestramento e selezione dei modelli con una sola riga di codice: `compare_models`. Tramite la cross-validation, questa funzione addestra e valuta le prestazioni dei modelli per tutti gli stimatori presenti nella libreria. Il risultato è una griglia di punteggi con le medie ottenute dalla cross-validation.