Nasazení modelu pro použití se službou Azure AI Search
PLATÍ PRO:
Python SDK azureml v1
V tomto článku se naučíte, jak pomocí služby Azure Machine Learning nasadit model pro použití se službou Azure AI Search.
Azure AI Search provádí zpracování obsahu nad heterogenním obsahem, aby bylo možné ho dotazovat lidmi nebo aplikacemi. Tento proces je možné vylepšit pomocí modelu nasazeného ze služby Azure Machine Learning.
Azure Machine Learning může nasadit natrénovaný model jako webovou službu. Webová služba se pak vloží do dovednosti Azure AI Search, která se stane součástí kanálu zpracování.
Důležité
Informace v tomto článku jsou specifické pro nasazení modelu. Poskytuje informace o podporovaných konfiguracích nasazení, které umožňují použití modelu službou Azure AI Search.
Informace o tom, jak nakonfigurovat Službu Azure AI Search tak, aby používala nasazený model, najdete v kurzu Sestavení a nasazení vlastní dovednosti pomocí služby Azure Machine Learning .
Při nasazování modelu pro použití se službou Azure AI Search musí nasazení splňovat následující požadavky:
- Azure Kubernetes Service slouží k hostování modelu pro odvozování.
- Povolte pro službu Azure Kubernetes Service protokol TLS (Transport Layer Security). Tls se používá k zabezpečení komunikace HTTPS mezi Azure AI Search a nasazeným modelem.
- Vstupní skript musí použít
inference_schemabalíček k vygenerování schématu OpenAPI (Swagger) pro službu. - Vstupní skript musí také přijímat data JSON jako vstup a generovat JSON jako výstup.
Požadavky
Pracovní prostor služby Azure Machine Learning. Další informace najdete v tématu Vytvoření prostředků pracovního prostoru.
Vývojové prostředí Pythonu s nainstalovanou sadou Azure Machine Learning SDK. Další informace najdete v sadě Azure Machine Learning SDK.
Registrovaný model.
Obecné znalosti o tom, jak a kde nasazovat modely.
Připojení k pracovnímu prostoru
Pracovní prostor Azure Machine Learning poskytuje centralizované místo pro práci se všemi artefakty, které vytvoříte při použití služby Azure Machine Learning. Pracovní prostor uchovává historii všech trénovacích úloh, včetně protokolů, metrik, výstupu a snímku vašich skriptů.
Pokud se chcete připojit k existujícímu pracovnímu prostoru, použijte následující kód:
Důležité
Tento fragment kódu očekává, že se konfigurace pracovního prostoru uloží do aktuálního adresáře nebo nadřazeného adresáře. Další informace najdete v tématu Vytváření a správa pracovních prostorů Služby Azure Machine Learning. Další informace o uložení konfigurace do souboru naleznete v tématu Vytvoření konfiguračního souboru pracovního prostoru.
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')
Vytvoření clusteru Kubernetes
Časový odhad: Přibližně 20 minut.
Cluster Kubernetes je sada instancí virtuálních počítačů (označovaných jako uzly), které se používají ke spouštění kontejnerizovaných aplikací.
Když nasadíte model ze služby Azure Machine Learning do služby Azure Kubernetes Service, model a všechny prostředky potřebné k jeho hostování jako webová služba se zabalí do kontejneru Dockeru. Tento kontejner se pak nasadí do clusteru.
Následující kód ukazuje, jak vytvořit nový cluster Azure Kubernetes Service (AKS) pro váš pracovní prostor:
Tip
Existující službu Azure Kubernetes Service můžete také připojit ke svému pracovnímu prostoru Azure Machine Learning. Další informace najdete v tématu Nasazení modelů do služby Azure Kubernetes Service.
Důležité
Všimněte si, že kód používá metodu enable_ssl() k povolení protokolu TLS (Transport Layer Security) pro cluster. To se vyžaduje, když plánujete používat nasazený model z 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)
Důležité
Azure vám bude účtovat, dokud cluster AKS existuje. Až s ním skončíte, nezapomeňte cluster AKS odstranit.
Další informace o používání AKS se službou Azure Machine Learning najdete v tématu Postup nasazení do služby Azure Kubernetes Service.
Napsání vstupního skriptu
Vstupní skript obdrží data odeslaná do webové služby, předá ho do modelu a vrátí výsledky vyhodnocování. Následující skript načte model při spuštění a pak ho použije k určení skóre dat. Tento soubor se někdy nazývá score.py.
Tip
Vstupní skript je specifický pro váš model. Skript například musí znát architekturu, která se má použít s vaším modelem, formáty dat atd.
Důležité
Pokud plánujete používat nasazený model z Azure AI Search, musíte balíček použít inference_schema k povolení generování schématu pro nasazení. Tento balíček poskytuje dekorátory, které umožňují definovat vstupní a výstupní formát dat pro webovou službu, která provádí odvozování pomocí 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()})
Další informace o vstupních skriptech najdete v tématu Postupy a kde nasadit.
Definování softwarového prostředí
Třída prostředí slouží k definování závislostí Pythonu pro službu. Zahrnuje závislosti vyžadované modelem i vstupním skriptem. V tomto příkladu nainstaluje balíčky z běžného indexu pypi i z úložiště 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
Další informace o prostředích najdete v tématu Vytváření a správa prostředí pro trénování a nasazení.
Definování konfigurace nasazení
Konfigurace nasazení definuje hostitelské prostředí služby Azure Kubernetes Service použité ke spuštění webové služby.
Tip
Pokud si nejste jistí, jestli vaše nasazení potřebuje paměť, procesor nebo GPU, můžete tyto informace zjistit pomocí profilace. Další informace najdete v tématu Jak a kde nasadit 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)
Další informace najdete v referenční dokumentaci pro AksService.deploy_configuration.
Definování konfigurace odvozování
Odvozování konfigurace odkazuje na vstupní skript a objekt prostředí:
from azureml.core.model import InferenceConfig
inf_config = InferenceConfig(entry_script='score.py', environment=myenv)
Další informace najdete v referenční dokumentaci pro inferenceConfig.
Nasazení modelu
Nasaďte model do clusteru AKS a počkejte na jeho vytvoření. V tomto příkladu se z registru načtou dva registrované modely a nasadí se do AKS. Po nasazení soubor score.py v nasazení načte tyto modely a použije je k odvozování.
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)
Další informace najdete v referenční dokumentaci k modelu.
Vydání ukázkového dotazu pro vaši službu
Následující příklad používá informace o nasazení uložené v aks_service proměnné v předchozí části kódu. Používá tuto proměnnou k načtení hodnoticí adresy URL a ověřovacího tokenu potřebného ke komunikaci se službou:
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)
Výsledek vrácený ze služby je podobný následujícímu formátu 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}]}}
Připojení k Azure AI Search
Informace o použití tohoto modelu z Azure AI Search najdete v kurzu Sestavení a nasazení vlastní dovednosti pomocí služby Azure Machine Learning .
Vyčištění prostředků
Pokud jste vytvořili cluster AKS speciálně pro tento příklad, odstraňte prostředky po dokončení jeho testování pomocí služby Azure AI Search.
Důležité
Azure vám účtuje podle toho, jak dlouho je cluster AKS nasazený. Až s ním skončíte, nezapomeňte ho vyčistit.
aks_service.delete()
aks_target.delete()