Ta strona została przetłumaczona przez Cloud Translation API.

Obsługa TensorFlow za pomocą platformy Docker

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:

Docker dla macOS
Docker dla Windows dla systemu Windows 10 lub nowszy Pro
Docker Toolbox dla dużo starszych wersji MacOS lub wersjach systemu Windows przed systemie Windows 10 Pro

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:

Up-to-date sterowniki NVIDIA dla systemu
nvidia-docker : Można wykonać instrukcje instalacji tutaj

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 .