Modelos externos no Mosaic AI Model Serving

Este artigo descreve modelos externos no Mosaic AI Model Serving incluindo seus provedores de modelos suportados e limitações.

O que são modelos externos?

Modelos externos são modelos de terceiros hospedados fora do Databricks. Suportados pelo Model Serving, os modelos externos permitem agilizar o uso e o gerenciamento de vários provedores de modelos de linguagem grande (LLM), como OpenAI e Anthropic, dentro de uma organização. Você também pode usar o Mosaic AI Model Servindo como um provedor para servir modelos personalizados, que oferece limites de taxa para esses endpoints. Como parte desse suporte, o Model Serving oferece uma interface de alto nível que simplifica a interação com esses serviços, fornecendo um ponto de extremidade unificado para lidar com solicitações específicas relacionadas ao LLM.

Além disso, o suporte do Azure Databricks para modelos externos fornece gerenciamento centralizado de credenciais. Ao armazenar chaves de API em um local seguro, as organizações podem melhorar sua postura de segurança minimizando a exposição de chaves de API confidenciais em todo o sistema. Ele também ajuda a evitar a exposição dessas chaves no código ou exigir que os usuários finais gerenciem as chaves com segurança.

Consulte Tutorial: Criar pontos de extremidade de modelo externos para consultar modelos OpenAI para obter orientação passo a passo sobre a criação de ponto de extremidade de modelo externo e consulta de modelos suportados atendidos por esses pontos de extremidade usando o SDK de implantações MLflow. Consulte os guias a seguir para obter instruções sobre como usar a interface do usuário de serviço e a API REST:

• Criar pontos de extremidade de serviço de modelo personalizado
• Modelos de base de consulta e modelos externos

Requerimentos

• Chave de API ou campos de autenticação para o provedor de modelo.
• Espaço de trabalho Databricks em regiões suportadas por modelos externos.

Fornecedores de modelos

Os modelos externos no Model Serving foram concebidos para suportar uma variedade de fornecedores de modelos. Um provedor representa a origem dos modelos de aprendizado de máquina, como OpenAI, Anthropic e assim por diante. Cada provedor tem suas características e configurações específicas que são encapsuladas dentro do external_model campo da configuração de ponto final do modelo externo.

Os seguintes provedores são suportados:

• openai: Para modelos oferecidos pelo OpenAI e as integrações do Azure para Azure OpenAI e Azure OpenAI com AAD.
• antrópica: Para modelos oferecidos pela Anthropic.
• cohere: Para modelos oferecidos pela Cohere.
• amazon-bedrock: Para modelos oferecidos pela Amazon Bedrock.
• google-cloud-vertex-ai: Para modelos oferecidos pelo Google Cloud Vertex AI.
• databricks-model-serving: Para Mosaic AI Model Serving endpoints com esquemas compatíveis. Consulte Configuração do ponto final.

Para solicitar suporte para um provedor não listado aqui, entre em contato com sua equipe de conta Databricks.

Modelos suportados

O modelo escolhido afeta diretamente os resultados das respostas obtidas das chamadas de API. Portanto, escolha um modelo que se adapte aos seus requisitos de caso de uso. Por exemplo, para gerar respostas de conversação, você pode escolher um modelo de chat. Por outro lado, para gerar incorporações de texto, você pode escolher um modelo de incorporação.

A tabela abaixo apresenta uma lista não exaustiva de modelos suportados e tipos de terminais correspondentes. As associações de modelo listadas abaixo podem ser usadas como um guia útil ao configurar um ponto de extremidade para qualquer tipo de modelo recém-lançado à medida que eles se tornam disponíveis com um determinado provedor. Os clientes são responsáveis por garantir a conformidade com as licenças de modelo aplicáveis.

** O provedor de modelos suporta modelos de conclusão e bate-papo ajustados. Para consultar um modelo ajustado, preencha o name external model campo da configuração com o nome do modelo ajustado.

† provedor de modelo oferece suporte a modelos de conclusão personalizados.

Use modelos servidos no Mosaic AI Model Serving endpoints

O Mosaic AI Model Serving endpoints como provedor é suportado para os llm/v1/completionstipos , llm/v1/chate endpoint llm/v1/embeddings . Esses pontos de extremidade devem aceitar os parâmetros de consulta padrão marcados como necessários, enquanto outros parâmetros podem ser ignorados, dependendo se o ponto de extremidade Mosaic AI Model Serving os suporta ou não.

Consulte POST /serving-endpoints/{name}/invocations na referência da API para parâmetros de consulta padrão.

Esses endpoints devem produzir respostas no seguinte formato OpenAI.

Para tarefas de conclusão:

{
"id": "123", # Not Required
"model": "test_databricks_model",
"choices": [
  {
    "text": "Hello World!",
    "index": 0,
    "logprobs": null, # Not Required
    "finish_reason": "length" # Not Required
  }
],
"usage": {
  "prompt_tokens": 8,
  "total_tokens": 8
  }
}

Para tarefas de chat:

{
  "id": "123", # Not Required
  "model": "test_chat_model",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "\n\nHello there, how may I assist you today?",
    },
    "finish_reason": "stop"
  },
  {
    "index": 1,
    "message": {
      "role": "human",
      "content": "\n\nWhat is the weather in San Francisco?",
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 8
  }
}

Para tarefas de incorporação:

{
  "data": [
    {
      "embedding": [
       0.0023064255,
        -0.009327292,
        .... # (1536 floats total for ada-002)
        -0.0028842222,
      ],
      "index": 0
    },
    {
      "embedding": [
        0.0023064255,
        -0.009327292,
        .... #(1536 floats total for ada-002)
        -0.0028842222,
      ],
      "index": 0
    }
  ],
  "model": "test_embedding_model",
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 8
  }
}

Configuração do ponto final

Para servir e consultar modelos externos, você precisa configurar um ponto de extremidade de serviço. Consulte Criar um modelo externo servindo ponto de extremidade

Para um modelo externo que serve o ponto de extremidade, você deve incluir o external_model campo e seus parâmetros na served_entities seção da configuração do ponto final. Se você configurar vários modelos externos em um ponto de extremidade de serviço, deverá fornecer um traffic_config para definir a porcentagem de roteamento de tráfego para cada modelo externo.

O external_model campo define o modelo para o qual esse ponto de extremidade encaminha solicitações. Ao especificar um modelo, é fundamental que o provedor ofereça suporte ao modelo que você está solicitando. Por exemplo, openai como um provedor suporta modelos como text-embedding-ada-002, mas outros provedores podem não. Se o modelo não for suportado pelo provedor, o Databricks retornará um erro HTTP 4xx ao tentar rotear solicitações para esse modelo.

A tabela abaixo resume os parâmetros do external_model campo. Consulte POST /api/2.0/serving-endpoints para obter os parâmetros de configuração do ponto final.

A seguir está um exemplo de criação de um ponto de extremidade de modelo externo usando a create_endpoint() API. Neste exemplo, uma solicitação enviada para o ponto de extremidade de conclusão é encaminhada para o claude-2 modelo fornecido pela anthropic.

import mlflow.deployments

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

client.create_endpoint(
    name="anthropic-completions-endpoint",
    config={
        "served_entities": [
            {
                "name": "test",
                "external_model": {
                    "name": "claude-2",
                    "provider": "anthropic",
                    "task": "llm/v1/completions",
                    "anthropic_config": {
                        "anthropic_api_key": "{{secrets/my_anthropic_secret_scope/anthropic_api_key}}"
                    }
                }
            }
        ]
    }
)

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. O exemplo abaixo, cria um ponto de extremidade de serviço que encaminha 50% do tráfego para gpt-4 fornecido pela OpenAI e os 50% restantes para 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}
            ]
        },
    }
)

Configurar o provedor para um ponto de extremidade

Ao criar um ponto de extremidade, você deve fornecer as configurações necessárias para o provedor de modelo especificado. As seções a seguir resumem os parâmetros de configuração de ponto de extremidade disponíveis para cada provedor de modelo.

OpenAI

Cohere

Anthropic

Azure OpenAI

O Azure OpenAI tem recursos distintos em comparação com o serviço OpenAI direto. Para uma visão geral, consulte a documentação de comparação.

Se você estiver usando o Azure OpenAI com a ID do Microsoft Entra, use os seguintes parâmetros em sua configuração de ponto de extremidade.

O exemplo a seguir demonstra como criar um ponto de extremidade com o Azure OpenAI:

client.create_endpoint(
    name="openai-chat-endpoint",
    config={
        "served_entities": [{
            "external_model": {
                "name": "gpt-3.5-turbo",
                "provider": "openai",
                "task": "llm/v1/chat",
                "openai_config": {
                    "openai_api_type": "azure",
                    "openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}",
                    "openai_api_base": "https://my-azure-openai-endpoint.openai.azure.com",
                    "openai_deployment_name": "my-gpt-35-turbo-deployment",
                    "openai_api_version": "2023-05-15"
                }
            }
        }]
    }
)

Google Cloud Vertex AI

Substrato rochoso amazônico

Para usar o Amazon Bedrock como um provedor de modelo externo, os clientes precisam garantir que o Bedrock esteja habilitado na região da AWS especificada e que o par de chaves da AWS especificado tenha as permissões apropriadas para interagir com os serviços do Bedrock. Para obter mais informações, consulte AWS Identity and Access Management.

O exemplo a seguir demonstra como criar um endpoint com o Amazon Bedrock usando chaves de acesso.

client.create_endpoint(
    name="bedrock-anthropic-completions-endpoint",
    config={
        "served_entities": [
            {
                "external_model": {
                    "name": "claude-v2",
                    "provider": "amazon-bedrock",
                    "task": "llm/v1/completions",
                    "amazon_bedrock_config": {
                        "aws_region": "<YOUR_AWS_REGION>",
                        "aws_access_key_id": "{{secrets/my_amazon_bedrock_secret_scope/aws_access_key_id}}",
                        "aws_secret_access_key": "{{secrets/my_amazon_bedrock_secret_scope/aws_secret_access_key}}",
                        "bedrock_provider": "anthropic",
                    },
                }
            }
        ]
    },
)

Se houver problemas de permissão da AWS, o Databricks recomenda que você verifique as credenciais diretamente com a API do Amazon Bedrock.

Laboratórios AI21

Configurar o AI Gateway em um ponto de extremidade

Você também pode configurar seu endpoint para habilitar os recursos do Mosaic AI Gateway , como limitação de taxa, rastreamento de uso e guarda-corpos.

Consulte Configurar o AI Gateway em pontos de extremidade de serviço de modelo.

Consultar um ponto de extremidade de modelo externo

Depois de criar um ponto de extremidade de modelo externo, ele estará pronto para receber tráfego de usuários.

Você pode enviar solicitações de pontuação para o endpoint usando o cliente OpenAI, a API REST ou o SDK de implantações MLflow.

• Consulte os parâmetros de consulta padrão para uma solicitação de pontuação em POST /serving-endpoints/{name}/invocations.
• Modelos de base de consulta e modelos externos

O exemplo a seguir consulta o claude-2 modelo de conclusão hospedado pela Anthropic usando o cliente OpenAI. Para usar o cliente OpenAI, preencha o model campo com o nome do ponto de extremidade de serviço do modelo que hospeda o modelo que você deseja consultar.

Este exemplo usa um ponto de extremidade criado anteriormente, anthropic-completions-endpoint, configurado para acessar modelos externos do provedor de modelo antrópico. Veja como criar pontos de extremidade de modelo externos.

Consulte Modelos suportados para obter modelos adicionais que você pode consultar e seus provedores.

import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

completion = client.completions.create(
  model="anthropic-completions-endpoint",
  prompt="what is databricks",
  temperature=1.0
)
print(completion)

Formato de resposta de saída esperado:

{
"id": "123", # Not Required
"model": "anthropic-completions-endpoint",
"choices": [
  {
    "text": "Hello World!",
    "index": 0,
    "logprobs": null, # Not Required
    "finish_reason": "length" # Not Required
  }
],
"usage": {
  "prompt_tokens": 8,
  "total_tokens": 8
  }
}

Parâmetros de consulta adicionais

Você pode passar quaisquer parâmetros adicionais suportados pelo provedor do ponto de extremidade como parte de sua consulta.

Por exemplo:

• logit_bias (suportado por OpenAI, Cohere).
• top_k (apoiado por Anthropic, Cohere).
• frequency_penalty (suportado por OpenAI, Cohere).
• presence_penalty (suportado por OpenAI, Cohere).
• stream (suportado por OpenAI, Anthropic, Cohere, Amazon Bedrock for Anthropic). Isso só está disponível para solicitações de bate-papo e conclusão.

Limitações

Dependendo do modelo externo escolhido, sua configuração pode fazer com que seus dados sejam processados fora da região de origem dos dados. Consulte Limites e regiões de serviço do modelo.

Se você optar por configurar vários modelos externos em um ponto de extremidade de serviço, todos os modelos externos deverão ter o mesmo tipo de tarefa e cada modelo precisará de um arquivo name. Não é possível ter modelos externos e modelos não externos no mesmo ponto de extremidade de serviço.

Recursos adicionais

• Tutorial: Crie pontos de extremidade de modelo externos para consultar modelos OpenAI.
• Modelos de base de consulta e modelos externos.