Jednym z najłatwiejszych sposobów rozpoczęcia korzystania z usługi TensorFlow Serving jest Docker .
# Download the TensorFlow Serving Docker image and repodocker pull tensorflow/serving
git clone https://github.com/tensorflow/serving
# Location of demo modelsTESTDATA="$(pwd)/serving/tensorflow_serving/servables/tensorflow/testdata"
# Start TensorFlow Serving container and open the REST API portdocker 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 APIcurl -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:
- Docker dla macOS
- Docker dla systemu Windows dla systemu Windows 10 Pro lub nowszego
- Docker Toolbox dla znacznie starszych wersji macOS lub wersji systemu Windows starszych niż Windows 10 Pro
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ślniemodel
) - 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ć:
- Aktualne sterowniki NVIDIA dla Twojego systemu
-
nvidia-docker
: Możesz postępować zgodnie z instrukcjami instalacji tutaj
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 .