Externí modely v obsluhě modelu AI v systému Mosaic AI

Tento článek popisuje externí modely v systému Mosaic AI Model Serving, včetně jeho podporovaných poskytovatelů modelů a jejich omezení.

Co jsou externí modely?

Externí modely jsou modely třetích stran hostované mimo Databricks. Podporované službou Model Obsluha, externí modely umožňují zjednodušit používání a správu různých poskytovatelů velkých jazykových modelů (LLM), jako jsou OpenAI a Anthropic, v rámci organizace. K poskytování vlastních modelů, které nabízejí omezení rychlosti pro tyto koncové body, můžete také použít model Mosaic AI, který slouží jako poskytovatel. V rámci této podpory nabízí služba Model Serving rozhraní vysoké úrovně, které zjednodušuje interakci s těmito službami tím, že poskytuje jednotný koncový bod pro zpracování konkrétních požadavků souvisejících s LLM.

Kromě toho podpora Azure Databricks pro externí modely poskytuje centralizovanou správu přihlašovacích údajů. Uložením klíčů rozhraní API do jednoho zabezpečeného umístění můžou organizace zlepšit stav zabezpečení minimalizací vystavení citlivých klíčů rozhraní API v celém systému. Pomáhá také zabránit zveřejnění těchto klíčů v kódu nebo vyžadovat, aby koncoví uživatelé mohli bezpečně spravovat klíče.

Viz kurz: Vytvoření koncových bodů externího modelu pro dotazování modelů OpenAI pro podrobné pokyny k vytvoření koncového bodu externího modelu a dotazování podporovaných modelů obsluhovaných těmito koncovými body pomocí sady SDK pro nasazení MLflow. Pokyny k používání uživatelského rozhraní obsluhy a rozhraní REST API najdete v následujících příručkách:

• Vytvoření vlastních koncových bodů pro obsluhu modelů
• Dotazování na základní modely

Požadavky

• Klíč API nebo ověřovací pole pro poskytovatele modelu.
• Pracovní prostor Databricks v regionech podporujících externí modely.

poskytovatelé modelu

Externí modely ve službě Model Serving jsou navržené tak, aby podporovaly různé poskytovatele modelů. Poskytovatel představuje zdroj modelů strojového učení, jako jsou OpenAI, Anthropic atd. Každý poskytovatel má své specifické vlastnosti a konfigurace, které jsou zapouzdřeny v external_model poli konfigurace koncového bodu externího modelu.

Podporují se následující poskytovatelé:

• openai: Pro modely, které nabízí OpenAI a integrace Azure pro Azure OpenAI a Azure OpenAI s AAD.
• anthropic: Pro modely, které nabízí Anthropic.
• cohere: Pro modely nabízené Společností Cohere.
• amazon-bedrock: Pro modely nabízené Amazon Bedrock.
• google-cloud-vertex-ai: Pro modely, které nabízí Google Cloud Vertex AI.
• databricks-model-serving: Pro koncové body služe AI modelů v Mosaic AI s kompatibilními schématy. Viz konfigurace koncového bodu.
• vlastní: Pro alternativní poskytovatele nebo modely za vlastními proxy servery, které jsou kompatibilní s rozhraním API OpenAI, ale nejsou přímo podporovány službou Databricks.

Pokud chcete požádat o podporu poskytovatele, který tu není uvedený, zkuste použít možnost vlastního poskytovatele nebo se obraťte na tým účtů Databricks.

Podporované modely

Model, který zvolíte, přímo ovlivňuje výsledky odpovědí, které získáte z volání rozhraní API. Proto zvolte model, který vyhovuje vašim požadavkům na případ použití. Například pro generování konverzačních odpovědí můžete zvolit model chatu. Naopak pro generování vkládání textu můžete zvolit model vkládání.

Podívejte se na podporované modely.

Používejte modely poskytované na koncových bodech služby Mosaic AI.

Mosaic AI Model Serving endpointy jsou jako poskytovatel podporovány pro typy endpointů llm/v1/completions, llm/v1/chat a llm/v1/embeddings. Tyto koncové body musí přijmout standardní parametry dotazu označené jako povinné, zatímco ostatní parametry můžou být ignorovány v závislosti na tom, jestli je koncový bod obsluhy modelu Mosaic AI podporuje.

Informace o standardních parametrech dotazu najdete v tématu POST /serving-endpoints/{name}/invocations v referenčních informacích k rozhraní API.

Tyto koncové body musí vytvářet odpovědi v následujícím formátu OpenAI.

Úkoly k dokončení

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

Pro úkoly chatu:

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

Pro úlohy embedování:

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

Konfigurace koncového bodu

Pokud chcete obsluhovat a dotazovat externí modely, musíte nakonfigurovat koncový bod obsluhy. Viz Vytvoření externího modelu obsluhující koncový bod

U externího modelu, který obsluhuje koncový bod, musíte zahrnout pole external_model a jeho parametry do served_entities části konfigurace koncového bodu. Pokud v koncovém bodu obsluhy nakonfigurujete více externích modelů , musíte zadat traffic_config procento směrování provozu pro každý externí model.

Pole external_model definuje model, do kterého tento koncový bod předává požadavky. Při zadávání modelu je důležité, aby poskytovatel podporoval požadovaný model. Například openai jako poskytovatel podporuje modely, jako je text-embedding-ada-002, ale jiní poskytovatelé nemusí. Pokud zprostředkovatel model nepodporuje, vrátí Databricks chybu HTTP 4xx při pokusu o směrování požadavků na tento model.

Následující tabulka shrnuje parametry pole external_model. Parametry konfigurace koncového bodu najdete v POST /api/2.0/serving-endpoints.

Následuje příklad vytvoření koncového bodu externího modelu pomocí create_endpoint() rozhraní API. V tomto příkladu se požadavek odeslaný do koncového bodu dokončení předá modelu claude-2, který poskytuje 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}}"
                    }
                }
            }
        ]
    }
)

Konfigurace zprostředkovatele pro koncový bod

Při vytváření koncového bodu musíte zadat požadované konfigurace pro zadaného poskytovatele modelu. Následující části shrnují dostupné parametry konfigurace koncového bodu pro každého zprostředkovatele modelu.

OpenAI

Koherence

Anthropic

Azure OpenAI

Azure OpenAI má v porovnání s přímou službou OpenAI jedinečné funkce. Přehled najdete v dokumentaci k porovnání.

Pokud používáte Azure OpenAI s ID Microsoft Entra, použijte v konfiguraci koncového bodu následující parametry. Databricks předává https://cognitiveservices.azure.com/ jako výchozí rozsah tokenu ID Microsoft Entra.

Následující příklad ukazuje, jak vytvořit koncový bod pomocí 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

Pokud chcete jako externího poskytovatele modelů použít Amazon Bedrock, musí zákazníci zajistit, aby byl v zadané oblasti AWS povolený bedrock a zadaný pár klíčů AWS má příslušná oprávnění pro interakci se službami Bedrock. Další informace najdete v tématu AWS Identity and Access Management.

Následující příklad ukazuje, jak vytvořit koncový bod s Amazon Bedrock pomocí přístupových klíčů.

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

Pokud dojde k problémům s oprávněními AWS, databricks doporučuje ověřit přihlašovací údaje přímo pomocí rozhraní AMAZON Bedrock API.

Testovací prostředí AI21

Vlastní poskytovatel

Následující příklad ukazuje, jak vytvořit koncový bod s vlastním poskytovatelem pomocí ověřování nosiče :

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

Následující příklad ukazuje, jak vytvořit koncový bod s vlastním poskytovatelem pomocí ověřování prostřednictvím klíče 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}}"
                        }
                    }
                }
            }
        ]
    },
)

Konfigurace služby AI Gateway na koncovém bodu

Také můžete nakonfigurovat svůj koncový bod, aby umožnil funkce Mosaic AI Gateway, jako jsou omezení rychlosti, sledování využití a mantinely.

Viz Konfigurujte AI bránu na koncových bodech pro obsluhu modelů.

Dotazování na koncový bod externího modelu

Po vytvoření koncového bodu externího modelu je připravený přijímat provoz od uživatelů.

Žádosti o bodování můžete do koncového bodu odesílat pomocí klienta OpenAI, rozhraní REST API nebo sady SDK pro nasazení MLflow.

• Podívejte se na standardní parametry dotazu pro bodovací požadavek v POST /serving-endpoints/{name}/invocations.
• Dotazování na základní modely

Následující příklad dotazuje model claude-2 dokončení hostovaný společností Anthropic za použití klienta OpenAI. Pokud chcete použít klienta OpenAI, vyplňte model pole názvem koncového bodu obsluhujícího model, který je hostitelem modelu, který chcete dotazovat.

Tento příklad používá dříve vytvořený koncový bod nakonfigurovaný anthropic-completions-endpointpro přístup k externím modelům od poskytovatele modelu Anthropic. Podívejte se, jak vytvořit koncové body externího modelu.

Další modely, které můžete dotazovat a jejich poskytovatele, najdete v podporovaných modelů.

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)

Očekávaný formát výstupní odpovědi:

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

Další parametry dotazu

V rámci dotazu můžete předat jakékoli další parametry podporované poskytovatelem koncového bodu.

Příklad:

• logit_bias (podporuje OpenAI, Cohere).
• top_k (podporuje Anthropic, Cohere).
• frequency_penalty (podporuje OpenAI, Cohere).
• presence_penalty (podporuje OpenAI, Cohere).
• stream (podporuje OpenAI, Anthropic, Cohere, Amazon Bedrock for Anthropic). Tato možnost je dostupná jenom pro žádosti o chat a dokončení.

• tools (podporuje OpenAI, Anthropic, Amazon Bedrock for Anthropic). Tato možnost je dostupná jenom pro žádosti o chat a dokončení. Tento parametr umožňuje integraci externích funkcí, včetně Computer Use (beta) pro Anthropic a Amazon Bedrock for Anthropic. Podívejte se na volání funkcí na službě Azure Databricks.

Podpora konfigurací síťového připojení pro externí modely

Podpora konfigurací síťového připojení (NCCS) pro externí modely, včetně služby Azure Private Link, je aktuálně ve verzi Private Preview. Spojte se s týmem vašeho účtu Databricks, abyste se mohli zapojit do zkušební verze.

Omezení

V závislosti na zvoleném externím modelu může vaše konfigurace způsobit zpracování dat mimo oblast, odkud vaše data pocházejí. Viz Omezení a oblasti služby Model Serving.

Další materiály

• Kurz: Vytvoření koncových bodů externího modelu pro dotazování modelů OpenAI
• základní modely dotazů.