Share via

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 obsługujące modele podstawowe.

Obsługa modeli usługi Databricks obsługuje następujące modele podstawowe:

  • Najnowocześniejsze otwarte modele udostępniane przez interfejsy API modelu foundation. Te modele są nadzorowanymi architekturami modeli podstawowych, które obsługują zoptymalizowane wnioskowanie. Modele podstawowe, takie jak Llama-2-70B-chat, BGE-Large i Mistral-7B, są dostępne do natychmiastowego użycia z cenami płatności 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.
  • Modele zewnętrzne. Są to 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 podstawowe, takie jak GPT-4 OpenAI, Claude Anthropic i inne.

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

W poniższym artykule opisano sposób tworzenia punktu końcowego obsługującego model podstawowy udostępniany przy użyciu modeli zewnętrznych usługi Databricks. W przypadku punktów końcowych, które obsługują precyzyjne warianty modeli udostępnianych przy użyciu interfejsów API modelu foundation, zobacz Tworzenie punktu końcowego aprowizowanej przepływności przy użyciu interfejsu API REST.

Obsługa interfejsu użytkownika

  1. W polu Nazwa podaj nazwę punktu końcowego.
  2. W sekcji Obsługiwane jednostki
    1. Kliknij pole Jednostka, aby otworzyć formularz Wybierz obsługiwaną jednostkę.
    2. Wybierz pozycję Model zewnętrzny.
    3. Wybierz dostawcę modelu, którego chcesz użyć.
    4. Kliknij pozycję Potwierdź
    5. Podaj nazwę modelu zewnętrznego, którego chcesz użyć. Formularz jest dynamicznie aktualizowany na podstawie wybranego wyboru. Zobacz dostępne modele zewnętrzne.
    6. Wybierz typ zadania. Dostępne zadania to czat, ukończenie i osadzanie.
    7. Podaj szczegóły konfiguracji na potrzeby uzyskiwania dostępu do wybranego dostawcy modelu. Zazwyczaj jest to wpis tajny, który odwołuje się do osobistego tokenu dostępu, który ma być używany przez punkt końcowy do uzyskiwania dostępu do tego modelu.
  3. Kliknij pozycję Utwórz. Zostanie wyświetlona strona Obsługa punktów końcowych z stanem obsługującym punkt końcowy wyświetlany jako Nie wszystko gotowe.

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 podstawowe są dostępne w publicznej wersji zapoznawczej.

Poniższy przykład tworzy punkt końcowy, który obsługuje pierwszą wersję modelu dostarczonego text-embedding-ada-002 przez usługę 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ń platformy 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 podstawowego 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.

Punkty końcowe można również tworzyć na potrzeby uzupełniania i zadań czatu, jak określono w task polu w external_model sekcji konfiguracji. Zobacz Modele zewnętrzne w usłudze Databricks Model Serving dla obsługiwanych modeli i dostawców 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 punktu końcowego modelu podstawowego

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.

Dopóki nowa konfiguracja nie będzie gotowa, stara konfiguracja będzie obsługiwać ruch przewidywania. 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.

Jeśli element 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 elementu external_model, nie można go zaktualizować, aby dodać element external_model.

Interfejs API REST

Aby zaktualizować punkt końcowy modelu podstawowego, zobacz dokumentację konfiguracji aktualizacji interfejsu API REST, aby uzyskać szczegółowe informacje o schemacie żą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ń platformy Mlflow

Aby zaktualizować punkt końcowy modelu podstawowego, zobacz dokumentację konfiguracji aktualizacji interfejsu API REST, aby uzyskać szczegółowe informacje o schemacie żą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