Trasformare modelli di Machine Learning in API con Python

Flask – Un framework per servizi web in Python:

Ora, potresti chiederti cos'è un web service? Un web service è una forma di API che presuppone che un'API sia ospitata su un server e possa essere consumata. Web API, Web Service - questi termini sono generalmente usati in modo intercambiabile.

Venendo a Flask, è un framework per lo sviluppo di servizi web in Python. Non è l'unico in Python, ce ne sono anche altri come Django, Falcon, Hug, ecc. Ma in questo tutorial userai Flask. Per imparare Flask, puoi fare riferimento a questi tutorial.

Se hai scaricato la distribuzione Anaconda, Flask è già installato. In caso contrario, dovrai installarlo tu con:

pip install flask

Flask è molto minimale. È il preferito dagli sviluppatori Python per molti motivi. Il framework Flask include un server web leggero integrato che richiede una configurazione minima e può essere controllato dal tuo codice Python. Questo è uno dei motivi per cui è così popolare.

Il codice seguente dimostra bene la minimalità di Flask. Il codice serve a creare una semplice Web-API che, alla ricezione di un determinato URL, produce un output specifico.

from flask import Flask

app = Flask(__name__)


@app.route("")
def hello():
    return "Welcome to machine learning model APIs!"


if __name__ == '__main__':
    app.run(debug=True)

Una volta eseguito, puoi navigare all'indirizzo web (inserisci l'indirizzo in un browser) mostrato nel terminale e osservare il risultato.

Alcuni punti:

• Jupyter Notebook è ottimo per tutto ciò che riguarda markdown, R e Python. Ma quando si tratta di costruire un server web, può mostrare comportamenti inconsistenti. Quindi è una buona idea scrivere il codice Flask in un editor di testo come Sublime ed eseguirlo dal terminale/command prompt.

• Assicurati di non chiamare il file flask.py.

• Flask gira per default sulla porta 5000. A volte il server Flask si avvia correttamente su questa porta, ma quando apri l'URL (che il server restituisce nel terminale) in un browser o in un client API come Postman, potresti non ottenere l'output. Considera la situazione seguente:

• Secondo Flask, il server è stato avviato correttamente sulla porta 5000, ma quando l'URL è stato aperto nel browser, non ha restituito nulla. Potrebbe trattarsi di un conflitto di porta. In questo caso, cambiare la porta predefinita 5000 con una a tua scelta è una buona idea. Puoi farlo semplicemente così:

  app.run(debug=True,port=12345)

• In tal caso, il server Flask apparirà più o meno così:

Ora, esaminiamo passo passo il codice che hai scritto:

• Hai creato un'istanza della classe Flask e passato la variabile "name" (che viene valorizzata automaticamente da Python). Questa variabile sarà "main" se questo file viene eseguito direttamente da Python come script. Se invece importi il file, il valore di "name" sarà il nome del file importato. Ad esempio, se avevi test.py e run.py e importavi test.py in run.py, il valore di "name" in test.py sarà test (app = Flask(test)).

• Sopra la definizione del metodo hello() c'è @app.route(""). route() è un decoratore che dice a Flask quale URL deve attivare la funzione definita come hello().

• Il metodo hello() è responsabile della produzione di un output (Welcome to machine learning model APIs!) ogni volta che la tua API viene correttamente colpita (o consumata). In questo caso, aprire un browser con localhost:5000/ produrrà l'output previsto (a condizione che il server Flask sia in esecuzione sulla porta 5000).

Ora studierai alcuni fattori da tenere a mente se stai trasformando i tuoi modelli di machine learning (costruiti con scikit-learn) in un'API Flask.

Modelli scikit-learn con Flask

Creare modelli di machine learning da molto semplici a molto complessi non è mai stato così facile in Python con scikit-learn. Ma ci sono alcuni punti da ricordare su scikit-learn:

• Scikit-learn è una libreria Python che offre strumenti semplici ed efficienti per data mining e data analysis. Scikit-learn ha i seguenti moduli principali:
  • Clustering
  • Regressione
  • Classificazione
  • Riduzione della dimensionalità
  • Selezione del modello
  • Preprocessing

(Assicurati di dare un'occhiata al corso di DataCamp Supervised Learning with scikit-learn tenuto dallo sviluppatore core di scikit-learn - Andreas Müller)

• Scikit-learn supporta la serializzazione e deserializzazione dei modelli che alleni con scikit-learn. Questo ti fa risparmiare il tempo del ritraining. Con una copia serializzata del tuo modello creato con scikit-learn puoi scrivere un'API Flask.
  
  
• I modelli scikit-learn richiedono dati in formato numerico. Per questo, se il dataset contiene feature categoriche non numeriche, è importante convertirle in numeriche. Per questa trasformazione, scikit-learn fornisce utility come LabelEncoder, OneHotEncoder, ecc. Queste si trovano nel modulo sklearn.preprocessing.
  
  
• I modelli scikit-learn non gestiscono implicitamente i valori mancanti. Devi gestire tu i missing nel dataset e poi passarli al modello. Per gestire i valori mancanti, scikit-learn offre un'ampia gamma di utility nel modulo sklearn.preprocessing.

Label encoding e valori mancanti sono passaggi importanti di preprocessing dei dati, essenziali per costruire un buon modello di machine learning. Se vuoi saperne di più, dai un'occhiata a questo corso di DataCamp:

• Preprocessing for Machine Learning in Python

Per questo tutorial userai il dataset Titanic, uno dei più popolari per vari motivi, ad esempio – il dataset contiene diverse tipologie di variabili e presenta valori mancanti, ecc. Questo tutorial di DataCamp copre un'ottima analisi del dataset, e il dataset può essere scaricato da qui.

Questo dataset riguarda un problema di classificazione: prevedere se un passeggero sopravviverà o meno dato un insieme di informazioni su di lui/lei.

Nota: Variabili e feature sono termini usati in modo intercambiabile in molti punti di questo tutorial.

Per semplificare ulteriormente, userai solo quattro variabili: age, sex, embarked e survived, dove survived è l'etichetta di classe.

# Import dependencies
import pandas as pd
import numpy as np

# Load the dataset in a dataframe object and include only four features as mentioned
url = "http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv"
df = pd.read_csv(url)
include = ['Age', 'Sex', 'Embarked', 'Survived'] # Only four features
df_ = df[include]

"Sex" e "Embarked" sono feature categoriche con valori non numerici e quindi richiedono trasformazioni numeriche. La feature “Age” ha valori mancanti. Questi possono essere imputati con una statistica di sintesi come mediana o media. I valori mancanti possono essere significativi, ed è utile indagare cosa rappresentino nelle applicazioni reali.

Scikit-learn tratta come NaN le celle senza contenuto. Qui, semplicemente sostituirai i NaN con 0 e scriverai una funzione di supporto per farlo.

categoricals = []
for col, col_type in df_.dtypes.iteritems():
     if col_type == 'O':
          categoricals.append(col)
     else:
          df_[col].fillna(0, inplace=True)

Le righe di codice sopra fanno quanto segue:

• Iterano su tutte le colonne del dataframe df e aggiungono all'elenco categorical le colonne con valori non numerici.

• Se le colonne non hanno valori non numerici (che in questo caso è solo Age), allora controllano se hanno valori mancanti e li riempiono con 0.

  Riempire i NaN con un singolo valore può avere conseguenze indesiderate, soprattutto se l'importo con cui sostituisci i NaN rientra nell'intervallo osservato per la variabile numerica. Poiché zero non è un valore di età osservato e legittimo, non stai introducendo bias, che invece introdurresti usando ad esempio 36! - Fonte

Ora che hai gestito i valori mancanti e separato le colonne non numeriche, sei pronto a convertirle in numeriche. Lo farai usando la One Hot Encoding. Pandas fornisce un metodo semplice, get_dummies(), per creare variabili OHE per un dato dataframe.

df_ohe = pd.get_dummies(df_, columns=categoricals, dummy_na=True)

Quando usi l'OHE, viene creata una nuova colonna per ogni combinazione colonna/valore, nel formato colonna_valore. Ad esempio, per la variabile “Embarked”, l'OHE produrrà “Embarked_C”, “Embarked_Q”, “Embarked_S” e “Embarked_nan”.

Ora che hai preprocessato con successo il dataset, sei pronto ad allenare il modello di machine learning. Userai un classificatore di Regressione Logistica.

from sklearn.linear_model import LogisticRegression
dependent_variable = 'Survived'
x = df_ohe[df_ohe.columns.difference([dependent_variable])]
y = df_ohe[dependent_variable]
lr = LogisticRegression()
lr.fit(x, y)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
          verbose=0, warm_start=False)

Hai costruito il tuo modello di machine learning. Ora salverai questo modello. Tecnicamente, serializzerai il modello. In Python, questo si chiama Pickling.

Salvataggio del modello: serializzazione e deserializzazione

Userai joblib di sklearn per questo.

from sklearn.externals import joblib
joblib.dump(lr, 'model.pkl')

['model.pkl']

Il modello di Regressione Logistica è ora persistito. Puoi caricare questo modello in memoria con una sola riga di codice. Caricare di nuovo il modello nel tuo ambiente di lavoro è noto come Deserializzazione.

lr = joblib.load('model.pkl')

Ora sei pronto a usare Flask per servire il tuo modello persistito. Hai già visto quanto sia minimale Flask per iniziare.

Creare un'API da un modello di Machine Learning usando Flask

Per servire il tuo modello con Flask, farai due cose:

• Caricare in memoria il modello già persistito all'avvio dell'applicazione,
• Creare un endpoint API che prenda variabili di input, le trasformi nel formato appropriato e restituisca le predizioni.

Più nello specifico, il tuo input di esempio all'API sarà simile al seguente:

[
    {"Age": 85, "Sex": "male", "Embarked": "S"},
    {"Age": 24, "Sex": '"female"', "Embarked": "C"},
    {"Age": 3, "Sex": "male", "Embarked": "C"},
    {"Age": 21, "Sex": "male", "Embarked": "S"}
]

(che è una lista JSON di input)

e la tua API restituirà un output come il seguente:

{"prediction": [0, 1, 1, 0]}

Le predizioni indicano lo stato di sopravvivenza, dove 0 rappresenta No e 1 rappresenta Sì.

JSON sta per JavaScript Object Notation, ed è uno dei formati di interscambio dati più usati. Se ti serve una rapida introduzione, segui questi tutorial.

Scriviamo una funzione predict() che farà quanto segue:

• Caricare in memoria il modello persistito all'avvio dell'applicazione,
• Creare un endpoint API che prenda variabili di input, le trasformi nel formato appropriato e restituisca le predizioni.

Hai già visto come caricare un modello persistito. Ora ti concentrerai su come usarlo per prevedere lo stato di sopravvivenza al ricevimento degli input.

from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/predict', methods=['POST'])
def predict():
     json_ = request.json
     query_df = pd.DataFrame(json_)
     query = pd.get_dummies(query_df)
     prediction = lr.predict(query)
     return jsonify({'prediction': list(prediction)})

Fantastico! Ma qui c'è un piccolo problema.

La funzione che hai scritto funzionerebbe solo se la richiesta in arrivo contenesse tutti i possibili valori per le variabili categoriche, cosa che potrebbe non verificarsi in tempo reale. Se la richiesta in arrivo non include tutti i possibili valori delle variabili categoriche, allora, secondo l'attuale definizione di predict(), get_dummies() genererà un dataframe con meno colonne di quante il classificatore si aspetti, causando un errore a runtime.

Per risolvere questo problema, persisterai anche l'elenco delle colonne durante il training del modello. Puoi serializzare qualsiasi oggetto Python in un file .pkl. Userai joblib nello stesso modo visto prima.

(Tieni presente che, come discusso, è sempre meglio scrivere tutto il codice lato server in un editor di testo ed eseguirlo da terminale)

model_columns = list(x.columns)
joblib.dump(model_columns, 'model_columns.pkl')

['model_columns.pkl']

Dato che hai già persistito l'elenco delle colonne, puoi semplicemente gestire i valori mancanti al momento della predizione. Dovrai caricare le colonne del modello all'avvio dell'applicazione.

@app.route('/predict', methods=['POST']) # Your API endpoint URL would consist /predict
def predict():
    if lr:
        try:
            json_ = request.json
            query = pd.get_dummies(pd.DataFrame(json_))
            query = query.reindex(columns=model_columns, fill_value=0)

            prediction = list(lr.predict(query))

            return jsonify({'prediction': prediction})

        except:

            return jsonify({'trace': traceback.format_exc()})
    else:
        print ('Train the model first')
        return ('No model here to use')

Hai incluso tutti gli elementi necessari nell'API "/predict" e ora ti basta scrivere la classe principale.

if __name__ == '__main__':
    try:
        port = int(sys.argv[1]) # This is for a command-line argument
    except:
        port = 12345 # If you don't provide any port then the port will be set to 12345
    lr = joblib.load(model_file_name) # Load "model.pkl"
    print ('Model loaded')
    model_columns = joblib.load(model_columns_file_name) # Load "model_columns.pkl"
    print ('Model columns loaded')
    app.run(port=port, debug=True)

La tua API è ora pronta per essere ospitata. Ma prima di andare oltre, ricapitoliamo tutto ciò che hai fatto finora:

Rimettere insieme i pezzi:

• Hai caricato il dataset Titanic e selezionato quattro feature.
• Hai effettuato il preprocessing necessario dei dati.
• Hai costruito un classificatore di Regressione Logistica e lo hai serializzato.
• Hai anche serializzato tutte le colonne del training come soluzione al problema di un numero di colonne inferiore al previsto, persistendo l'elenco delle colonne del training.
• Hai poi scritto una semplice API con Flask che predice se una persona è sopravvissuta al naufragio dato età, sesso e porto d'imbarco.

Mettiamo tutto il codice in un unico posto così non ti perdi nulla. Inoltre, è una buona pratica separare il codice del modello di Regressione Logistica e quello della tua API Flask in file .py separati.

Quindi il tuo model.py dovrebbe essere simile al seguente:

# Import dependencies
import pandas as pd
import numpy as np

# Load the dataset in a dataframe object and include only four features as mentioned
url = "http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv"
df = pd.read_csv(url)
include = ['Age', 'Sex', 'Embarked', 'Survived'] # Only four features
df_ = df[include]

# Data Preprocessing
categoricals = []
for col, col_type in df_.dtypes.iteritems():
     if col_type == 'O':
          categoricals.append(col)
     else:
          df_[col].fillna(0, inplace=True)

df_ohe = pd.get_dummies(df_, columns=categoricals, dummy_na=True)

# Logistic Regression classifier
from sklearn.linear_model import LogisticRegression
dependent_variable = 'Survived'
x = df_ohe[df_ohe.columns.difference([dependent_variable])]
y = df_ohe[dependent_variable]
lr = LogisticRegression()
lr.fit(x, y)

# Save your model
from sklearn.externals import joblib
joblib.dump(lr, 'model.pkl')
print("Model dumped!")

# Load the model that you just saved
lr = joblib.load('model.pkl')

# Saving the data columns from training
model_columns = list(x.columns)
joblib.dump(model_columns, 'model_columns.pkl')
print("Models columns dumped!")

Il tuo api.py dovrebbe essere simile al seguente:

# Dependencies
from flask import Flask, request, jsonify
from sklearn.externals import joblib
import traceback
import pandas as pd
import numpy as np

# Your API definition
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    if lr:
        try:
            json_ = request.json
            print(json_)
            query = pd.get_dummies(pd.DataFrame(json_))
            query = query.reindex(columns=model_columns, fill_value=0)

            prediction = list(lr.predict(query))

            return jsonify({'prediction': str(prediction)})

        except:

            return jsonify({'trace': traceback.format_exc()})
    else:
        print ('Train the model first')
        return ('No model here to use')

if __name__ == '__main__':
    try:
        port = int(sys.argv[1]) # This is for a command-line input
    except:
        port = 12345 # If you don't provide any port the port will be set to 12345

    lr = joblib.load("model.pkl") # Load "model.pkl"
    print ('Model loaded')
    model_columns = joblib.load("model_columns.pkl") # Load "model_columns.pkl"
    print ('Model columns loaded')

    app.run(port=port, debug=True)

Niente male! Ora testerai questa API in un client API chiamato Postman. Assicurati solo che model.py e api.py siano nella stessa directory e verifica anche di averli compilati entrambi prima del test. Fai riferimento alla seguente schermata del terminale, scattata dopo che entrambi i file .py sono stati compilati correttamente.

Se tutti i file sono stati compilati correttamente, la struttura della directory dovrebbe essere la seguente:

Nota: Il file IPYNB è facoltativo.

Testare la tua API in Postman

Per testare la tua API, ti servirà un client API. Postman è senza dubbio uno dei migliori. Puoi scaricarlo facilmente dal link sopra.

L'interfaccia di Postman appare così se hai scaricato l'ultima versione:

Dopo aver avviato correttamente il server Flask, devi inserire l'URL corretto con la giusta porta in Postman. Dovrebbe essere simile al seguente:

Congratulazioni! Hai appena costruito la tua prima API di machine learning.

La tua API può prevedere se un passeggero è sopravvissuto al naufragio del Titanic dati age, sex e embarked. Ora, il tuo amico può chiamarla dal suo codice frontend ed elaborare l'output dell'API in qualcosa di interessante.

Andare oltre:

In questo tutorial, hai coperto una delle competenze più richieste nell'industria per un Data Scientist full-stack, cioè creare un'API da un modello di machine learning. Sebbene l'API sia molto semplice, è sempre meglio partire dalle cose più semplici per capire a fondo i dettagli.

Puoi fare molto di più per migliorare. Opzioni possibili da considerare:

• Scrivere un'API "/train" che alleni un classificatore di Regressione Logistica con i dati.
• Codificare un modello di Rete Neurale usando keras e costruirne un'API.
• Ospitare la tua API sul Cloud in modo che possa essere consumata.
• Per portare le cose a un livello più avanzato, puoi consultare questo blog di Machine Learning Mastery che discute diversi approcci di livello industriale.

Le possibilità e le opportunità qui sono enormi. Devi solo scegliere con attenzione quelle più adatte a te.

Se vuoi saperne di più sul Machine Learning in Python, segui il corso di DataCamp Preprocessing for Machine Learning in Python e dai un'occhiata al nostro tutorial Machine Learning Basics - The Norms.

Riferimenti:

Di seguito alcuni riferimenti utilizzati nella stesura di questo blog:

• Flask: Building Python Web Services
• Un thread su Quora sull'argomento