Modelos externos no Mosaic AI Model Serving

Este artigo descreve modelos externos no Mosaic AI Model Serving, incluindo o seu modelo providers suportado e suas 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 providersde modelo 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

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.

Modelo providers

Os modelos externos no Model Serving foram concebidos para suportar uma variedade de modelos providers. 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 providers 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 get 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.

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 a consulta padrão parameters marcada como necessária, enquanto outros parameters podem ser ignorados, dependendo se o ponto de extremidade Mosaic AI Model Serving oferece suporte ou não a eles.

Consulte POST /serving-endpoints/{name}/invocations na referência da API para consultar parameterspadrã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 ponto de extremidade de serviço de modelo externo, deves incluir o campo external_model e o seu parameters 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 como provedor suporta modelos como text-embedding-ada-002, mas outros providers 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.

Abaixo, o table resume o campo external_modelparameters. Consulte POST /api/2.0/serving-endpoints para parametersde configuração de 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 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}}"
                    }
                }
            }
        ]
    }
)

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 a configuração de endpoint parameters disponível 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 estiveres a usar o Azure OpenAI com a identificação do Microsoft Entra, usa o seguinte parameters na tua configuração de endpoint.

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 o credentials diretamente com a API 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 a consulta padrão parameters para um pedido de avaliaçã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 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 os modelos suportados para obter modelos adicionais que pode consultar e os seus providers.

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

Consulta adicional parameters

Você pode passar qualquer parameters adicional suportado pelo provedor do endpoint como parte da 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.

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, a sua configuração pode fazer com que os seus dados sejam processados fora da região where de onde os seus dados se originaram. 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.