Distribuera en modell för användning med Azure AI Search

Artikel
11/15/2023

I den här artikeln lär du dig hur du använder Azure Machine Learning för att distribuera en modell för användning med Azure AI Search.

Azure AI Search utför innehållsbearbetning över heterogent innehåll för att göra det frågebart av människor eller program. Den här processen kan förbättras med hjälp av en modell som distribuerats från Azure Machine Learning.

Azure Machine Learning kan distribuera en tränad modell som en webbtjänst. Webbtjänsten bäddas sedan in i en Azure AI Search-färdighet, som blir en del av bearbetningspipelinen.

Viktigt!

Informationen i den här artikeln är specifik för distributionen av modellen. Den innehåller information om de distributionskonfigurationer som stöds som gör att modellen kan användas av Azure AI Search.

Information om hur du konfigurerar Azure AI Search för att använda den distribuerade modellen finns i självstudien Skapa och distribuera en anpassad färdighet med Azure Machine Learning .

När du distribuerar en modell för användning med Azure AI Search måste distributionen uppfylla följande krav:

Använd Azure Kubernetes Service som värd för modellen för slutsatsdragning.
Aktivera TLS (Transport Layer Security) för Azure Kubernetes Service. TLS används för att skydda HTTPS-kommunikation mellan Azure AI Search och den distribuerade modellen.
Postskriptet måste använda inference_schema paketet för att generera ett OpenAPI-schema (Swagger) för tjänsten.
Inmatningsskriptet måste också acceptera JSON-data som indata och generera JSON som utdata.

Förutsättningar

En Azure Machine Learning-arbetsyta. Mer information finns i Skapa arbetsyteresurser.
En Python-utvecklingsmiljö med Azure Machine Learning SDK installerat. Mer information finns i Azure Machine Learning SDK.
En registrerad modell.
En allmän förståelse för hur och var modeller ska distribueras.

Anslut till din arbetsyta

En Azure Machine Learning-arbetsyta ger en central plats där du kan arbeta med alla artefakter som du skapar när du använder Azure Machine Learning. Arbetsytan har en historik över alla träningsjobb, inklusive loggar, mått, utdata och en ögonblicksbild av dina skript.

Om du vill ansluta till en befintlig arbetsyta använder du följande kod:

Viktigt!

Det här kodfragmentet förväntar sig att konfigurationen av arbetsytan sparas i den aktuella katalogen eller dess överordnade. Mer information finns i Skapa och hantera Azure Machine Learning-arbetsytor. Mer information om hur du sparar konfigurationen i filen finns i Skapa en konfigurationsfil för arbetsytan.

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')

Skapa ett Kubernetes-kluster

Tidsuppskattning: Cirka 20 minuter.

Ett Kubernetes-kluster är en uppsättning virtuella datorinstanser (kallas noder) som används för att köra containerbaserade program.

När du distribuerar en modell från Azure Machine Learning till Azure Kubernetes Service paketeras modellen och alla tillgångar som behövs för att vara värd för den som en webbtjänst i en Docker-container. Den här containern distribueras sedan till klustret.

Följande kod visar hur du skapar ett nytt AKS-kluster (Azure Kubernetes Service) för din arbetsyta:

Dricks

Du kan också koppla en befintlig Azure Kubernetes Service till din Azure Machine Learning-arbetsyta. Mer information finns i Distribuera modeller till Azure Kubernetes Service.

Viktigt!

Observera att koden använder enable_ssl() metoden för att aktivera TLS (Transport Layer Security) för klustret. Detta krävs när du planerar att använda den distribuerade modellen från 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)

Viktigt!

Azure debiterar dig så länge AKS-klustret finns. Se till att ta bort AKS-klustret när du är klar med det.

Mer information om hur du använder AKS med Azure Machine Learning finns i Distribuera till Azure Kubernetes Service.

Skriva inmatningsskriptet

Inmatningsskriptet tar emot data som skickas till webbtjänsten, skickar dem till modellen och returnerar bedömningsresultatet. Följande skript läser in modellen vid start och använder sedan modellen för att poängsätta data. Den här filen kallas score.pyibland .

Dricks

Startskriptet är specifikt för din modell. Skriptet måste till exempel känna till ramverket som ska användas med din modell, dataformat osv.

Viktigt!

När du planerar att använda den distribuerade modellen från Azure AI Search måste du använda inference_schema paketet för att aktivera schemagenerering för distributionen. Det här paketet innehåller dekoratörer som gör att du kan definiera in- och utdataformatet för webbtjänsten som utför slutsatsdragning med hjälp av modellen.

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()})

Mer information om inmatningsskript finns i Hur och var du distribuerar.

Definiera programvarumiljön

Miljöklassen används för att definiera Python-beroenden för tjänsten. Den innehåller beroenden som krävs av både modellen och postskriptet. I det här exemplet installeras paket från det vanliga pypi-indexet samt från en GitHub-lagringsplats.

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

Mer information om miljöer finns i Skapa och hantera miljöer för utbildning och distribution.

Definiera distributionskonfigurationen

Distributionskonfigurationen definierar värdmiljön för Azure Kubernetes Service som används för att köra webbtjänsten.

Dricks

Om du inte är säker på hur mycket minne, PROCESSOR eller GPU du behöver för distributionen kan du använda profilering för att lära dig dessa. Mer information finns i Hur och var du distribuerar en modell.

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)

Mer information finns i referensdokumentationen för AksService.deploy_configuration.

Definiera inferenskonfigurationen

Inferenskonfigurationen pekar på inmatningsskriptet och miljöobjektet:

from azureml.core.model import InferenceConfig
inf_config = InferenceConfig(entry_script='score.py', environment=myenv)

Mer information finns i referensdokumentationen för InferenceConfig.

Distribuera modellen

Distribuera modellen till ditt AKS-kluster och vänta tills den har skapat tjänsten. I det här exemplet läses två registrerade modeller in från registret och distribueras till AKS. Efter distributionen score.py läser filen i distributionen in dessa modeller och använder dem för att utföra slutsatsdragning.

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)

Mer information finns i referensdokumentationen för Modell.

Utfärda en exempelfråga till din tjänst

I följande exempel används distributionsinformationen som lagras i variabeln aks_service i föregående kodavsnitt. Den använder den här variabeln för att hämta den poäng-URL och autentiseringstoken som behövs för att kommunicera med tjänsten:

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)

Resultatet som returneras från tjänsten liknar följande 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}]}}

Anslut till Azure AI Search

Information om hur du använder den här modellen från Azure AI Search finns i självstudien Skapa och distribuera en anpassad färdighet med Azure Machine Learning .

Rensa resurserna

Om du har skapat AKS-klustret specifikt för det här exemplet tar du bort dina resurser när du har testat det med Azure AI Search.

Viktigt!

Azure fakturerar dig baserat på hur länge AKS-klustret har distribuerats. Se till att rensa upp det när du är klar med det.

aks_service.delete()
aks_target.delete()

Nästa steg

Skapa och distribuera en anpassad färdighet med Azure Machine Learning

Distribuera en modell för användning med Azure AI Search

Förutsättningar

Anslut till din arbetsyta

Skapa ett Kubernetes-kluster

Skriva inmatningsskriptet

Definiera programvarumiljön

Definiera distributionskonfigurationen

Definiera inferenskonfigurationen

Distribuera modellen

Utfärda en exempelfråga till din tjänst

Anslut till Azure AI Search

Rensa resurserna

Nästa steg

Ytterligare resurser