Odpowiedz już dziś na lokalne wydarzenie TensorFlow Everywhere!
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Obsługa TensorFlow za pomocą platformy Docker

Jednym z najłatwiejszych sposobów rozpoczęcia korzystania z usługi TensorFlow Serving 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] }

Dodatkowe punkty końcowe obsługi można znaleźć w interfejsie Client REST API .

Zainstaluj Docker

Ogólne instrukcje instalacji znajdują się w witrynie Docker , ale podajemy tutaj kilka szybkich łączy:

Obsługa za pomocą platformy Docker

Ciągnięcie wyświetlanego obrazu

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

docker pull tensorflow/serving

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

Zobacz repozytorium tensorflow / udostępniania usługi Docker Hub, aby zapoznać się z innymi wersjami obrazów, które można pobrać.

Uruchomienie wyświetlanego obrazu

Obsługiwane obrazy (zarówno procesor, 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 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 do obsługi
  • Zapisany model do obsługi
  • Nazwa twojego modelu, do której będzie się odnosił twój klient

To, co zrobisz, to uruchomienie kontenera Docker , opublikowanie portów kontenera do portów twojego hosta i zamontowanie ścieżki twojego hosta do SavedModel do miejsca, w którym kontener oczekuje 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 8501 REST API na porcie 8501 naszego hosta i wzięliśmy model, który nazwaliśmy my_model i my_model 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 my_model i pozostawiliśmy MODEL_BASE_PATH na jej domyślną wartość.

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 porty gRPC i REST API w tym samym czasie lub wybrać tylko jeden lub drugi.

Przekazywanie dodatkowych argumentów

tensorflow_model_server obsługuje wiele dodatkowych argumentów, które można przekazać do obsługujących kontenerów dockera. 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 dla wszystkich innych argumentów wiersza poleceń obsługiwanych przez tensorflow_model_server .

Tworzenie własnego obrazu służącego do serwowania

Jeśli potrzebujesz obrazu do serwowania, który ma wbudowany model w kontenerze, możesz utworzyć własny obraz.

Najpierw uruchom wyświetlany obraz jako demona:

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, który obsługuje twój model, zmieniając MODEL_NAME aby pasował do nazwy twojego modelu ':

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

Możesz teraz przestać serving_base

docker kill serving_base

W ten sposób otrzymasz obraz platformy Docker o nazwie <my container> , który możesz wdrożyć i załadować model do obsługi przy uruchamianiu.

Służący przykład

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

docker pull tensorflow/serving

Spowoduje to pobranie najnowszego obrazu obsługi TensorFlow z zainstalowanym modelem ModelServer.

Następnie użyjemy modelu zabawki o nazwie Half Plus Two , który generuje 0.5 * x + 2 dla wartości x które podajemy 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ący na ten model i otwierający 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 docker i uruchomienie serwera TensorFlow Serving Model Server, powiązanie portu 8501 interfejsu API REST i zmapowanie naszego pożądanego modelu z naszego hosta do miejsca, w którym oczekiwane są modele w kontenerze. Nazwę modelu przekazujemy również jako zmienną środowiskową, która będzie ważna przy zapytaniu o model.

Aby zapytać model za pomocą predykcyjnego interfejsu API, 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 RESTful API można znaleźć tutaj .

Obsługa za pomocą Dockera przy użyciu GPU

Zainstaluj nvidia-docker

Zanim zaczniesz korzystać z GPU, oprócz zainstalowania Dockera będziesz potrzebować:

Uruchomiony obraz obsługujący GPU

Uruchomienie obrazu obsługującego GPU jest identyczne z uruchomieniem obrazu procesora. Więcej informacji znajdziesz w artykule o uruchamianiu obrazu do wyświetlenia .

Przykład obsługi GPU

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

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

docker pull tensorflow/serving:latest-gpu

Spowoduje to ściągnięcie minimalnego obrazu Dockera z ModelServer zbudowanym do uruchamiania 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 które podajemy 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ący na ten model i otwierający port REST API (8501):

docker run --runtime=nvidia -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 docker ze środowiskiem wykonawczym nvidia-docker docker, uruchomienie serwera TensorFlow Serving Model Server, powiązanie portu 8501 interfejsu API REST i zmapowanie pożądanego modelu z naszego hosta do miejsca, w którym oczekiwane są modele w kontenerze. Nazwę modelu przekazujemy również jako zmienną środowiskową, która będzie ważna przy zapytaniu o model.

WSKAZÓWKA: Przed wysłaniem zapytania do modelu należy poczekać, aż pojawi się 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 zapytać model za pomocą predykcyjnego interfejsu API, 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 maszynie bez GPU lub bez działającej kompilacji GPU TensorFlow Model Server zakończy się błędem, 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 RESTful API można znaleźć tutaj .

Programowanie za pomocą Dockera

Instrukcje dotyczące tworzenia i rozwijania obsługi Tensorflow można znaleźć w przewodniku Developing with Docker .