Freigeben über

Bereitstellen von Sprachmodellen in Batchendpunkten

GILT FÜR:Azure CLI ML-Erweiterung v2 (aktuell)Python-SDK azure-ai-ml v2 (aktuell)

Batchendpunkte können verwendet werden, um teure Modelle wie Sprachmodelle über Textdaten bereitzustellen. In diesem Tutorial erfahren Sie, wie Sie ein Modell bereitstellen, das Textzusammenfassungen langer Textsequenzen mithilfe eines Modells von HuggingFace erstellen kann. Außerdem wird gezeigt, wie Sie Rückschlüsse mithilfe von HuggingFace optimum und accelerate-Bibliotheken durchführen.

Informationen zu diesem Beispiel

Das Modell, mit dem wir arbeiten werden, wurde mit den beliebten Bibliothekstransformatoren von HuggingFace zusammen mit einem vortrainierten Modell von Facebook mit der BART-Architektur gebaut. Es wurde im folgenden Whitepaper eingeführt: BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation. Dieses Modell weist die folgenden Einschränkungen auf, die bei der Implementierung beachtet werden müssen:

  • Sie kann mit Sequenzen bis zu 1.024 Token arbeiten.
  • Es ist für die Zusammenfassung von Text in Englisch trainiert.
  • Wir werden Torch als Back-End verwenden.

Das Beispiel in diesem Artikel basiert auf Codebeispielen, die im Repository azureml-examples enthalten sind. Wenn Sie die Befehle lokal ausführen möchten, ohne YAML und andere Dateien kopieren oder einfügen zu müssen, verwenden Sie die folgenden Befehle, um das Repository zu klonen und zum Ordner für Ihre Programmiersprache zu wechseln:

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

Die Dateien für dieses Beispiel befinden sich in:

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

Folgen in Jupyter Notebooks

Sie können diesem Beispiel in einer Jupyter Notebook-Instanz nachspielen. Öffnen Sie in dem geklonten Repository folgendes Notebook: text-summarization-batch.ipynb.

Voraussetzungen

  • Ein Azure-Abonnement. Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

  • Ein Azure Machine Learning-Arbeitsbereich. Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Verwalten von Azure Machine Learning-Arbeitsbereichen.

  • Die folgenden Berechtigungen im Azure Machine Learning-Arbeitsbereich:

    • Zum Erstellen oder Verwalten von Batchendpunkten und Bereitstellungen: Verwenden Sie die Rolle „Besitzer“ oder „Mitwirkender“ oder eine benutzerdefinierte Rolle, der die Microsoft.MachineLearningServices/workspaces/batchEndpoints/*-Berechtigungen zugewiesen wurden.
    • Zum Erstellen von Azure Resource Manager-Bereitstellungen in der Arbeitsbereichsressourcengruppe: Verwenden Sie die Rolle „Besitzer“ oder „Mitwirkender“ oder eine benutzerdefinierte Rolle, der die Microsoft.Resources/deployments/write-Berechtigung in der Ressourcengruppe zugewiesen wurde, in der der Arbeitsbereich bereitgestellt wird.

  • Azure Machine Learning-CLI oder Azure Machine Learning-SDK für Python:

    Führen Sie den folgenden Befehl aus, um die Azure CLI und die ml-Erweiterung für Azure Machine Learning zu installieren:

    az extension add -n ml

    Bereitstellungen der Pipelinekomponenten für Batchendpunkte werden in Version 2.7 der ml-Erweiterung für die Azure CLI eingeführt. Verwenden Sie den az extension update --name ml-Befehl, um die aktuelle Version abzurufen.

Herstellen einer Verbindung mit Ihrem Arbeitsbereich

Der Arbeitsbereich ist die Ressource der obersten Ebene für Azure Machine Learning. Er bietet einen zentralen Ort für die Arbeit mit allen Artefakten, die Sie bei der Verwendung von Azure Machine Learning erstellen. In diesem Abschnitt stellen Sie eine Verbindung mit dem Arbeitsbereich her, in dem Sie Ihre Bereitstellungsaufgaben durchführen.

Geben Sie im folgenden Befehl Ihre Abonnement-ID, den Arbeitsbereichsnamen, den Ressourcengruppennamen und den Standort ein:

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

Registrieren des Modells

Aufgrund der Größe des Modells ist es in diesem Repository nicht enthalten. Stattdessen können Sie eine Kopie vom Hub des HuggingFace-Modells herunterladen. Sie benötigen die Pakete transformers und torch installiert in der Umgebung, die Sie verwenden.

%pip install transformers torch

Verwenden Sie den folgenden Code, um das Modell in einen model-Ordner herunterzuladen:

from transformers import pipeline

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

Wir können dieses Modell jetzt in der Azure Machine Learning-Registrierung registrieren:

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

Erstellen des Endpunkts

Wir erstellen einen Batchendpunkt mit dem Namen text-summarization-batch , an dem das HuggingFace-Modell bereitgestellt wird, um Textzusammenfassungen für Textdateien in Englisch auszuführen.

  1. Entscheiden Sie sich für den Namen des Endpunkts. Der Name des Endpunkts wird in dem URI angezeigt, der Ihrem Endpunkt zugeordnet ist. Daher müssen die Namen der Batchendpunkte innerhalb einer Azure-Region eindeutig sein. Beispielsweise kann es nur einen Endpunkt namens mybatchendpoint in westus2 geben.

    In diesem Fall platzieren wir den Namen des Endpunkts in einer Variable, damit wir später problemlos darauf verweisen können.

    ENDPOINT_NAME="text-summarization-batch"

  2. Konfigurieren Ihres Batchendpunkts

    Die folgende YAML-Datei definiert einen Batchendpunkt:

    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. Erstellen des Endpunkts:

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

Erstellen der Bereitstellung

Erstellen wir die Bereitstellung, die das Modell hosten soll:

  1. Wir müssen ein Bewertungsskript erstellen, das die von der Batchbereitstellung bereitgestellten CSV-Dateien lesen und die Bewertungen des Modells mit der Zusammenfassung zurückgeben kann. Mit diesem Skript werden die folgenden Aktionen ausgeführt:

    • Zeigt eine init-Funktion an, die die Hardwarekonfiguration (CPU im Vergleich zur GPU) erkennt und das Modell entsprechend lädt. Sowohl das Modell als auch der Tokenizer werden in globalen Variablen geladen. Wir verwenden kein pipeline-Objekt von HuggingFace, um die Einschränkung in den Sequenzlängen des derzeit verwendeten Modells zu berücksichtigen.
    • Beachten Sie, dass wir Modelloptimierungen durchführen, um die Leistung mithilfe von optimum- sowie accelerate-Bibliotheken zu verbessern. Wenn das Modell oder die Hardware dies nicht unterstützen, führen wir die Bereitstellung ohne solche Optimierungen aus.
    • Gibt eine run-Funktion an, die für jeden Minibatch ausgeführt wird, den die Batchbereitstellung bereitstellt.
    • Die run-Funktion liest den gesamten Batch mithilfe der datasets-Bibliothek. Der Text, den wir zusammenfassen müssen, befindet sich in der Spalte text.
    • Die run-Methode durchläuft alle Zeilen des Texts und führt die Vorhersage aus. Da dies ein sehr teures Modell ist, führt das Ausführen der Vorhersage über sämtliche Dateien zu einer Ausnahme aufgrund ungenügenden Arbeitsspeichers. Beachten Sie, dass das Modell nicht mit dem pipeline-Objekt aus transformers ausgeführt wird. Dies geschieht, um lange Textsequenzen und die Einschränkung von 1.024 Token im zugrunde liegenden Modell zu berücksichtigen.
    • Es gibt die Zusammenfassung des bereitgestellten Texts zurück.

    code/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

    Obwohl die Dateien von der Bereitstellung in Minibatches zur Verfügung gestellt werden, verarbeitet dieses Bewertungsskript eine Zeile nach der anderen. Dies ist ein gängiges Muster beim Umgang mit teuren Modellen (z. B. Transformatoren), da der Versuch, den gesamten Batch zu laden und es gleichzeitig an das Modell zu senden, zu einem hohen Speicherdruck für den Batchausführer führen kann (OOM-Ausnahmen).

  2. Wir müssen angeben, über welche Umgebung wir die Bereitstellung ausführen werden. In unserem Fall wird unser Modell auf Torch ausgeführt und erfordert die Bibliotheken transformers, accelerate und optimum von HuggingFace. Azure Machine Learning verfügt bereits über eine verfügbare Umgebung mit Torch- und GPU-Unterstützung. Wir werden nur ein paar Abhängigkeiten in einer conda.yaml Datei hinzufügen.

    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. Wir können die zuvor erwähnte Conda-Datei wie folgt verwenden:

    Die Umgebungsdefinition wird in die Bereitstellungsdatei aufgenommen.

    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

    Wichtig

    Die von uns erstellte Umgebung torch200-transformers-gpu erfordert ein CUDA 11.8-kompatibles Hardwaregerät, um Torch 2.0 und Ubuntu 20.04 auszuführen. Wenn Ihr GPU-Gerät diese Version von CUDA nicht unterstützt, können Sie die alternative Conda-Umgebung torch113-conda.yaml (auch im Repository verfügbar) überprüfen, in der Torch 1.3 über Ubuntu 18.04 mit CUDA 10.1 ausgeführt wird. Die Beschleunigung mithilfe der optimum Und accelerate Bibliotheken wird jedoch in dieser Konfiguration nicht unterstützt.

  4. Jede Bereitstellung wird auf Computeclustern ausgeführt. Sie unterstützen sowohl Azure Machine Learning Compute-Cluster (AmlCompute) als auch Kubernetes-Cluster. In diesem Beispiel kann unser Modell von der GPU-Beschleunigung profitieren, weshalb wir einen GPU-Cluster verwenden.

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

    Hinweis

    Zu diesem Zeitpunkt werden Ihnen noch keine Computeressourcen in Rechnung gestellt, da der Cluster bei null Knoten verbleibt, bis ein Batchendpunkt aufgerufen und ein Batchbewertungsauftrag übermittelt wird. Erfahren Sie mehr über das Verwalten und Optimieren von Kosten für AmlCompute.

  5. Erstellen wir nun die Bereitstellung.

    Um eine neue Bereitstellung unter dem erstellten Endpunkt zu erstellen, erstellen Sie eine YAML-Konfiguration wie die folgende. Sie können das vollständige YAML-Schema des Batchendpunkts auf zusätzliche Eigenschaften überprüfen.

    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

    Erstellen Sie dann die Bereitstellung mit dem folgenden Befehl:

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

    Wichtig

    In dieser Bereitstellung wird ein hoher Wert im timeout im Parameter retry_settings angezeigt. Der Grund ist die Art des Modells, das wir ausführen. Dies ist ein sehr teures Modell, und die Rückschlüsse auf eine einzelne Zeile können bis zu 60 Sekunden dauern. Der timeout Parameter steuert, wie viel Zeit die Batchbereitstellung warten soll, bis das Bewertungsskript die Verarbeitung der einzelnen Minibatches abgeschlossen hat. Da unser Modell Vorhersagen zeileweise ausführt, kann die Verarbeitung einer langen Datei Zeit in Anspruch nehmen. Beachten Sie auch, dass die Anzahl der Dateien pro Batch auf 1 (mini_batch_size=1) festgelegt ist. Dies hängt erneut mit der Art der Arbeit zusammen, die wir tun. Die Verarbeitung einer Datei pro Batch ist teuer genug, um sie zu rechtfertigen. Sie werden feststellen, dass dies ein Muster bei der NLP-Verarbeitung ist.

  6. Sie können zwar eine bestimmte Bereitstellung innerhalb eines Endpunkts aufrufen, in der Regel rufen Sie jedoch den Endpunkt selbst auf und überlassen diesem die Entscheidung, welche Bereitstellung verwendet werden soll. Eine derartige Bereitstellung wird als "Standard"-Bereitstellung bezeichnet. Dadurch erhalten Sie die Möglichkeit, die Standardbereitstellung und somit das Modell für die Bereitstellung zu ändern, ohne den Vertrag mit dem Benutzer ändern zu müssen, der den Endpunkt aufruft. Verwenden Sie die folgende Anweisung, um die Standardbereitstellung zu aktualisieren:

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

  7. An diesem Punkt ist unser Batch-Endpunkt zur Verwendung bereit.

Testen der Bereitstellung

Zum Testen unseres Endpunkts verwenden wir ein Beispiel aus dem Datensatz BillSum: A Corpus for Automatic Summarization of US Legislation. Dieses Beispiel ist im Repository im Ordner data enthalten. Beachten Sie, dass das Format der Daten CSV ist und dass sich der zusammenzufassende Inhalt, wie vom Modell erwartet, in der Spalte text befindet.

  1. Rufen wir den Endpunkt auf:

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

    Hinweis

    Das Hilfsprogramm jq wird möglicherweise nicht bei jeder Installation installiert. Anweisungen erhalten Sie unter diesem Link.

    Tipp

    Beachten Sie, dass die Daten durch Angabe eines lokalen Pfads als Eingabe in das Standardspeicherkonto von Azure Machine Learning hochgeladen werden.

  2. Ein Batchauftrag wird gestartet, sobald der Befehl zurückgegeben wird. Sie können den Status des Auftrags überwachen, bis er abgeschlossen ist:

    az ml job show -n $JOB_NAME --web

  3. Nachdem die Bereitstellung abgeschlossen wurde, können wir die Vorhersagen herunterladen:

    Verwenden Sie den folgenden Befehl, um die Vorhersagen herunterzuladen:

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

Überlegungen beim Bereitstellen von Textverarbeitungsmodellen

Wie in einigen Der Notizen in diesem Lernprogramm erwähnt, kann die Verarbeitung von Text einige Besonderheiten aufweisen, die eine bestimmte Konfiguration für Batchbereitstellungen erfordern. Berücksichtigen Sie beim Gestalten der Batchbereitstellung Folgendes:

  • Einige NLP-Modelle können in Bezug auf Arbeitsspeicher und Computezeit sehr teuer sein. Wenn dies der Fall ist, verringern Sie die Anzahl der Dateien, die in jedem Minibatch enthalten sind. Im vorherigen Beispiel wurde die Zahl auf das Minimum reduziert: 1 Datei pro Batch. Auch wenn dies bei Ihnen möglicherweise nicht der Fall ist, berücksichtigen Sie jedoch, wie viele Dateien Ihr Modell jedes Mal bewerten kann. Denken Sie daran, dass die Beziehung zwischen der Größe der Eingabe und dem Speicherbedarf Ihres Modells bei Deep Learning-Modellen möglicherweise nicht linear ist.
  • Wenn Ihr Modell nicht einmal eine Datei auf einmal verarbeiten kann (wie in diesem Beispiel), sollten Sie die Eingabedaten in Zeilen/Blöcken einlesen. Implementieren Sie die Batchverarbeitung auf Zeilenebene, wenn Sie einen höheren Durchsatz oder eine höhere Hardwareauslastung erzielen müssen.
  • Legen Sie den timeout-Wert Ihrer Bereitstellung entsprechend der Kosten Ihres Modells und der Datenmenge fest, die Sie verarbeiten möchten. Denken Sie daran, dass timeout angibt, wie lange die Batchbereitstellung warten würde, bis das Bewertungsskript für einen bestimmten Batch ausgeführt wird. Wenn Ihr Batch viele Dateien oder Dateien mit vielen Zeilen enthält, wirkt sich dies auf den Wert dieses Parameters aus.

Überlegungen zu MLflow-Modellen, die Text verarbeiten

Die gleichen Überlegungen, die weiter oben erwähnt wurden, gelten für MLflow-Modelle. Da Sie jedoch kein Bewertungsskript für Ihre MLflow-Modellbereitstellung bereitstellen müssen, benötigen einige der genannten Empfehlungen möglicherweise einen anderen Ansatz.

  • MLflow-Modelle in Batchendpunkten unterstützen das Lesen tabellarischer Daten als Eingabedaten, die lange Textsequenzen enthalten können. Weitere Informationen zu den unterstützten Dateitypen finden Sie unter Unterstützung von Dateitypen.
  • Batchbereitstellungen rufen die Vorhersagefunktion Ihres MLflow-Modells mit dem Inhalt einer gesamten Datei als Pandas-Datenrahmen auf. Wenn Ihre Eingabedaten viele Zeilen enthalten, besteht die Wahrscheinlichkeit, dass die Ausführung eines komplexen Modells (wie in diesem Tutorial dargestellt) zu einer Ausnahme wegen unzureichenden Arbeitsspeichers führt. Ist dies bei Ihnen der Fall, können Sie dies in Betracht ziehen:
    • Passen Sie an, wie Ihr Modell Vorhersagen ausführt, und implementieren Sie Batchverarbeitung. Informationen zum Anpassen der Ableitung des MLflow-Modells finden Sie unter Log custom models.
    • Erstellen Sie ein Bewertungsskript, und laden Sie Ihr Modell mit mlflow.<flavor>.load_model(). Details finden Sie unter Verwenden von MLflow-Modellen mit einem Bewertungsskript.
  • Last updated on