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 Serving como provedor para disponibilizar modelos personalizados, oferecendo limites de utilização 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 pontos de extremidade de modelo externos e a consulta a modelos suportados que são servidos por esses pontos de extremidade usando o SDK de Implementaçõ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 endpoints personalizados para disponibilização de modelos
• Modelos de base de consulta

Requerimentos

• Chave de API ou campos de autenticação para o provedor de modelo.
• Espaço de trabalho Databricks em regiões que suportam 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 as suas características e configurações específicas que são encapsuladas no campo da configuração do 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 endpoints do Mosaic AI Model Serving com esquemas compatíveis. Consulte Configuração do Endpoint.
• personalizado: Para provedores alternativos ou modelos por trás de proxies personalizados que são compatíveis com a API OpenAI, mas não são suportados diretamente pelo Databricks.

Para solicitar suporte para um provedor não listado aqui, tente usar a opção provedor de personalizado ou 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.

Consulte os modelos suportados.

Utilize modelos fornecidos nos pontos de serviço de modelos do Mosaic AI

Os endpoints do Mosaic AI Model Serving como provedor são suportados para os tipos de endpoint llm/v1/completions, llm/v1/chat e 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 em 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": [
        1.0023064255,
        -0.009327292,
        .... # (1536 floats total for ada-002)
        -0.0028842222,
      ],
      "index": 0
    },
    {
      "embedding": [
        1.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, é necessário configurar um endpoint de serviço. Consulte Criar um ponto de extremidade de serviço para modelo externo

Para um modelo externo que serve o ponto de extremidade, você deve incluir o campo external_model e seus parâmetros na seção served_entities da configuração do ponto de extremidade. 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, enquanto fornecedor, suporta modelos como text-embedding-ada-002, mas outros fornecedores podem não suportar. 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 de campo external_model. Consulte POST /api/2.0/serving-endpoints para obter os parâmetros de configuração do endpoint.

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 endpoint de conclusão é encaminhada para o modelo claude-2 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}}"
                    }
                }
            }
        ]
    }
)

Configurar o provedor para um endpoint

Ao criar um endpoint, deve-se 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 estiver a utilizar o Azure OpenAI com o Microsoft Entra ID, utilize os seguintes parâmetros na configuração do seu ponto de extremidade. Databricks passa https://cognitiveservices.azure.com/ como o escopo padrão para o token de ID do Microsoft Entra.

O exemplo a seguir demonstra como criar um endpoint 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 Amazon Bedrock.

Laboratórios AI21

Provedor personalizado

O exemplo a seguir demonstra como criar um endpoint com um provedor personalizado usando autenticação bearer .

client.create_endpoint(
    name="custom-provider-completions-endpoint",
    config={
        "served_entities": [
            {
                "external_model": {
                    "name": "custom-provider-model",
                    "provider": "custom",
                    "task": "llm/v1/chat",
                    "custom_provider_config": {
                        "custom_provider_url": "https://my-custom-provider.com",
                        "bearer_token_auth": {
                            "token": "{{secrets/my_custom_provider_secret_scope/custom_provider_token}}"
                        }
                    }
                }
            }
        ]
    },
)

O exemplo a seguir demonstra como criar um ponto de extremidade com um provedor personalizado usando autenticação de chave de API:

client.create_endpoint(
    name="custom-provider-completions-endpoint",
    config={
        "served_entities": [
            {
                "external_model": {
                    "name": "custom-provider-model",
                    "provider": "custom",
                    "task": "llm/v1/chat",
                    "custom_provider_config": {
                        "custom_provider_url": "https://my-custom-provider.com",
                        "api_key_auth": {
                            "key": "X-API-KEY",
                            "value": "{{secrets/my_custom_provider_secret_scope/custom_provider_api_key}}"
                        }
                    }
                }
            }
        ]
    },
)

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 nos pontos de extremidade para serviço de modelos.

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 proveniente dos utilizadores.

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

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 endpoint criado anteriormente, anthropic-completions-endpoint, configurado para aceder modelos externos do provedor de modelos da Anthropic. Veja como criar pontos de extremidade de modelos externos.

Consulte modelos suportados para modelos adicionais que pode consultar e os seus fornecedores.

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.

• tools (suportado por OpenAI, Anthropic, Amazon Bedrock for Anthropic). Isso só está disponível para solicitações de bate-papo e conclusão. Este parâmetro permite a integração de funcionalidades externas, incluindo Computer Use (beta) para Anthropic e Amazon Bedrock para Anthropic. Veja Chamada de Funções no Azure Databricks.

Suporte a configurações de conectividade de rede para modelos externos

O suporte para configurações de conectividade de rede (NCCs) para modelos externos, incluindo o link privado do Azure, está atualmente em visualização privada. Entre em contato com sua equipe de conta Databricks para participar da visualizaçã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.

Recursos adicionais

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