Service optimisé de modèle de langage étendu (LLM)

Important

Cette fonctionnalité est disponible en préversion publique.

Important

Les exemples de code de ce guide utilisent des API déconseillées. Databricks recommande d’utiliser le mode débit provisionné pour optimiser l’inférence des grands modèles de langage (LLM). Consultez Migrer des points de terminaison de service LLM optimisés vers un débit provisionné.

Cet article montre comment activer les optimisations pour les modèles de langage volumineux (LLMs) sur le service de modèle.

Le Service optimisé de modèle de langage étendu (LLM) offre des améliorations du débit et de la latence de l’ordre de 3 à 5 fois supérieures par rapport aux approches de service traditionnelles. Le tableau suivant récapitule les familles LLM prises en charge et leurs variantes.

Databricks recommande d’installer des modèles de base à l’aide de la Place de marché Databricks. Vous pouvez rechercher une famille de modèles. Ensuite, dans la page du modèle, sélectionnez Obtenir l’accès et indiquez les informations d’identification de connexion pour installer le modèle dans Unity Catalog.

Famille de modèles Installer à partir de la Place de marché
Llama 2 Modèles Llama 2
MPT
Mistral Modèles Mistral

Spécifications

  • Le service LLM optimisé est pris en charge dans le cadre de l'aperçu public des déploiements GPU.

  • Votre modèle doit être journalisé à l’aide de MLflow 2.4 et versions ultérieures ou de Databricks Runtime 13.2 ML et versions ultérieures.

  • Lors du déploiement de modèles, il est essentiel de faire correspondre la taille de paramètre de votre modèle à la taille de calcul appropriée. Pour les modèles comportant 50 milliards de paramètres ou plus, veuillez contacter l’équipe de votre compte Azure Databricks pour accéder aux GPU nécessaires.

    Taille des paramètres du modèle Taille de calcul recommandée Type de charge de travail
    7 milliards 1xA100 GPU_LARGE
    13 milliards 1xA100 GPU_LARGE
    30-34 milliards 1xA100 GPU_LARGE
    70 milliards 2xA100 GPU_LARGE_2

Consigner votre grand modèle de langage

Pour commencer, connectez votre modèle avec la saveur MLflow transformers et spécifiez le champ de tâche dans les métadonnées MLflow avec metadata = {"task": "llm/v1/completions"}. Cela permet de spécifier la signature d’API utilisée pour le point de terminaison de mise en service de modèle.

Le service LLM optimisé est compatible avec les types de routes pris en charge par Azure Databricks AI Gateway ; actuellement, llm/v1/completions. Si une famille de modèles ou un type de tâche que vous souhaitez servir n’est pas pris en charge, contactez l’équipe de votre compte Azure Databricks.

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'
    )

Une fois votre modèle journalisé, vous pouvez inscrire vos modèles dans Unity Catalog avec les éléments suivants, en remplaçant CATALOG.SCHEMA.MODEL_NAME par le nom à trois niveaux du modèle.


mlflow.set_registry_uri("databricks-uc")

registered_model_name=CATALOG.SCHEMA.MODEL_NAME

Créer votre point de terminaison d’inférence de modèle

Ensuite, créez votre point de terminaison d’inférence du modèle. Si votre modèle est pris en charge par le service LLM optimisé, Azure Databricks crée automatiquement un point de terminaison de service de modèle optimisé lorsque vous essayez de le servir.

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 de schéma d’entrée et de sortie

Un point de terminaison de mise en service LLM optimisé dispose de schémas d’entrée et de sortie contrôlés par Azure Databricks. Quatre formats différents sont pris en charge.

  • dataframe_split est un dataframe Pandas sérialisé au format JSON dans l’orientation split .

    {
  "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 est un dataframe Pandas sérialisé au format JSON dans l’orientation records .

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

  • Cas

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

  • entrées

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

Interrogez votre point de terminaison

Quand votre point de terminaison est prêt, vous pouvez l’interroger au moyen d’une requête d’API. Selon la taille et la complexité du modèle, le point de terminaison peut prendre 30 minutes ou plus pour être prêt.


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()))

Limites

  • Compte tenu des exigences d’installation plus importantes pour les modèles exécutés sur GPU, la création d’images de conteneur pour l’exécution sur GPU prend plus de temps que la création d’images de conteneur pour l’exécution sur CPU.
    • La taille du modèle a également un impact sur la création d’images. Par exemple, la génération de modèles comprenant 30 milliards de paramètres ou plus peut prendre au moins une heure.
    • Databricks réutilise le même conteneur la prochaine fois que la même version du modèle est déployée. De cette façon, les déploiements suivants prennent moins de temps.
  • La mise à l’échelle automatique pour la mise en service à l’aide de GPU prend plus de temps que pour la mise en service à l’aide de processeurs. Cela s’explique par une augmentation du temps de configuration pour les modèles servis sur des calculs GPU. Databricks recommande le surapprovisionnement pour éviter les expirations des délais d’attente des requêtes.
  • Last updated on