Für große Sprachmodelle (LLMs) optimierte Modellbereitstellung

Wichtig

Dieses Feature befindet sich in der Public Preview.

Wichtig

Die Codebeispiele in diesem Leitfaden verwenden veraltete APIs. Databricks empfiehlt, für die optimierte Inferenz mit LLMs die Funktion provisioned throughput zu verwenden. Weiter Informationen finden Sie unter Migration von optimierten LLM-Serving-Endpunkten zu bereitgestelltem Durchsatz.

In diesem Artikel wird veranschaulicht, wie Optimierungen für große Sprachmodelle (LLMs) für Model Serving aktiviert werden.

Die optimierte Bereitstellung von LLMs bietet im Vergleich zu traditionellen Bereitstellungsansätzen Verbesserungen bei Durchsatz und Latenz um den Faktor 3 bis 5. In der folgenden Tabelle sind die unterstützten LLM-Familien und ihre Varianten zusammengefasst.

Databricks empfiehlt die Installation von Basismodellen über Databricks Marketplace. Sie können nach einer Modellfamilie suchen, auf der Seite mit den Modellen Zugriff abrufen auswählen und Anmeldeinformationen angeben, um das Modell in Unity Catalog zu installieren.

Modellfamilie Installieren über Marketplace
Llama 2 Llama 2-Modelle
MPT
Mistral Mistral-Modelle

Anforderungen

  • Die optimierte Bereitstellung von LLMs wird im Rahmen der öffentlichen Vorschau von GPU-Bereitstellungen unterstützt.

  • Ihr Modell muss mit MLflow 2.4 oder höher bzw. mit Databricks Runtime 13.2 ML oder höher protokolliert werden.

  • Bei der Bereitstellung von Modellen ist es wichtig, die Parametergröße Ihres Modells mit der entsprechenden Berechnungsgröße abzugleichen. Wenden Sie sich für Modelle mit 50 Milliarden oder mehr Parametern an Ihr Azure Databricks-Kundenberatungsteam, um auf die erforderlichen GPUs zuzugreifen.

    Modellparametergröße Empfohlene Computegröße Workload-Typ
    7 Milliarden 1xA100 GPU_LARGE
    13 Milliarden 1xA100 GPU_LARGE
    30–34 Milliarden 1xA100 GPU_LARGE
    70 Milliarden 2xA100 GPU_LARGE_2

Protokollieren Ihres großen Sprachmodells

Protokollieren Sie zunächst Ihr Modell mit der transformers-Variante von MLflow, und geben Sie das Aufgabenfeld in den MLflow-Metadaten mit metadata = {"task": "llm/v1/completions"} an. Dadurch wird die API-Signatur angegeben, die für den Modellbereitstellungsendpunkt verwendet wird.

Die optimierte LLM-Bereitstellung ist mit den von Azure Databricks AI Gateway unterstützten Routentypen kompatibel; derzeit llm/v1/completions. Wenn Sie Modellfamilien oder Aufgabentypen bereitstellen möchten, die nicht unterstützt werden, wenden Sie sich an Ihr Azure Databricks-Kundenberatungsteam.

model = AutoModelForCausalLM.from_pretrained("mosaicml/mpt-7b-instruct",torch_dtype=torch.bfloat16, trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b-instruct")
with mlflow.start_run():
    components = {
        "model": model,
        "tokenizer": tokenizer,
    }
    mlflow.transformers.log_model(
        artifact_path="model",
        transformers_model=components,
        input_example=["Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\nWhat is Apache Spark?\n\n### Response:\n"],
        metadata={"task": "llm/v1/completions"},
        registered_model_name='mpt'
    )

Nach dem Protokollieren Ihr Modells können Sie es in Unity Catalog folgendermaßen registrieren, indem Sie CATALOG.SCHEMA.MODEL_NAME durch den Namen für die drei Ebenen des Modells ersetzen.


mlflow.set_registry_uri("databricks-uc")

registered_model_name=CATALOG.SCHEMA.MODEL_NAME

Erstellen Sie Ihren Endpunkt für die Modellbereitstellung

Erstellen Sie als Nächstes Ihren Endpunkt für die Modellbereitstellung. Wenn Ihr Modell von der für LLMs optimierten Modellbereitstellung unterstützt wird, erstellt Azure Databricks automatisch einen Endpunkt für die optimierte Modellbereitstellung, sobald Sie das Modell bereitstellen.

import requests
import json

# Set the name of the MLflow endpoint
endpoint_name = "llama2-3b-chat"

# Name of the registered MLflow model
model_name = "ml.llm-catalog.llama-13b"

# Get the latest version of the MLflow model
model_version = 3

# Specify the type of compute (CPU, GPU_SMALL, GPU_LARGE, etc.)
workload_type = "GPU_LARGE"

# Specify the scale-out size of compute (Small, Medium, Large, etc.)
workload_size = "Small"

# Specify Scale to Zero (only supported for CPU endpoints)
scale_to_zero = False

# Get the API endpoint and token for the current notebook context
API_ROOT = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiUrl().get()
API_TOKEN = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiToken().get()

# send the POST request to create the serving endpoint

data = {
    "name": endpoint_name,
    "config": {
        "served_models": [
            {
                "model_name": model_name,
                "model_version": model_version,
                "workload_size": workload_size,
                "scale_to_zero_enabled": scale_to_zero,
                "workload_type": workload_type,
            }
        ]
    },
}

headers = {"Context-Type": "text/json", "Authorization": f"Bearer {API_TOKEN}"}

response = requests.post(
    url=f"{API_ROOT}/api/2.0/serving-endpoints", json=data, headers=headers
)

print(json.dumps(response.json(), indent=4))

Format des Ein- und Ausgabeschemas

Ein optimierter LLM-Dienstendpunkt verfügt über ein Ein- und Ausgabeschema, das von Azure Databricks gesteuert wird. Es werden vier Formate unterstützt.

  • dataframe_split ist ein JSON-serialisierter Pandas-Dataframe in der split-Ausrichtung.

    {
  "dataframe_split": {
    "columns": ["prompt"],
    "index": [0],
    "data": [
      [
        "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"
      ]
    ]
  },
  "params": {
    "temperature": 0.5,
    "max_tokens": 100,
    "stop": ["word1", "word2"],
    "candidate_count": 1
  }
}

  • dataframe_records ist ein JSON-serialisierter Pandas-Dataframe in der records-Ausrichtung.

    {
  "dataframe_records": [
    {
      "prompt": "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"
    }
  ],
  "params": {
    "temperature": 0.5,
    "max_tokens": 100,
    "stop": ["word1", "word2"],
    "candidate_count": 1
  }
}

  • Beispiele

    {
  "instances": [
    {
      "prompt": "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"
    }
  ],
  "params": {
    "temperature": 0.5,
    "max_tokens": 100,
    "stop": ["word1", "word2"],
    "candidate_count": 1
  }
}

  • Eingaben

    {
  "inputs": {
    "prompt": "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"
  },
  "params": {
    "temperature": 0.5,
    "max_tokens": 100,
    "stop": ["word1", "word2"],
    "candidate_count": 1
  }
}

Endpunkt abfragen

Sobald Ihr Endpunkt einsatzbereit ist, können Sie ihn über eine API-Anforderung abfragen. Je nach Größe und Komplexität des Modells kann es 30 Minuten oder länger dauern, bis der Endpunkt bereit ist.


data = {
    "inputs": {
        "prompt": [
            "Hello, I'm a language model,"
        ]
    },
    "params": {
        "max_tokens": 100,
        "temperature": 0.0
    }
}

headers = {"Context-Type": "text/json", "Authorization": f"Bearer {API_TOKEN}"}

response = requests.post(
    url=f"{API_ROOT}/serving-endpoints/{endpoint_name}/invocations", json=data, headers=headers
)

print(json.dumps(response.json()))

Begrenzungen

  • Das Erstellen von Containerimages für GPU-Bereitstellungen dauert aufgrund der erhöhten Installationsanforderungen für Modelle, die auf der GPU bereitgestellt werden, länger als die Erstellung von Images für CPU-Bereitstellungen.
    • Die Modellgröße wirkt sich auch auf die Erstellung von Images aus. Beispielsweise kann das Erstellen von Modellen mit 30 Milliarden Parametern oder mehr mindestens eine Stunde dauern.
    • Databricks verwendet den gleichen Container bei der nächsten Bereitstellung derselben Version des Modells wieder, sodass nachfolgende Bereitstellungen weniger Zeit in Anspruch nehmen.
  • Die automatische Skalierung dauert für GPU-Bereitstellungen länger als für CPU-Bereitstellungen. Das liegt an der erhöhten Einrichtungsdauer für Modelle, die mit GPU-Computeressourcen bereitgestellt werden. Databricks empfiehlt eine Überprovisionierung, um Timeouts bei Anfragen zu vermeiden.
  • Last updated on