Treten Sie der SIG TFX-Addons-Community bei und helfen Sie mit, TFX noch besser zu machen! SIG TFX-Addons beitreten

TensorFlow-Bereitstellung mit Docker

Eine der einfachsten Möglichkeiten , um loszulegen Serving TensorFlow ist mit Docker .

# Download the TensorFlow Serving Docker image and repo
docker pull tensorflow/serving
git clone https://github.com/tensorflow/serving # Location of demo models TESTDATA="$(pwd)/serving/tensorflow_serving/servables/tensorflow/testdata" # Start TensorFlow Serving container and open the REST API port docker run -t --rm -p 8501:8501 \ -v "$TESTDATA/saved_model_half_plus_two_cpu:/models/half_plus_two" \ -e MODEL_NAME=half_plus_two \ tensorflow/serving & # Query the model using the predict API curl -d '{"instances": [1.0, 2.0, 5.0]}' \ -X POST http://localhost:8501/v1/models/half_plus_two:predict
# Returns => { "predictions": [2.5, 3.0, 4.5] }

Für zusätzliche Portion Endpunkte finden Sie in der Client - REST - API .

Docker installieren

Allgemeine Installationshinweise sind auf der Website Docker , aber wir geben einige schnelle Links:

Servieren mit Docker

Abrufen eines Bereitstellungsbilds

Nachdem Sie Docker installiert haben, können Sie das neueste Docker-Image von TensorFlow Serving abrufen, indem Sie Folgendes ausführen:

docker pull tensorflow/serving

Dadurch wird ein minimales Docker-Image mit installiertem TensorFlow Serving heruntergezogen.

Siehe die Docker Hub tensorflow / Portion Repo für andere Versionen von Bildern , die Sie ziehen können.

Ausführen eines Bereitstellungsimages

Die bereitgestellten Images (sowohl CPU als auch GPU) haben die folgenden Eigenschaften:

  • Port 8500 für gRPC verfügbar gemacht
  • Port 8501 für die REST-API verfügbar gemacht
  • Optional Umgebungsvariable MODEL_NAME (Standard - model )
  • Optional Umgebungsvariable MODEL_BASE_PATH (Standard /models )

Wenn das Bereitstellungsimage ModelServer ausführt, wird es wie folgt ausgeführt:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=${MODEL_NAME} --model_base_path=${MODEL_BASE_PATH}/${MODEL_NAME}

Um mit Docker zu dienen, benötigen Sie:

  • Ein offener Port auf Ihrem Host für die Bereitstellung
  • Ein SavedModel zum Servieren
  • Ein Name für Ihr Modell, auf den sich Ihr Kunde bezieht

Was Sie tun , ist die Docker laufen Container, veröffentlichen die Ports zu Ihrem Host-Ports des Containers und Ihrem Host-Pfad zum SavedModel Montage, wo die Containermodelle erwartet.

Schauen wir uns ein Beispiel an:

docker run -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  -e MODEL_NAME=my_model -t tensorflow/serving

In diesem Fall haben wir einen Docker Container, veröffentlichte die REST - API - Port 8501 zu unserem Host-Port 8501 und genommen ein Modell , das wir genannt begann my_model und gebunden an die Standardmodell Basispfad ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Schließlich haben wir in der Umgebungsvariablen gefüllt MODEL_NAME mit my_model und links MODEL_BASE_PATH auf den Standardwert.

Dies wird im Container ausgeführt:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=my_model --model_base_path=/models/my_model

Wenn wir den gRPC Port veröffentlichen wollten, würden wir verwenden -p 8500:8500 . Sie können sowohl gRPC- als auch REST-API-Ports gleichzeitig öffnen oder nur den einen oder den anderen öffnen.

Übergeben zusätzlicher Argumente

tensorflow_model_server unterstützt viele zusätzliche Argumente , dass Sie die Portion Docker Behälter passieren könnte. Wenn wir beispielsweise eine Modellkonfigurationsdatei übergeben möchten, anstatt den Modellnamen anzugeben, könnten wir Folgendes tun:

docker run -p 8500:8500 -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  --mount type=bind,source=/path/to/my/models.config,target=/models/models.config \
  -t tensorflow/serving --model_config_file=/models/models.config

Dieser Ansatz funktioniert für eine der anderen Befehlszeilenargumente , dass tensorflow_model_server unterstützt.

Erstellen Sie Ihr eigenes Serving-Image

Wenn Sie ein Bereitstellungs-Image wünschen, bei dem Ihr Modell in den Container integriert ist, können Sie Ihr eigenes Image erstellen.

Führen Sie zuerst ein Serving-Image als Daemon aus:

docker run -d --name serving_base tensorflow/serving

Kopieren Sie als Nächstes Ihr SavedModel in den Modellordner des Containers:

docker cp models/<my model> serving_base:/models/<my model>

Schließlich verpflichten die Container, Ihr Modell dienen , indem MODEL_NAME Ihr Modells der Namen übereinstimmen ` ':

docker commit --change "ENV MODEL_NAME <my model>" serving_base <my container>

Sie können jetzt aufhören serving_base

docker kill serving_base

Dies wird Ihnen mit einem Docker Bild verlassen genannt <my container> , dass Sie bereitstellen kann und wird für die Bedienung beim Start Ihres Modells laden.

Servierbeispiel

Lassen Sie uns ein vollständiges Beispiel durchgehen, in dem wir ein SavedModel laden und es mithilfe der REST-API aufrufen. Ziehen Sie zuerst das Bereitstellungsbild:

docker pull tensorflow/serving

Dadurch wird das neueste TensorFlow Serving-Image mit installiertem ModelServer abgerufen.

Als nächstes werden wir ein Spielzeugmodell namens verwenden Half Plus Two , die erzeugt 0.5 * x + 2 für die Werte von x wir für die Vorhersage liefern.

Um dieses Modell zu erhalten, klonen Sie zuerst das TensorFlow Serving-Repository.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Führen Sie als Nächstes den TensorFlow Serving-Container aus, der auf dieses Modell verweist und den REST-API-Port (8501) öffnet:

docker run -p 8501:8501 \
  --mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_cpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving &

Dies führt den Docker-Container aus und startet den TensorFlow Serving Model Server, bindet den REST-API-Port 8501 und ordnet unser gewünschtes Modell von unserem Host dort zu, wo Modelle im Container erwartet werden. Außerdem übergeben wir den Namen des Modells als Umgebungsvariable, was bei der Abfrage des Modells wichtig ist.

Um das Modell mit der Vorhersage-API abzufragen, können Sie Folgendes ausführen:

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Dies sollte eine Reihe von Werten zurückgeben:

{ "predictions": [2.5, 3.0, 4.5] }

Weitere Informationen über die RESTful API verwenden , können gefunden werden hier .

Bereitstellung mit Docker über Ihre GPU

Installieren Sie nvidia-docker

Bevor mit einer GPU dient, zusätzlich zur Installation von Docker , müssen Sie:

Ausführen eines GPU-Bereitstellungsimages

Das Ausführen eines GPU-Bereitstellungsimages ist identisch mit dem Ausführen eines CPU-Images. Weitere Einzelheiten finden Sie läuft eine Portion Bild .

Beispiel für GPU-Bereitstellung

Lassen Sie uns ein vollständiges Beispiel durchgehen, in dem wir ein Modell mit GPU-gebundenen Operationen laden und es mithilfe der REST-API aufrufen.

Installieren Sie zuerst nvidia-docker . Als Nächstes können Sie das neueste TensorFlow Serving-GPU-Docker-Image abrufen, indem Sie Folgendes ausführen:

docker pull tensorflow/serving:latest-gpu

Dadurch wird ein minimales Docker-Image mit ModelServer heruntergezogen, das für die Ausführung auf installierten GPUs erstellt wurde.

Als nächstes werden wir ein Spielzeugmodell namens verwenden Half Plus Two , die erzeugt 0.5 * x + 2 für die Werte von x wir für die Vorhersage liefern. Bei diesem Modell sind Ops an das GPU-Gerät gebunden und werden nicht auf der CPU ausgeführt.

Um dieses Modell zu erhalten, klonen Sie zuerst das TensorFlow Serving-Repository.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Führen Sie als Nächstes den TensorFlow Serving-Container aus, der auf dieses Modell verweist und den REST-API-Port (8501) öffnet:

docker run --gpus all -p 8501:8501 \
--mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_gpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving:latest-gpu &

Dadurch wird der Docker-Container ausgeführt, der TensorFlow Serving Model Server gestartet, der REST-API-Port 8501 gebunden und unser gewünschtes Modell von unserem Host dorthin abgebildet, wo Modelle im Container erwartet werden. Wir übergeben auch den Namen des Modells als Umgebungsvariable, was bei der Abfrage des Modells wichtig ist.

TIPP: Warten Sie vor dem Abfragen des Modells, bis eine Meldung wie die folgende angezeigt wird, die anzeigt, dass der Server bereit ist, Anfragen zu empfangen:

2018-07-27 00:07:20.773693: I tensorflow_serving/model_servers/main.cc:333]
Exporting HTTP/REST API at:localhost:8501 ...

Um das Modell mit der Vorhersage-API abzufragen, können Sie Folgendes ausführen:

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Dies sollte eine Reihe von Werten zurückgeben:

{ "predictions": [2.5, 3.0, 4.5] }

TIPP: Der Versuch, das GPU-Modell auf einem Computer ohne GPU oder ohne einen funktionierenden GPU-Build von TensorFlow Model Server auszuführen, führt zu einem Fehler, der wie folgt aussieht:

Cannot assign a device for operation 'a': Operation was explicitly assigned to /device:GPU:0

Weitere Informationen über die RESTful API verwenden , können gefunden werden hier .

Entwickeln mit Docker

Eine Anleitung, wie Tensorflow Serving zu bauen und zu entwickeln, finden Sie mit Docker Führung entwickeln .