Implantar um modelo para uso com o Azure AI Search

APLICA-SE A: Python SDK azureml v1

Este artigo ensina como usar o Aprendizado de Máquina do Azure para implantar um modelo para uso com o Azure AI Search.

O Azure AI Search executa o processamento de conteúdo em conteúdo heterogêneo, para torná-lo consultável por humanos ou aplicativos. Esse processo pode ser aprimorado usando um modelo implantado do Azure Machine Learning.

O Azure Machine Learning pode implantar um modelo treinado como um serviço Web. O serviço Web é então incorporado em uma habilidade de Pesquisa de IA do Azure, que se torna parte do pipeline de processamento.

Ao implantar um modelo para uso com o Azure AI Search, a implantação deve atender aos seguintes requisitos:

• Use o Serviço Kubernetes do Azure para hospedar o modelo para inferência.
• Habilite a segurança da camada de transporte (TLS) para o Serviço Kubernetes do Azure. O TLS é usado para proteger as comunicações HTTPS entre o Azure AI Search e o modelo implantado.
• O script de entrada deve usar o inference_schema pacote para gerar um esquema OpenAPI (Swagger) para o serviço.
• O script de entrada também deve aceitar dados JSON como entrada e gerar JSON como saída.

Pré-requisitos

• Uma área de trabalho do Azure Machine Learning. Para obter mais informações, consulte Criar recursos de espaço de trabalho.

• Um ambiente de desenvolvimento Python com o SDK do Azure Machine Learning instalado. Para obter mais informações, consulte SDK do Azure Machine Learning.

• Um modelo registado.

• Uma compreensão geral de como e onde implantar modelos.

Ligar à sua área de trabalho

Um espaço de trabalho do Azure Machine Learning fornece um local centralizado para trabalhar com todos os artefatos que você cria quando usa o Azure Machine Learning. O espaço de trabalho mantém um histórico de todos os trabalhos de treinamento, incluindo logs, métricas, saída e um instantâneo de seus scripts.

Para se conectar a um espaço de trabalho existente, use o seguinte código:

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

Criar um cluster do Kubernetes

Estimativa de tempo: Aproximadamente 20 minutos.

Um cluster Kubernetes é um conjunto de instâncias de máquina virtual (chamadas nós) que são usadas para executar aplicativos em contêineres.

Quando você implanta um modelo do Aprendizado de Máquina do Azure no Serviço Kubernetes do Azure, o modelo e todos os ativos necessários para hospedá-lo como um serviço Web são empacotados em um contêiner do Docker. Esse contêiner é então implantado no cluster.

O código a seguir demonstra como criar um novo cluster do Serviço Kubernetes do Azure (AKS) para seu espaço de trabalho:

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)

Para obter mais informações sobre como usar o AKS com o Azure Machine Learning, consulte Como implantar no Serviço Kubernetes do Azure.

Escrever o script de entrada

O script de entrada recebe dados enviados para o serviço Web, passa-os para o modelo e retorna os resultados da pontuação. O script a seguir carrega o modelo na inicialização e, em seguida, usa o modelo para pontuar dados. Esse arquivo às vezes é chamado de score.py.

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

Para obter mais informações sobre scripts de entrada, consulte Como e onde implantar.

Definir o ambiente de software

A classe de ambiente é usada para definir as dependências Python para o serviço. Inclui dependências exigidas pelo modelo e pelo script de entrada. Neste exemplo, ele instala pacotes do índice pypi regular, bem como de um repositório 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

Para obter mais informações sobre ambientes, consulte Criar e gerenciar ambientes para treinamento e implantação.

Definir a configuração de implantação

A configuração de implantação define o ambiente de hospedagem do Serviço Kubernetes do Azure usado para executar o serviço Web.

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)

Para obter mais informações, consulte a documentação de referência do AksService.deploy_configuration.

Definir a configuração de inferência

A configuração de inferência aponta para o script de entrada e o objeto de ambiente:

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

Para obter mais informações, consulte a documentação de referência para InferenceConfig.

Implementar o modelo

Implante o modelo em seu cluster AKS e aguarde até que ele crie seu serviço. Neste exemplo, dois modelos registrados são carregados do registro e implantados no AKS. Após a implantação, o score.py arquivo na implantação carrega esses modelos e os usa para executar a inferência.

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)

Para obter mais informações, consulte a documentação de referência para Modelo.

Emitir uma consulta de exemplo para o seu serviço

O exemplo a seguir usa as informações de implantação armazenadas na aks_service variável pela seção de código anterior. Ele usa essa variável para recuperar a URL de pontuação e o token de autenticação necessários para se comunicar com o serviço:

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)

O resultado retornado do serviço é semelhante ao seguinte 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}]}}

Conectar-se à Pesquisa de IA do Azure

Para obter informações sobre como usar esse modelo do Azure AI Search, consulte o tutorial Criar e implantar uma habilidade personalizada com o Azure Machine Learning .

Limpar os recursos

Se você criou o cluster AKS especificamente para este exemplo, exclua seus recursos depois de terminar de testá-lo com o Azure AI Search.

aks_service.delete()
aks_target.delete()

Próximos passos

• Crie e implante uma habilidade personalizada com o Azure Machine Learning