Criar um endpoint de modelo de serviço de fundação

Neste artigo, o senhor aprenderá a criar um endpoint de modelo de serviço que serve modelos de fundação.

Databricks A servindo modelo suporta os seguintes modelos de fundação:

  • Modelos abertos de última geração disponibilizados pelas APIs do Foundation Model. Esses modelos são arquiteturas de modelo de base selecionadas que oferecem suporte à inferência otimizada. Os modelos básicos, como Llama-2-70B-chat, BGE-Large e Mistral-7B, estão disponíveis para uso imediato com preços pay-per-tokens. As cargas de trabalho de produção, usando modelos básicos ou ajustados, podem ser implantadas com garantias de desempenho usando o provisionamento da taxa de transferência.

  • Modelos externos. Esses são modelos hospedados fora da Databricks. que atendem a modelos externos podem ser controlados de forma centralizada e os clientes podem estabelecer limites de taxa e controle de acesso para eles. Os exemplos incluem modelos de fundação como o GPT-4 da OpenAI, o Claude da Anthropic e outros.

A servindo modelo oferece as seguintes opções para a criação da servindo modelo endpoint:

  • A UI de serviço

  • API REST

  • SDK de implantações do MLflow

Para criar endpoints que atendam a modelos tradicionais de ML ou Python, consulte Criar endpoint de modelo de serviço personalizado.

Requisitos

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")

Criar um endpoint de modelo de serviço de fundação

A seguir, descrevemos como criar um endpoint que atende a um modelo básico disponibilizado usando modelos externos do Databricks. Para obter o endpoint que serve variantes ajustadas dos modelos disponibilizados usando as APIs do Foundation Model, consulte Criar seu provisionamento Taxa de transferência endpoint usando a API REST.

  1. No campo Name (Nome ), forneça um nome para seu endpoint.

  2. Na seção Entidades atendidas

    1. Clique no campo Entity (Entidade ) para abrir o formulário Select served entity (Selecionar entidade atendida ).

    2. Selecione o modelo externo.

    3. Selecione o provedor de modelos que o senhor deseja usar.

    4. Clique em Confirm

    5. Forneça o nome do modelo externo que o senhor deseja usar. O formulário é atualizado dinamicamente com base em sua seleção. Veja os modelos externos disponíveis.

    6. Selecione o tipo de tarefa. As tarefas disponíveis são bate-papo, conclusões e incorporações.

    7. Forneça os detalhes de configuração para acessar o provedor de modelo selecionado. Normalmente, esse é o segredo que faz referência ao access tokenpessoal que o senhor deseja que o endpoint use para acessar esse modelo.

  3. Clique em Create. A página Serving endpoints é exibida com o estado Serving endpoint mostrado como Not Ready.

Criar um modelo de serviço endpoint

Importante

Os parâmetros da API REST para a criação de pontos de extremidade de atendimento que atendem aos modelos da fundação estão em Public Preview.

O exemplo a seguir cria um endpoint que serve a primeira versão do modelo text-embedding-ada-002 fornecido pela OpenAI.

Consulte POST /api/2.0/serving-endpoint para os parâmetros de configuração do endpoint.

{
  "name": "openai_endpoint",
  "config":{
    "served_entities": [
      {
        "name": "openai_embeddings",
        "external_model":{
          "name": "text-embedding-ada-002",
          "provider": "openai",
          "task": "llm/v1/embeddings",
          "openai_config":{
            "openai_api_key": "{{secrets/my_scope/my_openai_api_key}}"
          }
        }
      }
    ]
  },
  "rate_limits": [
    {
      "calls": 100,
      "key": "user",
      "renewal_period": "minute"
    }
  ],
  "tags": [
    {
      "key": "team",
      "value": "gen-ai"
    }
  ]
}

A seguir, um exemplo de resposta.

{
  "name": "openai_endpoint",
  "creator": "user@email.com",
  "creation_timestamp": 1699617587000,
  "last_updated_timestamp": 1699617587000,
  "state": {
    "ready": "READY"
  },
  "config": {
    "served_entities": [
      {
        "name": "openai_embeddings",
        "external_model": {
          "provider": "openai",
          "name": "text-embedding-ada-002",
          "task": "llm/v1/embeddings",
          "openai_config": {
            "openai_api_key": "{{secrets/my_scope/my_openai_api_key}}"
          }
        },
        "state": {
          "deployment": "DEPLOYMENT_READY",
          "deployment_state_message": ""
        },
        "creator": "user@email.com",
        "creation_timestamp": 1699617587000
      }
  ],
    "traffic_config": {
      "routes": [
        {
          "served_model_name": "openai_embeddings",
          "traffic_percentage": 100
        }
      ]
    },
    "config_version": 1
  },
  "tags": [
    {
      "key": "team",
      "value": "gen-ai"
    }
  ],
  "id": "69962db6b9db47c4a8a222d2ac79d7f8",
  "permission_level": "CAN_MANAGE",
  "route_optimized": false
}

O seguinte cria um endpoint para embeddings com OpenAI text-embedding-ada-002.

Para o endpoint do modelo de fundação, o senhor deve fornecer a chave de API do provedor de modelo que deseja usar. Consulte POST /api/2.0/serving-endpoint na API REST para obter detalhes sobre o esquema de solicitação e resposta.

Também é possível criar endpoints para conclusões e tarefas de chat, conforme especificado pelo campo task na seção external_model da configuração. Consulte Modelos externos em Databricks servindo modelo para saber quais são os modelos e provedores suportados para cada tarefa.


from mlflow.deployments import get_deploy_client

client = get_deploy_client("databricks")
endpoint = client.create_endpoint(
    name="chat",
    config={
        "served_entities": [
            {
                "name": "completions",
                "external_model": {
                    "name": "gpt-4",
                    "provider": "openai",
                    "task": "llm/v1/chat",
                    "openai_config": {
                        "openai_api_key": "{{secrets/scope/key}}",
                    },
                },
            }
        ],
    },
)
assert endpoint == {
    "name": "chat",
    "creator": "alice@company.com",
    "creation_timestamp": 0,
    "last_updated_timestamp": 0,
    "state": {...},
    "config": {...},
    "tags": [...],
    "id": "88fd3f75a0d24b0380ddc40484d7a31b",
}

Atualizar um endpoint do modelo da fundação

Depois de ativar um endpoint modelo, o senhor pode definir a configuração do compute conforme desejar. Essa configuração é particularmente útil se o senhor precisar de recurso adicional para o seu modelo. O tamanho da carga de trabalho e a compute configuração key do site desempenham um papel importante em quais recursos são alocados para atender ao seu modelo.

Até que a nova configuração esteja pronta, a configuração antiga continua atendendo ao tráfego de previsão. Enquanto houver uma atualização em andamento, outra atualização não poderá ser feita.

Quando um external_model está presente em uma configuração de endpoint, a lista de entidades servidas só pode ter um objeto served_entity. O ponto de extremidade existente com um external_model não pode ser atualizado para não ter mais um external_model. Se o endpoint for criado sem um external_model, o senhor não poderá atualizá-lo para adicionar um external_model.

Para atualizar o endpoint do modelo da fundação, consulte a documentação de configuração de atualização da API REST para obter detalhes sobre o esquema de solicitação e resposta.

{
  "name": "openai_endpoint",
  "served_entities":[
    {
      "name": "openai_chat",
      "external_model":{
        "name": "gpt-4",
        "provider": "openai",
        "task": "llm/v1/chat",
        "openai_config":{
          "openai_api_key": "{{secrets/my_scope/my_openai_api_key}}"
        }
      }
    }
  ]
}

Para atualizar o endpoint do modelo da fundação, consulte a documentação de configuração de atualização da API REST para obter detalhes sobre o esquema de solicitação e resposta.

from mlflow.deployments import get_deploy_client

client = get_deploy_client("databricks")
endpoint = client.update_endpoint(
    endpoint="chat",
    config={
        "served_entities": [
            {
                "name": "chats",
                "external_model": {
                    "name": "gpt-4",
                    "provider": "openai",
                    "task": "llm/v1/chat",
                    "openai_config": {
                        "openai_api_key": "{{secrets/scope/key}}",
                    },
                },
            }
        ],
    },
)
assert endpoint == {
    "name": "chats",
    "creator": "alice@company.com",
    "creation_timestamp": 0,
    "last_updated_timestamp": 0,
    "state": {...},
    "config": {...},
    "tags": [...],
    "id": "88fd3f75a0d24b0380ddc40484d7a31b",
  }

rate_limits = client.update_endpoint(
    endpoint="chat",
    config={
        "rate_limits": [
            {
                "key": "user",
                "renewal_period": "minute",
                "calls": 10,
            }
        ],
    },
)
assert rate_limits == {
    "rate_limits": [
        {
            "key": "user",
            "renewal_period": "minute",
            "calls": 10,
        }
    ],
}