Servir vários modelos para um modelo que serve o ponto de extremidade

Artigo
11/02/2024

Este artigo descreve como configurar programaticamente um ponto de extremidade de serviço de modelo para servir vários modelos e a divisão de tráfego entre eles.

O atendimento a vários modelos a partir de um único ponto de extremidade permite dividir o tráfego entre modelos diferentes para comparar seu desempenho e facilitar os testes A/B. Você também pode servir diferentes versões de um modelo ao mesmo tempo, o que facilita a experimentação de novas versões, mantendo a versão atual em produção.

Você pode servir qualquer um dos seguintes tipos de modelo em um ponto de extremidade Mosaic AI Model Serving . Não é possível atender diferentes tipos de modelo em um único ponto de extremidade. Por exemplo, você não pode servir um modelo personalizado e um modelo externo no mesmo ponto de extremidade.

Modelos à medida
Modelos de IA generativa disponibilizados por meio da taxa de transferência provisionada de APIs do Modelo de Base
Modelos externos

Requisitos

Consulte os Requisitos para a criação de pontos finais de serviço de modelo.

Para entender as opções de controle de acesso para o modelo que serve pontos de extremidade e as diretrizes de práticas recomendadas para gerenciamento de endpoints, consulte Servindo ACLs de endpoint.

Criar um ponto de extremidade e definir a divisão de tráfego inicial

Ao criar pontos de extremidade de serviço de modelo usando a API de serviço do Databricks Mosaic AI ou a interface do usuário de serviço do Databricks Mosaic AI, você também pode definir a divisão de tráfego inicial para os modelos que deseja servir nesse ponto de extremidade. As seções a seguir fornecem exemplos de como definir a divisão de tráfego para vários modelos personalizados ou modelos de IA generativos servidos em um ponto de extremidade.

Servir vários modelos personalizados para um ponto de extremidade

O exemplo de API REST a seguir cria um único ponto de extremidade com dois modelos personalizados no Unity Catalog e define o tráfego de ponto de extremidade dividido entre esses modelos. A entidade servida, current, hospeda a versão 1 de model-A e obtém 90% do tráfego de ponto final, enquanto a outra entidade servida, challenger, hospeda a versão 1 de model-B e obtém 10% do tráfego de ponto final.

POST /api/2.0/serving-endpoints

{
   "name":"multi-model"
   "config":
   {
      "served_entities":
      [
         {
            "name":"current",
            "entity_name":"catalog.schema.model-A",
            "entity_version":"1",
            "workload_size":"Small",
            "scale_to_zero_enabled":true
         },
         {
            "name":"challenger",
            "entity_name":"catalog.schema.model-B",
            "entity_version":"1",
            "workload_size":"Small",
            "scale_to_zero_enabled":true
         }
      ],
      "traffic_config":
      {
         "routes":
         [
            {
               "served_model_name":"current",
               "traffic_percentage":"90"
            },
            {
               "served_model_name":"challenger",
               "traffic_percentage":"10"
            }
         ]
      }
   }
}

Servir vários modelos para um ponto de extremidade de taxa de transferência provisionado

O exemplo de API REST a seguir cria um único ponto de extremidade de taxa de transferência provisionado de APIs de Modelo de Base com dois modelos e define o tráfego de ponto de extremidade dividido entre esses modelos. O ponto de extremidade chamado multi-pt-model, hospeda a versão 2 do mistral_7b_instruct_v0_1-2 qual obtém 60% do tráfego do ponto de extremidade e também hospeda a versão 3 do mixtral_8x7b_instruct_v0_1-3 qual obtém 40% do tráfego do ponto final.


POST /api/2.0/serving-endpoints
{
   "name":"multi-pt-model"
   "config":
   {
      "served_entities":
      [
         {
            "name":"mistral_7b_instruct_v0_1-2",
            "entity_name":"system.ai.mistral_7b_instruct_v0_1",
            "entity_version":"2",
            "min_provisioned_throughput":0,
            "max_provisioned_throughput":1940
         },
         {
            "name":"mixtral_8x7b_instruct_v0_1-3",
            "entity_name":"system.ai.mixtral_8x7b_instruct_v0_1",
            "entity_version":"3",
            "min_provisioned_throughput":0,
            "max_provisioned_throughput":1240
         }
      ],
      "traffic_config":
      {
         "routes":
         [
            {
               "served_model_name":"mistral_7b_instruct_v0_1-2",
               "traffic_percentage":"60"
            },
            {
               "served_model_name":"mixtral_8x7b_instruct_v0_1-3",
               "traffic_percentage":"40"
            }
         ]
      }
   }
}

Servir vários modelos externos a um endpoint

Você também pode configurar vários modelos externos em um ponto de extremidade de serviço, desde que todos tenham o mesmo tipo de tarefa e cada modelo tenha um arquivo name. Não é possível ter modelos externos e modelos não externos no mesmo ponto de extremidade de serviço.

O exemplo a seguir cria um ponto de extremidade de serviço que roteia 50% do tráfego para gpt-4 fornecido pelo OpenAI e os 50% restantes para claude-3-opus-20240229 o fornecido pelo Anthropic.

import mlflow.deployments

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

client.create_endpoint(
    name="mix-chat-endpoint",
    config={
        "served_entities": [
            {
                "name": "served_model_name_1",
                "external_model": {
                    "name": "gpt-4",
                    "provider": "openai",
                    "task": "llm/v1/chat",
                    "openai_config": {
                        "openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}"
                    }
                }
            },
            {
                "name": "served_model_name_2",
                "external_model": {
                    "name": "claude-3-opus-20240229",
                    "provider": "anthropic",
                    "task": "llm/v1/chat",
                    "anthropic_config": {
                        "anthropic_api_key": "{{secrets/my_anthropic_secret_scope/anthropic_api_key}}"
                    }
                }
            }
        ],
        "traffic_config": {
            "routes": [
                {"served_model_name": "served_model_name_1", "traffic_percentage": 50},
                {"served_model_name": "served_model_name_2", "traffic_percentage": 50}
            ]
        },
    }
)

Atualize a divisão de tráfego entre os modelos servidos

Você também pode atualizar a divisão de tráfego entre os modelos servidos. O exemplo de API REST a seguir define o modelo servido, current, para obter 50% do tráfego de ponto de extremidade e o outro modelo, challenger, para obter os 50% restantes do tráfego.

Você também pode fazer essa atualização na guia Servindo na interface do usuário do Databricks Mosaic AI usando o botão Editar configuração .

PUT /api/2.0/serving-endpoints/{name}/config

{
   "served_entities":
   [
      {
         "name":"current",
         "entity_name":"catalog.schema.model-A",
         "entity_version":"1",
         "workload_size":"Small",
         "scale_to_zero_enabled":true
      },
      {
         "name":"challenger",
         "entity_name":"catalog.schema.model-B",
         "entity_version":"1",
         "workload_size":"Small",
         "scale_to_zero_enabled":true
      }
   ],
   "traffic_config":
   {
      "routes":
      [
         {
            "served_model_name":"current",
            "traffic_percentage":"50"
         },
         {
            "served_model_name":"challenger",
            "traffic_percentage":"50"
         }
      ]
   }
}

Consultar modelos individuais por trás de um ponto de extremidade

Em alguns cenários, talvez você queira consultar modelos individuais por trás do ponto de extremidade.

Pode fazê-lo utilizando:

POST /serving-endpoints/{endpoint-name}/served-models/{served-model-name}/invocations

Aqui é consultado o modelo específico de serviço. O formato da solicitação é o mesmo que consultar o ponto de extremidade. Ao consultar o modelo de serviço individual, as configurações de tráfego são ignoradas.

No contexto do multi-model exemplo de ponto de extremidade, se todas as solicitações forem enviadas para /serving-endpoints/multi-model/served-models/challenger/invocations, todas as solicitações serão atendidas challenger pelo modelo servido.

Partilhar via