Generowanie danych strukturalnych na potrzeby funkcji hybrydowych w aplikacjach internetowych

Modele Gemini domyślnie zwracają odpowiedzi w postaci nieustrukturyzowanego tekstu. W niektórych przypadkach użycia wymagany jest jednak tekst strukturalny (np. JSON lub wyliczenia). Możesz na przykład używać odpowiedzi w innych zadaniach, które wymagają ustalonego schematu danych.

Aby mieć pewność, że wygenerowane dane wyjściowe modelu zawsze są zgodne z określonym schematem, możesz zdefiniować schemat, który działa jak plan odpowiedzi modelu. Możesz wtedy bezpośrednio wyodrębniać dane z wyników modelu, co wymaga mniej przetwarzania końcowego.

Oto kilka przykładowych przypadków użycia:

  • Sprawdź, czy odpowiedź modelu zawiera prawidłowy kod JSON i jest zgodna z podanym przez Ciebie schematem.
    Na przykład model może generować uporządkowane wpisy dotyczące przepisów, które zawsze zawierają nazwę przepisu, listę składników i kroki. Dzięki temu możesz łatwiej analizować i wyświetlać te informacje w interfejsie aplikacji.

  • Ograniczanie sposobu, w jaki model może odpowiadać podczas zadań klasyfikacji.
    Możesz na przykład poprosić model o oznaczanie tekstu określonym zestawem etykiet (np. określonym zestawem wyliczeń, takim jak positive i negative), a nie etykietami generowanymi przez model (które mogą mieć pewien stopień zmienności, np. good, positive, negative lub bad).

Z tego artykułu dowiesz się, jak generować dane wyjściowe w formacie strukturalnym (np. JSON i wyliczenia) w przypadku hybrydowych interfejsów aplikacji internetowych.

 Przejdź do danych wyjściowych JSON  Przejdź do danych wyjściowych wyliczenia

Konfiguracja uporządkowanych danych wyjściowych

Generowanie danych wyjściowych o strukturze (np. JSON i wyliczenia) jest obsługiwane w przypadku wnioskowania przy użyciu modeli hostowanych w chmurze i na urządzeniu.

  • Tryby wnioskowania hybrydowego: skonfiguruj zarówno inCloudParams jak i onDeviceParams tak, aby model odpowiadał w postaci strukturalnych danych wyjściowych niezależnie od tego, czy wnioskowanie jest przeprowadzane w chmurze czy na urządzeniu:

    • W przypadku modeli na urządzeniu: określ responseConstraint w onDeviceParams, używając schematu utworzonego za pomocą Schema metod pomocniczych lub zwykłego schematu JSON.

    • W przypadku modeli hostowanych w chmurze: określ responseMimeType (application/json w przypadku JSON lub text/x.enum w przypadku wyliczeń) i responseSchema w inCloudParams.

  • Tryby wnioskowania inne niż hybrydowe: używaj tylko odpowiedniej konfiguracji opisanej powyżej.

Zanim zaczniesz

Kliknij Gemini API dostawcę, aby wyświetlić na tej stronie treści i kod dostawcy.

Upewnij się, że masz za sobą przewodnik dla początkujących dotyczący tworzenia środowisk hybrydowych.


 Przejdź do danych wyjściowych JSON  Przejdź do danych wyjściowych wyliczenia

Dane wyjściowe JSON

W przykładach poniżej dostosowano ogólny przykład danych wyjściowych JSON do wnioskowania hybrydowego (np. PREFER_ON_DEVICE).

W scenariuszu tych przykładów model generuje listę profili postaci do opowiadania fantasy ze strukturalnymi atrybutami, takimi jak imię, wiek, gatunek i opcjonalne akcesoria.

Schematy odpowiedzi możesz zdefiniować za pomocą jednej z tych metod:

  • Metody pomocnicze Firebase Schema (zalecane): używaj metod pomocniczych (np. Schema.object() i Schema.enumString()), aby pisać zwięzłe i kompaktowe schematy bezpośrednio w kodzie bez dodatkowego kodu standardowego.

  • Zwykły schemat JSON: użyj standardowego obiektu schematu JSON, jeśli masz już definicje schematów, udostępniasz schematy na różnych platformach lub w usługach backendu albo importujesz schematy z plików JSON.

Przykład 1. Korzystanie z metod pomocniczych Firebase Schema

W tym przykładzie użyto metod pomocniczych Schema (takich jak Schema.object, Schema.array, Schema.string i Schema.number) udostępnianych przez pakiet SDK Firebase AI Logic do zdefiniowania schematu obiektu.

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlać treści dotyczące tego dostawcy. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode,
  Schema
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define a schema using the `Schema` helper methods.
// Optional properties are specified in optionalProperties.
const jsonSchema = Schema.object({
  properties: {
    characters: Schema.array({
      items: Schema.object({
        properties: {
          name: Schema.string(),
          age: Schema.number(),
          species: Schema.string(),
          accessory: Schema.string()
        },
        optionalProperties: ["accessory"]
      })
    })
  }
});

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    }
  },
  // For on-device models, pass the schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});

const prompt = "Create profiles for some characters for a fantasy story.";

// Generate the structured output.
const result = await model.generateContent(prompt);

// Access the generated JSON string conforming to the schema from response.text().
console.log(result.response.text());

// Parse the JSON string into a JavaScript object.
console.log(JSON.parse(result.response.text()));

Przykład 2. Używanie zwykłego schematu JSON

W tym przykładzie schemat jest zdefiniowany tylko za pomocą kodu JSON.

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlać treści dotyczące tego dostawcy. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define the schema as a plain JSON object.
// Properties are required by default unless omitted from the required array.
const jsonSchema = {
  type: "object",
  properties: {
    characters: {
      type: "array",
      items: {
        type: "object",
        properties: {
          name: {
            type: "string",
            nullable: false
          },
          age: {
            type: "number",
            nullable: false
          },
          species: {
            type: "string",
            nullable: false
          },
          accessory: {
            type: "string",
            nullable: true
          }
        },
        nullable: false,
        required: [
          "name",
          "age",
          "species"
        ]
      },
      nullable: false
    }
  },
  nullable: false,
  required: [
    "characters"
  ]
};

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    }
  },
  // For on-device models, pass the schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});

const prompt = "Create profiles for some characters for a fantasy story.";

// Generate the structured output.
const result = await model.generateContent(prompt);

// Access the generated JSON string conforming to the schema from response.text().
console.log(result.response.text());

// Parse the JSON string into a JavaScript object.
console.log(JSON.parse(result.response.text()));

Dane wyjściowe typu wyliczeniowego

W przykładach poniżej dostosowano ogólny przykład danych wyjściowych wyliczenia do wnioskowania hybrydowego (np. PREFER_ON_DEVICE).

W scenariuszu tych przykładów model klasyfikuje opis filmu, wybierając jeden gatunek z wstępnie zdefiniowanej listy dozwolonych opcji (drama, comedy lub documentary).

Schematy odpowiedzi możesz zdefiniować za pomocą jednej z tych metod:

  • Metody pomocnicze Firebase Schema (zalecane): używaj metod pomocniczych (np. Schema.object() i Schema.enumString()), aby pisać zwięzłe i kompaktowe schematy bezpośrednio w kodzie bez dodatkowego kodu standardowego.

  • Zwykły schemat JSON: użyj standardowego obiektu schematu JSON, jeśli masz już definicje schematów, udostępniasz schematy na różnych platformach lub w usługach backendu albo importujesz schematy z plików JSON.

Przykład 1. Korzystanie z metod pomocniczych Firebase Schema

W tym przykładzie do zdefiniowania dozwolonych wartości typu wyliczeniowego użyto metody pomocniczej Schema.enumString udostępnianej przez pakiet SDK Firebase AI Logic.

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlać treści dotyczące tego dostawcy. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode,
  Schema
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define an enum schema using the `Schema` helper method with allowed string values.
const enumSchema = Schema.enumString({
  enum: ["drama", "comedy", "documentary"]
});

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "text/x.enum",
      responseSchema: enumSchema
    }
  },
  // For on-device models, pass the enum schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: enumSchema
    }
  }
});

const prompt = `The film aims to educate and inform viewers about real-life
subjects, events, or people. It offers a factual record of a particular topic
by combining interviews, historical footage, and narration. The primary purpose
of a film is to present information and provide insights into various aspects
of reality.`;

// Generate the structured enum output.
const result = await model.generateContent(prompt);

// Access the selected enum value string from response.text().
console.log(result.response.text());

Przykład 2. Używanie zwykłego schematu JSON

W tym przykładzie schemat wyliczenia jest zdefiniowany tylko przy użyciu JSON.

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlać treści dotyczące tego dostawcy. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define the enum schema as a plain JSON object.
const enumSchema = {
  type: "string",
  enum: ["drama", "comedy", "documentary"]
};

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "text/x.enum",
      responseSchema: enumSchema
    }
  },
  // For on-device models, pass the enum schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: enumSchema
    }
  }
});

const prompt = `The film aims to educate and inform viewers about real-life
subjects, events, or people. It offers a factual record of a particular topic
by combining interviews, historical footage, and narration. The primary purpose
of a film is to present information and provide insights into various aspects
of reality.`;

// Generate the structured enum output.
const result = await model.generateContent(prompt);

// Access the selected enum value string from response.text().
console.log(result.response.text());


Prześlij opinię o korzystaniu z usługi Firebase AI Logic