Diffusion optimisée de grands modèles de langage (LLM)

info

Aperçu

Cette fonctionnalité est en aperçu public.

important

Les exemples de code dans ce guide utilisent des APIs obsolètes. Databricks recommande d'utiliser l'expérience throughput provisionné pour l'inférence optimisée des LLM. Voir Migrer des endpoints de service LLM optimisés vers un throughput provisionné.

Cet article explique comment activer les optimisations pour les grands modèles de langage (LLM) sur Model Serving.

Le service LLM optimisé améliore le throughput et la latence d'un facteur 3 à 5 par rapport aux approches de service traditionnelles. Le tableau suivant résume les familles de LLM prises en charge et leurs variantes.

Databricks recommande d'installer les modèles de fondation à l'aide de Databricks Marketplace. Vous pouvez rechercher une famille de modèles et, depuis la page du modèle, sélectionner Obtenir l'accès et fournir les informations d'identification pour installer le modèle dans Unity Catalog.

Famille de modèles	Installer depuis la marketplace
Llama 2	Modèles Llama 2
MPT
Mistral	Modèles Mistral

Exigences

Le service LLM optimisé est pris en charge dans le cadre de la préversion publique des déploiements GPU.
Votre modèle doit être enregistré à l’aide de MLflow 2,4 et versions supérieures ou de Databricks Runtime 13,2 ML et versions supérieures.
Databricks recommande d'utiliser des modèles dans Unity Catalog pour un upload et un download plus rapides des modèles volumineux.

Lors du déploiement de modèles, il est essentiel de faire correspondre la taille du parameter de votre modèle avec la taille de compute appropriée. Voir le tableau ci-dessous pour les recommandations. Pour les modèles avec 50 milliards de parameters ou plus, veuillez contacter votre équipe de compte Databricks pour accéder aux GPU nécessaires.

Taille du paramètre de modèle	Taille de compute recommandée	Type de GPU
7 milliards	1xA10	`GPU_MEDIUM`
13 milliards	4xA10	`MULTIGPU_MEDIUM`
De 30 à 34 milliards	4xA10	`MULTIGPU_MEDIUM`
70 milliards	8xA10 ou 8xA100	`GPU_MEDIUM_8` OU `GPU_LARGE_8`

Taille du paramètre de modèle	Taille de compute recommandée	Type de GPU
7 milliards	1xA10	`GPU_MEDIUM`
13 milliards	4xA10	`MULTIGPU_MEDIUM`
De 30 à 34 milliards	4xA10	`MULTIGPU_MEDIUM`
70 milliards	8xA10 ou 8xA100	`GPU_MEDIUM_8` OU `GPU_LARGE_8`

Journalisez votre grand modèle linguistique

Tout d'abord, enregistrez votre modèle avec le *flavor* MLflow transformers et spécifiez le champ de tâche dans les métadonnées MLflow avec metadata = {"task": "llm/v1/completions"}. Ceci spécifie la signature de l'API utilisée pour l'endpoint de service de modèle.

Le service LLM optimisé est compatible avec les types de routes pris en charge par Databricks AI Gateway ; actuellement, llm/v1/completions. S'il existe une famille de modèles ou un type de tâche que vous souhaitez déployer et qui n'est pas pris en charge, contactez votre équipe de compte Databricks.

Python
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={&quot;task&quot;: &quot;llm/v1/completions&quot;},
        registered_model_name='mpt'
    )

Une fois votre modèle enregistré, vous pouvez enregistrer vos modèles dans Unity Catalog en remplaçant CATALOG.SCHEMA.MODEL_NAME par le nom à trois niveaux du modèle.

Python

mlflow.set_registry_uri("databricks-uc")

registered_model_name=CATALOG.SCHEMA.MODEL_NAME

Créez votre endpoint de service de modèle

Ensuite, créez votre endpoint de service de modèle. Si votre modèle est pris en charge par le service LLM optimisé, Databricks crée automatiquement un Endpoint de service de modèle optimisé lorsque vous tentez de le servir.

Python
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_MEDIUM, etc.)
workload_type = "GPU_MEDIUM"

# 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 endpoint de diffusion de LLM optimisé possède des schémas d'entrée et de sortie que Databricks contrôle. Quatre formats différents sont pris en charge.

dataframe_split est un DataFrame Pandas sérialisé JSON dans l'orientation split.

JSON
{
  "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é JSON dans l'orientation records.

JSON
{
  "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 c4.2xlarge

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

JSON
{
  "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 Endpoint

Une fois votre endpoint prêt, vous pouvez l'interroger en faisant une requête API. Selon la taille et la complexité du modèle, cela peut prendre 30 minutes ou plus pour que l'endpoint soit prêt.

Python

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

Limitations

Compte tenu des exigences d'installation accrues pour les modèles servis sur GPU, la création d'images conteneur pour le service GPU prend plus de temps que la création d'images pour le service CPU.
- La taille du modèle a également un impact sur la création d’images. Par exemple, les modèles qui ont 30 milliards de paramètres ou plus peuvent prendre au moins une heure à construire.
- Databricks réutilise le même conteneur la prochaine fois que la même version du Model est déployée, de sorte que les déploiements suivants prendront moins de temps.
L'autoscaling pour le service GPU prend plus de temps que pour le service CPU, en raison de l'augmentation du temps de configuration pour les modèles servis sur le compute GPU. Databricks recommande le surprovisionnement pour éviter les délais d'attente des requêtes.

Exigences​

Journalisez votre grand modèle linguistique​

Créez votre endpoint de service de modèle​

Format de schéma d'entrée et de sortie​

Interrogez votre Endpoint​

Limitations​