Jak wdrożyć zarejestrowany model języka R w punkcie końcowym online (w czasie rzeczywistym)

Artykuł
01/10/2024

DOTYCZY: Rozszerzenie interfejsu wiersza polecenia platformy Azure w wersji 2 (bieżąca)

W tym artykule dowiesz się, jak wdrożyć model języka R w zarządzanym punkcie końcowym (internetowy interfejs API), aby aplikacja mogła oceniać nowe dane względem modelu niemal w czasie rzeczywistym.

Wymagania wstępne

Obszar roboczy usługi Azure Machine Edukacja.
Zainstalowany interfejs wiersza polecenia platformy Azure i rozszerzenie ml. Możesz też użyć wystąpienia obliczeniowego w obszarze roboczym, które ma wstępnie zainstalowany interfejs wiersza polecenia.
Co najmniej jedno środowisko niestandardowe skojarzone z obszarem roboczym. Utwórz środowisko języka R lub inne środowisko niestandardowe, jeśli go nie masz.
Znajomość pakietu języka R plumber
Model, który został wytrenowany i spakowany przy crateużyciu polecenia , i zarejestrowany w obszarze roboczym

Utwórz folder z tą strukturą

Utwórz tę strukturę folderów dla projektu:

📂 r-deploy-azureml
 ├─📂 docker-context
 │  ├─ Dockerfile
 │  └─ start_plumber.R
 ├─📂 src
 │  └─ plumber.R
 ├─ deployment.yml
 ├─ endpoint.yml

Zawartość każdego z tych plików jest wyświetlana i objaśniona w tym artykule.

Dockerfile

Jest to plik, który definiuje środowisko kontenera. W tym miejscu zdefiniujesz również instalację dodatkowych pakietów języka R.

Przykładowy plik Dockerfile będzie wyglądać następująco:

# REQUIRED: Begin with the latest R container with plumber
FROM rstudio/plumber:latest

# REQUIRED: Install carrier package to be able to use the crated model (whether from a training job
# or uploaded)
RUN R -e "install.packages('carrier', dependencies = TRUE, repos = 'https://cloud.r-project.org/')"

# OPTIONAL: Install any additional R packages you may need for your model crate to run
RUN R -e "install.packages('<PACKAGE-NAME>', dependencies = TRUE, repos = 'https://cloud.r-project.org/')"
RUN R -e "install.packages('<PACKAGE-NAME>', dependencies = TRUE, repos = 'https://cloud.r-project.org/')"

# REQUIRED
ENTRYPOINT []

COPY ./start_plumber.R /tmp/start_plumber.R 

CMD ["Rscript", "/tmp/start_plumber.R"]

Zmodyfikuj plik, aby dodać pakiety potrzebne do skryptu oceniania.

Hydraulik. R

Ważne

W tej sekcji pokazano, jak utworzyć strukturę hydraulika. Skrypt języka R . Aby uzyskać szczegółowe informacje o pakiecie plumber , zobacz plumber dokumentację .

Hydraulik pliku . R to skrypt języka R , w którym zdefiniujesz funkcję oceniania. Ten skrypt wykonuje również zadania niezbędne do działania punktu końcowego. Skrypt:

Pobiera ścieżkę, w której model jest instalowany ze zmiennej środowiskowej AZUREML_MODEL_DIR w kontenerze.
Ładuje obiekt modelu utworzony za pomocą crate funkcji z carrier pakietu, który został zapisany jako crate.bin , gdy został spakowany.
Unserializuje obiekt modelu
Definiuje funkcję oceniania

Napiwek

Upewnij się, że dowolna funkcja oceniania może zostać przekonwertowana z powrotem na format JSON. Niektóre obiekty języka R nie są łatwo konwertowane.

# plumber.R
# This script will be deployed to a managed endpoint to do the model scoring

# REQUIRED
# When you deploy a model as an online endpoint, Azure Machine Learning mounts your model
# to your endpoint. Model mounting enables you to deploy new versions of the model without
# having to create a new Docker image.

model_dir <- Sys.getenv("AZUREML_MODEL_DIR")

# REQUIRED
# This reads the serialized model with its respecive predict/score method you 
# registered. The loaded load_model object is a raw binary object.
load_model <- readRDS(paste0(model_dir, "/models/crate.bin"))

# REQUIRED
# You have to unserialize the load_model object to make it its function
scoring_function <- unserialize(load_model)

# REQUIRED
# << Readiness route vs. liveness route >>
# An HTTP server defines paths for both liveness and readiness. A liveness route is used to
# check whether the server is running. A readiness route is used to check whether the 
# server's ready to do work. In machine learning inference, a server could respond 200 OK 
# to a liveness request before loading a model. The server could respond 200 OK to a
# readiness request only after the model has been loaded into memory.

#* Liveness check
#* @get /live
function() {
  "alive"
}

#* Readiness check
#* @get /ready
function() {
  "ready"
}

# << The scoring function >>
# This is the function that is deployed as a web API that will score the model
# Make sure that whatever you are producing as a score can be converted 
# to JSON to be sent back as the API response
# in the example here, forecast_horizon (the number of time units to forecast) is the input to scoring_function.  
# the output is a tibble
# we are converting some of the output types so they work in JSON


#* @param forecast_horizon 
#* @post /score
function(forecast_horizon) {
  scoring_function(as.numeric(forecast_horizon)) |> 
    tibble::as_tibble() |> 
    dplyr::transmute(period = as.character(yr_wk),
                     dist = as.character(logmove),
                     forecast = .mean) |> 
    jsonlite::toJSON()
}

start_plumber. R

Plik start_plumber. R to skrypt języka R , który jest uruchamiany po uruchomieniu kontenera i wywołuje hydraulika. Skrypt języka R . Użyj następującego skryptu zgodnie z rzeczywistym użyciem.

entry_script_path <- paste0(Sys.getenv('AML_APP_ROOT'),'/', Sys.getenv('AZUREML_ENTRY_SCRIPT'))

pr <- plumber::plumb(entry_script_path)

args <- list(host = '0.0.0.0', port = 8000); 

if (packageVersion('plumber') >= '1.0.0') {
  pr$setDocs(TRUE)
} else { 
  args$swagger <- TRUE 
} 

do.call(pr$run, args)

Kompilowanie kontenera

W tych krokach założono, że masz usługę Azure Container Registry skojarzona z obszarem roboczym, która jest tworzona podczas tworzenia pierwszego środowiska niestandardowego. Aby sprawdzić, czy masz środowisko niestandardowe:

Zaloguj się do usługi Azure Machine Edukacja Studio.
W razie potrzeby wybierz swój obszar roboczy.
W obszarze nawigacji po lewej stronie wybierz pozycję Środowiska.
W górnej części wybierz pozycję Środowiska niestandardowe.
Jeśli widzisz środowiska niestandardowe, nic więcej nie jest potrzebne.
Jeśli nie widzisz żadnych środowisk niestandardowych, utwórz środowisko języka R lub inne środowisko niestandardowe. (Nie będziesz używać tego środowiska do wdrożenia, ale użyjesz rejestru kontenerów, który również zostanie utworzony dla Ciebie).

Po sprawdzeniu, czy masz co najmniej jedno środowisko niestandardowe, wykonaj następujące kroki, aby utworzyć kontener.

Otwórz okno terminalu i zaloguj się na platformie Azure. Jeśli robisz to z wystąpienia obliczeniowego usługi Azure Machine Edukacja, użyj:
```
az login --identity
```
Jeśli nie korzystasz z wystąpienia obliczeniowego, pomiń --identity i postępuj zgodnie z monitem, aby otworzyć okno przeglądarki w celu uwierzytelnienia.
Upewnij się, że masz najnowsze wersje interfejsu wiersza polecenia i ml rozszerzenie:
```
az upgrade
```
Jeśli masz wiele subskrypcji platformy Azure, ustaw aktywną subskrypcję na używaną dla obszaru roboczego. (Ten krok można pominąć, jeśli masz dostęp tylko do pojedynczej subskrypcji). Zastąp <SUBSCRIPTION-NAME> ciąg nazwą subskrypcji. Usuń również nawiasy klamrowe <>.
```
az account set --subscription "<SUBSCRIPTION-NAME>"
```
Ustaw domyślny obszar roboczy. Jeśli robisz to z wystąpienia obliczeniowego, możesz użyć następującego polecenia w następujący sposób. Jeśli jesteś na innym komputerze, zastąp zamiast tego nazwę grupy zasobów i obszaru roboczego. (Te wartości można znaleźć w pliku Azure Machine Edukacja Studio).
```
az configure --defaults group=$CI_RESOURCE_GROUP workspace=$CI_WORKSPACE
```
Upewnij się, że jesteś w katalogu projektu.
```
cd r-deploy-azureml
```
Aby skompilować obraz w chmurze, wykonaj następujące polecenia powłoki bash w terminalu. Zastąp <IMAGE-NAME> ciąg nazwą, którą chcesz nadać obrazowi.

Jeśli obszar roboczy znajduje się w sieci wirtualnej, zobacz Włączanie usługi Azure Container Registry (ACR), aby uzyskać --image-build-compute dodatkowe kroki dodawania do az acr build polecenia w ostatnim wierszu tego kodu.
```
WORKSPACE=$(az config get --query "defaults[?name == 'workspace'].value" -o tsv)
ACR_NAME=$(az ml workspace show -n $WORKSPACE --query container_registry -o tsv | cut -d'/' -f9-)
IMAGE_TAG=${ACR_NAME}.azurecr.io/<IMAGE-NAME>

az acr build ./docker-context -t $IMAGE_TAG -r $ACR_NAME
```

Ważne

Utworzenie obrazu potrwa kilka minut. Przed przejściem do następnej sekcji poczekaj na ukończenie procesu kompilacji. Nie zamykaj tego terminalu, użyjesz go obok, aby utworzyć wdrożenie.

Polecenie az acr automatycznie przekaże folder docker-context , który zawiera artefakty do skompilowania obrazu — do chmury, w której obraz zostanie skompilowany i hostowany w usłudze Azure Container Registry.

Wdrażanie modelu

W tej sekcji artykułu zdefiniujesz i utworzysz punkt końcowy oraz wdrożenie , aby wdrożyć model i obraz utworzony w poprzednich krokach w zarządzanym punkcie końcowym online.

Punkt końcowy to punkt końcowy HTTPS, który klienci — na przykład aplikacja — mogą wywoływać w celu odbierania danych wyjściowych oceniania wytrenowanego modelu. Zapewniają:

Uwierzytelnianie przy użyciu uwierzytelniania opartego na kluczu i tokenie
Kończenie żądań protokołu SSL
Stabilny identyfikator URI oceniania (endpoint-name.region.inference.ml.Azure.com)

Wdrożenie to zestaw zasobów wymaganych do hostowania modelu, który wykonuje rzeczywiste ocenianie. Pojedynczy punkt końcowy może zawierać wielewdrożeń. Możliwości równoważenia obciążenia usługi Azure Machine Edukacja zarządzanych punktów końcowych umożliwiają nadanie dowolnego procentu ruchu do każdego wdrożenia. Alokacja ruchu może służyć do bezpiecznego wdrażania wdrożeń niebieski/zielonych przez równoważenie żądań między różnymi wystąpieniami.

Tworzenie zarządzanego punktu końcowego online

W katalogu projektu dodaj plik endpoint.yml z następującym kodem. Zastąp <ENDPOINT-NAME> ciąg nazwą, którą chcesz nadać zarządzany punkt końcowy.
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: <ENDPOINT-NAME>
auth_mode: aml_token
```
Korzystając z tego samego terminalu, w którym utworzono obraz, wykonaj następujące polecenie interfejsu wiersza polecenia, aby utworzyć punkt końcowy:
```
az ml online-endpoint create -f endpoint.yml
```
Pozostaw otwarty terminal, aby kontynuować korzystanie z niego w następnej sekcji.

Tworzenie wdrożenia

Aby utworzyć wdrożenie, dodaj następujący kod do pliku deployment.yml .

Zastąp <ENDPOINT-NAME> ciąg nazwą punktu końcowego zdefiniowaną w pliku endpoint.yml
Zastąp <DEPLOYMENT-NAME> ciąg nazwą, którą chcesz nadać wdrożeniu
Zastąp <MODEL-URI> ciąg identyfikatorem URI zarejestrowanego modelu w postaci azureml:modelname@latest
Zastąp <IMAGE-TAG> element wartością z:
```
echo $IMAGE_TAG
```

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: <DEPLOYMENT-NAME>
endpoint_name: <ENDPOINT-NAME>
code_configuration:
  code: ./src
  scoring_script: plumber.R
model: <MODEL-URI>
environment:
  image: <IMAGE-TAG>
  inference_config:
    liveness_route:
      port: 8000
      path: /live
    readiness_route:
      port: 8000
      path: /ready
    scoring_route:
      port: 8000
      path: /score
instance_type: Standard_DS2_v2
instance_count: 1

Następnie w terminalu wykonaj następujące polecenie interfejsu wiersza polecenia, aby utworzyć wdrożenie (zwróć uwagę, że ustawiasz 100% ruchu na ten model):
```
az ml online-deployment create -f deployment.yml --all-traffic --skip-script-validation
```

Uwaga

Wdrożenie usługi może potrwać kilka minut. Przed przejściem do następnej sekcji poczekaj na zakończenie wdrażania.

Przetestuj

Po pomyślnym utworzeniu wdrożenia możesz przetestować punkt końcowy przy użyciu programu Studio lub interfejsu wiersza polecenia:

Studio
Interfejs wiersza polecenia platformy Azure

Przejdź do usługi Azure Machine Edukacja Studio i wybierz pozycję w menu Punkty końcowe po lewej stronie. Następnie wybierz utworzony wcześniej r-endpoint-iris .

Wprowadź następujący kod JSON w polu tekstowym Dane wejściowe do przechowywania punktu końcowego w czasie rzeczywistym:

{
    "forecast_horizon" : [2]
}

Kliknij przycisk Testuj. Powinny zostać wyświetlone następujące dane wyjściowe:

Tworzenie przykładowego żądania

W folderze nadrzędnym projektu utwórz plik o nazwie sample_request.json i wypełnij go:

{
    "forecast_horizon" : [2]
}

Wywoływanie punktu końcowego

Wywołaj żądanie. W tym przykładzie użyto nazwy r-endpoint-forecast:

az ml online-endpoint invoke --name r-endpoint-forecast --request-file sample_request.json

Czyszczenie zasobów

Teraz, gdy punkt końcowy został pomyślnie wygenerowany, możesz go usunąć, aby nie ponosić bieżących kosztów:

az ml online-endpoint delete --name r-endpoint-forecast

Następne kroki

Aby uzyskać więcej informacji na temat używania języka R z usługą Azure Machine Edukacja, zobacz Omówienie możliwości języka R w usłudze Azure Machine Edukacja