Modell üzembe helyezése az Azure AI Search szolgáltatással való használatra
A KÖVETKEZŐKRE VONATKOZIK:
Python SDK azureml v1
Ez a cikk bemutatja, hogyan helyezhet üzembe egy Modellt az Azure AI Search használatával az Azure Machine Learning használatával.
Az Azure AI Search heterogén tartalmakon keresztül végez tartalomfeldolgozást, hogy az emberek vagy alkalmazások lekérdezhetők legyenek. Ez a folyamat az Azure Machine Learningből üzembe helyezett modellel bővíthető.
Az Azure Machine Learning webszolgáltatásként üzembe helyezhet egy betanított modellt. A webszolgáltatás ezután beágyazódik egy Azure AI Search-képességbe, amely a feldolgozási folyamat részévé válik.
Fontos
A cikkben szereplő információk a modell üzembe helyezésére vonatkoznak. Információkat nyújt a támogatott üzembehelyezési konfigurációkról, amelyek lehetővé teszik, hogy a modellt az Azure AI Search használja.
Az Azure AI Search üzembe helyezett modell használatára való konfigurálásáról az Egyéni képességek létrehozása és üzembe helyezése az Azure Machine Learning oktatóanyagában olvashat.
Az Azure AI Search szolgáltatással használható modell üzembe helyezésekor az üzembe helyezésnek meg kell felelnie a következő követelményeknek:
- Használja az Azure Kubernetes Service-t a modell következtetéshez való üzemeltetéséhez.
- Engedélyezze a transport layer security (TLS) szolgáltatást az Azure Kubernetes Service-hez. A TLS az Azure AI Search és az üzembe helyezett modell közötti HTTPS-kommunikáció védelmére szolgál.
- A belépési szkriptnek a
inference_schemacsomag használatával kell létrehoznia egy OpenAPI -sémát (Swagger) a szolgáltatáshoz. - A beviteli szkriptnek jSON-adatokat is el kell fogadnia bemenetként, és JSON-t kell létrehoznia kimenetként.
Előfeltételek
Egy Azure Machine Learning-munkaterület. További információ: Munkaterület-erőforrások létrehozása.
Egy Python-fejlesztési környezet, amelyen telepítve van az Azure Machine Learning SDK. További információ: Azure Machine Learning SDK.
Regisztrált modell.
A modellek üzembe helyezésének általános ismerete.
Csatlakozás a munkaterülethez
Az Azure Machine Learning-munkaterületek központi helyet biztosítanak az Azure Machine Learning használatakor létrehozott összes összetevővel való munkához. A munkaterület megőrzi az összes betanítási feladat előzményeit, beleértve a naplókat, a metrikákat, a kimenetet és a szkriptek pillanatképét.
Meglévő munkaterülethez való csatlakozáshoz használja a következő kódot:
Fontos
Ez a kódrészlet arra számít, hogy a munkaterület konfigurációja az aktuális könyvtárban vagy annak szülőjében lesz mentve. További információ: Azure Machine Learning-munkaterületek létrehozása és kezelése. A konfiguráció fájlba mentéséről további információt a munkaterület konfigurációs fájljának létrehozása című témakörben talál.
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')
Kubernetes-fürt létrehozása
Időbecslés: Körülbelül 20 perc.
A Kubernetes-fürtök a tárolóalapú alkalmazások futtatásához használt virtuálisgép-példányok (úgynevezett csomópontok) készletei.
Amikor üzembe helyez egy modellt az Azure Machine Learningből az Azure Kubernetes Service-be, a modell és a webszolgáltatásként való üzemeltetéséhez szükséges összes eszköz egy Docker-tárolóba lesz csomagolva. Ezt a tárolót ezután telepíti a fürtre.
Az alábbi kód bemutatja, hogyan hozhat létre új Azure Kubernetes Service-fürtöt (AKS) a munkaterülethez:
Tipp.
Egy meglévő Azure Kubernetes-szolgáltatást is csatolhat az Azure Machine Learning-munkaterülethez. További információ: Modellek üzembe helyezése az Azure Kubernetes Service-ben.
Fontos
Figyelje meg, hogy a kód a metódussal engedélyezi a enable_ssl() fürt átviteli rétegének biztonságát (TLS). Erre akkor van szükség, ha az Azure AI Searchből származó üzembe helyezett modell használatát tervezi.
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)
Fontos
Az Azure addig számláz, amíg az AKS-fürt létezik. Ha végzett vele, törölje az AKS-fürtöt.
Az AKS és az Azure Machine Learning használatával kapcsolatos további információkért lásd : Üzembe helyezés az Azure Kubernetes Service-ben.
A beviteli szkript írása
A bejegyzésszkript fogadja a webszolgáltatásnak küldött adatokat, átadja azokat a modellnek, és visszaadja a pontozási eredményeket. Az alábbi szkript betölti a modellt az indításkor, majd a modell használatával végzi az adatok pontozását. Ezt a fájlt néha nevezik score.py.
Tipp.
A bejegyzés parancsfájlja egyedi a modellnél. A szkriptnek például ismernie kell a modellhez, adatformátumokhoz stb. használható keretrendszert.
Fontos
Amikor az Azure AI Searchben üzembe helyezett modellt tervezi használni, a csomaggal engedélyeznie kell a inference_schema sémagenerálást az üzembe helyezéshez. Ez a csomag dekorátorokat biztosít, amelyek lehetővé teszik a modell használatával következtetést végző webszolgáltatás bemeneti és kimeneti adatformátumának meghatározását.
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()})
A beviteli szkriptekkel kapcsolatos további információkért tekintse meg a telepítés módját és helyét.
A szoftverkörnyezet meghatározása
A környezeti osztály a szolgáltatás Python-függőségeinek meghatározására szolgál. A modell és a belépési szkript által megkövetelt függőségeket is tartalmaz. Ebben a példában a szokásos pypi-indexből, valamint egy GitHub-adattárból telepíti a csomagokat.
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
A környezetekkel kapcsolatos további információkért lásd : Környezetek létrehozása és kezelése betanításhoz és üzembe helyezéshez.
Az üzembehelyezési konfiguráció meghatározása
Az üzembe helyezési konfiguráció határozza meg a webszolgáltatás futtatásához használt Azure Kubernetes Service üzemeltetési környezetet.
Tipp.
Ha nem biztos abban, hogy az üzembe helyezés memória-, PROCESSZOR- vagy GPU-igényei vannak, ezeket profilkészítéssel is megismerheti. További információkért lásd a modell üzembe helyezésének módját és helyét.
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)
További információt a AksService.deploy_configuration referenciadokumentációjában talál.
A következtetés konfigurációjának meghatározása
A következtetés konfigurációja a belépési szkriptre és a környezeti objektumra mutat:
from azureml.core.model import InferenceConfig
inf_config = InferenceConfig(entry_script='score.py', environment=myenv)
További információkért tekintse meg az InferenceConfig referenciadokumentációját.
A modell üzembe helyezése
Telepítse a modellt az AKS-fürtön, és várja meg, amíg létrejön a szolgáltatás. Ebben a példában két regisztrált modell töltődik be a beállításjegyzékből, és üzembe helyezve az AKS-ben. Az üzembe helyezés után az üzembe helyezés során a score.py fájl betölti ezeket a modelleket, és következtetések végrehajtására használja őket.
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)
További információkért tekintse meg a Model referenciadokumentációját.
Minta lekérdezés kiállítása a szolgáltatás számára
Az alábbi példa a változóban az aks_service előző kódszakaszban tárolt üzembehelyezési információkat használja. Ezzel a változóval kéri le a szolgáltatással való kommunikációhoz szükséges pontozási URL-címet és hitelesítési jogkivonatot:
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)
A szolgáltatásból visszaadott eredmény a következő JSON-hoz hasonló:
{"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}]}}
Csatlakozás az Azure AI Search szolgáltatáshoz
A modell Azure AI Searchből való használatával kapcsolatos információkért tekintse meg az Egyéni képesség létrehozása és üzembe helyezése az Azure Machine Learning oktatóanyagában.
Az erőforrások eltávolítása
Ha kifejezetten ehhez a példához hozta létre az AKS-fürtöt, törölje az erőforrásokat, miután befejezte a tesztelést az Azure AI Search szolgáltatással.
Fontos
Az Azure az AKS-fürt üzembe helyezésének hossza alapján számláz. A művelet befejezése után mindenképpen tisztítsa meg.
aks_service.delete()
aks_target.delete()