Generowanie danych strukturalnych na potrzeby funkcji hybrydowych w aplikacjach internetowych

Modele Gemini domyślnie zwracają odpowiedzi w postaci nieustrukturyzowanego tekstu. Niektóre przypadki użycia wymagają jednak tekstu strukturalnego (np. JSON lub wyliczenia). Możesz na przykład używać odpowiedzi do innych zadań, 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. Dzięki temu możesz 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 schematem.
    Model może na przykład 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 dodanie do tekstu określonego zestawu etykiet (np. określonego zestawu wyliczeń, takich jak positive i negative), a nie etykiet generowanych przez model (które mogą się różnić, 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 (takich jak JSON i wyliczenia) jest obsługiwane w przypadku wnioskowania z użyciem modeli hostowanych w chmurze i na urządzeniu.

  • Tryby wnioskowania hybrydowego: skonfiguruj oba tryby inCloudParams i onDeviceParams tak, aby model odpowiadał za pomocą danych strukturalnych 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: w inCloudParams określ responseMimeType (application/json w przypadku JSON lub text/x.enum w przypadku wyliczeń) i responseSchema.

  • 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 po tworzeniu środowisk hybrydowych.


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

Dane wyjściowe JSON

W tych przykładach 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ć na jeden z tych sposobów:

  • Firebase Schema metody pomocnicze (zalecane): używaj metod pomocniczych (np. Schema.object() i Schema.enumString()), aby pisać zwięzłe, 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 schematu obiektu użyto metod pomocniczych Schema (takich jak Schema.object, Schema.array, Schema.string i Schema.number) udostępnianych przez pakiet SDK Firebase AI Logic.

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, 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 przy użyciu JSON.

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, 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ć na jeden z tych sposobów:

  • Firebase Schema metody pomocnicze (zalecane): używaj metod pomocniczych (np. Schema.object() i Schema.enumString()), aby pisać zwięzłe, 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 wyliczeniowych użyto metody pomocniczej Schema.enumString udostępnianej przez pakiet SDK Firebase AI Logic.

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, 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 za pomocą JSON.

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, 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