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

In diesem Artikel wird beschrieben, wie Sie die Optimierungen für große Sprachmodelle (LLMs) für Mosaic AI Model Serving aktivieren.

Die für LLMs optimierte Modellimplementierung bietet eine Verbesserung des Durchsatzes und der Latenz um das Drei- bis Fünffache im Vergleich zu herkömmlichen Bereitstellungsansätzen. 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.

Anforderungen

• Die für LLMs optimierte Modellbereitstellung wird als Teil der Public Preview von GPU-Bereitstellungen unterstützt.

• Ihr Modell muss mit MLflow 2.4 und höher oder Databricks Runtime 13.2 for Machine Learning und höher protokolliert werden.

• Bei der Bereitstellung von Modellen ist es wichtig, dass die Parametergröße Ihres Modells mit der entsprechenden Computegröße übereinstimmt. 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	Workloadtyp
  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 für LLMs optimierte Modellbereitstellung ist mit den Routentypen kompatibel, die von Azure Databricks AI Gateway unterstützt werden; 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 Ihres Modellbereitstellungsendpunkts

Erstellen Sie als Nächstes Ihren Modellbereitstellungsendpunkt. 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
    }
  }
  

• instances

  {
    "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
    }
  }
  

• inputs

  
  {
    "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
    }
  }
  

Abfragen Ihres Endpunkts

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. Für Databricks wird eine Überbereitstellung empfohlen, um Timeouts bei Anforderungen zu vermeiden.