Fornecer vários modelos a um ponto de extremidade de serviço de modelo

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

Atender a vários modelos de um único endpoint permite dividir o tráfego entre diferentes modelos para comparar seu desempenho e facilitar o teste 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 disponibilizar qualquer um dos seguintes tipos de modelo em um endpoint de Model Serving. Você não pode implantar diferentes tipos de modelo em um único endpoint. Por exemplo, você não pode servir um modelo personalizado e um modelo externo no mesmo ponto de extremidade.

Requisitos

Consulte os Requisitos para a criação do endpoint de serviço de modelo.

Para entender as opções de controle de acesso para pontos de extremidade de serviço de modelo e diretrizes de melhores práticas para o gerenciamento de ponto de extremidade, consulte ACLs de pontos de extremidade de serviço.

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 Model Serving ou a interface do usuário de Model Serving, 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 base servidos em um ponto de extremidade.

Disponibilize vários modelos personalizados em um endpoint

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

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

Disponibilize vários modelos em um endpoint com throughput provisionado

O exemplo de API REST a seguir cria um único endpoint de throughput provisionado das APIs de modelos fundacionais com dois modelos e define a divisão de tráfego do endpoint entre esses modelos. O endpoint chamado multi-pt-model hospeda a versão 2 de meta_llama_v3_1_70b_instruct, que recebe 60% do tráfego do endpoint, e também hospeda a versão 3 de meta_llama_v3_1_8b_instruct, que recebe 40% do tráfego do endpoint.


POST /api/2.0/serving-endpoints
{
   "name":"multi-pt-model"
   "config":
   {
      "served_entities":
      [
         {
            "name":"meta_llama_v3_1_70b_instruct",
            "entity_name":"system.ai.meta_llama_v3_1_70b_instruct",
            "entity_version":"4",
            "min_provisioned_throughput":0,
            "max_provisioned_throughput":2400
         },
         {
            "name":"meta_llama_v3_1_8b_instruct",
            "entity_name":"system.ai.meta_llama_v3_1_8b_instruct",
            "entity_version":"4",
            "min_provisioned_throughput":0,
            "max_provisioned_throughput":1240
         }
      ],
      "traffic_config":
      {
         "routes":
         [
            {
               "served_model_name":"meta_llama_v3_1_8b_instruct",
               "traffic_percentage":"60"
            },
            {
               "served_model_name":"meta_llama_v3_1_70b_instruct",
               "traffic_percentage":"40"
            }
         ]
      }
   }
}

Disponibilizar vários modelos externos em um endpoint

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

O exemplo a seguir cria um endpoint de veiculação que roteia 50% do tráfego para o gpt-4 fornecido pela OpenAI e os 50% restantes para o claude-3-opus-20240229 fornecido pela 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}
            ]
        },
    }
)

Atualizar a divisão de tráfego entre modelos fornecidos

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

Você também pode fazer essa atualização na guia Serving na interface do usuário do Azure Databricks usando o botão Edit configuration.

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 endpoint

Em alguns cenários, talvez você queira consultar cada modelo individualmente por trás do endpoint.

Você pode fazer isso usando:

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

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

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

  • Last updated on