Pular para o conteúdo principal

Serviço otimizado de modelo de linguagem grande (LLM)

info

Visualização

Esse recurso está em Public Preview.

important

Os exemplos de código neste guia usam APIs obsoletas. Databricks recomenda o uso da experiência do provisionamento Taxa de transferência para a inferência otimizada de LLMs. Consulte Migrar endpoint de atendimento otimizado do LLM para provisionamento Taxa de transferência.

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

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

A Databricks recomenda a instalação de modelos de base usando o Databricks Marketplace. O senhor pode pesquisar uma família de modelos e, na página do modelo, selecionar Get access (Obter acesso ) e fornecer credenciais de login para instalar o modelo no Unity Catalog.

Família de modelos

Instalar a partir do marketplace

Llama 2

Modelos Llama 2

MPT

Mistral

Modelos Mistral

Requisitos​

  • O serviço LLM otimizado é suportado como parte da visualização pública das implantações de GPU.

  • Seu modelo deve ser de logs usando MLflow 2.4 e acima ou Databricks Runtime 13.2 ML e acima.

  • A Databricks recomenda o uso de modelos no Unity Catalog para acelerar o upload e o download de modelos grandes.

  • Ao implantar modelos, é essencial combinar o tamanho do parâmetro do seu modelo com o tamanho apropriado do site compute. Consulte a tabela abaixo para obter recomendações. Para modelos com 50 bilhões ou mais de parâmetros, entre em contato com a equipe Databricks account para acessar as GPUs necessárias.

    Tamanho do parâmetro do modelo

    Tamanho recomendado para compute

    Tipo de GPU

    7 bilhões

    1 x A10

    GPU_MEDIUM

    13 bilhões

    4xA10

    MULTIGPU_MEDIUM

    30-34 bilhões

    4xA10

    MULTIGPU_MEDIUM

    70 bilhões

    8xA10 ou 8xA100

    GPU_MEDIUM_8 ou GPU_LARGE_8

registrar seu modelo de linguagem grande​

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

O serviço LLM otimizado é compatível com os tipos de rota suportados pelo Databricks AI Gateway; atualmente, llm/v1/completions. Se houver um modelo de família ou tipo de tarefa que o senhor queira servir e que não seja suportado, entre em contato com a equipe Databricks account .

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

Depois que o modelo for registrado, o senhor poderá registrar seus modelos em Unity Catalog com o seguinte procedimento, no qual substitui CATALOG.SCHEMA.MODEL_NAME pelo nome de três níveis do modelo.

Python

mlflow.set_registry_uri("databricks-uc")

registered_model_name=CATALOG.SCHEMA.MODEL_NAME

Crie seu modelo de atendimento endpoint​

Em seguida, crie seu modelo de serviço endpoint. Se o seu modelo for compatível com o serviço otimizado LLM, o Databricks criará automaticamente um modelo de serviço otimizado endpoint quando o senhor tentar servi-lo.

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

Formato do esquema de entrada e saída​

Um LLM otimizado que atende ao endpoint tem esquemas de entrada e saída que o Databricks controla. Quatro formatos diferentes são suportados.

  • dataframe_split é um Pandas Dataframe serializado em JSON na orientação 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 é um Pandas Dataframe serializado em JSON na orientação 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
      }
    }

  • instâncias

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

  • entradas

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

Consultar seu endpoint​

Depois que seu endpoint estiver pronto, o senhor 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 endpoint fique pronto.

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

Limitações​

  • Dado o aumento dos requisitos de instalação dos modelos fornecidos na GPU, a criação de imagens de contêiner para o serviço da GPU leva mais tempo do que a criação da imagem para o serviço da CPU.

    • O tamanho do modelo também afeta a criação de imagens. Por exemplo, modelos com 30 bilhões de parâmetros ou mais podem levar pelo menos uma hora para serem construídos.
    • Databricks reutiliza o mesmo contêiner na próxima vez que a mesma versão do modelo for implantada, de modo que as implantações subsequentes levarão menos tempo.

  • A autoescala para servir a GPU leva mais tempo do que para servir a CPU, devido ao aumento do tempo de configuração para modelos servidos na GPU compute. A Databricks recomenda o provisionamento excessivo para evitar o tempo limite das solicitações.

Última atualização em