Generowanie uporządkowanych danych wyjściowych za pomocą interfejsu Gemini API

Python Node.js Go Dart (Flutter) Android Swift Web REST

Gemini domyślnie generuje tekst nieustrukturyzowany, ale niektóre aplikacje wymagają tekstu ustrukturyzowanego. W takich przypadkach możesz ograniczyć Gemini do odpowiadania w formacie JSON, czyli uporządkowanych danych odpowiednich do automatycznego przetwarzania. Możesz też ograniczyć model do odpowiadania jedną z opcji określonych w typie zbiorczym.

Oto kilka przypadków użycia, które mogą wymagać uporządkowanych danych wyjściowych z modelu:

• Utwórz bazę danych firm, pobierając informacje o nich z artykułów prasowych.
• wyodrębniać ze standardowych życiorysów informacje,
• Wyodrębnianie składników z przepisów i wyświetlanie linku do strony internetowej sklepu spożywczego dla każdego składnika.

W promptzie możesz poprosić Gemini o wygenerowanie danych wyjściowych w formacie JSON, ale pamiętaj, że nie ma gwarancji, że model wygeneruje dane w tym formacie. Aby uzyskać bardziej deterministyczną odpowiedź, możesz przekazać konkretny schemat JSON w polu responseSchema, aby Gemini zawsze odpowiadał zgodnie z oczekiwaną strukturą. Więcej informacji o pracy ze schematami znajdziesz w artykule Więcej informacji o schematach JSON.

Z tego przewodnika dowiesz się, jak wygenerować plik JSON za pomocą metody generateContent w wybranym pakiecie SDK lub bezpośrednio za pomocą interfejsu API REST. Przykłady pokazują dane wejściowe w postaci samego tekstu, ale Gemini może też generować odpowiedzi w formacie JSON na potrzeby żądań multimodalnych, które obejmują obrazy, filmy i dźwięk.

Zanim zaczniesz: skonfiguruj projekt i klucz interfejsu API

Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt i klucz interfejsu API.

Wygeneruj kod JSON

Gdy model jest skonfigurowany tak, aby zwracać dane w formacie JSON, odpowiada na każdy prompt z danymi w tym formacie.

Możesz kontrolować strukturę odpowiedzi JSON, podając schemat. Schemat można podać modelowi na 2 sposoby:

• Jako tekst w promptach
• Jako uporządkowany schemat dostarczony w ramach konfiguracji modelu

Podanie schematu jako tekstu w promptach

W tym przykładzie model zwraca przepisy na ciasteczka w określonym formacie JSON.

Ponieważ model otrzymuje specyfikację formatu z tekstu w promptzie, możesz mieć pewną swobodę w sposobie jej przedstawienia. Możesz użyć dowolnego formatu do przedstawienia schematu JSON.

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

const model = genAI.getGenerativeModel({
  model: "gemini-1.5-flash",
});

const prompt = `List a few popular cookie recipes using this JSON schema:

Recipe = {'recipeName': string}
Return: Array<Recipe>`;

const result = await model.generateContent(prompt);
console.log(result.response.text());
controlled_generation.js

Dane wyjściowe mogą wyglądać tak:

[{"recipeName": "Chocolate Chip Cookies"}, {"recipeName": "Oatmeal Raisin Cookies"}, {"recipeName": "Snickerdoodles"}, {"recipeName": "Sugar Cookies"}, {"recipeName": "Peanut Butter Cookies"}]

Przekazywanie schematu w ramach konfiguracji modelu

Ten przykład wykonuje następujące czynności:

1. Tworzy instancję modelu skonfigurowanego za pomocą schematu, aby zwracać odpowiedzi w formacie JSON.
2. Prosimy o zwrócenie przepisów na ciasteczka.

Ta bardziej formalna metoda deklarowania schematu JSON zapewnia większą kontrolę niż poleganie tylko na tekście w promptach.

// Make sure to include these imports:
// import { GoogleGenerativeAI, SchemaType } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

const schema = {
  description: "List of recipes",
  type: SchemaType.ARRAY,
  items: {
    type: SchemaType.OBJECT,
    properties: {
      recipeName: {
        type: SchemaType.STRING,
        description: "Name of the recipe",
        nullable: false,
      },
    },
    required: ["recipeName"],
  },
};

const model = genAI.getGenerativeModel({
  model: "gemini-1.5-pro",
  generationConfig: {
    responseMimeType: "application/json",
    responseSchema: schema,
  },
});

const result = await model.generateContent(
  "List a few popular cookie recipes.",
);
console.log(result.response.text());
controlled_generation.js

Dane wyjściowe mogą wyglądać tak:

[{"recipeName": "Chocolate Chip Cookies"}, {"recipeName": "Oatmeal Raisin Cookies"}, {"recipeName": "Snickerdoodles"}, {"recipeName": "Sugar Cookies"}, {"recipeName": "Peanut Butter Cookies"}]

Więcej informacji o schematach JSON

Gdy skonfigurujesz model tak, aby zwracał odpowiedź w formacie JSON, możesz użyć obiektu Schema do zdefiniowania kształtu danych JSON. Obiekt Schema reprezentuje wybrany podzbiór obiektu schematu OpenAPI 3.0.

Oto reprezentacja w pseudo-formacie JSON wszystkich pól Schema:

{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "propertyOrdering": [
    string
  ],
  "items": {
    object (Schema)
  }
}

Type schematu musi być jednym z typów danych OpenAPI. W przypadku każdego elementu Type prawidłowy jest tylko podzbiór pól. Na liście poniżej każdy typ Type jest powiązany z odpowiednimi polami:

• string -> enum, format
• integer -> format
• number -> format
• boolean
• array -> minItems, maxItems, items
• object -> właściwości, wymagane, propertyOrdering, nullable

Oto kilka przykładowych schematów z prawidłowymi kombinacjami typu i pola:

{ "type": "string", "enum": ["a", "b", "c"] }

{ "type": "string", "format": "date-time" }

{ "type": "integer", "format": "int64" }

{ "type": "number", "format": "double" }

{ "type": "boolean" }

{ "type": "array", "minItems": 3, "maxItems": 3, "items": { "type": ... } }

{ "type": "object",
  "properties": {
    "a": { "type": ... },
    "b": { "type": ... },
    "c": { "type": ... }
  },
  "nullable": true,
  "required": ["c"],
  "propertyOrdering": ["c", "b", "a"]
}

Pełną dokumentację pól schematu, które są używane w Gemini API, znajdziesz w dokumentacji schematu.

Sortowanie obiektów

Gdy pracujesz z schematami JSON w interfejsie Gemini API, ważna jest kolejność właściwości. Domyślnie interfejs API sortuje właściwości alfabetycznie i nie zachowuje kolejności, w jakiej są one zdefiniowane (chociaż pakiety SDK Google Gen AI mogą zachować tę kolejność). Jeśli przekazujesz modelowi przykłady z skonfigurowanym schematem, a kolejność właściwości przykładów nie jest zgodna z kolejnością właściwości schematu, wynik może być niejasny lub nieoczekiwany.

Aby zapewnić spójne i przewidywalne sortowanie właściwości, możesz użyć opcjonalnego pola propertyOrdering[].

"propertyOrdering": ["recipe_name", "ingredients"]

propertyOrdering[] – nie jest to standardowe pole w specyfikacji OpenAPI – to tablica ciągów znaków służąca do określania kolejności właściwości w odpowiedzi. Określając kolejność właściwości, a następnie podając przykłady z tymi właściwościami w tej samej kolejności, możesz potencjalnie poprawić jakość wyników.