Implantar um modelo para uso com o Azure AI Search
APLICA-SE A: 
SDK do Python do AzureML v1
Este artigo mostra como usar o Azure Machine Learning para implantar um modelo para uso com o Azure AI Search.
O Azure AI Search executa o processamento de conteúdo sobre conteúdo heterogêneo, para torná-lo passível de consulta 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 a uma habilidade da Pesquisa de IA do Azure, que se torna parte do pipeline de processamento.
Importante
As informações neste artigo são específicas para a implantação do modelo. Ele fornece informações sobre as configurações de implantação com suporte que permitem que o modelo seja usado pelo Azure AI Search.
Para obter informações sobre como configurar o Azure AI Search para usar o modelo implantado, confira o tutorial Criar e implantar uma habilidade personalizada com o Azure Machine Learning.
Ao implantar um modelo para uso com o Azure AI Search, a implantação deve atender aos seguintes requisitos:
- Usar o Serviço de Kubernetes do Azure para hospedar o modelo para a inferência.
- Habilitar o protocolo TLS para o Serviço de Kubernetes do Azure. O TLS é usado para proteger comunicações HTTPS entre o Azure AI Search e o modelo implantado.
- O script de entrada deve usar o pacote
inference_schemapara 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
Um Workspace do Azure Machine Learning. Para obter mais informações, consulte Criar recursos de workspace.
Um ambiente de desenvolvimento Python com o SDK do Azure Machine Learning instalado. Para saber mais, confira o SDK do Azure Machine Learning.
Um modelo registrado.
Uma compreensão geral de Como e onde implantar modelos.
Conectar-se ao workspace
Um workspace do Azure Machine Learning fornece um local centralizado para trabalhar com todos os artefatos que você criar ao usar o Azure Machine Learning. O workspace 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 workspace existente, use o seguinte código:
Importante
Esse snippet de código espera que a configuração do workspace seja salva no diretório atual ou no pai dele. Para obter mais informações, consulte Criar e gerenciar workspaces do Azure Machine Learning. Para obter mais informações sobre como salvar a configuração no arquivo, confira Criar um arquivo de configuração de workspace.
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
Tempo estimado: aproximadamente 20 minutos.
Um cluster do Kubernetes é um conjunto de instâncias de máquina virtual (chamadas de nós) que são usadas para executar aplicativos conteineirizados.
Quando você implanta um modelo do Azure Machine Learning para o Serviço de 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 seguinte código demonstra como criar um cluster do AKS (Serviço de Kubernetes do Azure) para seu workspace:
Dica
Você também pode anexar um Serviço de Kubernetes do Azure existente ao seu workspace do Azure Machine Learning. Para obter mais informações, confira Como implantar modelos no Serviço de Kubernetes do Azure.
Importante
Observe que o código usa o método enable_ssl() para habilitar o protocolo TLS para o cluster. Isso é necessário ao planejar usar o modelo implantado do 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)
Importante
O Azure cobrará você desde que o cluster do AKS exista. Certifique-se de excluir o cluster do AKS quando tiver terminado.
Para obter mais informações sobre como usar o AKS com o Azure Machine Learning, consulte Como implantar no Serviço de 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 é chamado às vezes de score.py.
Dica
O script de entrada é específico para cada modelo. Por exemplo, o script deve saber a estrutura a ser usada com seu modelo, formatos de dados etc.
Importante
Ao planejar o uso do modelo implantado do Azure AI Search, use o pacote inference_schema para habilitar a geração de esquema para a implantação. Esse pacote fornece decoradores que permitem que você defina o formato de dados de entrada e saída para o serviço Web que executa a inferência usando o modelo.
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 do Python para o serviço. Ela inclui dependências exigidas pelo modelo e pelo script de entrada. Neste exemplo, ela 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, confira 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 de Kubernetes do Azure usado para executar o serviço Web.
Dica
Se você não tiver certeza sobre as necessidades de memória, CPU ou GPU de sua implantação, poderá usar a criação de perfil para se informar. Para obter mais informações, confira Como e em que local implantar um modelo.
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, confira a documentação de referência de 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, confira a documentação de referência de InferenceConfig.
Implantar o modelo
Implante o modelo em seu cluster do 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 arquivo score.py 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, confira a documentação de referência do modelo.
Emitir uma consulta de exemplo para seu serviço
O exemplo a seguir usa as informações de implantação armazenadas na variável aks_service 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 comunicação 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 ao Azure AI Search
Para obter informações sobre como usar esse modelo do Azure AI Search, confira o tutorial Criar e implantar uma habilidade personalizada com o Azure Machine Learning.
Limpar os recursos
Se você criou o cluster do AKS especificamente para esse exemplo, exclua seus recursos depois de terminar de testá-lo com o Azure AI Search.
Importante
O Azure cobra com base em quanto tempo o cluster do AKS é implantado. Certifique-se de limpá-lo depois de concluir a tarefa.
aks_service.delete()
aks_target.delete()