Megosztás a következőn keresztül:

Nyelvi modellek üzembe helyezése kötegelt végpontokon

  • Cikk

ÉRVÉNYES:Azure CLI ml-bővítmény v2 (aktuális)Python SDK azure-ai-ml v2 (aktuális)

A Batch-végpontok felhasználhatók drága modellek, például nyelvi modellek szöveges adatokon keresztüli üzembe helyezésére. Ebben az oktatóanyagban megtudhatja, hogyan helyezhet üzembe olyan modellt, amely képes a HuggingFace modell használatával a hosszú szövegsorozatok szöveges összegzésére. Azt is bemutatja, hogyan lehet következtetésoptimalizálást végezni a HuggingFace optimum és accelerate a tárak használatával.

A minta ismertetése

A modell, amellyel dolgozni fogunk, a HuggingFace népszerű könyvtárátalakítóival, valamint egy előre betanított Facebook-modellel és a BART architektúrával készült. A bart: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation című tanulmányban jelent meg. Ez a modell a következő korlátozásokkal rendelkezik, amelyeket fontos szem előtt tartani az üzembe helyezéshez:

  • Akár 1024 jogkivonatot tartalmazó sorozatokkal is használható.
  • A szöveg angol nyelvű összegzésére van betanítve.
  • Torch-ot használjuk háttérrendszerként.

A cikkben szereplő példa az azureml-examples adattárban található kódmintákon alapul. Ha helyileg szeretné futtatni a parancsokat a YAML és más fájlok másolása/beillesztése nélkül, először klónozza az adattárat, majd módosítsa a könyvtárakat a mappára:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

A példában szereplő fájlok a következők:

cd endpoints/batch/deploy-models/huggingface-text-summarization

Követés a Jupyter Notebooksban

Ezt a mintát követheti egy Jupyter Notebookban. A klónozott adattárban nyissa meg a következő jegyzetfüzetet: text-summarization-batch.ipynb.

Előfeltételek

  • Azure-előfizetés. Ha még nincs Azure-előfizetése, kezdés előtt hozzon létre egy ingyenes fiókot. Próbálja ki az Azure Machine Learning ingyenes vagy fizetős verzióját.

  • Egy Azure Machine Learning-munkaterület. Munkaterület létrehozásához lásd: Azure Machine Learning-munkaterületek kezelése.

  • Győződjön meg arról, hogy rendelkezik a következő engedélyekkel a Machine Learning-munkaterületen:

    • Batch-végpontok és -üzemelő példányok létrehozása vagy kezelése: Használjon tulajdonosi, közreműködői vagy egyéni szerepkört, amely lehetővé teszi Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
    • Azure Resource Manager-üzemelő példányok létrehozása a munkaterület erőforráscsoportjában: Használjon tulajdonosi, közreműködői vagy egyéni szerepkört, amely lehetővé teszi Microsoft.Resources/deployments/write abban az erőforráscsoportban, amelyben a munkaterület telepítve van.

  • Telepítse a következő szoftvert a Machine Learning használatához:

    Futtassa a következő parancsot az Azure CLI és az ml Azure Machine Learning bővítményének telepítéséhez:

    az extension add -n ml

    A Batch-végpontok folyamatösszetevő-üzembe helyezését az ml Azure CLI bővítményének 2.7-es verziójában vezetjük be. az extension update --name ml A parancs használatával szerezze be a legújabb verziót.

Csatlakozás a munkaterülethez

A munkaterület a Machine Learning legfelső szintű erőforrása. Központosított helyet biztosít a Machine Learning használatakor létrehozott összes összetevővel való munkához. Ebben a szakaszban ahhoz a munkaterülethez csatlakozik, ahol végrehajtja az üzembe helyezési feladatokat.

A következő parancsban adja meg az előfizetés azonosítójának, munkaterületének, helyének és erőforráscsoportjának értékeit:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

A modell regisztrálása

A modell mérete miatt nem szerepel ebben az adattárban. Ehelyett letölthet egy másolatot a HuggingFace-modell központjából. Szüksége van a csomagokra transformers , és torch telepíteni kell a használt környezetben.

%pip install transformers torch

A következő kóddal töltse le a modellt egy mappába model:

from transformers import pipeline

model = pipeline("summarization", model="facebook/bart-large-cnn")
model_local_path = 'model'
summarizer.save_pretrained(model_local_path)

Most már regisztrálhatjuk ezt a modellt az Azure Machine Learning regisztrációs adatbázisában:

MODEL_NAME='bart-text-summarization'
az ml model create --name $MODEL_NAME --path "model"

A végpont létrehozása

Létrehozunk egy kötegvégpontot, amely a HuggingFace-modell üzembe helyezésének helyét adja text-summarization-batch meg a szövegösszesítés angol nyelvű szövegfájlokon való futtatásához.

  1. Döntse el a végpont nevét. A végpont neve a végponthoz társított URI-ban végződik. Emiatt a kötegvégpontok nevének egyedinek kell lennie egy Azure-régióban. Például csak egy kötegvégpont lehet, amelyben a név mybatchendpoint szerepel westus2.

    Ebben az esetben helyezzük el a végpont nevét egy változóban, hogy később könnyen hivatkozhassunk rá.

    ENDPOINT_NAME="text-summarization-batch"

  2. A kötegvégpont konfigurálása

    A következő YAML-fájl egy kötegvégpontot határoz meg:

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: text-summarization-batch
description: A batch endpoint for summarizing text using a HuggingFace transformer model.
auth_mode: aad_token

  3. Hozza létre a végpontot:

    az ml batch-endpoint create --file endpoint.yml  --name $ENDPOINT_NAME

Az üzembe helyezés létrehozása

Hozzuk létre a modellt üzemeltető üzembe helyezést:

  1. Létre kell hoznunk egy pontozószkriptet, amely képes beolvasni a kötegtelepítés által biztosított CSV-fájlokat, és visszaadni a modell pontszámait az összegzéssel. A következő szkript a következő műveleteket hajtja végre:

    • Olyan függvényt init jelöl, amely észleli a hardverkonfigurációt (CPU és GPU), és ennek megfelelően tölti be a modellt. A modell és a tokenizer is globális változókba van betöltve. Nem használunk objektumot pipeline a HuggingFace-ből, hogy figyelembe vesszük a jelenleg használt modell sorozatának korlátozását.
    • Figyelje meg, hogy modelloptimalizálásokat hajtunk végre a teljesítmény javítása érdekében a kódtárak és accelerate a kódtárak használatávaloptimum. Ha a modell vagy a hardver nem támogatja, az üzembe helyezést ilyen optimalizálás nélkül futtatjuk.
    • Egy függvényt run jelöl, amelyet a batch üzembe helyezése által biztosított mini kötegekhez hajtanak végre.
    • A run függvény a teljes köteget beolvassa a datasets kódtár használatával. Az összegezni kívánt szöveg az oszlopban texttalálható.
    • A run metódus a szöveg minden során végigfuttat, és futtatja az előrejelzést. Mivel ez egy nagyon költséges modell, az előrejelzés teljes fájlokon való futtatása memóriakivételt eredményez. Figyelje meg, hogy a modell nem fut a pipeline következő objektummal transformers: . Ez a hosszú szöveges sorozatok és az 1024-jogkivonatok korlátozásának figyelembe vételével történik a használt alapul szolgáló modellben.
    • A megadott szöveg összegzését adja vissza.

    kód/batch_driver.py

    import os
import time
import torch
import subprocess
import mlflow
from pprint import pprint
from transformers import AutoTokenizer, BartForConditionalGeneration
from optimum.bettertransformer import BetterTransformer
from datasets import load_dataset


def init():
    global model
    global tokenizer
    global device

    cuda_available = torch.cuda.is_available()
    device = "cuda" if cuda_available else "cpu"

    if cuda_available:
        print(f"[INFO] CUDA version: {torch.version.cuda}")
        print(f"[INFO] ID of current CUDA device: {torch.cuda.current_device()}")
        print("[INFO] nvidia-smi output:")
        pprint(
            subprocess.run(["nvidia-smi"], stdout=subprocess.PIPE).stdout.decode(
                "utf-8"
            )
        )
    else:
        print(
            "[WARN] CUDA acceleration is not available. This model takes hours to run on medium size data."
        )

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")

    # load the tokenizer
    tokenizer = AutoTokenizer.from_pretrained(
        model_path, truncation=True, max_length=1024
    )

    # Load the model
    try:
        model = BartForConditionalGeneration.from_pretrained(
            model_path, device_map="auto"
        )
    except Exception as e:
        print(
            f"[ERROR] Error happened when loading the model on GPU or the default device. Error: {e}"
        )
        print("[INFO] Trying on CPU.")
        model = BartForConditionalGeneration.from_pretrained(model_path)
        device = "cpu"

    # Optimize the model
    if device != "cpu":
        try:
            model = BetterTransformer.transform(model, keep_original_model=False)
            print("[INFO] BetterTransformer loaded.")
        except Exception as e:
            print(
                f"[ERROR] Error when converting to BetterTransformer. An unoptimized version of the model will be used.\n\t> {e}"
            )

    mlflow.log_param("device", device)
    mlflow.log_param("model", type(model).__name__)


def run(mini_batch):
    resultList = []

    print(f"[INFO] Reading new mini-batch of {len(mini_batch)} file(s).")
    ds = load_dataset("csv", data_files={"score": mini_batch})

    start_time = time.perf_counter()
    for idx, text in enumerate(ds["score"]["text"]):
        # perform inference
        inputs = tokenizer.batch_encode_plus(
            [text], truncation=True, padding=True, max_length=1024, return_tensors="pt"
        )
        input_ids = inputs["input_ids"].to(device)
        summary_ids = model.generate(
            input_ids, max_length=130, min_length=30, do_sample=False
        )
        summaries = tokenizer.batch_decode(
            summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
        )

        # Get results:
        resultList.append(summaries[0])
        rps = idx / (time.perf_counter() - start_time + 00000.1)
        print("Rows per second:", rps)

    mlflow.log_metric("rows_per_second", rps)
    return resultList

    Tipp.

    Bár a fájlokat az üzembe helyezés mini kötegekben biztosítja, ez a pontozó szkript egyszerre egy sort dolgoz fel. Ez egy gyakori minta drága modellek (például transzformátorok) kezelésekor, mivel a teljes köteg betöltése és a modellbe való egyidejű elküldése nagy memóriaterhelést okozhat a batch-végrehajtóra (OOM-példapéldák).

  2. Meg kell jelölnünk, hogy melyik környezetben fogjuk futtatni az üzembe helyezést. A mi esetünkben a modell fut, Torch és a kódtárakra transformersés accelerateoptimum a HuggingFace-ből van szükség. Az Azure Machine Learning már rendelkezik torch- és GPU-támogatással rendelkező környezettel. Csak néhány függőséget fogunk hozzáadni egy conda.yaml fájlhoz.

    environment/torch200-conda.yaml

    name: huggingface-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip
  - pip:
    - torch==2.0
    - transformers
    - accelerate
    - optimum
    - datasets
    - mlflow
    - azureml-mlflow
    - azureml-core
    - azureml-dataset-runtime[fuse]

  3. A korábban említett conda-fájlt az alábbiak szerint használhatjuk:

    A környezetdefiníció szerepel az üzembehelyezési fájlban.

    deployment.yml

    compute: azureml:gpu-cluster
environment:
  name: torch200-transformers-gpu
  image: mcr.microsoft.com/azureml/openmpi4.1.0-cuda11.8-cudnn8-ubuntu22.04:latest

    Fontos

    A létrehozott környezethez torch200-transformers-gpu egy CUDA 11.8-kompatibilis hardvereszközre van szükség a Torch 2.0 és az Ubuntu 20.04 futtatásához. Ha a GPU-eszköz nem támogatja a CUDA ezen verzióját, ellenőrizheti az alternatív torch113-conda.yaml conda környezetet (amely szintén elérhető az adattárban), amely a Torch 1.3-at futtatja az Ubuntu 18.04-es verzióján keresztül a CUDA 10.1-es verziójával. Ebben a konfigurációban azonban a gyorsítás és accelerate a optimum kódtárak használata nem támogatott.

  4. Minden üzembe helyezés számítási fürtökön fut. Az Azure Machine Learning Compute-fürtöket (AmlCompute) és a Kubernetes-fürtöket egyaránt támogatják. Ebben a példában a modellünk profitálhat a GPU-gyorsításból, ezért használunk GPU-fürtöt.

    az ml compute create -n gpu-cluster --type amlcompute --size STANDARD_NV6 --min-instances 0 --max-instances 2

    Feljegyzés

    A számításért ezen a ponton nem számítunk fel díjat, mivel a fürt 0 csomóponton marad, amíg meg nem hívja a batch végpontot, és el nem küld egy kötegpontozási feladatot. További információ az AmlCompute költségeinek kezeléséről és optimalizálásáról.

  5. Most hozzuk létre az üzembe helyezést.

    Ha új üzembe helyezést szeretne létrehozni a létrehozott végpont alatt, hozzon létre egy konfigurációt YAML az alábbihoz hasonlóan. További tulajdonságokat a teljes kötegelt végpont YAML-sémája is ellenőrizhet.

    deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: text-summarization-batch
name: text-summarization-optimum
description: A text summarization deployment implemented with HuggingFace and BART architecture with GPU optimization using Optimum.
type: model
model: azureml:bart-text-summarization@latest
compute: azureml:gpu-cluster
environment:
  name: torch200-transformers-gpu
  image: mcr.microsoft.com/azureml/openmpi4.1.0-cuda11.8-cudnn8-ubuntu22.04:latest
  conda_file: environment/torch200-conda.yaml
code_configuration:
  code: code
  scoring_script: batch_driver.py
resources:
  instance_count: 2
settings:
  max_concurrency_per_instance: 1
  mini_batch_size: 1
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 1
    timeout: 3000
  error_threshold: -1
  logging_level: info

    Ezután hozza létre az üzembe helyezést a következő paranccsal:

    az ml batch-deployment create --file deployment.yml --endpoint-name $ENDPOINT_NAME --set-default

    Fontos

    Ebben az üzembe helyezésben nagy értéket fog látni a paraméterben timeout retry_settings. Ennek oka a futó modell természete. Ez egy nagyon költséges modell, és egy sor következtetése akár 60 másodpercet is igénybe vehet. A timeout paraméterek azt határozzák meg, hogy mennyi ideig kell várnia a Batch üzembe helyezésének, amíg a pontozási szkript befejezi az egyes mini kötegek feldolgozását. Mivel a modell sorról sorra futtat előrejelzéseket, egy hosszú fájl feldolgozása időigényes lehet. Azt is megfigyelheti, hogy a kötegenkénti fájlok száma 1 (mini_batch_size=1). Ez ismét kapcsolódik az általunk végzett munka természetéhez. A kötegenként egyszerre egy fájl feldolgozása elég költséges ahhoz, hogy igazolja azt. Ezt az NLP-feldolgozás mintájaként fogja látni.

  6. Bár meghívhat egy adott üzembe helyezést egy végponton belül, általában magát a végpontot szeretné meghívni, és hagyja, hogy a végpont döntse el, melyik üzembe helyezést használja. Az ilyen üzembe helyezés neve "alapértelmezett" üzemelő példány. Ez lehetővé teszi az alapértelmezett üzembe helyezés megváltoztatását, és ezáltal az üzembe helyezést kiszolgáló modell módosítását anélkül, hogy módosítaná a végpontot megvevő felhasználóval kötött szerződést. Az alapértelmezett üzembe helyezés frissítéséhez használja az alábbi utasításokat:

    DEPLOYMENT_NAME="text-summarization-hfbart"
az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

  7. Ezen a ponton a kötegvégpont készen áll a használatra.

Az üzembe helyezés tesztelése

A végpont teszteléséhez a BillSum: A Corpus for Automatic Summarization of US Legislation adatkészletet fogjuk használni. Ez a minta szerepel a mappában datalévő adattárban. Figyelje meg, hogy az adatok formátuma CSV, és az összegzendő tartalom az oszlop textalatt található, a modell által elvárt módon.

  1. Hívjuk meg a végpontot:

    JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input data --input-type uri_folder --query name -o tsv)

    Feljegyzés

    Előfordulhat, hogy a segédprogram jq nem minden telepítésre telepíthető. Ebben a hivatkozásban talál útmutatást.

    Tipp.

    Figyelje meg, hogy a helyi elérési út bemenetként való megjelölésével az adatok feltölthetők az Alapértelmezett Azure Machine Learning-tárfiókba.

  2. A parancs visszatérése után azonnal elindul egy kötegelt feladat. A feladat állapotát a befejezésig figyelheti:

    az ml job show -n $JOB_NAME --web

  3. Az üzembe helyezés befejezése után letöltheti az előrejelzéseket:

    Az előrejelzések letöltéséhez használja a következő parancsot:

    az ml job download --name $JOB_NAME --output-name score --download-path .

Szövegeket feldolgozó modellek üzembe helyezésekor megfontolandó szempontok

Ahogy az oktatóanyag néhány megjegyzésében is említettük, a szöveg feldolgozása bizonyos sajátosságokkal rendelkezhet, amelyek a kötegelt üzembe helyezéshez speciális konfigurációt igényelnek. A kötegtelepítés tervezésekor vegye figyelembe az alábbi szempontokat:

  • Egyes NLP-modellek memória és számítási idő szempontjából nagyon költségesek lehetnek. Ha ez a helyzet, fontolja meg az egyes mini kötegeken található fájlok számának csökkentését. A fenti példában a számot kötegenként legalább 1 fájlra vettük fel. Bár lehet, hogy ez nem az Ön esete, vegye figyelembe, hogy a modell hány fájlt képes pontszámot adni minden alkalommal. Ne feledje, hogy a bemenet mérete és a modell memóriaigénye közötti kapcsolat nem feltétlenül lineáris a mélytanulási modellek esetében.
  • Ha a modell nem is tud egyszerre egy fájlt kezelni (például ebben a példában), érdemes lehet sorba/adattömbbe beolvasni a bemeneti adatokat. Ha nagyobb átviteli sebességet vagy hardverkihasználtságot szeretne elérni, akkor a sorok szintjén implementálhatja a kötegelést.
  • Állítsa be az timeout üzembe helyezés értékét a modell költségének és a várhatóan feldolgozandó adatok számának megfelelően. Ne feledje, hogy a timeout köteg üzembe helyezési ideje azt jelzi, hogy a pontozószkript mikor fut egy adott kötegre. Ha a köteg számos fájllal vagy fájllal rendelkezik, amely sok sort tartalmaz, ez hatással van ennek a paraméternek a megfelelő értékére.

A szöveget feldolgozó MLflow-modellek szempontjai

A fent említett szempontok az MLflow-modellekre is érvényesek. Mivel azonban nem kell pontozószkriptet megadnia az MLflow-modell üzembe helyezéséhez, az említett javaslatok némelyike más megközelítést igényelhet.

  • A Batch-végpontok MLflow-modelljei támogatják a táblázatos adatok bemeneti adatokként való olvasását, amelyek hosszú szöveges sorozatokat tartalmazhatnak. A támogatott fájltípusokról további információt a Fájltípusok támogatása című témakörben talál.
  • A Batch-üzemelő példányok meghívják az MLflow-modell előrejelzési függvényét egy teljes fájl tartalmával Pandas-adatkeretként. Ha a bemeneti adatok sok sort tartalmaznak, valószínű, hogy egy összetett modell futtatása (például az oktatóanyagban bemutatott) memóriakivételt eredményez. Ha ez a helyzet, megfontolhatja a következő szempontokat: