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.
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, consulte 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:
- 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_schemapacote 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:
Importante
Este trecho de código espera que a configuração do espaço de trabalho seja salva no diretório atual ou em seu pai. Para obter mais informações, consulte Criar e gerenciar espaços de trabalho do Azure Machine Learning. Para obter mais informações sobre como salvar a configuração no arquivo, consulte Criar um arquivo de configuração do espaço de trabalho.
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:
Gorjeta
Você também pode anexar um Serviço Kubernetes do Azure existente ao seu espaço de trabalho do Azure Machine Learning. Para obter mais informações, consulte Como implantar modelos no Serviço Kubernetes do Azure.
Importante
Observe que o código usa o método para habilitar a enable_ssl() segurança da camada de transporte (TLS) para o cluster. Isso é necessário quando você planeja 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ê enquanto o cluster AKS existir. Certifique-se de excluir seu cluster AKS quando terminar de usá-lo.
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.
Gorjeta
O script de entrada é específico do seu modelo. Por exemplo, o script deve conhecer a estrutura a ser usada com seu modelo, formatos de dados, etc.
Importante
Ao planejar usar o modelo implantado do Azure AI Search, você deve usar o pacote para habilitar a inference_schema geração de esquema para a implantação. Este pacote fornece decoradores que permitem definir 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 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.
Gorjeta
Se você não tiver certeza sobre as necessidades de memória, CPU ou GPU de sua implantação, você pode usar a criação de perfil para aprender isso. Para obter mais informações, consulte Como e onde 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, 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.
Importante
O Azure cobra você com base em quanto tempo o cluster AKS é implantado. Certifique-se de limpá-lo depois de terminar de usá-lo.
aks_service.delete()
aks_target.delete()
Próximos passos
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários