Udostępnij za pośrednictwem

Tworzenie podstawowego modelu obsługującego punkty końcowe

  • Artykuł

Z tego artykułu dowiesz się, jak utworzyć model obsługujący punkty końcowe, które wdrażają i obsługują modele podstawowe.

Usługa Mosaic AI Model Serving obsługuje następujące modele:

  • Modele zewnętrzne. Są to podstawowe modele hostowane poza platformą Databricks. Punkty końcowe obsługujące modele zewnętrzne mogą być centralnie zarządzane, a klienci mogą ustanowić limity szybkości i kontrolę dostępu dla nich. Przykłady obejmują modele bazowe, takie jak GPT-4 OpenAI i Claude Anthropic.
  • Najnowocześniejsze otwarte modele bazowe udostępniane przez Foundation Model APIs. Te modele to starannie dobrane architektury modeli podstawowych, które wspierają zoptymalizowane wnioskowanie. Modele podstawowe, takie jak Meta-Llama-3.1-70B-Instruct, GTE-Large i Mistral-7B, są dostępne do natychmiastowego użycia z opłatami za token. Obciążenia produkcyjne, korzystając z podstawowych lub dostrojonych modeli, można wdrażać z gwarancjami wydajności przy użyciu aprowizowanej przepływności.

Obsługa modelu udostępnia następujące opcje tworzenia punktu końcowego obsługującego model:

  • Interfejs użytkownika obsługującego
  • Interfejs API REST
  • Zestaw SDK wdrożeń MLflow

Aby utworzyć punkty końcowe obsługujące tradycyjne modele uczenia maszynowego lub języka Python, zobacz Tworzenie niestandardowych punktów końcowych obsługujących model.

Wymagania

import mlflow.deployments

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

Tworzenie podstawowego modelu obsługującego punkt końcowy

Możesz utworzyć punkt końcowy, który obsługuje dostrojone warianty modeli bazowych udostępnianych przy użyciu interfejsów API modelu bazowego aprovisionowaną przepływność. Zobacz Tworzenie punktu końcowego przepływności aprowizacji przy użyciu API REST.

W przypadku modeli podstawowych, które są udostępniane przy użyciu interfejsów API modeli podstawowych na zasadach płatności za token, usługa Databricks automatycznie udostępnia określone punkty końcowe, aby uzyskać dostęp do obsługiwanych modeli w obszarze roboczym usługi Databricks. Aby uzyskać do nich dostęp, wybierz kartę Obsługa na lewym pasku bocznym obszaru roboczego. Interfejsy API modelu podstawowego znajdują się w górnej części widoku listy końcowych punktów.

Aby wykonać zapytanie dotyczące tych punktów końcowych, zobacz Modele podstaw zapytań.

Tworzenie zewnętrznego punktu końcowego obsługującego model

W poniższym artykule opisano sposób tworzenia punktu końcowego, który wysyła zapytanie do modelu podstawowego udostępnionego przy użyciu modeli zewnętrznych usługi Databricks.

Dostarczanie interfejsu użytkownika

  1. W polu Nazwa podaj nazwę punktu końcowego.
  2. W sekcji Obsługiwane jednostki
    1. Kliknij pole Entity, aby otworzyć formularz Select served entity (Wybieranie obsługiwanej jednostki).
    2. Wybierz modele Foundation .
    3. W polu Wybierz model podstawowy wybierz dostawcę modelu, którego chcesz użyć z tych wymienionych w obszarze Dostawcy modeli zewnętrznych. Formularz jest dynamicznie aktualizowany na podstawie wyboru dostawcy modelu.
    4. Kliknij Potwierdź.
    5. Podaj szczegóły konfiguracji na potrzeby uzyskiwania dostępu do wybranego dostawcy modelu. Zazwyczaj jest to tajny klucz, który odnosi się do tokenu dostępu osobistego, którego punkt końcowy ma używać do dostępu do tego modelu.
    6. Wybierz zadanie. Dostępne zadania to czat, uzupełnianie i osadzanie.
    7. Wybierz nazwę modelu zewnętrznego, którego chcesz użyć. Lista modeli dynamicznie aktualizuje się na podstawie wybranego zadania. Zobacz dostępne modele zewnętrzne.
  3. Kliknij pozycję Utwórz. Na stronie Obsługa punktów końcowych pojawia się ze stanem obsługi punktu końcowego wyświetlanym jako Niegotowy.

Tworzenie punktu końcowego obsługującego model

Interfejs API REST

Ważne

Parametry interfejsu API REST do tworzenia punktów końcowych obsługujących modele zewnętrzne znajdują się w publicznej wersji zapoznawczej.

Poniższy przykład tworzy punkt końcowy, który obsługuje pierwszą wersję modelu text-embedding-ada-002 dostarczonego przez OpenAI.

Zobacz POST /api/2.0/serving-endpoints, aby uzyskać parametry konfiguracji punktu końcowego.

{
  "name": "openai_endpoint",
  "config":
  {
    "served_entities":
    [
      {
        "name": "openai_embeddings",
        "external_model":{
          "name": "text-embedding-ada-002",
          "provider": "openai",
          "task": "llm/v1/embeddings",
          "openai_config":{
            "openai_api_key": "{{secrets/my_scope/my_openai_api_key}}"
          }
        }
      }
    ]
  },
  "rate_limits": [
    {
      "calls": 100,
      "key": "user",
      "renewal_period": "minute"
    }
  ],
  "tags": [
    {
      "key": "team",
      "value": "gen-ai"
    }
  ]
}

Poniżej znajduje się przykładowa odpowiedź.

{
  "name": "openai_endpoint",
  "creator": "user@email.com",
  "creation_timestamp": 1699617587000,
  "last_updated_timestamp": 1699617587000,
  "state": {
    "ready": "READY"
  },
  "config": {
    "served_entities": [
      {
        "name": "openai_embeddings",
        "external_model": {
          "provider": "openai",
          "name": "text-embedding-ada-002",
          "task": "llm/v1/embeddings",
          "openai_config": {
            "openai_api_key": "{{secrets/my_scope/my_openai_api_key}}"
          }
        },
        "state": {
          "deployment": "DEPLOYMENT_READY",
          "deployment_state_message": ""
        },
        "creator": "user@email.com",
        "creation_timestamp": 1699617587000
      }
    ],
    "traffic_config": {
      "routes": [
        {
          "served_model_name": "openai_embeddings",
          "traffic_percentage": 100
        }
      ]
    },
    "config_version": 1
  },
  "tags": [
    {
      "key": "team",
      "value": "gen-ai"
    }
  ],
  "id": "69962db6b9db47c4a8a222d2ac79d7f8",
  "permission_level": "CAN_MANAGE",
  "route_optimized": false
}

Zestaw SDK wdrożeń MLflow

Poniżej przedstawiono sposób tworzenia punktu końcowego na potrzeby osadzania za pomocą interfejsu OpenAI text-embedding-ada-002.

W przypadku punktów końcowych modelu zewnętrznego należy podać klucze interfejsu API dla dostawcy modelu, którego chcesz użyć. Zobacz POST /api/2.0/serving-endpoints w interfejsie API REST, aby uzyskać szczegółowe informacje o schemacie żądania i odpowiedzi. Aby zapoznać się z przewodnikiem krok po kroku, zobacz Samouczek: tworzenie zewnętrznych punktów końcowych modelu w celu wykonywania zapytań dotyczących modeli OpenAI.

Punkty końcowe można również tworzyć na potrzeby uzupełnień i zadań czatu, określonych przez pole task w sekcji external_model konfiguracji. Zobacz Modele zewnętrzne w narzędziu Mosaic AI Model Serving, aby zapoznać się z obsługiwanymi modelami i dostawcami dla każdego zadania.


from mlflow.deployments import get_deploy_client

client = get_deploy_client("databricks")
endpoint = client.create_endpoint(
    name="chat",
    config={
        "served_entities": [
            {
                "name": "completions",
                "external_model": {
                    "name": "gpt-4",
                    "provider": "openai",
                    "task": "llm/v1/chat",
                    "openai_config": {
                        "openai_api_key": "{{secrets/scope/key}}",
                    },
                },
            }
        ],
    },
)
assert endpoint == {
    "name": "chat",
    "creator": "alice@company.com",
    "creation_timestamp": 0,
    "last_updated_timestamp": 0,
    "state": {...},
    "config": {...},
    "tags": [...],
    "id": "88fd3f75a0d24b0380ddc40484d7a31b",
}

Aktualizowanie modelu obsługującego punkty końcowe

Po włączeniu punktu końcowego modelu można ustawić konfigurację obliczeniową zgodnie z potrzebami. Ta konfiguracja jest szczególnie przydatna, jeśli potrzebujesz dodatkowych zasobów dla modelu. Rozmiar obciążenia i konfiguracja obliczeniowa odgrywają kluczową rolę w zasobach przydzielonych do obsługi modelu.

Do czasu aż nowa konfiguracja będzie gotowa, stara konfiguracja będzie obsługiwać ruch związany z przewidywaniem. Chociaż trwa aktualizacja, nie można wprowadzić innej aktualizacji. W interfejsie użytkownika obsługującego możesz anulować aktualizację konfiguracji w toku, wybierając pozycję Anuluj aktualizację w prawym górnym rogu strony szczegółów punktu końcowego. Ta funkcja jest dostępna tylko w interfejsie użytkownika obsługującego.

Gdy external_model znajduje się w konfiguracji punktu końcowego, lista obsługiwanych jednostek może mieć tylko jeden obiekt served_entity. Nie można zaktualizować istniejących punktów końcowych z elementem external_model , aby nie mieć już elementu external_model. Jeśli punkt końcowy jest tworzony bez external_model, nie można go zaktualizować, aby dodać external_model.

API REST

Aby zaktualizować swój punkt końcowy, zobacz dokumentację konfiguracji aktualizacji interfejsu API REST , aby uzyskać szczegóły schematu żądania i odpowiedzi.

{
  "name": "openai_endpoint",
  "served_entities":
  [
    {
      "name": "openai_chat",
      "external_model":{
        "name": "gpt-4",
        "provider": "openai",
        "task": "llm/v1/chat",
        "openai_config":{
          "openai_api_key": "{{secrets/my_scope/my_openai_api_key}}"
        }
      }
    }
  ]
}

Zestaw SDK wdrożeń MLflow

Aby zaktualizować swój punkt końcowy, zobacz dokumentację konfiguracji aktualizacji interfejsu API REST , aby uzyskać szczegóły schematu żądania i odpowiedzi.

from mlflow.deployments import get_deploy_client

client = get_deploy_client("databricks")
endpoint = client.update_endpoint(
    endpoint="chat",
    config={
        "served_entities": [
            {
                "name": "chats",
                "external_model": {
                    "name": "gpt-4",
                    "provider": "openai",
                    "task": "llm/v1/chat",
                    "openai_config": {
                        "openai_api_key": "{{secrets/scope/key}}",
                    },
                },
            }
        ],
    },
)
assert endpoint == {
    "name": "chats",
    "creator": "alice@company.com",
    "creation_timestamp": 0,
    "last_updated_timestamp": 0,
    "state": {...},
    "config": {...},
    "tags": [...],
    "id": "88fd3f75a0d24b0380ddc40484d7a31b",
  }

rate_limits = client.update_endpoint(
    endpoint="chat",
    config={
        "rate_limits": [
            {
                "key": "user",
                "renewal_period": "minute",
                "calls": 10,
            }
        ],
    },
)
assert rate_limits == {
    "rate_limits": [
        {
            "key": "user",
            "renewal_period": "minute",
            "calls": 10,
        }
    ],
}

Dodatkowe zasoby