Externa modeller i Mosaic AI Model Serving

Den här artikeln beskriver externa modeller i Mosaic AI Model Serving, inklusive modellleverantörer som stöds och begränsningar.

Vad är externa modeller?

Externa modeller är tredjepartsmodeller som finns utanför Databricks. Med hjälp av modellservering kan externa modeller effektivisera användningen och hanteringen av olika LLM-leverantörer (large language model), till exempel OpenAI och Anthropic, inom en organisation. Du kan också använda Mosaic AI Model Serving som leverantör för att hantera anpassade modeller, som erbjuder hastighetsbegränsningar för dessa slutpunkter. Som en del av det här stödet erbjuder Model Serving ett högnivågränssnitt som förenklar interaktionen med dessa tjänster genom att tillhandahålla en enhetlig slutpunkt för att hantera specifika LLM-relaterade begäranden.

Dessutom tillhandahåller Azure Databricks-stöd för externa modeller centraliserad hantering av autentiseringsuppgifter. Genom att lagra API-nycklar på en säker plats kan organisationer förbättra sin säkerhetsstatus genom att minimera exponeringen av känsliga API-nycklar i hela systemet. Det hjälper också till att förhindra att dessa nycklar exponeras i kod eller kräver att slutanvändarna hanterar nycklar på ett säkert sätt.

Se Självstudie: Skapa externa modellslutpunkter för att fråga OpenAI-modeller för stegvis vägledning om hur du skapar och frågar modeller som stöds av dessa slutpunkter med hjälp av SDK för MLflow-distributioner. Se följande guider för instruktioner om hur du använder användargränssnittet för servering och REST-API:et:

• Skapa anpassade modellserverslutpunkter
• Fråga efter fundamentala modeller

Krav

• API-nyckel- eller autentiseringsfält för modellprovidern.
• Databricks-arbetsyta i regioner där externa modeller stöds.

Leverantörer av modeller

Externa modeller i Model Serving är utformade för att stödja en mängd olika modellprovidrar. En provider representerar källan till maskininlärningsmodellerna, till exempel OpenAI, Anthropic och så vidare. Varje provider har sina specifika egenskaper och konfigurationer som är inkapslade inom external_model fältet för den externa modellens slutpunktskonfiguration.

Följande leverantörer stöds:

• openai: För modeller som erbjuds av OpenAI och Azure-integreringarna för Azure OpenAI och Azure OpenAI med AAD.
• antropiska: För modeller som erbjuds av antropiska.
• cohere: För modeller som erbjuds av Cohere.
• amazon-bedrock: För modeller som erbjuds av Amazon Bedrock.
• google-cloud-vertex-ai: För modeller som erbjuds av Google Cloud Vertex AI.
• databricks-model-serving: För Mosaic AI Model Serving-slutpunkter med kompatibla scheman. Se Slutpunktskonfiguration.
• anpassade: För alternativa leverantörer eller modeller som ligger bakom anpassade proxyservrar och är kompatibla med OpenAI API, men som inte stöds direkt av Databricks.

Om du vill begära support för en leverantör som inte visas här kan du prova att använda alternativet anpassad provider eller kontakta ditt Databricks-kontoteam.

Modeller som stöds

Den modell du väljer påverkar direkt resultatet av de svar du får från API-anropen. Välj därför en modell som passar dina krav för användningsfall. För att generera konversationssvar kan du till exempel välja en chattmodell. För att generera inbäddningar av text kan du däremot välja en inbäddningsmodell.

Se modeller som stöds.

Använda modeller som hanteras på Mosaic AI Model Serving-slutpunkter

Mosaic AI Model Serving-slutpunkter som leverantör stöds för slutpunktstyperna llm/v1/completions, llm/v1/chat och llm/v1/embeddings. Dessa slutpunkter måste acceptera standardfrågeparametrarna som markerats som obligatoriska, medan andra parametrar kan ignoreras beroende på om slutpunkten för Mosaic AI Model Serving stöder dem eller inte.

Se POST /serving-endpoints/{name}/invocations i API-referensen för standardfrågeparametrar.

Dessa slutpunkter måste generera svar i följande OpenAI-format.

För uppgifter att slutföra:

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

För chattuppgifter:

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

För uppgifter med inbäddningar:

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

Slutpunktskonfiguration

För att tillhandahålla och fråga externa modeller behöver du konfigurera en tjänstgörande slutpunkt. Se Skapa en extern modell som betjänar slutpunkten

För en extern modell som betjänar slutpunkten måste du inkludera fältet external_model och dess parametrar i avsnittet served_entities i slutpunktskonfigurationen. Om du konfigurerar flera externa modeller i en serverslutpunkt måste du ange en traffic_config för att definiera trafikdirigeringsprocenten för varje extern modell.

Fältet external_model definierar den modell som slutpunkten vidarebefordrar begäranden till. När du anger en modell är det viktigt att providern stöder den modell som du begär. Till exempel stöder openai som leverantör modeller som text-embedding-ada-002, men andra leverantörer kanske inte gör det. Om modellen inte stöds av providern returnerar Databricks ett HTTP 4xx-fel när begäranden dirigeras till modellen.

Tabellen nedan sammanfattar external_model fältparametrar. Se POST /api/2.0/serving-endpoints för slutpunktskonfigurationsparametrar.

Följande är ett exempel på hur du skapar en extern modellslutpunkt med hjälp av API:et create_endpoint() . I det här exemplet vidarebefordras en begäran som skickas till slutpunkten för slutförande till modellen claude-2 som tillhandahålls av 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}}"
                    }
                }
            }
        ]
    }
)

Konfigurera providern för en slutpunkt

När du skapar en slutpunkt måste du ange de konfigurationer som krävs för den angivna modellprovidern. I följande avsnitt sammanfattas de tillgängliga slutpunktskonfigurationsparametrarna för varje modellprovider.

OpenAI

Sammanhållning

Anthropic

Azure OpenAI

Azure OpenAI har distinkta funktioner jämfört med den direkta OpenAI-tjänsten. En översikt finns i jämförelsedokumentationen.

Om du använder Azure OpenAI med Microsoft Entra-ID använder du följande parametrar i slutpunktskonfigurationen. Databricks skickar https://cognitiveservices.azure.com/ som standardomfång för Microsoft Entra ID-token.

I följande exempel visas hur du skapar en slutpunkt med 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

Amazon Bedrock

Om du vill använda Amazon Bedrock som en extern modellleverantör måste kunderna se till att Bedrock är aktiverat i den angivna AWS-regionen och att det angivna AWS-nyckelparet har rätt behörighet att interagera med Bedrock-tjänster. Mer information finns i AWS-identitets- och åtkomsthantering.

I följande exempel visas hur du skapar en slutpunkt med Amazon Bedrock med hjälp av åtkomstnycklar.

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

Om det finns AWS-behörighetsproblem rekommenderar Databricks att du verifierar autentiseringsuppgifterna direkt med Amazon Bedrock API-.

AI21 Labs

Anpassad leverantör

I följande exempel visas hur du skapar en slutpunkt med en anpassad leverantör och använder bärarauktorisering.

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

I följande exempel visas hur du skapar en slutpunkt med en anpassad leverantör med hjälp av autentisering med API-nyckel .

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

Konfigurera AI Gateway på en slutpunkt

Du kan också konfigurera slutpunkten för att aktivera Mosaic AI Gateway-funktioner , till exempel hastighetsbegränsning, användningsspårning och skyddsräcken.

Se Konfigurera AI Gateway på modell som betjänar slutpunkter.

Fråga en extern modellslutpunkt

När du har skapat en extern modellslutpunkt är den redo att ta emot trafik från användare.

Du kan skicka bedömningsbegäranden till slutpunkten med hjälp av OpenAI-klienten, REST-API:et eller SDK:n för MLflow-distributioner.

• Se standardfrågeparametrarna för en bedömningsbegäran i POST /serving-endpoints/{name}/invocations.
• Sök grundläggande modeller

I följande exempel efterfrågas slutförandemodellen claude-2 som hanteras av Anthropic med hjälp av OpenAI-klienten. Om du vill använda OpenAI-klienten fyller du i model fältet med namnet på den modell som betjänar slutpunkten som är värd för den modell som du vill fråga efter.

I det här exemplet används en tidigare skapad slutpunkt, anthropic-completions-endpoint, som konfigurerats för åtkomst till externa modeller från den antropiska modellprovidern. Se hur du skapar externa modellslutpunkter.

Se Stödda modeller för andra modeller och deras leverantörer som du kan söka.

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)

Förväntat utdatasvarsformat:

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

Ytterligare frågeparametrar

Du kan skicka eventuella ytterligare parametrar som stöds av slutpunktens provider som en del av din fråga.

Till exempel:

• logit_bias (stöds av OpenAI, Cohere).
• top_k (stöds av Anthropic, Cohere).
• frequency_penalty (stöds av OpenAI, Cohere).
• presence_penalty (stöds av OpenAI, Cohere).
• stream (stöds av OpenAI, Anthropic, Cohere, Amazon Bedrock for Anthropic). Detta är endast tillgängligt för chatt- och slutförandebegäranden.

• tools (stöds av OpenAI, Anthropic, Amazon Bedrock for Anthropic). Detta är endast tillgängligt för chatt- och slutförandebegäranden. Den här parametern möjliggör integrering av externa funktioner, inklusive datoranvändning (beta) för Anthropic och Amazon Bedrock för Anthropic. Se Funktionsanrop på Azure Databricks.

Stöd för nätverksanslutningskonfigurationer för externa modeller

Stöd för nätverksanslutningskonfigurationer (NCC) för externa modeller, inklusive azure private link, finns för närvarande i privat förhandsversion. Kontakta ditt Databricks-kontoteam för att delta i förhandsversionen.

Begränsningar

Beroende på vilken extern modell du väljer kan konfigurationen leda till att dina data bearbetas utanför den region där dina data har sitt ursprung. Se Gränser och regioner för Model Serving.

Ytterligare resurser

• Självstudie: Skapa externa modellslutpunkter för att fråga OpenAI-modeller.
• Query Foundation-modeller.