Dane wyjściowe ze strukturą w usłudze Azure Databricks

Strukturalne wyjścia w Azure Databricks pozwalają generować odpowiedzi w określonym formacie JSON jako część workflow aplikacji AI. Pracują z dowolnym obsługiwanym modelem czatu przez pole response_format operacyjne. Używasz tego samego formatu żądania niezależnie od dostawcy modelu. Azure Databricks obsługuje wszelkie tłumaczenia specyficzne dla dostawcy, więc nie musisz używać natywnego formatu strukturalnych wyjść danego dostawcy.

Tip

Kod Genie (tryb agenta) może to zrobić za Ciebie. Wypróbuj ten przykładowy monit:

Query the databricks-gpt-oss-20b model with a JSON schema response format to extract title, authors, abstract, and keywords from a research paper description. Note: this model returns content as a list of blocks; extract the block with type "text" and parse it.

Co to są dane wyjściowe strukturyzowane?

Dane wyjściowe ze strukturą umożliwiają generowanie danych strukturalnych w postaci obiektów JSON na podstawie danych wejściowych. Możesz wygenerować tekst, obiekty JSON bez struktury i obiekty JSON zgodne z określonym schematem JSON. Dane wyjściowe o ustalonej strukturze są obsługiwane przez modele czatu korzystające z interfejsów API modeli bazowych, które działają na zasadzie opłat za token oraz przez aprowizowane punkty końcowe wydajności.

Usługa Databricks zaleca używanie danych wyjściowych ze strukturą w następujących scenariuszach:

  • Wyodrębnianie danych z dużych ilości dokumentów. Na przykład identyfikowanie i klasyfikowanie opinii o recenzji produktu jako negatywne, pozytywne lub neutralne.
  • Zadania wnioskowania wsadowego, które wymagają danych wyjściowych w określonym formacie.
  • Przetwarzanie danych, takie jak przekształcanie danych bez struktury na dane ustrukturyzowane.

Używanie danych wyjściowych ze strukturą

Określ ustrukturyzowane dane wyjściowe przy użyciu response_format w żądaniu czatu. Zobacz Odniesienie do modelu Foundation API REST.

Poniżej przedstawiono przykład wyodrębniania danych dokumentów badawczych do określonego schematu JSON.

import os
import json
from openai import OpenAI

DATABRICKS_TOKEN = os.environ.get('YOUR_DATABRICKS_TOKEN')
DATABRICKS_BASE_URL = os.environ.get('YOUR_DATABRICKS_BASE_URL')

client = OpenAI(
  api_key=DATABRICKS_TOKEN,
  base_url=DATABRICKS_BASE_URL
  )

response_format = {
      "type": "json_schema",
      "json_schema": {
        "name": "research_paper_extraction",
        "schema": {
          "type": "object",
          "properties": {
            "title": { "type": "string" },
            "authors": {
              "type": "array",
              "items": { "type": "string" }
            },
            "abstract": { "type": "string" },
            "keywords": {
              "type": "array",
              "items": { "type": "string" }
            }
          },
        },
        "strict": True
      }
    }

messages = [{
        "role": "system",
        "content": "You are an expert at structured data extraction. You will be given unstructured text from a research paper and should convert it into the given structure."
      },
      {
        "role": "user",
        "content": "..."
      }]

response = client.chat.completions.create(
    model="databricks-gpt-oss-20b",
    messages=messages,
    response_format=response_format
)

print(json.dumps(response.choices[0].message.model_dump()['content'], indent=2))

Poniżej przedstawiono przykład wyodrębniania JSON, ale schemat JSON nie jest znany wcześniej.

import os
import json
from openai import OpenAI

DATABRICKS_TOKEN = os.environ.get('YOUR_DATABRICKS_TOKEN')
DATABRICKS_BASE_URL = os.environ.get('YOUR_DATABRICKS_BASE_URL')

client = OpenAI(
  api_key=DATABRICKS_TOKEN,
  base_url=DATABRICKS_BASE_URL
  )

response_format = {
      "type": "json_object",
    }

messages = [
      {
        "role": "user",
        "content": "Extract the name, size, price, and color from this product description as a JSON object:\n<description>\nThe SmartHome Mini is a compact smart home assistant available in black or white for only $49.99. It's 5 inches wide.\n</description>"
      }]

response = client.chat.completions.create(
    model="databricks-gpt-oss-20b",
    messages=messages,
    response_format=response_format
)

print(json.dumps(response.choices[0].message.model_dump()['content'], indent=2))

Schemat JSON

Interfejsy API modeli bazowych szeroko wspierają ustrukturyzowane dane wyjściowe akceptowane przez OpenAI. Jednak użycie prostszego schematu JSON dla definicji schematu JSON powoduje generowanie JSON o wyższej jakości. Aby podwyższyć jakość generowania, interfejsy API modelu fundacyjnego obsługują tylko podzestaw specyfikacji schematu JSON .

Następujące klucze definicji wywołań funkcji nie są obsługiwane:

  • Wyrażenia regularne wykorzystujące pattern.
  • Złożone zagnieżdżanie lub komponowanie schematów i ich walidacja przy użyciu: anyOf, oneOf, allOf, prefixItems lub $ref.
  • Listy typów z wyjątkiem specjalnego przypadku [type, “null”], w którym jeden typ na liście jest prawidłowym typem JSON, a drugi jest "null"

Strukturalne wyniki z modelami Anthropic Claude

Poniższy przykład wyodrębnia dane do konkretnego schematu JSON za pomocą modelu Claude'a. Jedyną zmianą względem poprzednich przykładów jest wartość model .

import os
import json
from openai import OpenAI

DATABRICKS_TOKEN = os.environ.get('YOUR_DATABRICKS_TOKEN')
DATABRICKS_BASE_URL = os.environ.get('YOUR_DATABRICKS_BASE_URL')

client = OpenAI(
  api_key=DATABRICKS_TOKEN,
  base_url=DATABRICKS_BASE_URL
  )

response_format = {
      "type": "json_schema",
      "json_schema": {
        "name": "research_paper_extraction",
        "schema": {
          "type": "object",
          "properties": {
            "title": { "type": "string" },
            "authors": {
              "type": "array",
              "items": { "type": "string" }
            },
            "abstract": { "type": "string" },
            "keywords": {
              "type": "array",
              "items": { "type": "string" }
            }
          },
        },
        "strict": True
      }
    }

messages = [{
        "role": "system",
        "content": "You are an expert at structured data extraction. You will be given unstructured text from a research paper and should convert it into the given structure."
      },
      {
        "role": "user",
        "content": "..."
      }]

response = client.chat.completions.create(
    model="databricks-claude-sonnet-4-5",
    messages=messages,
    response_format=response_format
)

print(json.dumps(response.choices[0].message.model_dump()['content'], indent=2))

Modele Claude'a mają dodatkowe ograniczenia dla wyników strukturalnych. Zobacz sekcję Ograniczenia.

Użycie tokenu

Iniekcja monitów i inne techniki są używane w celu zwiększenia jakości ustrukturyzowanych danych wyjściowych. Ma to wpływ na liczbę tokenów wejściowych i wyjściowych używanych przez model, co z kolei powoduje implikacje dotyczące rozliczeń.

Ograniczenia

  • Maksymalna liczba kluczy określonych w schemacie JSON wynosi 64.
  • Interfejsy API modelu foundation nie wymuszają ograniczeń dotyczących długości ani rozmiaru obiektów i tablic.
    • Obejmuje to słowa kluczowe, takie jak maxProperties, minPropertiesi maxLength.
  • Silnie zagnieżdżone schematy JSON powodują generowanie niższej jakości. Jeśli to możliwe, spróbuj spłaszczać schemat JSON, aby uzyskać lepsze wyniki.

Modele Anthropic Claude mają następujące dodatkowe ograniczenia dla wyników strukturalnych:

  • Obsługiwany json_schema jest tylko typ strukturalnego wyjścia. json_object nie jest obsługiwana. Dla wyjścia bez ograniczeń pomijamy response_format.
  • Strukturalne wyjścia nie są wspierane przez streaming. Ustaw stream tak, że false gdy określasz .response_format
  • Parametr response_format dla wyjść strukturalnych Claude'a nie może być połączony z tools lub tool_choice.
  • Last updated on