Zewnętrzne modele w obsłudze modeli AI Mosaic

W tym artykule opisano modele zewnętrzne w usłudze Mosaic AI Model Serving, w tym obsługiwanych dostawców modeli i ograniczeń.

Co to są modele zewnętrzne?

Modele zewnętrzne to modele innych firm hostowane poza usługą Databricks. Obsługiwane przez obsługę modeli, modele zewnętrzne umożliwiają usprawnienie użycia i zarządzania różnymi dużymi dostawcami modelu językowego (LLM), takimi jak OpenAI i Anthropic, w organizacji. Możesz również użyć usługi Mosaic AI Model Serving jako dostawcy do obsługi modeli niestandardowych, która oferuje limity szybkości dla tych punktów końcowych. W ramach tej obsługi obsługa modelu oferuje interfejs wysokiego poziomu, który upraszcza interakcję z tymi usługami, zapewniając ujednolicony punkt końcowy do obsługi określonych żądań związanych z usługą LLM.

Ponadto obsługa usługi Azure Databricks dla modeli zewnętrznych zapewnia scentralizowane zarządzanie poświadczeniami. Przechowując klucze interfejsu API w jednej bezpiecznej lokalizacji, organizacje mogą zwiększyć poziom zabezpieczeń, minimalizując narażenie poufnych kluczy interfejsu API w całym systemie. Pomaga to również zapobiec ujawnieniu tych kluczy w kodzie lub konieczności bezpiecznego zarządzania kluczami przez użytkowników końcowych.

Zobacz Samouczek: tworzenie zewnętrznych punktów końcowych modelu w celu wykonywania zapytań dotyczących modeli OpenAI, aby uzyskać szczegółowe wskazówki dotyczące tworzenia zewnętrznego punktu końcowego modelu i wykonywania zapytań dotyczących obsługiwanych modeli obsługiwanych przez te punkty końcowe przy użyciu zestawu SDK wdrożeń platformy MLflow. Zapoznaj się z następującymi przewodnikami, aby uzyskać instrukcje dotyczące używania interfejsu użytkownika obsługującego i interfejsu API REST:

• Tworzenie niestandardowych punktów końcowych obsługujących model
• Modele podstaw zapytań

Wymagania

• Klucz API lub pola uwierzytelniania dla dostawcy modelu.
• Obszar roboczy usługi Databricks w regionach obsługiwanych przez modele zewnętrzne.

Dostawcy modelu

Modele zewnętrzne w usłudze Model Serving są przeznaczone do obsługi różnych dostawców modeli. Dostawca reprezentuje źródło modeli uczenia maszynowego, takich jak OpenAI, Anthropic itd. Każdy dostawca ma swoje specyficzne cechy i konfiguracje, które są zawarte w polu konfiguracji punktu końcowego modelu zewnętrznego.

Obsługiwane są następujące dostawcy:

• openai: w przypadku modeli oferowanych przez platformę OpenAI i integracji platformy Azure dla usług Azure OpenAI i Azure OpenAI z usługą AAD.
• antropic: w przypadku modeli oferowanych przez Antropic.
• cohere: W przypadku modeli oferowanych przez Cohere.
• amazon-bedrock: Dla modeli oferowanych przez Amazon Bedrock.
• google-cloud-vertex-ai: w przypadku modeli oferowanych przez usługę Google Cloud Vertex AI.
• databricks-model-serving: dla punktów końcowych Mosaic AI Model Serving ze zgodnymi schematami. Zobacz Konfiguracja punktu końcowego.
• niestandardowe: dla alternatywnych dostawców lub modeli obsługiwanych przez niestandardowe serwery proxy zgodne z interfejsem API OpenAI, ale które nie są bezpośrednio wspierane przez Databricks.

Aby poprosić o wsparcie dla dostawcy, którego nie ma na liście, spróbuj użyć opcji niestandardowego dostawcy lub skontaktuj się z zespołem ds. konta Databricks.

Obsługiwane modele

Wybrany model ma bezpośredni wpływ na wyniki odpowiedzi uzyskanych z wywołań interfejsu API. W związku z tym wybierz model pasujący do wymagań przypadków użycia. Na przykład w przypadku generowania odpowiedzi konwersacyjnych można wybrać model czatu. Z drugiej strony w przypadku generowania osadzania tekstu można wybrać model osadzania.

Zobacz obsługiwane modele.

Korzystaj z modeli obsługiwanych na punktach końcowych Mosaic AI Model Serving

Końcowe punkty obsługiwane przez Mosaic AI Model Serving jako dostawcę są dostępne dla typów końcowych llm/v1/completions, llm/v1/chat i llm/v1/embeddings. Te punkty końcowe muszą zaakceptować standardowe parametry zapytania oznaczone jako wymagane, podczas gdy inne parametry mogą być ignorowane w zależności od tego, czy punkt końcowy obsługi modelu sztucznej inteligencji mozaiki obsługuje je.

Zobacz POST /serving-endpoints/{name}/invocations w dokumentacji API, aby uzyskać informacje o standardowych parametrach zapytania.

Te punkty końcowe muszą generować odpowiedzi w następującym formacie OpenAI.

W przypadku zadań dotyczących ukończenia:

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

W przypadku zadań czatu:

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

W przypadku zadań osadzania:

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

Konfiguracja punktu końcowego

Aby obsługiwać modele zewnętrzne i zapytywać je, należy skonfigurować punkt końcowy obsługi. Zobacz Tworzenie zewnętrznego punktu końcowego obsługującego model

W przypadku punktu końcowego obsługującego model zewnętrzny należy uwzględnić pole external_model i jego parametry w sekcji served_entities konfiguracji punktu końcowego. Jeśli skonfigurujesz wiele modeli zewnętrznych w punkcie końcowym obsługującym, musisz podać element , traffic_config aby zdefiniować procent routingu ruchu dla każdego modelu zewnętrznego.

Pole external_model definiuje model, do którego ten punkt końcowy przekazuje żądania. Podczas określania modelu ważne jest, aby dostawca obsługiwał żądany model. Na przykład openai jako dostawca obsługuje modele, takie jak text-embedding-ada-002, ale inni dostawcy mogą nie. Jeśli model nie jest obsługiwany przez dostawcę, usługa Databricks zwraca błąd HTTP 4xx podczas próby kierowania żądań do tego modelu.

Poniższa tabela zawiera podsumowanie parametrów pola external_model. Zobacz POST /api/2.0/serving-endpoints, aby uzyskać parametry konfiguracji punktu końcowego.

Poniżej przedstawiono przykład tworzenia zewnętrznego punktu końcowego modelu przy użyciu interfejsu create_endpoint() API. W tym przykładzie żądanie wysłane do punktu końcowego jest przekazywane do modelu claude-2 dostarczonego przez 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}}"
                    }
                }
            }
        ]
    }
)

Konfigurowanie dostawcy dla punktu końcowego

Podczas tworzenia punktu końcowego należy podać wymagane konfiguracje dla określonego dostawcy modelu. W poniższych sekcjach podsumowano dostępne parametry konfiguracji punktu końcowego dla każdego dostawcy modelu.

OpenAI

Spójność

Anthropic

Azure OpenAI

Usługa Azure OpenAI ma różne funkcje w porównaniu z bezpośrednią usługą OpenAI. Aby uzyskać przegląd, zobacz dokumentację porównawczą.

Jeśli używasz usługi Azure OpenAI z identyfikatorem Entra firmy Microsoft, użyj następujących parametrów w konfiguracji punktu końcowego. Usługa Databricks przekazuje https://cognitiveservices.azure.com/ jako domyślny zakres tokenu Entra ID firmy Microsoft.

W poniższym przykładzie pokazano, jak utworzyć punkt końcowy za pomocą usługi 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

Aby korzystać z usługi Amazon Bedrock jako zewnętrznego dostawcy modeli, klienci muszą upewnić się, że aplikacja Bedrock jest włączona w określonym regionie platformy AWS, a określona para kluczy platformy AWS ma odpowiednie uprawnienia do interakcji z usługami Bedrock. Aby uzyskać więcej informacji, zobacz AWS Identity and Access Management (Zarządzanie tożsamościami i dostępem na platformie AWS).

W poniższym przykładzie pokazano, jak utworzyć punkt końcowy w usłudze Amazon Bedrock przy użyciu kluczy dostępu.

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

Jeśli występują problemy z uprawnieniami platformy AWS, usługa Databricks zaleca sprawdzenie poświadczeń bezpośrednio za pomocą interfejsu API Amazon Bedrock.

Laboratoria AI21

Dostawca niestandardowy

W poniższym przykładzie pokazano, jak utworzyć interfejs końcowy z niestandardowym dostawcą przy użyciu uwierzytelniania nosiciela :

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

W poniższym przykładzie pokazano, jak utworzyć punkt końcowy z dostawcą niestandardowym przy użyciu uwierzytelniania klucza 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}}"
                        }
                    }
                }
            }
        ]
    },
)

Konfigurowanie bramy sztucznej inteligencji na urządzeniu końcowym

Możesz również skonfigurować punkt końcowy, aby włączyć funkcje Mosaic AI Gateway, takie jak ograniczanie szybkości, śledzenie użycia i wprowadzenie zabezpieczeń.

Zobacz Konfigurowanie bramy AI na punktach końcowych obsługi modelu.

Wykonywanie zapytań względem zewnętrznego punktu końcowego modelu

Po utworzeniu zewnętrznego punktu końcowego modelu jest on gotowy do odbierania ruchu od użytkowników.

Żądania oceniania można wysyłać do punktu końcowego przy użyciu klienta OpenAI, interfejsu API REST lub zestawu SDK wdrożeń MLflow.

• Zobacz standardowe parametry zapytania dla żądania oceny w POST /serving-endpoints/{name}/wywołania.
• Modele podstaw zapytań

Poniższy przykład wysyła zapytanie do modelu uzupełniania claude-2 hostowanego przez Anthropic, wykorzystując klienta OpenAI. Aby użyć klienta OpenAI, wypełnij model pole nazwą punktu końcowego obsługującego model, który hostuje model, którego chcesz wykonać zapytanie.

W tym przykładzie użyto wcześniej utworzonego punktu końcowego , anthropic-completions-endpointskonfigurowanego do uzyskiwania dostępu do modeli zewnętrznych od dostawcy modelu antropicznego. Zobacz, jak tworzyć punkty końcowe modelu zewnętrznego.

Zobacz Obsługiwane modele, aby uzyskać dodatkowe modele, dla których można wykonywać zapytania i ich dostawców.

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)

Oczekiwany format odpowiedzi wyjściowej:

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

dodatkowe parametry zapytania

Możesz przekazać wszelkie dodatkowe parametry obsługiwane przez dostawcę punktu końcowego w ramach zapytania.

Na przykład:

• logit_bias (obsługiwane przez openAI, Cohere).
• top_k (obsługiwane przez Anthropic, Cohere).
• frequency_penalty (obsługiwane przez openAI, Cohere).
• presence_penalty (obsługiwane przez openAI, Cohere).
• stream (obsługiwane przez OpenAI, Anthropic, Cohere, Amazon Bedrock for Anthropic). Jest to dostępne tylko w przypadku żądań czatu i żądań zakończenia.

• tools (obsługiwane przez OpenAI, Anthropic, Amazon Bedrock for Anthropic). Jest to dostępne tylko w przypadku żądań czatu i prośb o zakończenie. Ten parametr umożliwia integrację funkcji zewnętrznych, w tym Computer Use (beta) dla Anthropic oraz Amazon Bedrock dla Anthropic. Zobacz Wywoływanie funkcji w usłudze Azure Databricks.

Obsługa konfiguracji łączności sieciowej dla modeli zewnętrznych

Obsługa konfiguracji łączności sieciowej (NCC) dla modeli zewnętrznych, w tym usługi Azure Private Link, jest obecnie dostępna w prywatnej wersji zapoznawczej. Skontaktuj się z zespołem odpowiedzialnym za konto Databricks, aby wziąć udział w wersji testowej.

Ograniczenia

W zależności od wybranego modelu zewnętrznego konfiguracja może spowodować przetwarzanie danych poza regionem, w którym pochodzą dane. Zobacz Limity i regiony serwowania modeli.

Dodatkowe zasoby

• Samouczek: tworzenie zewnętrznych punktów końcowych modelu w celu wykonywania zapytań dotyczących modeli OpenAI.
• Modele podstawowe zapytań.