Wie stellt man ein Modell in Python mithilfe von TensorFlow Serving bereit?

Der Einsatz von Modellen für maschinelles Lernen ist entscheidend, um Anwendungen der künstlichen Intelligenz funktionsfähig zu machen. Und um Modelle in Produktionsumgebungen effektiv bereitzustellen, bietet TensorFlow Serving eine zuverlässige Lösung. Wenn ein Modell trainiert und einsatzbereit ist, ist es von entscheidender Bedeutung, es effizient bereitzustellen, um Echtzeitanforderungen zu bearbeiten. TensorFlow Serving ist ein leistungsstarkes Tool, das die reibungslose Bereitstellung von Modellen für maschinelles Lernen in Produktionsumgebungen unterstützt.

In diesem Artikel befassen wir uns eingehend mit den Schritten zur Bereitstellung eines Modells in Python mithilfe von TensorFlow Serving.

Was ist Modellbereitstellung?

Bei der Modellbereitstellung geht es darum, trainierte Modelle für maschinelles Lernen für Echtzeitvorhersagen verfügbar zu machen. Dies bedeutet, dass das Modell von einer Entwicklungsumgebung in ein Produktionssystem verschoben wird, wo es eingehende Anfragen effizient bearbeiten kann. TensorFlow Serving ist ein speziell entwickeltes Hochleistungssystem, das speziell für die Bereitstellung von Modellen für maschinelles Lernen entwickelt wurde.

TensorFlow-Dienst einrichten

Zuerst müssen wir TensorFlow Serving auf unserem System installieren. Bitte befolgen Sie die folgenden Schritte, um TensorFlow Serving einzurichten -

Schritt 1: TensorFlow Serving installieren

Installieren Sie zunächst TensorFlow Serving mit dem Paketmanager pip. Öffnen Sie die Eingabeaufforderung oder das Terminal und geben Sie den folgenden Befehl ein: -

pip install tensorflow-serving-api

Schritt 2: Starten Sie den TensorFlow-Dienstserver

Starten Sie nach der Installation den TensorFlow Serving-Server, indem Sie den folgenden Befehl ausführen -

tensorflow_model_server --rest_api_port=8501 --model_name=my_model --model_base_path=/path/to/model/directory

Ersetzen Sie `/path/to/model/directory` durch den Pfad, in dem das trainierte Modell gespeichert ist.

Bereit zum Einsatz des Modells

Bevor das Modell bereitgestellt wird, muss es in einem Format gespeichert werden, das TensorFlow Serving verstehen kann. Befolgen Sie diese Schritte, um Ihr Modell für die Bereitstellung vorzubereiten -

Speichern Sie das Modell im SavedModel-Format

Verwenden Sie in einem Python-Skript den folgenden Code, um das trainierte Modell im SavedModel-Format zu speichern -

import tensorflow as tf

# Assuming `model` is your trained TensorFlow model
tf.saved_model.save(model, '/path/to/model/directory')

Modellsignatur definieren

Die Modellsignatur liefert Informationen über die Eingabe- und Ausgabetensoren des Modells. Verwenden Sie die Funktion `tf.saved_model.signature_def_utils.build_signature_def`, um die Modellsignatur zu definieren. Hier ist ein Beispiel -

inputs = {'input': tf.saved_model.utils.build_tensor_info(model.input)}
outputs = {'output': tf.saved_model.utils.build_tensor_info(model.output)}

signature = tf.saved_model.signature_def_utils.build_signature_def(
   inputs=inputs,
   outputs=outputs,
   method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME
)

Modell mit Signatur speichern

Um das Modell zusammen mit der Signatur zu speichern, verwenden Sie den folgenden Code -

builder = tf.saved_model.builder.SavedModelBuilder('/path/to/model/directory')
builder.add_meta_graph_and_variables(
   sess=tf.keras.backend.get_session(),
   tags=[tf.saved_model.tag_constants.SERVING],
   signature_def_map={
      tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature
   }
)
builder.save

()

Verwenden Sie TensorFlow Serving, um das Modell bereitzustellen

Da unser Modell nun fertig ist, ist es an der Zeit, es mit TensorFlow Serving bereitzustellen. Bitte befolgen Sie die folgenden Schritte -

Verbinden Sie sich mit TensorFlow Serving

Verwenden Sie im Python-Skript das gRPC-Protokoll, um eine Verbindung mit TensorFlow Serving herzustellen. Hier ist ein Beispiel -

from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc

channel = grpc.insecure_channel('localhost:8501')
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)

Anfrage erstellen

Um eine Vorhersage zu treffen, erstellen Sie eine Anforderungs-Protobuf-Nachricht und geben Sie den Modellnamen und den Signaturnamen an. Hier ist ein Beispiel -

request = predict_pb2.PredictRequest()
request.model_spec.name = 'my_model'
request.model_spec.signature_name = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
request.inputs['input'].CopyFrom(tf.contrib.util.make_tensor_proto(data, shape=data.shape))

Ersetzen Sie `Daten` durch die Eingabedaten, die Sie vorhersagen möchten.

Senden Sie eine Anfrage und erhalten Sie eine Antwort

Senden Sie die Anfrage an TensorFlow Serving und rufen Sie die Antwort ab. Hier ist ein Beispiel -

response = stub.Predict(request, timeout_seconds)
output = tf.contrib.util.make_ndarray(response.outputs['output'])

Der Parameter

`timeout_seconds` gibt die maximale Zeit an, die auf eine Antwort gewartet werden soll.

Testen Sie das bereitgestellte Modell

Um sicherzustellen, dass das bereitgestellte Modell ordnungsgemäß funktioniert, muss es mit Beispieleingaben getestet werden. So testen Sie ein bereitgestelltes Modell –

Beispieldaten vorbereiten

Erstellen Sie einen Satz Beispieleingabedaten, die dem erwarteten Eingabeformat des Modells entsprechen.

Senden Sie eine Anfrage an ein bereitgestelltes Modell

Erstellen und senden Sie Anfragen an bereitgestellte Modelle.

request = predict_pb2.PredictRequest()
request.model_spec.name = 'my_model'
request.model_spec.signature_name = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
request.inputs['input'].CopyFrom(tf.contrib.util.make_tensor_proto(data, shape=data.shape))

Ausgabe auswerten

Vergleichen Sie die vom bereitgestellten Modell erhaltene Ausgabe mit der erwarteten Ausgabe. Dieser Schritt stellt sicher, dass das Modell genaue Vorhersagen trifft.

Bereitstellungen skalieren und überwachen

Da die prognostizierte Nachfrage steigt, ist es wichtig, Ihre Bereitstellung zu skalieren, um große Mengen eingehender Anfragen zu bewältigen. Darüber hinaus hilft die Überwachung von Bereitstellungen dabei, die Leistung und den Zustand bereitgestellter Modelle zu verfolgen. Erwägen Sie die Implementierung der folgenden Skalierungs- und Überwachungsstrategien -

Zoom

• Verwenden Sie mehrere Instanzen von TensorFlow Serving für den Lastausgleich.

• Containerisieren Sie mit Plattformen wie Docker und Kubernetes.

Überwachung

• Erfassen Sie Metriken wie Anforderungslatenz, Fehlerrate und Durchsatz.

• Legen Sie Warnungen und Benachrichtigungen für kritische Ereignisse fest.

Beispiel

Das folgende Programmbeispiel zeigt, wie ein Modell mithilfe der TensorFlow-Bereitstellung bereitgestellt wird -

import tensorflow as tf
from tensorflow import keras

# Load the trained model
model = keras.models.load_model("/path/to/your/trained/model")

# Convert the model to the TensorFlow SavedModel format
export_path = "/path/to/exported/model"
tf.saved_model.save(model, export_path)

# Start the TensorFlow Serving server
import os
os.system("tensorflow_model_server --port=8501 --model_name=your_model --model_base_path={}".format(export_path))

Im obigen Beispiel müssen Sie „/path/to/your/trained/model“ durch den tatsächlichen Pfad zum trainierten Modell ersetzen. Das Modell wird mit der Funktion load_model() von Keras geladen.

Als nächstes wird das Modell in das TensorFlow SavedModel-Format konvertiert und im angegebenen Exportpfad gespeichert.

Dann verwenden Sie die Funktion os.system(), um den TensorFlow Serving-Server zu starten, der den Befehl tensorflow_model_server ausführt. Dieser Befehl gibt den Server-Port, den Modellnamen (Ihr_Modell) und den Basispfad an, in dem sich das exportierte Modell befindet.

Bitte stellen Sie sicher, dass TensorFlow Serving installiert ist, und ersetzen Sie den Dateipfad durch den entsprechenden Wert für Ihr System.

Gewünschte Ausgabe

Nachdem der Server erfolgreich gestartet ist, ist er bereit, Vorhersagedienste bereitzustellen. Sie können andere Programme oder APIs verwenden, um Vorhersageanfragen an den Server zu senden, und der Server antwortet mit einer Vorhersageausgabe basierend auf dem geladenen Modell.

Fazit

Zusammenfassend ist es wichtig, Modelle für maschinelles Lernen in Produktionsumgebungen einzusetzen, um ihre Vorhersagefähigkeiten zu nutzen. In diesem Artikel untersuchen wir den Prozess der Bereitstellung von Modellen in Python mithilfe von TensorFlow Serving. Wir besprachen die Installation von TensorFlow Serving, die Vorbereitung der Modellbereitstellung, die Bereitstellung des Modells und das Testen seiner Leistung. Mit den folgenden Schritten können wir das TensorFlow-Modell erfolgreich bereitstellen und genaue Echtzeitvorhersagen treffen.

Das obige ist der detaillierte Inhalt vonWie stellt man ein Modell in Python mithilfe von TensorFlow Serving bereit?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!