Come utilizzare TensorFlow Serving?
TensorFlow Serving è un sistema open source sviluppato da Google per la distribuzione di modelli di machine learning, in particolare quelli creati con TensorFlow, in ambienti di produzione. Il suo scopo principale è fornire un sistema di distribuzione flessibile e ad alte prestazioni per il deployment di nuovi algoritmi ed esperimenti, mantenendo la stessa architettura server e le stesse API. Questo framework è ampiamente adottato per la distribuzione di modelli grazie alla sua capacità di gestire più modelli, il versioning e l'efficienza delle richieste di inferenza.
Introduzione al servizio TensorFlow
TensorFlow Serving supporta l'implementazione di modelli addestrati per l'inferenza (previsione) in modo scalabile ed efficiente. È progettato per gestire previsioni in tempo reale (servizio online) e offre funzionalità come la gestione delle versioni dei modelli, l'hot-swap dei modelli e opzioni di configurazione avanzate per l'implementazione dei modelli.
Il sistema viene in genere utilizzato in scenari in cui un modello addestrato deve essere esposto come servizio, accessibile tramite chiamate API. Ciò consente una perfetta integrazione nelle applicazioni di produzione in cui sono richieste previsioni.
Fase 1: Preparazione di un modello addestrato
Prima di utilizzare TensorFlow Serving, è necessario addestrare un modello ed esportarlo nel formato SavedModel di TensorFlow. SavedModel è il formato di serializzazione universale per i modelli TensorFlow, contenente il grafico, le variabili e i metadati necessari per il servizio.
Supponiamo che un semplice modello di stima venga creato utilizzando l'API di alto livello Estimator di TensorFlow:
python
import tensorflow as tf
# Define a simple linear regression estimator
feature_columns = [tf.feature_column.numeric_column("x", shape=[1])]
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)
# Prepare training data
import numpy as np
x_train = np.array([[1.], [2.], [3.], [4.]])
y_train = np.array([[0.], [-1.], [-2.], [-3.]])
input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
{"x": x_train},
y_train,
batch_size=1,
num_epochs=None,
shuffle=True
)
# Train the estimator
estimator.train(input_fn=input_fn, steps=1000)
# Export the trained model
def serving_input_receiver_fn():
inputs = {"x": tf.placeholder(shape=[None, 1], dtype=tf.float32)}
return tf.estimator.export.ServingInputReceiver(inputs, inputs)
export_dir = estimator.export_savedmodel('exported_model', serving_input_receiver_fn)
Dopo l'addestramento, il modello esportato è disponibile nella directory `exported_model`, in genere con una sottodirectory con timestamp che rappresenta la versione del modello.
Passaggio 2: installazione di TensorFlow Serving
TensorFlow Serving può essere installato ed eseguito in diversi modi: in modo nativo su Linux, tramite container Docker o compilando dal codice sorgente. L'approccio Docker è il più comodo ed è ufficialmente supportato.
Per installare Docker sul tuo sistema, consulta la documentazione ufficiale di Docker. Una volta che Docker sarà disponibile, potrai estrarre l'immagine di TensorFlow Serving:
{{EJS15}}Passaggio 3: servire il modello con TensorFlow Serving
Supponendo che il modello esportato si trovi in `/models/my_model/1/`, dove `1` è il numero di versione, esegui il contenitore Docker TensorFlow Serving come segue:
sh
docker run -p 8501:8501 --name=tf_serving_linear \
--mount type=bind,source=/models/my_model,target=/models/my_model \
-e MODEL_NAME=my_model -t tensorflow/serving
Spiegazione dei parametri:
- `-p 8501:8501` mappa la porta 8501 del contenitore all'host, esponendo l'API REST.
- `--name=tf_serving_linear` assegna un nome al contenitore.
- `--mount type=bind,source=...,target=...` monta la directory del modello locale nel contenitore Docker.
- `-e MODEL_NAME=my_model` specifica il nome del modello che TensorFlow Serving servirà.
- `-t tensorflow/serving` specifica l'immagine di TensorFlow Serving.
La struttura delle directory per i modelli dovrebbe essere:
/models/
my_model/
1/
saved_model.pb
variables/
TensorFlow Serving rileva automaticamente la sottodirectory della versione (`1`), consentendo un facile controllo delle versioni e degli aggiornamenti del modello.
Passaggio 4: creazione di previsioni tramite API REST
Una volta che il server è in esecuzione, le previsioni possono essere effettuate tramite richieste HTTP POST all'endpoint REST API.
Ecco un esempio in cui viene utilizzato `curl` per inviare una richiesta di previsione:
sh
curl -d '{"instances": [{"x": [1.0]}, {"x": [2.0]}]}' \
-H "Content-Type: application/json" \
http://localhost:8501/v1/models/my_model:predict
- La chiave ``instances'` contiene un elenco di esempi di input, ognuno dei quali corrisponde alla firma di input prevista dal modello (in questo caso `x`).
TensorFlow Serving restituisce una risposta di previsione in formato JSON:
json
{
"predictions": [[output_1], [output_2]]
}
Dove `output_1` e `output_2` sono i valori previsti rispettivamente per gli input 1.0 e 2.0.
Passaggio 5: creazione di previsioni tramite API gRPC
TensorFlow Serving supporta anche gRPC, che garantisce prestazioni migliori ed è comunemente utilizzato in ambienti di produzione ad alta produttività.
Esempio di codice Python che utilizza l'API gRPC:
python
import grpc
import tensorflow as tf
from tensorflow_serving.apis import predict_pb2, prediction_service_pb2_grpc
# Connect to TensorFlow Serving server
channel = grpc.insecure_channel('localhost:8500')
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
# Prepare request
request = predict_pb2.PredictRequest()
request.model_spec.name = 'my_model'
request.model_spec.signature_name = 'serving_default'
request.inputs['x'].CopyFrom(
tf.make_tensor_proto([[1.0], [2.0]], shape=[2, 1])
)
# Make prediction
result = stub.Predict(request, 10.0)
print(result)
- Il server deve essere avviato con la porta gRPC esposta (`-p 8500:8500`), che è l'impostazione predefinita nell'immagine Docker.
Fase 6: Controllo delle versioni e gestione del modello
TensorFlow Serving è progettato per gestire in modo efficiente il versioning dei modelli. La struttura delle directory consente la coesistenza di più versioni di un modello. Ad esempio:
/models/
my_model/
1/
2/
Se viene aggiunta una nuova versione (ad esempio, `2`), TensorFlow Serving può passare automaticamente alla nuova versione senza tempi di inattività, a seconda della configurazione. Per impostazione predefinita, viene servita la versione con il numero più alto.
Per specificare la versione del modello in una richiesta, l'API REST fornisce un endpoint:
http://localhost:8501/v1/models/my_model/versions/2:predict
Ciò consente strategie di canarying, distribuzioni blue-green e rollback.
Passaggio 7: configurazione avanzata
TensorFlow Serving supporta funzionalità più avanzate, come l'elaborazione simultanea di più modelli, il monitoraggio e l'elaborazione in batch personalizzata.
- Servizi per più modelli:
Crea un file `models.config`:
model_config_list: {
config: {
name: 'model1',
base_path: '/models/model1',
model_platform: 'tensorflow'
},
config: {
name: 'model2',
base_path: '/models/model2',
model_platform: 'tensorflow'
}
}
Avviare il server con:
sh
docker run -p 8501:8501 \
--mount type=bind,source=/models,target=/models \
-t tensorflow/serving \
--model_config_file=/models/models.config
- Monitoraggio:
TensorFlow Serving espone le metriche tramite un endpoint compatibile con Prometheus in `/monitoring/prometheus/metrics`.
- Dosaggio:
Per quanto riguarda le prestazioni, abilitare il batching può essere utile per i carichi di lavoro ad alta produttività. Il batching può essere configurato tramite parametri da riga di comando o file di configurazione.
Fase 8: Considerazioni sulla sicurezza e sulla produzione
In produzione, assicurati che gli endpoint di TensorFlow Serving siano protetti mediante livelli di autenticazione e autorizzazione, nonché protezioni a livello di rete (ad esempio, eseguendo un proxy inverso o un gateway API).
Registrazione, monitoraggio e avvisi sono fondamentali per le distribuzioni in produzione. Integra TensorFlow Serving con soluzioni centralizzate di registrazione e monitoraggio per monitorare utilizzo, prestazioni e guasti.
Esempio di flusso di lavoro end-to-end
Formazione ed esportazione di un modello:
1. Addestrare uno stimatore semplice come mostrato nel passaggio 1.
2. Esportare il modello nel formato SavedModel, ad esempio `/models/linear/1/`.
Avvio del servizio TensorFlow:
sh
docker run -p 8501:8501 --name=tf_serving_example \
--mount type=bind,source=/models/linear,target=/models/linear \
-e MODEL_NAME=linear -t tensorflow/serving
Fare una previsione:
sh
curl -d '{"instances": [{"x": [5.0]}]}' \
-H "Content-Type: application/json" \
http://localhost:8501/v1/models/linear:predict
Risposta:
{{EJS27}}Risoluzione dei problemi comuni
1. Modello non trovato: Assicurarsi che la struttura della directory del modello sia corretta e che la variabile d'ambiente `MODEL_NAME` corrisponda alla directory corretta.
2. Firma non corrispondente: La firma di input del modello esportato deve corrispondere all'input fornito durante le richieste di previsione. Utilizzare lo strumento `saved_model_cli` per ispezionare la firma di SavedModel.
3. Conflitti portuali: Assicurarsi che le porte specificate (8501 per REST, 8500 per gRPC) non siano utilizzate da altri processi.
4. Autorizzazioni sui file: Verificare che Docker abbia l'autorizzazione per accedere ai file del modello sulla macchina host.
Integrazione con Google Cloud
TensorFlow Serving può essere integrato con Google Cloud AI Platform per distribuzioni gestite. Tuttavia, i principi fondamentali di esportazione dei modelli, elaborazione e query rimangono invariati. Google Cloud AI Platform fornisce un servizio gestito per l'elaborazione dei modelli TensorFlow, astraendo la gestione dell'infrastruttura.
paragrafo
TensorFlow Serving offre una soluzione robusta e flessibile per la distribuzione di modelli TensorFlow in un ambiente di produzione. Supporta interfacce REST e gRPC, consente la gestione delle versioni e si integra perfettamente in architetture di distribuzione scalabili. Partendo dall'esportazione del modello, passando per la distribuzione basata su Docker e culminando nell'inferenza basata su API, TensorFlow Serving semplifica la transizione dallo sviluppo del modello alla distribuzione reale. La sua compatibilità sia con stimatori semplici che con modelli complessi lo rende uno strumento versatile nel toolkit di distribuzione per il machine learning.
Altre domande e risposte recenti riguardanti EITC/AI/GCML Google Cloud Machine Learning:
- Quali sono alcuni algoritmi AI/ML comuni da utilizzare sui dati elaborati?
- In che modo i modelli Keras sostituiscono gli stimatori TensorFlow?
- Come configurare uno specifico ambiente Python con Jupyter Notebook?
- Che cos'è Classifier.export_saved_model e come utilizzarlo?
- Perché la regressione viene spesso utilizzata come predittore?
- I moltiplicatori di Lagrange e le tecniche di programmazione quadratica sono rilevanti per l'apprendimento automatico?
- È possibile applicare più di un modello durante il processo di apprendimento automatico?
- Il Machine Learning può adattare l'algoritmo da utilizzare a seconda dello scenario?
- Qual è il percorso più semplice per un principiante assoluto senza alcuna formazione di programmazione, per l'addestramento e l'implementazione di modelli di intelligenza artificiale di base su Google AI Platform utilizzando una versione di prova/livello gratuito e una console GUI in modo graduale?
- Come addestrare e distribuire in modo pratico un semplice modello di intelligenza artificiale in Google Cloud AI Platform tramite l'interfaccia GUI della console GCP in un tutorial passo passo?
Visualizza altre domande e risposte in EITC/AI/GCML Google Cloud Machine Learning