Menyebarkan model untuk digunakan dengan Azure AI Search
BERLAKU UNTUK:
Python SDK azureml v1
Artikel ini mengajarkan cara menggunakan Azure Pembelajaran Mesin untuk menyebarkan model untuk digunakan dengan Azure AI Search.
Pencarian Azure AI melakukan pemrosesan konten melalui konten heterogen, untuk membuatnya dapat dikueri oleh manusia atau aplikasi. Proses ini dapat ditingkatkan dengan menggunakan model yang diterapkan dari Azure Machine Learning.
Azure Machine Learning dapat menyebarkan model terlatih sebagai layanan web. Layanan web kemudian disematkan dalam keterampilan Azure AI Search, yang menjadi bagian dari alur pemrosesan.
Penting
Informasi dalam artikel ini khusus untuk penyebaran model. Ini menyediakan informasi tentang konfigurasi penyebaran yang didukung yang memungkinkan model digunakan oleh Azure AI Search.
Untuk informasi tentang cara mengonfigurasi Azure AI Search untuk menggunakan model yang disebarkan, lihat tutorial Membangun dan menyebarkan keterampilan kustom dengan Azure Pembelajaran Mesin.
Saat menyebarkan model untuk digunakan dengan Azure AI Search, penyebaran harus memenuhi persyaratan berikut:
- Gunakan Azure Kubernetes Service untuk meng-host model untuk inferensi.
- Aktifkan keamanan lapisan transport (TLS) untuk Azure Kubernetes Service. TLS digunakan untuk mengamankan komunikasi HTTPS antara Azure AI Search dan model yang disebarkan.
- Skrip entri harus menggunakan paket
inference_schemauntuk menghasilkan skema OpenAPI (Swagger) untuk layanan. - Skrip entri juga harus menerima data JSON sebagai input, dan menghasilkan JSON sebagai output.
Prasyarat
Ruang kerja Azure Machine Learning. Untuk informasi selengkapnya, lihat Membuat sumber daya ruang kerja.
Lingkungan pengembangan Python dengan Azure Machine Learning SDK terpasang. Untuk informasi selengkapnya, lihat Azure Machine Learning SDK.
Model terdaftar.
Pemahaman umum tentang Bagaimana dan di mana menyebarkan model.
Menyambungkan ke ruang kerja Anda
Ruang kerja adalah sumber daya tingkat teratas untuk Azure Machine Learning, menyediakan tempat terpusat untuk bekerja dengan semua artefak yang Anda buat saat Anda menggunakan Azure Machine Learning. Ruang kerja menyimpan riwayat semua pekerjaan pelatihan, termasuk log, metrik, output, dan snapshot skrip Anda.
Untuk menyambungkan ke ruang kerja yang sudah ada, gunakan kode berikut:
Penting
Cuplikan kode ini mengharapkan konfigurasi ruang kerja disimpan di direktori saat ini atau induknya. Untuk informasi selengkapnya, lihat Membuat dan mengelola ruang kerja Azure Machine Learning. Untuk informasi selengkapnya tentang menyimpan konfigurasi ke file, lihat Membuat file konfigurasi ruang kerja.
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')
Buatlah kluster Kubernetes
Perkiraan waktu: Sekitar 20 menit.
Klaster Kube adalah sekumpulan instans mesin virtual (disebut simpul) yang digunakan untuk menjalankan aplikasi kontainer.
Saat Anda menyebarkan model dari Azure Machine Learning ke Azure Kubernetes Service, model dan semua aset yang diperlukan untuk meng-hostnya sebagai layanan web dikemas ke dalam kontainer Docker. Kontainer ini kemudian disebarkan ke kluster.
Kode berikut menunjukkan Azure Container Service (AKS) baru untuk ruang kerja Anda:
Tip
Anda juga dapat melampirkan Azure Kubernetes Service yang ada ke ruang kerja Azure Machine Learning Anda. Untuk informasi lebih lanjut, lihat Cara menggunakan model ke Azure Kubernetes Service.
Penting
Perhatikan bahwa kode menggunakan metode enable_ssl() untuk mengaktifkan keamanan lapisan transportasi (TLS) untuk kluster. Ini diperlukan saat Anda berencana menggunakan model yang disebarkan dari 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)
Penting
Azure akan menagih Anda selama kluster AKS ada. Pastikan untuk menghapus kluster AKS saat Anda selesai dengan kluster tersebut.
Untuk informasi lebih lanjut tentang penggunaan AKS dengan Azure Machine Learning, lihat Cara menyebarkan ke Layanan Azure Kubernetes.
Menulis skrip entri
Skrip entri menerima data yang dikirimkan ke layanan web, meneruskannya ke model, dan mengembalikan hasil penilaian. Skrip berikut memuat model saat startup, dan kemudian menggunakan model untuk menilai data. File ini terkadang disebut score.py.
Tip
Skrip entri khusus untuk model Anda. Misalnya, skrip harus mengetahui kerangka kerja yang akan digunakan dengan model, format data, dll.
Penting
Saat Anda berencana menggunakan model yang disebarkan dari Azure AI Search, Anda harus menggunakan inference_schema paket untuk mengaktifkan pembuatan skema untuk penyebaran. Paket ini menyediakan dekorator yang memungkinkan Anda menentukan format data input dan output untuk layanan web yang melakukan inferensi menggunakan 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()})
Untuk informasi selengkapnya tentang skrip entri, lihat Cara dan tempat untuk menyebarkan.
Tentukan lingkungan perangkat lunak
Kelas lingkungan digunakan untuk menentukan dependensi Python untuk layanan. Ini termasuk dependensi yang diperlukan oleh model dan skrip entri. Dalam contoh ini, paket dipasang dari indeks pypi reguler, serta dari repo 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
Untuk informasi selengkapnya tentang lingkungan, lihat Membuat dan mengelola lingkungan untuk pelatihan dan penyebaran.
Tentukan konfigurasi penyebaran
Konfigurasi penyebaran mendefinisikan lingkungan Azure Kubernetes Service yang digunakan untuk menjalankan layanan web.
Tip
Jika Anda tidak yakin tentang memori, CPU, atau kebutuhan GPU penyebaran, Anda dapat menggunakan pembuatan profil untuk mempelajarinya. Untuk informasi selengkapnya, lihat Cara dan tempat untuk menyebarkan model.
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)
Untuk informasi selengkapnya, lihat dokumentasi referensi untuk AksService.deploy_configuration.
Tentukan konfigurasi inferensi
Konfigurasi inferensi menunjuk ke skrip entri dan objek lingkungan:
from azureml.core.model import InferenceConfig
inf_config = InferenceConfig(entry_script='score.py', environment=myenv)
Untuk informasi selengkapnya, lihat dokumentasi referensi untuk InferenceConfig.
Menyebarkan model
Terapkan model ke kluster AKS Anda dan tunggu hingga layanan Anda dibuat. Dalam contoh ini, dua model terdaftar dimuat dari registri dan disebarkan ke AKS. Setelah penyebaran, file score.py dalam penyebaran memuat model-model ini dan menggunakannya untuk melakukan inferensi.
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)
Untuk informasi selengkapnya, lihat dokumentasi referensi untuk Model.
Mengeluarkan contoh kueri ke layanan Anda
Contoh berikut menggunakan informasi penyebaran yang disimpan dalam variabel aks_service oleh bagian kode sebelumnya. Ini menggunakan variabel ini untuk mengambil URL penilaian dan token otentikasi yang diperlukan untuk berkomunikasi dengan layanan:
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)
Hasil yang dikembalikan dari layanan ini mirip dengan JSON berikut:
{"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}]}}
Menyambungkan ke Azure AI Search
Untuk informasi tentang menggunakan model ini dari Azure AI Search, lihat tutorial Membangun dan menyebarkan keterampilan kustom dengan Azure Pembelajaran Mesin.
Membersihkan sumber daya
Jika Anda membuat kluster AKS khusus untuk contoh ini, hapus sumber daya Anda setelah selesai mengujinya dengan Azure AI Search.
Penting
Azure menagih Anda berdasarkan berapa lama kluster AKS disebarkan. Pastikan untuk membersihkannya setelah Anda selesai.
aks_service.delete()
aks_target.delete()