Tutorial: Criar pontos de extremidade de modelo externos para consultar modelos OpenAI

Este artigo fornece instruções passo a passo para configurar e consultar um ponto de extremidade de modelo externo que serve modelos OpenAI para conclusão, bate-papo e incorporações usando o SDK de implantações MLflow. Saiba mais sobre modelos externos.

Se preferir usar a interface do usuário de serviço para realizar essa tarefa, consulte Criar um modelo externo servindo ponto de extremidade.

Requisitos

  • Databricks Runtime 13.0 ML ou superior.
  • MLflow 2.9 ou superior.
  • Chaves de API OpenAI.
  • Instale a CLI do Databricks versão 0.205 ou superior.

(Opcional) Etapa 0: Armazenar a chave da API OpenAI usando a CLI Databricks Secrets

Você pode fornecer suas chaves de API como cadeias de caracteres de texto sem formatação na Etapa 3 ou usando os Segredos do Azure Databricks.

Para armazenar a chave da API OpenAI como um segredo, você pode usar a CLI Databricks Secrets (versão 0.205 e superior). Você também pode usar a API REST para segredos.

O seguinte cria o escopo secreto chamado e, em seguida, my_openai_secret_scopecria o segredo openai_api_key nesse escopo.

databricks secrets create-scope my_openai_secret_scope
databricks secrets put-secret my_openai_secret_scope openai_api_key

Etapa 1: Instalar o MLflow com suporte a modelos externos

Use o seguinte para instalar uma versão MLflow com suporte a modelos externos:

%pip install mlflow[genai]>=2.9.0

Etapa 2: Criar e gerenciar um ponto de extremidade de modelo externo

Importante

Os exemplos de código nesta seção demonstram o uso do SDK CRUD de implantações MLflow do Public Preview .

Para criar um ponto de extremidade de modelo externo para um modelo de linguagem grande (LLM), use o create_endpoint() método do SDK de implantações MLflow. Você também pode criar pontos de extremidade de modelo externos na interface do usuário de serviço.

O trecho de código a seguir cria um ponto de extremidade de conclusão para o OpenAI gpt-3.5-turbo-instruct, conforme especificado na served_entities seção da configuração. Para seu ponto de extremidade, certifique-se de preencher o name e openai_api_key com seus valores exclusivos para cada campo.

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
    name="openai-completions-endpoint",
    config={
        "served_entities": [{
            "name": "openai-completions",
            "external_model": {
                "name": "gpt-3.5-turbo-instruct",
                "provider": "openai",
                "task": "llm/v1/completions",
                "openai_config": {
                    "openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}"
                }
            }
        }]
    }
)

O trecho de código a seguir mostra como você pode fornecer sua chave de API OpenAI como uma cadeia de caracteres de texto simples para uma maneira alternativa de criar o mesmo ponto de extremidade de conclusão como acima.

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
    name="openai-completions-endpoint",
    config={
        "served_entities": [{
            "name": "openai-completions",
            "external_model": {
                "name": "gpt-3.5-turbo-instruct",
                "provider": "openai",
                "task": "llm/v1/completions",
                "openai_config": {
                    "openai_api_key_plaintext": "sk-yourApiKey"
                }
            }
        }]
    }
)

Se você estiver usando o Azure OpenAI, também poderá especificar o nome da implantação do Azure OpenAI, a URL do ponto de extremidade e a openai_config versão da API na seção da configuração.

client.create_endpoint(
    name="openai-completions-endpoint",
    config={
        "served_entities": [
          {
            "name": "openai-completions",
            "external_model": {
                "name": "gpt-3.5-turbo-instruct",
                "provider": "openai",
                "task": "llm/v1/completions",
                "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"
                },
            },
          }
        ],
    },
)

Para atualizar um ponto de extremidade, use update_endpoint(). O trecho de código a seguir demonstra como atualizar os limites de taxa de um ponto de extremidade para 20 chamadas por minuto por usuário.

client.update_endpoint(
    endpoint="openai-completions-endpoint",
    config={
        "rate_limits": [
            {
                "key": "user",
                "renewal_period": "minute",
                "calls": 20
            }
        ],
    },
)

Etapa 3: Enviar solicitações para um ponto de extremidade de modelo externo

Importante

Os exemplos de código nesta seção demonstram o uso do método MLflow Deployments SDK predict() .

Você pode enviar solicitações de bate-papo, conclusão e incorporação para um ponto de extremidade de modelo externo usando o método do SDK de implantações MLflow predict() .

O seguinte envia uma solicitação para gpt-3.5-turbo-instruct hospedado pela OpenAI.

completions_response = client.predict(
    endpoint="openai-completions-endpoint",
    inputs={
        "prompt": "What is the capital of France?",
        "temperature": 0.1,
        "max_tokens": 10,
        "n": 2
    }
)
completions_response == {
    "id": "cmpl-8QW0hdtUesKmhB3a1Vel6X25j2MDJ",
    "object": "text_completion",
    "created": 1701330267,
    "model": "gpt-3.5-turbo-instruct",
    "choices": [
        {
            "text": "The capital of France is Paris.",
            "index": 0,
            "finish_reason": "stop",
            "logprobs": None
        },
        {
            "text": "Paris is the capital of France",
            "index": 1,
            "finish_reason": "stop",
            "logprobs": None
        },
    ],
    "usage": {
        "prompt_tokens": 7,
        "completion_tokens": 16,
        "total_tokens": 23
    }
}

Etapa 4: Comparar modelos de um provedor diferente

O serviço de modelos suporta muitos fornecedores de modelos externos, incluindo Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI e muito mais. Você pode comparar LLMs entre provedores, ajudando a otimizar a precisão, a velocidade e o custo de seus aplicativos usando o AI Playground.

O exemplo a seguir cria um ponto de extremidade para Anthropic claude-2 e compara sua resposta a uma pergunta que usa OpenAI gpt-3.5-turbo-instruct. Ambas as respostas têm o mesmo formato padrão, o que as torna fáceis de comparar.

Criar um ponto de extremidade para Anthropic claude-2

import mlflow.deployments

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

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

Comparar as respostas de cada parâmetro de avaliação


openai_response = client.predict(
    endpoint="openai-completions-endpoint",
    inputs={
        "prompt": "How is Pi calculated? Be very concise."
    }
)
anthropic_response = client.predict(
    endpoint="anthropic-completions-endpoint",
    inputs={
        "prompt": "How is Pi calculated? Be very concise."
    }
)
openai_response["choices"] == [
    {
        "text": "Pi is calculated by dividing the circumference of a circle by its diameter."
                " This constant ratio of 3.14159... is then used to represent the relationship"
                " between a circle's circumference and its diameter, regardless of the size of the"
                " circle.",
        "index": 0,
        "finish_reason": "stop",
        "logprobs": None
    }
]
anthropic_response["choices"] == [
    {
        "text": "Pi is calculated by approximating the ratio of a circle's circumference to"
                " its diameter. Common approximation methods include infinite series, infinite"
                " products, and computing the perimeters of polygons with more and more sides"
                " inscribed in or around a circle.",
        "index": 0,
        "finish_reason": "stop",
        "logprobs": None
    }
]

Recursos adicionais

Modelos externos em Mosaic AI Model Serving.