Een model implementeren voor gebruik met Azure AI Search
VAN TOEPASSING OP:
Python SDK azureml v1
In dit artikel leert u hoe u Azure Machine Learning gebruikt om een model te implementeren voor gebruik met Azure AI Search.
Azure AI Search voert inhoudsverwerking uit op heterogene inhoud, zodat deze kan worden opzocht door mensen of toepassingen. Dit proces kan worden uitgebreid met behulp van een model dat is geïmplementeerd vanuit Azure Machine Learning.
Azure Machine Learning kan een getraind model implementeren als een webservice. De webservice wordt vervolgens ingesloten in een Azure AI Search-vaardigheid, die deel uitmaakt van de verwerkingspijplijn.
Belangrijk
De informatie in dit artikel is specifiek voor de implementatie van het model. Het biedt informatie over de ondersteunde implementatieconfiguraties waarmee het model kan worden gebruikt door Azure AI Search.
Zie de zelfstudie Een aangepaste vaardigheid bouwen en implementeren met Azure Machine Learning voor meer informatie over het configureren van Azure AI Search voor het gebruik van het geïmplementeerde model.
Bij het implementeren van een model voor gebruik met Azure AI Search moet de implementatie voldoen aan de volgende vereisten:
- Gebruik Azure Kubernetes Service om het model te hosten voor deductie.
- Schakel TLS (Transport Layer Security) in voor de Azure Kubernetes Service. TLS wordt gebruikt om HTTPS-communicatie tussen Azure AI Search en het geïmplementeerde model te beveiligen.
- Het invoerscript moet het
inference_schemapakket gebruiken om een OpenAPI-schema (Swagger) voor de service te genereren. - Het invoerscript moet ook JSON-gegevens als invoer accepteren en JSON als uitvoer genereren.
Vereisten
Een Azure Machine Learning-werkruimte. Zie Werkruimteresources maken voor meer informatie.
Een Python-ontwikkelomgeving waarop de Azure Machine Learning SDK is geïnstalleerd. Zie Azure Machine Learning SDK voor meer informatie.
Een geregistreerd model.
Een algemeen begrip van hoe en waar modellen moeten worden geïmplementeerd.
Verbinding maken met uw werkruimte
Een Azure Machine Learning-werkruimte biedt een gecentraliseerde plek om te werken met alle artefacten die u maakt wanneer u Azure Machine Learning gebruikt. De werkruimte bewaart een geschiedenis van alle trainingstaken, waaronder logboeken, metrische gegevens, uitvoer en een momentopname van uw scripts.
Gebruik de volgende code om verbinding te maken met een bestaande werkruimte:
Belangrijk
Dit codefragment verwacht dat de werkruimteconfiguratie wordt opgeslagen in de huidige of de bovenliggende map. Zie Azure Machine Learning-werkruimten maken en beheren voor meer informatie. Zie Een configuratiebestand voor een werkruimte maken voor meer informatie over de configuratie als bestand opslaan.
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')
Een Kubernetes-cluster maken
Geschatte tijd: ongeveer 20 minuten.
Een Kubernetes-cluster is een set exemplaren van virtuele machines (knooppunten genoemd) die worden gebruikt voor het uitvoeren van containertoepassingen.
Wanneer u een model implementeert van Azure Machine Learning naar Azure Kubernetes Service, worden het model en alle assets die nodig zijn om het als een webservice te hosten, verpakt in een Docker-container. Deze container wordt vervolgens geïmplementeerd in het cluster.
De volgende code laat zien hoe u een nieuw AKS-cluster (Azure Kubernetes Service) voor uw werkruimte maakt:
Tip
U kunt ook een bestaande Azure Kubernetes Service koppelen aan uw Azure Machine Learning-werkruimte. Zie Modellen implementeren in Azure Kubernetes Service voor meer informatie.
Belangrijk
U ziet dat de code de enable_ssl() methode gebruikt om TLS (Transport Layer Security) voor het cluster in te schakelen. Dit is vereist wanneer u van plan bent het geïmplementeerde model te gebruiken vanuit 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)
Belangrijk
Azure factureert u zolang het AKS-cluster bestaat. Zorg ervoor dat u uw AKS-cluster verwijdert wanneer u klaar bent.
Zie How to deploy to Azure Kubernetes Service (Implementeren in Azure Kubernetes Service) voor meer informatie over het gebruik van AKS met Azure Machine Learning.
Het invoerscript schrijven
Het invoerscript ontvangt gegevens die zijn verzonden naar de webservice, geeft deze door aan het model en retourneert de scoreresultaten. Het volgende script laadt het model bij het opstarten en gebruikt vervolgens het model om gegevens te scoren. Dit bestand wordt soms wel genoemd score.py.
Tip
Het invoerscript is specifiek voor uw model. Het script moet bijvoorbeeld het framework kennen dat moet worden gebruikt met uw model, gegevensindelingen, enzovoort.
Belangrijk
Wanneer u van plan bent het geïmplementeerde model te gebruiken vanuit Azure AI Search, moet u het inference_schema pakket gebruiken om het genereren van schema's voor de implementatie in te schakelen. Dit pakket biedt decorators waarmee u de indeling voor invoer- en uitvoergegevens kunt definiëren voor de webservice die deductie uitvoert met behulp van het model.
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()})
Zie Hoe en waar u kunt implementeren voor meer informatie over invoerscripts.
De softwareomgeving definiëren
De omgevingsklasse wordt gebruikt om de Python-afhankelijkheden voor de service te definiëren. Het bevat afhankelijkheden die vereist zijn voor zowel het model als het invoerscript. In dit voorbeeld worden pakketten geïnstalleerd vanuit de reguliere pypi-index en vanuit een GitHub-opslagplaats.
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
Zie Omgevingen maken en beheren voor training en implementatie voor meer informatie over omgevingen.
De implementatieconfiguratie definiëren
De implementatieconfiguratie definieert de Azure Kubernetes Service-hostingomgeving die wordt gebruikt om de webservice uit te voeren.
Tip
Als u niet zeker weet wat de geheugen-, CPU- of GPU-behoeften van uw implementatie zijn, kunt u profilering gebruiken om deze te leren. Zie Hoe en waar u een model kunt implementeren voor meer informatie.
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)
Zie de referentiedocumentatie voor AksService.deploy_configuration voor meer informatie.
De deductieconfiguratie definiëren
De deductieconfiguratie verwijst naar het invoerscript en het omgevingsobject:
from azureml.core.model import InferenceConfig
inf_config = InferenceConfig(entry_script='score.py', environment=myenv)
Zie de referentiedocumentatie voor InferenceConfig voor meer informatie.
Model implementeren
Implementeer het model in uw AKS-cluster en wacht totdat het uw service heeft gemaakt. In dit voorbeeld worden twee geregistreerde modellen uit het register geladen en geïmplementeerd in AKS. Na de implementatie worden deze modellen door het score.py bestand in de implementatie geladen en gebruikt om deductie uit te voeren.
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)
Zie de referentiedocumentatie voor Model voor meer informatie.
Een voorbeeldquery aan uw service uitgeven
In het volgende voorbeeld worden de implementatiegegevens gebruikt die zijn opgeslagen in de aks_service variabele door de vorige codesectie. Deze variabele wordt gebruikt om de score-URL en het verificatietoken op te halen dat nodig is om te communiceren met de service:
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)
Het resultaat dat door de service wordt geretourneerd, is vergelijkbaar met de volgende 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}]}}
Verbinding maken met Azure AI Search
Zie de zelfstudie Een aangepaste vaardigheid bouwen en implementeren met Azure Machine Learning voor meer informatie over het gebruik van dit model vanuit Azure AI Search.
De resources opschonen
Als u het AKS-cluster specifiek voor dit voorbeeld hebt gemaakt, verwijdert u uw resources nadat u klaar bent met het testen ervan met Azure AI Search.
Belangrijk
Azure factureert u op basis van hoe lang het AKS-cluster is geïmplementeerd. Zorg ervoor dat u het opschoont nadat u klaar bent.
aks_service.delete()
aks_target.delete()