Obsługa TensorFlow za pomocą platformy Docker

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Jednym z najprostszych sposobów, aby zacząć korzystać TensorFlow porcja to z 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] }

Dodatkowych punktów końcowych obsługujących, zobacz API Client REST .

Zainstaluj Docker

Ogólne instrukcje montażu znajdują się na stronie Docker , ale dajemy kilka szybkich łączy tutaj:

Obsługa za pomocą Dockera

Ciągnięcie obrazu serwowania

Po zainstalowaniu platformy Docker 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 Docker Hub tensorflow / serwującą repo dla innych wersji obrazów, które można ciągnąć.

Uruchamianie obrazu serwowania

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

  • Port 8500 narażony na gRPC
  • Port 8501 wyeksponowany dla REST API
  • Opcjonalnie zmienna MODEL_NAME (domyślnie model )
  • Zmienna opcjonalnie środowisko MODEL_BASE_PATH (domyślnie /models )

Gdy obraz obsługujący 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}

Do obsługi z Dockerem potrzebne są:

  • Otwarty port na twoim hoście do obsługi
  • Zapisany model do obsługi
  • Nazwa Twojego modelu, do której będzie się odwoływać Twój klient

Co zrobisz się uruchomić Docker pojemnik, publikować porty pojemnika do portów Państwa gospodarz, a montaż ścieżkę swojego gospodarza do SavedModel gdzie pojemnik spodziewa 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, zaczęliśmy pojemnik Docker, opublikowane port REST API 8501 do portu naszego gospodarza 8501, a podjęte przez nas model o nazwie my_model i związał go na ścieżkę domyślną modelu bazowego ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Wreszcie, mamy wypełnione w zmiennej środowiskowej MODEL_NAME z my_model i opuścił MODEL_BASE_PATH na wartość domyślną.

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ć otwarte jednocześnie porty gRPC i REST API lub zdecydować się na otwarcie tylko jednego lub drugiego.

Przekazywanie dodatkowych argumentów

tensorflow_model_server obsługuje wiele dodatkowych argumentów, które można przekazać do pojemników służących Docker. Na przykład, gdybyśmy chcieli przekazać plik konfiguracyjny modelu zamiast określać 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 na którykolwiek z pozostałych argumentów wiersza poleceń, które tensorflow_model_server podporach.

Tworzenie własnego obrazu serwowania

Jeśli potrzebujesz obrazu do wyświetlania, który ma Twój model wbudowany w kontener, możesz utworzyć własny obraz.

Najpierw uruchom obraz służący jako demon:

docker run -d --name serving_base tensorflow/serving

Następnie skopiuj swój SavedModel do folderu modelu kontenera:

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

Wreszcie popełnić pojemnik, który jest serwującą model zmieniając MODEL_NAME dopasować nazwę swojego modelu ` ':

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

Teraz można zatrzymać serving_base

docker kill serving_base

To zostawię was z obrazem Docker nazwie <my container> które można wdrożyć i załadować swój model do serwowania na starcie.

Przykład serwowania

Przejdźmy przez pełny przykład, w którym ładujemy SavedModel i wywołujemy go za pomocą interfejsu API REST. Najpierw wyciągnij obraz serwowania:

docker pull tensorflow/serving

Spowoduje to pobranie najnowszego obrazu TensorFlow Serving z zainstalowanym ModelServer.

Następnie użyjemy model zabawkę o nazwie Half Plus Two , który generuje 0.5 * x + 2 dla wartości x świadczymy dla predykcji.

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 REST API (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 dockera i uruchomienie serwera modelu obsługi serwera TensorFlow, powiązanie portu 8501 interfejsu API REST i mapowanie pożądanego modelu z naszego hosta na miejsce, w którym oczekuje się modeli w kontenerze. Przekazujemy również nazwę modelu jako zmienną środowiskową, co będzie ważne podczas wykonywania zapytania 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

Powinno to zwrócić zestaw wartości:

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

Więcej informacji na temat korzystania z relaksującego API można znaleźć tutaj .

Obsługa za pomocą Dockera przy użyciu procesora graficznego

Zainstaluj nvidia-docker

Przed podaniem z GPU, oprócz instalacji Döcker , trzeba będzie:

Uruchamianie obrazu obsługującego GPU

Uruchamianie obrazu obsługującego procesor GPU jest identyczne z uruchamianiem obrazu procesora. Aby uzyskać więcej informacji, zobacz prowadzenie serwującą obraz .

Przykład udostępniania GPU

Przejdźmy przez pełny przykład, w którym ładujemy model za pomocą operacji związanych z GPU i wywołujemy go za pomocą interfejsu API REST.

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

docker pull tensorflow/serving:latest-gpu

Spowoduje to ściągnięcie minimalnego obrazu platformy Docker z serwerem ModelServer zbudowanym do pracy na zainstalowanych procesorach graficznych.

Następnie użyjemy model zabawkę o nazwie Half Plus Two , który generuje 0.5 * x + 2 dla wartości x świadczymy dla predykcji. 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 REST API (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 dockera, uruchomienie serwera modeli obsługiwania TensorFlow, powiązanie portu 8501 interfejsu API REST i mapowanie pożądanego modelu z naszego hosta do miejsca, w którym spodziewane są modele w kontenerze. Przekazujemy również nazwę modelu jako zmienną środowiskową, co będzie ważne podczas wykonywania zapytania 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 odbierania żą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

Powinno to zwrócić zestaw wartości:

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

WSKAZÓWKA: Próba uruchomienia modelu GPU na komputerze bez GPU lub bez działającej kompilacji GPU serwera TensorFlow Model Server spowoduje błąd, który wygląda 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 relaksującego API można znaleźć tutaj .

Programowanie z Dockerem

Aby uzyskać instrukcje, jak budować i rozwijać Tensorflow podaniem, patrz Rozwijanie z Docker przewodnika .