Partilhar via

Criar modelo de base servindo endpoints

Neste artigo, aprende a criar endpoints de serviço de modelos que implementam e disponibilizam modelos fundamentais.

O Mosaic AI Model Serving suporta os seguintes modelos:

  • Modelos externos. Estes são modelos de base que são hospedados fora do Databricks. Os endpoints que atendem modelos externos podem ser controlados centralmente e os clientes podem estabelecer limites de taxa e controle de acesso para eles. Exemplos incluem modelos de fundação como o GPT-4 da OpenAI e o Claude da Anthropic.
  • Modelos de fundação aberta de última geração disponibilizados por APIs de modelo de fundação. Esses modelos são arquiteturas de modelo de base selecionadas que suportam inferência otimizada. Modelos básicos, como Meta-Llama-3.1-70B-Instruct, GTE-Large e Mistral-7B estão disponíveis para uso imediato com pagamento por token. As cargas de trabalho de produção, utilizando modelos básicos ou ajustados, podem ser implementadas com garantias de desempenho ao usar a largura de banda provisionada.

O Model Serving fornece as seguintes opções para a criação de pontos finais de serviço de modelo:

  • A interface de serviço
  • API REST
  • SDK de Implementações MLflow

Para criar pontos de extremidade que servem modelos tradicionais de ML ou Python, veja Criar pontos de extremidade de serviço de modelo personalizado.

Requerimentos

import mlflow.deployments

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

Criar um modelo de base que sirva o ponto de extremidade

Você pode criar um ponto de extremidade que atenda variantes ajustadas de modelos fundamentais disponibilizados usando APIs de Modelos Fundamentais taxa de transferência provisionada. Consulte Criar o seu ponto de extremidade de taxa de transferência provisionada usando a API REST.

Para modelos fundamentais que são disponibilizados usando APIs de Modelo de Fundação pagamento por token, Databricks fornece automaticamente pontos de extremidade específicos para acessar os modelos suportados no seu workspace do Databricks. Para acessá-los, selecione a guia Servindo na barra lateral esquerda do espaço de trabalho. As APIs do Modelo Fundacional estão localizadas no topo da lista de Endpoints.

Para consultar esses pontos de extremidade, consulte Usar modelos de base.

Criar um endpoint de serviço de modelo externo

A seguir descrevemos como criar um ponto de extremidade que consulta um modelo básico disponibilizado usando modelos externos do Databricks.

Servindo a interface do usuário

  1. No campo Nome, forneça um nome para o seu ponto de extremidade.
  2. Na secção Entidades servidas
    1. Clique no campo Entidade para abrir o formulário selecionar entidade atendida.
    2. Selecione Foundation Models.
    3. No campo Selecione um modelo de base, selecione o provedor de modelo que você deseja usar entre os listados em Provedores de modelo externos. O formulário atualiza-se dinamicamente com base na escolha do fornecedor de modelos.
    4. Clique Confirm.
    5. Forneça os detalhes de configuração para acessar o provedor de modelo selecionado. Normalmente, este é o segredo que se refere ao token de acesso pessoal que você deseja que o ponto de extremidade use para aceder a este modelo.
    6. Selecione a tarefa. As tarefas disponíveis são chat, conclusão e incorporações.
    7. Selecione o nome do modelo externo que deseja usar. A lista de modelos é atualizada dinamicamente com base na sua seleção de tarefas. Consulte os modelos externos disponíveis.
  3. Clique em Criar. A página de pontos de serviço aparece com o estado do ponto de serviço mostrado como Não Pronto.

Criar um ponto de extremidade de serviço de modelo

API REST

Importante

Os parâmetros da API REST para criar pontos finais de serviço que atendem modelos externos estão em visualização pública .

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

Consulte POST /api/2.0/serving-endpoints para obter os parâmetros de configuração do ponto final.

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

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

SDK de Implementações MLflow

O seguinte cria um endpoint para integrações com a OpenAI text-embedding-ada-002.

Para pontos de extremidade de modelo externos, você deve fornecer chaves de API para o provedor de modelo que deseja usar. Consulte POST /api/2.0/serving-endpoints na API REST para obter detalhes do esquema de pedido e resposta. Para obter um guia passo a passo, consulte Tutorial: Criar endpoints externos de modelo para consultar modelos OpenAI.

Você também pode criar pontos de extremidade para conclusão e tarefas de chat, conforme especificado pelo task campo na external_model seção da configuração. Consulte Modelos externos em Mosaic AI Model Serving para 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",
}

Atualização dos pontos finais de implementação de modelos

Depois de ativar um endpoint do modelo, podes definir a configuração de computação conforme desejado. Essa configuração é particularmente útil se você precisar de recursos adicionais para seu modelo. O tamanho da carga de trabalho e a configuração de computação desempenham um papel fundamental nos recursos alocados para atender ao seu modelo.

Até que a nova configuração esteja pronta, a configuração antiga continua servindo o tráfego de previsão. Embora haja uma atualização em andamento, outra atualização não pode ser feita. Na interface de serviço, pode-se cancelar uma atualização de configuração em andamento selecionando Cancelar atualização no canto superior direito da página de detalhes do endpoint. Essa funcionalidade só está disponível na Interface do Usuário de Serviço (Serving UI).

Quando um external_model está presente numa configuração de endpoint, a lista das entidades oferecidas só pode ter um objeto served_entity. Os pontos de extremidade existentes com um external_model não podem ser atualizados para deixar de ter um external_model. Se o ponto de extremidade for criado sem um external_model, você não poderá atualizá-lo para adicionar um external_model.

API REST

Para atualizar o seu ponto de extremidade, verifique a documentação de configuração de atualização da API REST para obter detalhes do 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}}"
        }
      }
    }
  ]
}

SDK de Implementações MLflow

Para atualizar o seu ponto de extremidade, verifique a documentação de configuração de atualização da API REST para obter detalhes do 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,
        }
    ],
}

Recursos adicionais

  • Last updated on