Wdrażanie modelu do użycia z usługą Azure AI Search
DOTYCZY:
Zestaw SDK języka Python w wersji 1
W tym artykule pokazano, jak za pomocą usługi Azure Machine Learning wdrożyć model do użycia z usługą Azure AI Search.
Usługa Azure AI Search wykonuje przetwarzanie zawartości za pośrednictwem heterogenicznej zawartości, aby umożliwić wykonywanie zapytań przez ludzi lub aplikacje. Ten proces można ulepszyć przy użyciu modelu wdrożonego z usługi Azure Machine Learning.
Usługa Azure Machine Learning może wdrożyć wytrenowany model jako usługę internetową. Usługa internetowa jest następnie osadzona w umiejętności usługi Azure AI Search, która staje się częścią potoku przetwarzania.
Ważne
Informacje przedstawione w tym artykule są specyficzne dla wdrożenia modelu. Zawiera on informacje na temat obsługiwanych konfiguracji wdrażania, które umożliwiają korzystanie z modelu przez usługę Azure AI Search.
Aby uzyskać informacje na temat konfigurowania usługi Azure AI Search pod kątem korzystania z wdrożonego modelu, zobacz samouczek Tworzenie i wdrażanie niestandardowej umiejętności za pomocą usługi Azure Machine Learning .
Podczas wdrażania modelu do użycia z usługą Azure AI Search wdrożenie musi spełniać następujące wymagania:
- Użyj usługi Azure Kubernetes Service do hostowania modelu na potrzeby wnioskowania.
- Włącz zabezpieczenia warstwy transportu (TLS) dla usługi Azure Kubernetes Service. Protokół TLS służy do zabezpieczania komunikacji HTTPS między usługą Azure AI Search a wdrożonym modelem.
- Skrypt wpisu musi używać pakietu do generowania schematu
inference_schemaOpenAPI (Swagger) dla usługi. - Skrypt wejściowy musi również akceptować dane JSON jako dane wejściowe i generować dane JSON jako dane wyjściowe.
Wymagania wstępne
Obszar roboczy usługi Azure Machine Learning. Aby uzyskać więcej informacji, zobacz Tworzenie zasobów obszaru roboczego.
Środowisko programistyczne języka Python z zainstalowanym zestawem Azure Machine Learning SDK. Aby uzyskać więcej informacji, zobacz Zestaw SDK usługi Azure Machine Learning.
Zarejestrowany model.
Ogólna wiedza na temat sposobu i miejsca wdrażania modeli.
Nawiązywanie połączenia z obszarem roboczym
Obszar roboczy usługi Azure Machine Learning zapewnia scentralizowane miejsce do pracy ze wszystkimi artefaktami tworzonymi podczas korzystania z usługi Azure Machine Learning. Obszar roboczy przechowuje historię wszystkich zadań szkoleniowych, w tym dzienniki, metryki, dane wyjściowe i migawkę skryptów.
Aby nawiązać połączenie z istniejącym obszarem roboczym, użyj następującego kodu:
Ważne
Ten fragment kodu oczekuje, że konfiguracja obszaru roboczego zostanie zapisana w bieżącym katalogu lub jego elemencie nadrzędnym. Aby uzyskać więcej informacji, zobacz Tworzenie obszarów roboczych usługi Azure Machine Learning i zarządzanie nimi. Aby uzyskać więcej informacji na temat zapisywania konfiguracji w pliku, zobacz Tworzenie pliku konfiguracji obszaru roboczego.
from azureml.core import Workspace
try:
# Load the workspace configuration from local cached inffo
ws = Workspace.from_config()
print(ws.name, ws.location, ws.resource_group, ws.location, sep='\t')
print('Library configuration succeeded')
except:
print('Workspace not found')
Tworzenie klastra Kubernetes
Szacowany czas: około 20 minut.
Klaster Kubernetes to zestaw wystąpień maszyn wirtualnych (nazywanych węzłami), które są używane do uruchamiania konteneryzowanych aplikacji.
Podczas wdrażania modelu z usługi Azure Machine Learning w usłudze Azure Kubernetes Service model i wszystkie zasoby potrzebne do hostowania go jako usługi internetowej są pakowane do kontenera platformy Docker. Ten kontener jest następnie wdrażany w klastrze.
Poniższy kod przedstawia sposób tworzenia nowego klastra usługi Azure Kubernetes Service (AKS) dla obszaru roboczego:
Napiwek
Możesz również dołączyć istniejącą usługę Azure Kubernetes Service do obszaru roboczego usługi Azure Machine Learning. Aby uzyskać więcej informacji, zobacz How to deploy models to Azure Kubernetes Service (Jak wdrażać modele w usłudze Azure Kubernetes Service).
Ważne
Zwróć uwagę, że kod używa enable_ssl() metody w celu włączenia zabezpieczeń warstwy transportu (TLS) dla klastra. Jest to wymagane w przypadku planowania korzystania z wdrożonego modelu z usługi Azure AI Search.
from azureml.core.compute import AksCompute, ComputeTarget
# Create or attach to an AKS inferencing cluster
# Create the provisioning configuration with defaults
prov_config = AksCompute.provisioning_configuration()
# Enable TLS (sometimes called SSL) communications
# Leaf domain label generates a name using the formula
# "<leaf-domain-label>######.<azure-region>.cloudapp.azure.com"
# where "######" is a random series of characters
prov_config.enable_ssl(leaf_domain_label = "contoso")
cluster_name = 'amlskills'
# Try to use an existing compute target by that name.
# If one doesn't exist, create one.
try:
aks_target = ComputeTarget(ws, cluster_name)
print("Attaching to existing cluster")
except Exception as e:
print("Creating new cluster")
aks_target = ComputeTarget.create(workspace = ws,
name = cluster_name,
provisioning_configuration = prov_config)
# Wait for the create process to complete
aks_target.wait_for_completion(show_output = True)
Ważne
Platforma Azure będzie rozliczać Cię tak długo, jak klaster usługi AKS istnieje. Pamiętaj, aby usunąć klaster usługi AKS po zakończeniu pracy z nim.
Aby uzyskać więcej informacji na temat korzystania z usługi AKS z usługą Azure Machine Learning, zobacz How to deploy to Azure Kubernetes Service (Jak wdrożyć w usłudze Azure Kubernetes Service).
Pisanie skryptu wpisu
Skrypt wejścia odbiera dane przesłane do usługi internetowej, przekazuje je do modelu i zwraca wyniki oceniania. Poniższy skrypt ładuje model podczas uruchamiania, a następnie używa modelu do oceny danych. Ten plik jest czasami nazywany .score.py
Napiwek
Skrypt wejściowy jest specyficzny dla modelu. Na przykład skrypt musi znać strukturę do użycia z modelem, formatami danych itp.
Ważne
Podczas planowania korzystania z wdrożonego modelu z usługi Azure AI Search należy użyć inference_schema pakietu w celu włączenia generowania schematu dla wdrożenia. Ten pakiet udostępnia dekoratory, które umożliwiają zdefiniowanie formatu danych wejściowych i wyjściowych dla usługi internetowej wykonującej wnioskowanie przy użyciu modelu.
from azureml.core.model import Model
from nlp_architect.models.absa.inference.inference import SentimentInference
from spacy.cli.download import download as spacy_download
import traceback
import json
# Inference schema for schema discovery
from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType
from inference_schema.parameter_types.standard_py_parameter_type import StandardPythonParameterType
def init():
"""
Set up the ABSA model for Inference
"""
global SentInference
spacy_download('en')
aspect_lex = Model.get_model_path('hotel_aspect_lex')
opinion_lex = Model.get_model_path('hotel_opinion_lex')
SentInference = SentimentInference(aspect_lex, opinion_lex)
# Use inference schema decorators and sample input/output to
# build the OpenAPI (Swagger) schema for the deployment
standard_sample_input = {'text': 'a sample input record containing some text' }
standard_sample_output = {"sentiment": {"sentence": "This place makes false booking prices, when you get there, they say they do not have the reservation for that day.",
"terms": [{"text": "hotels", "type": "AS", "polarity": "POS", "score": 1.0, "start": 300, "len": 6},
{"text": "nice", "type": "OP", "polarity": "POS", "score": 1.0, "start": 295, "len": 4}]}}
@input_schema('raw_data', StandardPythonParameterType(standard_sample_input))
@output_schema(StandardPythonParameterType(standard_sample_output))
def run(raw_data):
try:
# Get the value of the 'text' field from the JSON input and perform inference
input_txt = raw_data["text"]
doc = SentInference.run(doc=input_txt)
if doc is None:
return None
sentences = doc._sentences
result = {"sentence": doc._doc_text}
terms = []
for sentence in sentences:
for event in sentence._events:
for x in event:
term = {"text": x._text, "type":x._type.value, "polarity": x._polarity.value, "score": x._score,"start": x._start,"len": x._len }
terms.append(term)
result["terms"] = terms
print("Success!")
# Return the results to the client as a JSON document
return {"sentiment": result}
except Exception as e:
result = str(e)
# return error message back to the client
print("Failure!")
print(traceback.format_exc())
return json.dumps({"error": result, "tb": traceback.format_exc()})
Aby uzyskać więcej informacji na temat skryptów wejściowych, zobacz Jak i gdzie wdrożyć.
Definiowanie środowiska oprogramowania
Klasa środowiska służy do definiowania zależności języka Python dla usługi. Zawiera zależności wymagane zarówno przez model, jak i skrypt wejścia. W tym przykładzie instaluje pakiety z zwykłego indeksu pypi, a także z repozytorium GitHub.
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core import Environment
conda = None
pip = ["azureml-defaults", "azureml-monitoring",
"git+https://github.com/NervanaSystems/nlp-architect.git@absa", 'nlp-architect', 'inference-schema',
"spacy==2.0.18"]
conda_deps = CondaDependencies.create(conda_packages=None, pip_packages=pip)
myenv = Environment(name='myenv')
myenv.python.conda_dependencies = conda_deps
Aby uzyskać więcej informacji na temat środowisk, zobacz Tworzenie środowisk i zarządzanie nimi na potrzeby trenowania i wdrażania.
Definiowanie konfiguracji wdrożenia
Konfiguracja wdrożenia definiuje środowisko hostingu usługi Azure Kubernetes Service używane do uruchamiania usługi internetowej.
Napiwek
Jeśli nie masz pewności co do pamięci, procesora CPU lub procesora GPU wdrożenia, możesz użyć profilowania, aby dowiedzieć się tego. Aby uzyskać więcej informacji, zobacz Jak i gdzie wdrożyć model.
from azureml.core.model import Model
from azureml.core.webservice import Webservice
from azureml.core.image import ContainerImage
from azureml.core.webservice import AksWebservice, Webservice
# If deploying to a cluster configured for dev/test, ensure that it was created with enough
# cores and memory to handle this deployment configuration. Note that memory is also used by
# things such as dependencies and Azure Machine Learning components.
aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True,
autoscale_min_replicas=1,
autoscale_max_replicas=3,
autoscale_refresh_seconds=10,
autoscale_target_utilization=70,
auth_enabled=True,
cpu_cores=1, memory_gb=2,
scoring_timeout_ms=5000,
replica_max_concurrent_requests=2,
max_request_wait_time=5000)
Aby uzyskać więcej informacji, zobacz dokumentację referencyjną AksService.deploy_configuration.
Definiowanie konfiguracji wnioskowania
Konfiguracja wnioskowania wskazuje skrypt wejścia i obiekt środowiska:
from azureml.core.model import InferenceConfig
inf_config = InferenceConfig(entry_script='score.py', environment=myenv)
Aby uzyskać więcej informacji, zobacz dokumentację referencyjną programu InferenceConfig.
Wdrażanie modelu
Wdróż model w klastrze usługi AKS i poczekaj na utworzenie usługi. W tym przykładzie dwa zarejestrowane modele są ładowane z rejestru i wdrażane w usłudze AKS. Po wdrożeniu score.py plik we wdrożeniu ładuje te modele i używa ich do wnioskowania.
from azureml.core.webservice import AksWebservice, Webservice
c_aspect_lex = Model(ws, 'hotel_aspect_lex')
c_opinion_lex = Model(ws, 'hotel_opinion_lex')
service_name = "hotel-absa-v2"
aks_service = Model.deploy(workspace=ws,
name=service_name,
models=[c_aspect_lex, c_opinion_lex],
inference_config=inf_config,
deployment_config=aks_config,
deployment_target=aks_target,
overwrite=True)
aks_service.wait_for_deployment(show_output = True)
print(aks_service.state)
Aby uzyskać więcej informacji, zobacz dokumentację referencyjną dotyczącą modelu.
Wystawianie przykładowego zapytania do usługi
W poniższym przykładzie użyto informacji o wdrożeniu przechowywanych w zmiennej aks_service w poprzedniej sekcji kodu. Używa tej zmiennej do pobierania adresu URL oceniania i tokenu uwierzytelniania wymaganego do komunikowania się z usługą:
import requests
import json
primary, secondary = aks_service.get_keys()
# Test data
input_data = '{"raw_data": {"text": "This is a nice place for a relaxing evening out with friends. The owners seem pretty nice, too. I have been there a few times including last night. Recommend."}}'
# Since authentication was enabled for the deployment, set the authorization header.
headers = {'Content-Type':'application/json', 'Authorization':('Bearer '+ primary)}
# Send the request and display the results
resp = requests.post(aks_service.scoring_uri, input_data, headers=headers)
print(resp.text)
Wynik zwrócony z usługi jest podobny do następującego kodu JSON:
{"sentiment": {"sentence": "This is a nice place for a relaxing evening out with friends. The owners seem pretty nice, too. I have been there a few times including last night. Recommend.", "terms": [{"text": "place", "type": "AS", "polarity": "POS", "score": 1.0, "start": 15, "len": 5}, {"text": "nice", "type": "OP", "polarity": "POS", "score": 1.0, "start": 10, "len": 4}]}}
Nawiązywanie połączenia z usługą Azure AI Search
Aby uzyskać informacje na temat korzystania z tego modelu z usługi Azure AI Search, zobacz samouczek Tworzenie i wdrażanie niestandardowej umiejętności za pomocą usługi Azure Machine Learning .
Oczyszczanie zasobów
Jeśli utworzono klaster usługi AKS specjalnie dla tego przykładu, usuń zasoby po zakończeniu testowania za pomocą usługi Azure AI Search.
Ważne
Platforma Azure rozlicza się na podstawie czasu wdrożenia klastra usługi AKS. Pamiętaj, aby wyczyścić go po zakończeniu pracy z nim.
aks_service.delete()
aks_target.delete()