Servindo modelo de linguagem grande (LLM) otimizado

Artigo
01/02/2025

Importante

Esta funcionalidade está em Pré-visualização Pública.

Importante

Os exemplos de código neste guia usam APIs obsoletas. O Databricks recomenda o uso da experiência de taxa de transferência provisionada para inferência otimizada de LLMs. Consulte Migrar pontos de extremidade de serviço LLM otimizados para taxa de transferência provisionada.

Este artigo demonstra como habilitar otimizações para modelos de linguagem grandes (LLMs) no Mosaic AI Model Serving.

O serviço LLM otimizado oferece melhorias de rendimento e latência na faixa de 3 a 5 vezes melhor em comparação com as abordagens de serviço tradicionais. O table a seguir resume as famílias LLM suportadas e suas variantes.

A Databricks recomenda a instalação de modelos de fundação usando o Databricks Marketplace. Você pode pesquisar por uma família de modelos e, na página do modelo, selectGet acessar e fornecer o login credentials para instalar o modelo no Unity Catalog.

Família de modelos	Instalar a partir do Marketplace
Lama 2	Llama 2 Modelos
TMF
Mistral	Modelos Mistral

Requisitos

O serviço LLM otimizado é suportado como parte da visualização pública de implantações de GPU.
Seu modelo deve ser registrado usando MLflow 2.4 e superior ou Databricks Runtime 13.2 ML e superior.

Ao implantar modelos, é essencial combinar o tamanho do parâmetro do seu modelo com o tamanho de computação apropriado. Para modelos com 50 bilhões ou mais de parameters, entre em contato com sua equipe de conta do Azure Databricks para acessar as GPUs necessárias.

Tamanho do parâmetro do modelo	Tamanho de computação recomendado	Tipo de carga de trabalho
7 mil milhões	1xA100	`GPU_LARGE`
13 mil milhões	1xA100	`GPU_LARGE`
30-34 mil milhões	1xA100	`GPU_LARGE`
70 mil milhões	2xA100	`GPU_LARGE_2`

Registre seu modelo de idioma grande

Primeiro, registre seu modelo com o sabor MLflow transformers e especifique o campo de tarefa nos metadados MLflow com metadata = {"task": "llm/v1/completions"}. Isso especifica a assinatura da API usada para o ponto de extremidade de serviço do modelo.

O serviço LLM otimizado é compatível com os tipos de rota suportados pelo Azure Databricks AI Gateway; atualmente, llm/v1/completions. Se houver uma família de modelos ou um tipo de tarefa que você deseja atender que não seja suportado, entre em contato com sua equipe de conta do 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'
    )

Depois de o seu modelo ser registado, poderá registar os seus modelos no Unity Catalog com o seguinte where, substituindo CATALOG.SCHEMA.MODEL_NAME pelo nome de três níveis do modelo.


mlflow.set_registry_uri("databricks-uc")

registered_model_name=CATALOG.SCHEMA.MODEL_NAME

Crie seu ponto de extremidade de serviço de modelo

Em seguida, crie seu ponto de extremidade de serviço de modelo. Se o seu modelo for suportado pelo serviço LLM otimizado, o Azure Databricks criará automaticamente um ponto de extremidade de serviço de modelo otimizado quando você tentar atendê-lo.

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

Formato de entrada e saída schema

Um ponto de extremidade de serviço LLM otimizado tem esquemas de entrada e saída que o Azure Databricks controla. São suportados quatro formatos diferentes.

dataframe_split é o Pandas Dataframe serializado por JSON na split orientação.


{
  "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 é o Pandas Dataframe serializado por JSON na records orientação.

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

instâncias

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

Insumos


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

Consultar o seu ponto de extremidade

Depois que seu endpoint estiver pronto, você poderá consultá-lo fazendo uma solicitação de API. Dependendo do tamanho e da complexidade do modelo, pode levar 30 minutos ou mais para que o ponto final get esteja pronto.


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

Limitações

Dado o aumento dos requisitos de instalação para modelos servidos em GPU, a criação de imagens de contêiner para servir GPU leva mais tempo do que a criação de imagens para servir CPU.
- O tamanho do modelo também afeta a criação de imagens. Por exemplo, modelos que têm 30 bilhões de parameters ou mais podem levar pelo menos uma hora para serem construídos.
- O Databricks reutiliza o mesmo contêiner na próxima vez que a mesma versão do modelo for implantada, portanto, as implantações subsequentes levarão menos tempo.
O dimensionamento automático para o serviço de GPU leva mais tempo do que para o serviço de CPU, devido ao aumento do tempo de set para modelos servidos na computação de GPU. O Databricks recomenda o provisionamento excessivo para evitar tempos limite de solicitações.

Partilhar via