Samouczek: tworzenie zewnętrznych punktów końcowych modelu w celu wykonywania zapytań dotyczących modeli OpenAI
Ten artykuł zawiera instrukcje krok po kroku dotyczące konfigurowania i wykonywania zapytań dotyczących zewnętrznego punktu końcowego modelu obsługującego modele OpenAI do uzupełniania, czatu i tworzenia osadzeń, korzystając z SDK MLflow Deployments. Dowiedz się więcej o modelach zewnętrznych.
Jeśli wolisz używać interfejsu użytkownika obsługującego do wykonania tego zadania, zobacz Tworzenie zewnętrznego punktu końcowego obsługującego model.
Wymagania
- Databricks Runtime 13.0 ML lub nowszy.
- MLflow 2.9 lub nowszy.
- Klucze interfejsu API openAI.
- Zainstaluj interfejs wiersza polecenia usługi Databricks w wersji 0.205 lub nowszej.
(Opcjonalnie) Krok 0: Przechowaj klucz API OpenAI za pomocą interfejsu wiersza poleceń Databricks Secrets.
Klucze interfejsu API można podać jako ciągi tekstowe w kroku 3 lub za pomocą Azure Databricks Secrets.
Aby przechowywać klucz interfejsu API OpenAI jako sekret, możesz użyć Databricks Secrets CLI w wersji 0.205 lub nowszej. Możesz również użyć interfejsu API REST do zarządzania tajemnicami.
Poniższy kod tworzy zakres wpisów tajnych o nazwie my_openai_secret_scope, a następnie tworzy wpis tajny openai_api_key w tym zakresie.
databricks secrets create-scope my_openai_secret_scope
databricks secrets put-secret my_openai_secret_scope openai_api_key
Krok 1. Instalowanie biblioteki MLflow z obsługą modeli zewnętrznych
Użyj poniższych instrukcji, aby zainstalować wersję platformy MLflow z obsługą modeli zewnętrznych:
%pip install mlflow[genai]>=2.9.0
Krok 2. Tworzenie punktu końcowego modelu zewnętrznego i zarządzanie nim
Ważne
Przykłady kodu w tej sekcji ilustrują użycie zestawu SDK CRUD wdrożeń MLflow w Publicznej Wersji Zapoznawczej.
Aby utworzyć zewnętrzny punkt końcowy modelu dla dużego modelu językowego (LLM), użyj create_endpoint() metody z zestawu MLflow Deployments SDK. Możesz również utworzyć zewnętrzne punkty końcowe modelu w interfejsie użytkownika Serving.
Poniższy fragment kodu tworzy punkt końcowy dopełniania dla OpenAI gpt-3.5-turbo-instruct, zgodnie z określeniem w sekcji served_entities konfiguracji. W przypadku punktu końcowego pamiętaj o wypełnieniu name i openai_api_key unikatowymi wartościami dla każdego pola.
import mlflow.deployments
client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
name="openai-completions-endpoint",
config={
"served_entities": [{
"name": "openai-completions",
"external_model": {
"name": "gpt-3.5-turbo-instruct",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}"
}
}
}]
}
)
Poniższy fragment kodu pokazuje, jak można podać klucz interfejsu API OpenAI jako ciąg w postaci zwykłego tekstu, aby uzyskać alternatywny sposób tworzenia tego samego punktu końcowego uzupełniania, co powyżej.
import mlflow.deployments
client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
name="openai-completions-endpoint",
config={
"served_entities": [{
"name": "openai-completions",
"external_model": {
"name": "gpt-3.5-turbo-instruct",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_key_plaintext": "sk-yourApiKey"
}
}
}]
}
)
Jeśli używasz usługi Azure OpenAI, możesz również określić nazwę wdrożenia usługi Azure OpenAI, adres URL punktu końcowego i wersję interfejsu API w openai_config sekcji konfiguracji.
client.create_endpoint(
name="openai-completions-endpoint",
config={
"served_entities": [
{
"name": "openai-completions",
"external_model": {
"name": "gpt-3.5-turbo-instruct",
"provider": "openai",
"task": "llm/v1/completions",
"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"
},
},
}
],
},
)
Aby zaktualizować punkt końcowy, użyj update_endpoint(). Poniższy fragment kodu pokazuje, jak zaktualizować limity szybkości punktu końcowego do 20 wywołań na minutę na użytkownika.
client.update_endpoint(
endpoint="openai-completions-endpoint",
config={
"rate_limits": [
{
"key": "user",
"renewal_period": "minute",
"calls": 20
}
],
},
)
Krok 3. Wysyłanie żądań do zewnętrznego punktu końcowego modelu
Ważne
Przykłady kodu w tej sekcji przedstawiają użycie metody SDK wdrożeń MLflow predict().
Żądania czatu, uzupełniania i osadzania można wysyłać do zewnętrznego punktu końcowego modelu przy użyciu metody zestawu SDK predict() wdrożeń MLflow.
Poniższe wysyła żądanie do gpt-3.5-turbo-instruct hostowanego przez OpenAI.
completions_response = client.predict(
endpoint="openai-completions-endpoint",
inputs={
"prompt": "What is the capital of France?",
"temperature": 0.1,
"max_tokens": 10,
"n": 2
}
)
completions_response == {
"id": "cmpl-8QW0hdtUesKmhB3a1Vel6X25j2MDJ",
"object": "text_completion",
"created": 1701330267,
"model": "gpt-3.5-turbo-instruct",
"choices": [
{
"text": "The capital of France is Paris.",
"index": 0,
"finish_reason": "stop",
"logprobs": None
},
{
"text": "Paris is the capital of France",
"index": 1,
"finish_reason": "stop",
"logprobs": None
},
],
"usage": {
"prompt_tokens": 7,
"completion_tokens": 16,
"total_tokens": 23
}
}
Krok 4. Porównanie modeli z innego dostawcy
Obsługa modeli obsługuje wielu dostawców modeli zewnętrznych, takich jak Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI i nie tylko. Możesz porównać modele językowe LLM różnych dostawców, co umożliwia optymalizację dokładności, szybkości oraz kosztów aplikacji przy użyciu AI Playground.
Poniższy przykład tworzy punkt końcowy dla Anthropic claude-2 i porównuje jego odpowiedź na pytanie z odpowiedzią korzystającą z OpenAI gpt-3.5-turbo-instruct. Obie odpowiedzi mają ten sam standardowy format, co ułatwia ich porównywanie.
Utwórz punkt końcowy dla Anthropic claude-2
import mlflow.deployments
client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
name="anthropic-completions-endpoint",
config={
"served_entities": [
{
"name": "claude-completions",
"external_model": {
"name": "claude-2",
"provider": "anthropic",
"task": "llm/v1/completions",
"anthropic_config": {
"anthropic_api_key": "{{secrets/my_anthropic_secret_scope/anthropic_api_key}}"
},
},
}
],
},
)
Porównanie odpowiedzi z każdego punktu końcowego
openai_response = client.predict(
endpoint="openai-completions-endpoint",
inputs={
"prompt": "How is Pi calculated? Be very concise."
}
)
anthropic_response = client.predict(
endpoint="anthropic-completions-endpoint",
inputs={
"prompt": "How is Pi calculated? Be very concise."
}
)
openai_response["choices"] == [
{
"text": "Pi is calculated by dividing the circumference of a circle by its diameter."
" This constant ratio of 3.14159... is then used to represent the relationship"
" between a circle's circumference and its diameter, regardless of the size of the"
" circle.",
"index": 0,
"finish_reason": "stop",
"logprobs": None
}
]
anthropic_response["choices"] == [
{
"text": "Pi is calculated by approximating the ratio of a circle's circumference to"
" its diameter. Common approximation methods include infinite series, infinite"
" products, and computing the perimeters of polygons with more and more sides"
" inscribed in or around a circle.",
"index": 0,
"finish_reason": "stop",
"logprobs": None
}
]