Obsługa TensorFlow za pomocą platformy Docker

Jednym z najłatwiejszych sposobów rozpoczęcia korzystania z udostępniania TensorFlow jest 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] }

Aby uzyskać dodatkowe obsługujące punkty końcowe, zobacz interfejs API REST klienta .

Zainstaluj Dockera

Ogólne instrukcje instalacji znajdują się na stronie Dockera , ale tutaj podajemy kilka szybkich linków:

Obsługa z Dockerem

Wyciąganie obrazu służącego

Po zainstalowaniu Dockera możesz pobrać najnowszy obraz okna dokowanego TensorFlow Serving, uruchamiając:

docker pull tensorflow/serving

Spowoduje to ściągnięcie minimalnego obrazu Dockera z zainstalowanym TensorFlow Serving.

Zobacz repozytorium tensorflow/serving Docker Hub, aby poznać inne wersje obrazów, które możesz pobrać.

Uruchamianie wyświetlanego obrazu

Wyświetlane obrazy (zarówno CPU, jak i GPU) mają następujące właściwości:

  • Port 8500 udostępniony dla gRPC
  • Port 8501 udostępniony dla interfejsu API REST
  • Opcjonalna zmienna środowiskowa MODEL_NAME (domyślnie jest to model )
  • Opcjonalna zmienna środowiskowa MODEL_BASE_PATH (domyślnie /models )

Gdy wyświetlany obraz uruchamia ModelServer, uruchamia go w następujący sposób:

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

Aby obsługiwać Docker, będziesz potrzebować:

  • Otwarty port na hoście, na którym można służyć
  • SavedModel do obsługi
  • Nazwa Twojego modelu, do której będzie się odnosił Twój klient

Jedyne, co musisz zrobić, to uruchomić kontener Docker , opublikować porty kontenera w portach hosta i zamontować ścieżkę hosta do SavedModel, gdzie kontener będzie oczekiwał modeli.

Spójrzmy na przykład:

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

W tym przypadku uruchomiliśmy kontener Docker, opublikowaliśmy port API REST 8501 na porcie 8501 naszego hosta, pobraliśmy model, który nazwaliśmy my_model i powiązaliśmy go z domyślną ścieżką bazową modelu ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Na koniec wypełniliśmy zmienną środowiskową MODEL_NAME wartością my_model i pozostawiliśmy wartość domyślną MODEL_BASE_PATH .

To będzie działać w kontenerze:

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

Gdybyśmy chcieli opublikować port gRPC, użylibyśmy -p 8500:8500 . Możesz mieć jednocześnie otwarte porty gRPC i REST API lub wybrać otwieranie tylko jednego lub drugiego.

Przekazywanie dodatkowych argumentów

tensorflow_model_server obsługuje wiele dodatkowych argumentów, które można przekazać do obsługujących kontenerów dokowanych. Na przykład, jeśli chcielibyśmy przekazać plik konfiguracyjny modelu zamiast podawać nazwę modelu, moglibyśmy wykonać następujące czynności:

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

To podejście działa w przypadku dowolnego innego argumentu wiersza poleceń obsługiwanego przez tensorflow_model_server .

Tworzenie własnego obrazu do serwowania

Jeśli chcesz wyświetlać obraz, który ma wbudowany w kontenerze Twój model, możesz utworzyć własny obraz.

Najpierw uruchom obraz obsługujący jako demon:

docker run -d --name serving_base tensorflow/serving

Następnie skopiuj SavedModel do folderu modelu kontenera:

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

Na koniec zatwierdź kontener obsługujący Twój model, zmieniając MODEL_NAME tak, aby pasował do nazwy Twojego modelu ` ':

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

Możesz teraz przerwać serving_base 

docker kill serving_base

Spowoduje to pozostawienie obrazu Dockera o nazwie <my container> , który możesz wdrożyć i załadować model do obsługi podczas uruchamiania.

Przykład serwowania

Przeanalizujmy pełny przykład, w którym ładujemy SavedModel i wywołujemy go za pomocą interfejsu API REST. Najpierw pociągnij obraz do serwowania: 

docker pull tensorflow/serving

Spowoduje to pobranie najnowszego obrazu obsługującego TensorFlow z zainstalowanym serwerem ModelServer.

Następnie użyjemy modelu zabawki o nazwie Half Plus Two , który generuje 0.5 * x + 2 dla wartości x podanych do przewidywania.

Aby uzyskać ten model, najpierw sklonuj repozytorium TensorFlow Serving. 

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

Następnie uruchom kontener TensorFlow Serving, wskazując go na ten model i otwierając port API REST (8501): 

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 &

Spowoduje to uruchomienie kontenera dokowanego i uruchomienie serwera modeli obsługujących TensorFlow, powiązanie portu 8501 interfejsu API REST i zamapowanie żądanego modelu z naszego hosta na miejsce, w którym oczekiwane są modele w kontenerze. Nazwę modelu przekazujemy także jako zmienną środowiskową, która będzie istotna przy wykonywaniu zapytań do modelu.

Aby wysłać zapytanie do modelu za pomocą interfejsu API przewidywania, możesz uruchomić 

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

To powinno zwrócić zestaw wartości: 

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

Więcej informacji na temat korzystania z RESTful API znajdziesz tutaj .

Udostępnianie w Dockerze przy użyciu procesora graficznego

Zainstaluj nvidia-docker

Przed obsługą GPU, oprócz instalacji Dockera , będziesz potrzebować:

Uruchamianie obrazu obsługującego procesor graficzny

Uruchamianie obrazu obsługującego procesor graficzny jest identyczne z uruchamianiem obrazu procesora. Więcej informacji znajdziesz w artykule Uruchamianie wyświetlanego obrazu .

Przykład serwowania GPU

Przeanalizujmy pełny przykład, w którym ładujemy model z operacjami związanymi z procesorem graficznym i wywołujemy go za pomocą interfejsu API REST.

Najpierw zainstaluj nvidia-docker . Następnie możesz pobrać najnowszy obraz okna dokowanego GPU TensorFlow Serving, uruchamiając: 

docker pull tensorflow/serving:latest-gpu

Spowoduje to ściągnięcie minimalnego obrazu Dockera z serwerem ModelServer zbudowanym do działania na zainstalowanych procesorach graficznych.

Następnie użyjemy modelu zabawki o nazwie Half Plus Two , który generuje 0.5 * x + 2 dla wartości x podanych do przewidywania. Ten model będzie miał operacje powiązane z urządzeniem GPU i nie będzie działać na procesorze.

Aby uzyskać ten model, najpierw sklonuj repozytorium TensorFlow Serving. 

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

Następnie uruchom kontener TensorFlow Serving, wskazując go na ten model i otwierając port API REST (8501): 

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 &

Spowoduje to uruchomienie kontenera dokowanego, uruchomienie serwera modeli obsługujących TensorFlow, powiązanie portu 8501 interfejsu API REST i zamapowanie żądanego modelu z naszego hosta na miejsce, w którym oczekiwane są modele w kontenerze. Nazwę modelu przekazujemy także jako zmienną środowiskową, która będzie istotna przy wykonywaniu zapytań do modelu.

WSKAZÓWKA: Przed wysłaniem zapytania do modelu poczekaj, aż zobaczysz komunikat podobny do poniższego, wskazujący, że serwer jest gotowy do przyjmowania żądań: 

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

Aby wysłać zapytanie do modelu za pomocą interfejsu API przewidywania, możesz uruchomić 

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

To powinno zwrócić zestaw wartości: 

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

WSKAZÓWKA: Próba uruchomienia modelu GPU na komputerze bez procesora GPU lub bez działającej kompilacji GPU serwera TensorFlow Model Server zakończy się błędem wyglądającym następująco: 

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

Więcej informacji na temat korzystania z RESTful API znajdziesz tutaj .

Programowanie z Dockerem

Aby uzyskać instrukcje dotyczące tworzenia i rozwijania udostępniania Tensorflow, zapoznaj się z przewodnikiem dotyczącym programowania za pomocą Dockera .