Questo articolo è stato pubblicato nell'ambito del Blogathon sulla scienza dei dati
introduzione
Ti guiderò attraverso il processo di Implementa un modello di machine learning come API utilizzando FastAPI e Heroku. Cose trattate in questo articolo:
- Una rapida introduzione al set di dati e al modello
- Nozioni di base FastAPI
- Come strutturare il codice per utilizzare il modello ML
- Come testare e recuperare questa API?
- Implementazione in Heroku
- bono: Generazione di documenti
Il set di dati e il modello
La dichiarazione del problema che ho scelto per questa serie di articoli è Classificazione del genere musicale. Il set di dati è stato compilato da un gruppo di ricerca chiamato The Echo Nest. Contiene vari dettagli tecnici sulla musica. Questi includono Acustica, ballabilità, Energia, strumentalità, vivacità, parla, tempo e valencia. La variabile oggettiva di questi dati è se il brano appartiene al genere Rock o Hip-Hop.. Prossimo, vengono mostrati alcuni dettagli sul set di dati:
L'identificazione della traccia non è stata utile per la nostra analisi e, così, è stato cancellato. Genre_top è la nostra variabile di destinazione e contiene “Musica rock” oh “Hip-Hop”. Ho addestrato un classificatore ad albero decisionale per questo set di dati e ho ottenuto un buon punteggio di precisione. (Non ho provato altri modelli di ensemble come Random Forest, ma puoi provarlo).
Una volta che hai finito di adattare il modello e testarlo con dati casuali, è ora di selezionare il modello. Lo stripping è il processo di conversione di un oggetto Python in un flusso di byte. Salva il modello come file in modo che sia possibile accedervi / carica più tardi. Ecco il codice per lo stesso se non hai familiarità:
pkl_filename="modello.pkl"
con aperto(pkl_filename, 'wb') come f:
sottaceto.discarica(modello, F)
Introduzione a FastAPI
È un framework web che accelera lo sviluppo back-end di un sito web utilizzando Python. Questo telaio è nuovo di zecca, adattabile e facile da imparare. Consente agli utenti di configurare rapidamente l'API, genera documenti automatici per tutti gli endpoint, offre l'autenticazione, convalida dei dati, consente codice asincrono e molto altro. È costruito su Starlette, cos'è una cornice? / toolkit ASGI leggero e fornisce codice pronto per la produzione.
In secondo luogo, Flask è più vecchio di FastAPI ma è ancora utilizzato per molti progetti. Il suo approccio minimalista è promettente e anche la creazione di API con il pallone non è così difficile. Entrambi i framework hanno i loro pro e contro.
Dai un'occhiata a questo articolo per un confronto dettagliato FastAPI: Il giusto sostituto per i flaconi?
Per implementare il nostro modello di apprendimento automatico, useremo l'approccio FastAPI. Prima di immergersi nel codice per creare l'API del modello, comprendiamo alcune nozioni di base di FastAPI che aiuteranno a comprendere meglio la base di codice.
Nozioni di base FastAPI
La struttura del codice FastAPI è molto simile alla struttura dell'applicazione Flask. È necessario creare endpoint in cui il nostro servizio clienti possa effettuare richieste e ottenere i dati richiesti. Vedere l'implementazione del codice di base di seguito:
importare uvicorn
da fastapi import FastAPI
app = FastAPI()
@app.get('/')
indice def():
Restituzione {'Messaggio': "Questa è la home page di questa API. Vai a /apiv1/ o /apiv2/?nome="}
@app.get('/ apiv1 /{nome}')
def api1(nome: str):
Restituzione {'Messaggio': f'Ciao! @{nome}'}
@app.get('/apiv2 /')
def api2(nome: str):
Restituzione {'Messaggio': f'Ciao! @{nome}'}
if __name__ == '__main__':
uvicorn.run(app, ospite="127.0.0.1", porta=4000, debug=Vero)
- Le prime due righe importano FastAPI e uvicorn. L'Uvicorn è usato per implementare il server e gestire tutte le chiamate in Python.
- Prossimo, viene creata un'istanza dell'applicazione FastAPI.
- Per aggiungere percorsi / endpoint a questa istanza dell'applicazione, viene creata una funzione e viene aggiunto un decoratore di percorso. Questo decoratore registra la funzione per il percorso definito in modo che quando viene richiesto quel particolare percorso, la funzione viene chiamata e il suo risultato viene restituito al client. In genere, restituiamo un oggetto JSON in modo che possa essere analizzato in qualsiasi lingua.
- La parte migliore di FastAPI è che puoi definire questi percorsi direttamente per i metodi HTTP. nella fiaschetta, devi aggiungerli manualmente a un elenco di metodi (aggiornato sul pallone 2.0).
- Per ottenere input dai clienti, puoi usare i parametri del percorso, parametri di query o organi di richiesta. Il percorso “/apiv1 / {Nome}"Implementa un approccio basato sui percorsi in cui i parametri vengono passati come percorsi. La strada “/ apiv2 /” implementa un approccio basato su query in cui i parametri vengono passati aggiungendo il “?” alla fine dell'URL e utilizzando “&” per aggiungere più parametri.
Guarda questi percorsi in azione:
Richiedi la messa a fuoco del corpo
Con questo approccio, i dati del cliente possono essere passati alla nostra API. E FastAPI, per semplificare le cose, usiamo modelli Pydantic per definire la struttura dei dati per i dati di ricezione. Pydantic esegue tutti i controlli di tipo dei parametri e restituisce errori spiegabili se viene ricevuto il tipo di parametro sbagliato. Aggiungiamo una classe di dati al nostro codice esistente e creiamo un percorso per il corpo della richiesta:
.
.
# Dopo altre importazioni
da pydantic import BaseModel
Dettagli classe(Modello base):
f_name: str
il_nome: str
numero di telefono: int
app = FastAPI()
.
.
.
# Dopo le vecchie rotte
@app.post('/apiv3 /')
def api3(dati: Particolari):
Restituzione {'Messaggio': dati}
La funzione path dichiara un parametro “dati” del tipo “Particolari” definito sopra. Questo modello di “Particolari” eredita dal modello base di Pydantic e offre la convalida dei dati. Per testare questo percorso, Sto usando l'estensione del codice VS client Thunder per effettuare una richiesta di posta al nostro percorso API “/ apiv3 /”:
Avvolgere il modello
Ora che abbiamo rimosso i concetti da FastAPI, è ora di integrare il modello nella struttura del codice FastAPI per effettuare richieste di previsione. Creeremo un percorso “/ predizione” che prenderà i dati inviati dal corpo della richiesta client e la nostra API restituirà la risposta come oggetto JSON contenente il risultato. Diamo un'occhiata prima al codice e poi ti spiego la meccanica:
importare uvicorn
importare sottaceti
da fastapi import FastAPI
da pydantic import BaseModel
classe Musica(Modello base):
acustica: galleggiante
ballabilità: galleggiante
energia: galleggiante
strumentalità: galleggiante
vitalità: galleggiante
discorsività: galleggiante
tempo: galleggiante
valenza: galleggiante
app = FastAPI()
con aperto("./File FastAPI/model.pkl", "rb") come f:
modello = pickle.load(F)
@app.get('/')
indice def():
Restituzione {'Messaggio': 'Questa è la homepage dell'API '}
@app.post('/predizione')
def get_music_category(dati: Musica):
ricevuto = data.dict()
acustica = ricevuta['acustica']
ballabilità = ricevuto['danzabilità']
energia = ricevuta['energia']
strumentalità = ricevuto['strumentalità']
vivacità = ricevuto['vitalità']
discorsività = ricevuto['discorso']
tempo = ricevuto['tempo']
valenza = ricevuta['valenza']
pred_name = model.predict([[acustica, ballabilità, energia,
strumentalità, vitalità, discorsività, tempo, valenza]]).elencare()[0]
Restituzione {'predizione': pred_name}
if __name__ == '__main__':
uvicorn.run(app, ospite="127.0.0.1", porta=4000, debug=Vero)
- Abbiamo creato una classe Music Model che definisce tutti i parametri del nostro modello ML. Tutti i valori sono di tipo float.
- Prossimo, carichiamo il modello staccandolo e salvando il modello come “modello”. Questo oggetto modello verrà utilizzato per ottenere le previsioni.
- La funzione di percorso “/ predizione” dichiarare un parametro chiamato “dati” del tipo di modello “Canzone”. Questo parametro è accessibile come dizionario. L'oggetto dizionario ci permetterà di accedere ai valori dei parametri come coppie chiave-valore.
- Ora, stiamo salvando tutti i valori dei parametri inviati dal cliente. Questi valori vengono ora inseriti nella funzione di previsione del modello e abbiamo la nostra previsione per i dati forniti.
Tutti i codici discussi in questo articolo sono disponibili su il mio repository GitHub.
Test API del modello
Ora è il momento di testare l'API. Puoi testare l'API attraverso due metodi:
Cliente Thunder / Postino
Stiamo utilizzando il client thunder per inviare una richiesta di posta al percorso “/ predizione” con un corpo di richiesta. Il corpo della richiesta contiene le coppie chiave-valore dei parametri e dovremmo aspettarci una risposta JSON con il genere musicale classificato.
Fai una richiesta utilizzando il modulo di richiesta
Se non desideri utilizzare le estensioni VSCode o qualsiasi software di test API, puoi semplicemente creare un programma Python separato per chiamare questa API. Il modulo delle richieste Python consente di chiamare le API.
richieste di importazione
import json
URL = "<URL-host-locale>/predizione"
carico utile = json.dumps({
"acustica": 0.344719513,
"ballabilità": 0.758067547,
"energia": 0.323318405,
"strumentalità": 0.0166768347,
"vitalità": 0.0856723112,
"discorsività": 0.0306624283,
"tempo": 101.993,
"valenza": 0.443876228
})
intestazioni = {
'Tipo di contenuto': 'applicazione/json'
}
risposta = richieste.richiesta("INVIARE", URL, intestazioni=intestazioni, dati=carico utile)
Stampa(risposta.testo)
Sostituire “URL-host-locale” con il tuo URL che ottieni dopo aver eseguito il file API del modello FastAPI. L'output per questo è:
Viva! Hai creato con successo un'API per il tuo modello di machine learning utilizzando FastAPI.
Implementazione in Heroku
La nostra API è pronta per essere utilizzata da qualsiasi tipo di programma che effettua una chiamata alla nostra API. Ma non puoi eseguire questo programma tutto il giorno sul tuo sistema locale, è praticamente impossibile. Perciò, devi distribuire il tuo servizio su una piattaforma cloud in grado di eseguire il tuo codice e restituire i resi.
Heroku è una di quelle piattaforme che offre hosting gratuito. Per implementare la nostra API in Heroku, dobbiamo creare questi file:
- Requisiti.txt: Questo file dovrebbe elencare tutti i moduli esterni che hai usato nella tua applicazione. Per il nostro caso, era FastAPI, scikit-impara, uvicorno e alcuni altri moduli ausiliari.
- runtime.txt: Questo file specifica la versione di Python che Heroku installerà sul suo endpoint.
- Procfile: Questo file è il file di interfaccia tra il nostro codice Python e la piattaforma Heroku. Nota: la maggior parte di voi non crea questo file correttamente. Non è un file di testo. Questo file non ha estensione. Per creare tali file, puoi usare GitHub per aggiungere file o codice Vs o cmd su Windows o terminale su Linux. Questo file conterrebbe il seguente comando per FastAPI:
ragnatela: gunicorn -w 4 -k uvicorn.workers.UvicornWorker :app
Qui, sostituisci file_name con il nome del file Python in cui hai creato il codice FastAPI. Dopodichè:
- Metti tutti questi file (modello, file pitone, requisiti.txt, Procfile) in un repository GitHub
- Accedi a Heroku e crea una nuova app. Connetti il tuo repository GitHub
- Fai clic su Distribuisci filiale e la tua API sarà attiva e funzionante affinché chiunque possa utilizzarla con il collegamento.
bono: Generazione di documenti
FastAPI ha una funzione speciale. Genera automaticamente documenti per gli endpoint API creati. Per accedere a questi documenti, basta visitare il punto finale “/ documenti” e otterrai un'interfaccia utente grafica accattivante creata con Swagger e OpenAI. Ora che abbiamo implementato il servizio, lo screenshot qui sotto proviene dall'applicazione Heroku Deployed. (Collegamento: https://kivymlapp.herokuapp.com/)
conclusione
In questo articolo dettagliato, il FastAPI . presentato, le sue basi, come creare un file API per il modello di apprendimento automatico, come testare questa API e come implementare questa API sulla piattaforma Heroku. Abbiamo anche visto come accedere all'endpoint del documento che FastAPI genera automaticamente.
Nel prossimo articolo, Mostrerò come utilizzare l'API creata in questo articolo per creare un'app di previsione musicale Android utilizzando Python e convertiremo anche quel file da Python in APK.
Nota: puoi usare questo link, Link principale a tutti i miei articoli su Internet, che si aggiorna ogni volta che inserisco un nuovo articolo per trovare quell'articolo.
se hai qualsiasi dubbio, richiesta o potenziale opportunità, allora puoi comunicare con me attraverso
1. Linkedin – Su / kaustubh-gupta /
2. Twitter – @ Kaustubh1828
3. GitHub – kaustubhgupta
