Twórz hybrydowe rozwiązania z modelami na urządzeniu i hostowanymi w chmurze


Tworzenie aplikacji i funkcji opartych na AI z użyciem hybrydowego wnioskowania za pomocą Firebase AI Logic. Hybrydowe wnioskowanie umożliwia uruchamianie wnioskowania z wykorzystaniem modeli na urządzeniu (jeśli są dostępne) i bezproblemowe przechodzenie do modeli hostowanych w chmurze.

W tej wersji hybrydowe wnioskowanie jest dostępne za pomocą pakietu SDK klienta Firebase AI Logic dla sieci z obsługą wnioskowania na urządzeniu w Chrome na komputery.

Przejdź do przykładów kodu

Zalecane przypadki użycia i obsługiwane funkcje

Zalecane przypadki użycia:

  • Korzystanie z modelu na urządzeniu do wnioskowania:

    • Zwiększona prywatność
    • Kontekst lokalny
    • Bezpłatne wnioskowanie
    • Funkcje offline

  • Korzystanie z funkcji hybrydowych:

    • Docieraj do 100% swoich odbiorców niezależnie od dostępności modelu urządzenia

Obsługiwane funkcje i możliwości wnioskowania na urządzeniu:

  • generowanie treści jednoobrotowych, strumieniowych i niestrumieniowych;
  • Generowanie tekstu na podstawie danych wejściowych zawierających tylko tekst
  • generowanie tekstu na podstawie tekstu i obrazu, w tym obrazów w formatach JPEG i PNG;
  • generowanie uporządkowanych danych wyjściowych, w tym w formacie JSON i enumeracji;

Rozpocznij

Z tego przewodnika dowiesz się, jak zacząć korzystać z pakietu SDK Firebase AI Logic do wykonywania hybrydowej analizy na potrzeby sieci Web.

Wnioskowanie z użyciem modelu na urządzeniu korzysta z Prompt API w Chrome, natomiast wnioskowanie z użyciem modelu hostowanego w chmurze korzysta z wybranego przez Ciebie dostawcy Gemini API (Gemini Developer API lub Vertex AI Gemini API).

Krok 1. Skonfiguruj Chrome i Prompt API do działania na urządzeniu

  1. Pobierz najnowszą wersję Chrome w wersji deweloperskiej.

    Wnioskowanie na urządzeniu jest dostępne w Chrome w wersji 138 lub nowszej.

  2. Włącz interfejs Prompt API w swojej instancji Chrome, ustawiając te flagi:

    • chrome://flags/#optimization-guide-on-device-model: ustaw wartość Włączono.
    • chrome://flags/#prompt-api-for-gemini-nano: ustaw wartość Włączono.

    Więcej informacji o używaniu interfejsów API na localhost znajdziesz w dokumentacji Chrome. Opcjonalnie możesz dołączyć do programu wczesnego testowania Chrome (EPP), aby przesyłać opinie.

  3. Aby włączyć model multimodalny na urządzeniu, ustaw tę flagę:

    • chrome://flags/#prompt-api-for-gemini-nano-multimodal-input: ustaw na Włączono.

  4. Weryfikacja interfejsu API lokalnie:

    1. Uruchom ponownie Chrome.

    2. Kliknij Narzędzia dla deweloperów > Konsola.

    3. Wykonaj zapytanie:

      await LanguageModel.availability();

    4. Upewnij się, że dane wyjściowe to available, downloading lub downloadable. .

    5. Jeśli dane wyjściowe to downloadable, możesz rozpocząć pobieranie modelu, wykonując polecenie await LanguageModel.create();. W przeciwnym razie pierwsze żądanie dotyczące wnioskowania na urządzeniu spowoduje w tle pobranie modelu, co może potrwać kilka minut.

Krok 2. Skonfiguruj projekt Firebase i połącz aplikację z Firebase.

  1. Zaloguj się w konsoli Firebase, a potem wybierz projekt Firebase.

  2. W konsoli Firebase otwórz stronę Firebase AI Logic.

  3. Kliknij Rozpocznij, aby uruchomić skonfigurowany przepływ pracy, który pomoże Ci skonfigurować wymagane interfejsy API i zasoby dla projektu.

  4. Wybierz dostawcę „Gemini API”, którego chcesz używać z pakietami SDK „Firebase AI Logic”. W każdej chwili możesz skonfigurować innego dostawcę interfejsu API i z niego korzystać.

    • Gemini Developer API – opcjonalne rozliczenia (dostępne w bezpłatnym planie cennika Spark)
      – konsola włączy wymagane interfejsy API i utworzy w projekcie klucz interfejsu API Gemini.
      Nie dodawaj tego klucza interfejsu API Gemini do kodu aplikacji. Więcej informacji

      Jeśli chcesz zmienić plan taryfowy, możesz skonfigurować rozliczenia później.

    • Vertex AI Gemini API – wymagane rozliczenia (wymaga planu Blaze z opłatą za użycie)
       – konsola pomoże Ci skonfigurować rozliczenia i włączyć wymagane interfejsy API w projekcie.

  5. Jeśli w ramach procesu w konsoli pojawi się odpowiedni komunikat, postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby zarejestrować aplikację i połączyć ją z Firebase.

  6. Aby dodać pakiet SDK do aplikacji, przejdź do następnego kroku w tym przewodniku.

Krok 3. Dodaj pakiet SDK

Biblioteka Firebase zapewnia dostęp do interfejsów API do interakcji z modelami generatywnymi. Biblioteka jest częścią pakietu Firebase JavaScript SDK na potrzeby internetu.

  1. Zainstaluj pakiet Firebase JS SDK na potrzeby internetu za pomocą npm.

    Funkcja hybrydowa jest dostępna pod innym tagiem npm, więc pamiętaj, aby uwzględnić go w komandach instalacji.

    npm install firebase@eap-ai-hybridinference

  2. Inicjalizacja Firebase w aplikacji:

    import { initializeApp } from "firebase/app";

// 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);

Krok 4. Inicjuj usługę i utwórz instancję modelu.

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod związane z tym dostawcą.

Zanim wyślesz prompt do modelu Gemini, zainicjuj usługę wybranego dostawcy interfejsu API i utwórz instancję GenerativeModel.

Ustaw wartość mode na jedną z tych opcji:

  • prefer_on_device: konfiguruje pakiet SDK tak, aby używał modelu na urządzeniu, jeśli jest on dostępny, lub przełączył się na model hostowany w chmurze.

  • only_on_device: konfiguruje pakiet SDK do korzystania z modelu na urządzeniu lub zgłasza wyjątek.

  • only_in_cloud: skonfiguruj pakiet SDK tak, aby nigdy nie używał modelu na urządzeniu.

Domyślnie, gdy używasz prefer_on_device lub only_in_cloud, model hostowany w chmurze ma wartość gemini-2.0-flash-lite, ale możesz zastąpić ustawienie domyślne.

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } 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() });

// Create a `GenerativeModel` instance
// Set the mode, for example to use on-device model when possible
const model = getGenerativeModel(ai, { mode: "prefer_on_device" });

Wysyłanie żądania prompta do modelu

W tej sekcji znajdziesz przykłady przesyłania różnych typów danych wejściowych w celu generowania różnych typów danych wyjściowych, w tym:

Jeśli chcesz wygenerować dane wyjściowe w postaci uporządkowanej (np. w formacie JSON lub enum), użyj jednego z tych przykładów „generowania tekstu” i dodatkowo skonfiguruj model, aby odpowiadał zgodnie z dostarczonym schematem.

Generowanie tekstu na podstawie danych wejściowych zawierających tylko tekst

Zanim spróbujesz użyć tego przykładu, przeczytaj sekcję Wprowadzenie w tym przewodniku.

Możesz użyć generateContent() do wygenerowania tekstu z prompta zawierającego tekst:

// Imports + initialization of FirebaseApp and backend service + creation of model instance

// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To generate text output, call `generateContent` with the text input
  const result = await model.generateContent(prompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

generowanie tekstu na podstawie danych wejściowych typu tekst i obraz (multimodalnych);

Zanim spróbujesz użyć tego przykładu, przeczytaj sekcję Wprowadzenie w tym przewodniku.

Możesz użyć generateContent(), aby wygenerować tekst z prompta zawierającego pliki tekstowe i obrazowe. Musisz podać mimeType każdego pliku wejściowego oraz sam plik.

Obsługiwane typy obrazów wejściowych do wnioskowania na urządzeniu to PNG i JPEG.

// Imports + initialization of FirebaseApp and backend service + creation of model instance

// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the image
  const prompt = "Write a poem about this picture:";

  const fileInputEl = document.querySelector("input[type=file]");
  const imagePart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call `generateContent` with the text and image
  const result = await model.generateContent([prompt, imagePart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Co jeszcze możesz zrobić?

Oprócz powyższych przykładów możesz też użyć alternatywnych trybów wnioskowania, zastąpić domyślny model zastępczywy i skonfigurować model, aby kontrolować odpowiedzi.

Używanie alternatywnych trybów wnioskowania

W przykladach powyżej do skonfigurowania pakietu SDK w celu używania modelu na urządzeniu (jeśli jest dostępny) lub korzystania z modelu hostowanego w chmurze użyto trybu prefer_on_device. Pakiet SDK udostępnia 2 alternatywne tryby wnioskowania: only_on_device i only_in_cloud.

  • Użyj trybu only_on_device, aby pakiet SDK mógł korzystać tylko z modelu na urządzeniu. W tej konfiguracji interfejs API zwróci błąd, jeśli model na urządzeniu jest niedostępny.

    const model = getGenerativeModel(ai, { mode: "only_on_device" });

  • Użyj trybu only_in_cloud, aby pakiet SDK mógł korzystać tylko z modelu hostowanego w chmurze.

    const model = getGenerativeModel(ai, { mode: "only_in_cloud" });

Zastępowanie domyślnego modelu zastępczego

Jeśli używasz trybu prefer_on_device, pakiet SDK użyje modelu hostowanego w chmurze, jeśli model na urządzeniu jest niedostępny. Domyślny model zapasowy hostowany w chmurze to gemini-2.0-flash-lite. Ten model hostowany w chmurze jest też domyślnie używany w trybie only_in_cloud.

Opcja konfiguracji inCloudParams pozwala określić alternatywny domyślny model hostowany w chmurze:

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
  }
});

Znajdź nazwy wszystkich obsługiwanych modeli Gemini.

Używanie konfiguracji modelu do kontrolowania odpowiedzi

W każdym żądaniu wysłanym do modelu możesz dołączyć konfigurację modelu, aby określić, jak model ma generować odpowiedź. Modele hostowane w chmurze i modele na urządzeniu oferują różne opcje konfiguracji.

Konfiguracja jest utrzymywana przez cały okres istnienia instancji. Jeśli chcesz użyć innej konfiguracji, utwórz nową instancję GenerativeModel z tą konfiguracją.

Konfigurowanie modelu hostowanego w chmurze

Aby skonfigurować model Gemini hostowany w chmurze, użyj opcji inCloudParams. Dowiedz się więcej o dostępnych parametrach.

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
    temperature: 0.8,
    topK: 10
  }
});

Konfigurowanie modelu na urządzeniu

Pamiętaj, że wnioskowanie z użyciem modelu na urządzeniu korzysta z interfejsu Prompt API w Chrome.

Aby skonfigurować model na urządzeniu, użyj opcji onDeviceParams. Dowiedz się więcej o dostępnych parametrach.

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  onDeviceParams: {
    createOptions: {
      temperature: 0.8,
      topK: 8
    }
  }
});

Konfigurowanie danych uporządkowanych

Generowanie uporządkowanych danych wyjściowych (np. w formacie JSON i enum) jest obsługiwane w przypadku wnioskowania z wykorzystaniem zarówno modeli hostowanych w chmurze, jak i modeli na urządzeniu.

Aby uzyskać hybrydową analizę, użyj zarówno parametru inCloudParams, jak i onDeviceParams, aby skonfigurować model w celu uzyskania odpowiedzi w formie danych ustrukturyzowanych. W przypadku innych trybów użyj tylko odpowiedniej konfiguracji.

  • W przypadku inCloudParams: podaj odpowiednią wartość responseMimeType (w tym przykładzie application/json) oraz wartość responseSchema, której model ma używać.

  • W przypadku onDeviceParams: podaj responseConstraint, którego ma używać model.

Dane wyjściowe JSON

W tym przykładzie ogólny przykład danych wyjściowych w formacie JSON jest dostosowany do hybrydowego wnioskowania:

import {
  getAI,
  getGenerativeModel,
  Schema
} from "firebase/ai";

const jsonSchema = Schema.object({
 properties: {
    characters: Schema.array({
      items: Schema.object({
        properties: {
          name: Schema.string(),
          accessory: Schema.string(),
          age: Schema.number(),
          species: Schema.string(),
        },
        optionalProperties: ["accessory"],
      }),
    }),
  }
});

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    },
  }
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});
Wyjście typu wyliczeniowego

Podobnie jak wyżej, ale w przypadku wnioskowania hybrydowego dostosuj dokumentację dotyczącą wyjścia enum:

// ...

const enumSchema = Schema.enumString({
  enum: ["drama", "comedy", "documentary"],
});

const model = getGenerativeModel(ai, {

// ...

    generationConfig: {
      responseMimeType: "text/x.enum",
      responseSchema: enumSchema
    },

// ...

Funkcje, które nie są jeszcze dostępne na potrzeby wnioskowania na urządzeniu

Ponieważ jest to wersja eksperymentalna, nie wszystkie funkcje pakietu Web SDK są dostępne do korzystania z inferencji na urządzeniu. Te funkcje nie są jeszcze obsługiwane w ramach wnioskowania na urządzeniu (ale są zwykle dostępne w przypadku wnioskowania w chmurze).

  • Generowanie tekstu na podstawie typów plików obrazów innych niż JPEG i PNG

    • Może korzystać z modelu hostowanego w chmurze. Tryb only_on_device spowoduje jednak błąd.

  • generowanie tekstu na podstawie danych wejściowych w postaci dźwięku, wideo i dokumentów (np. plików PDF);

    • Może korzystać z modelu hostowanego w chmurze. Tryb only_on_device spowoduje jednak błąd.

  • generowanie obrazów za pomocą modeli Gemini lub Imagen,

    • Może korzystać z modelu hostowanego w chmurze. Tryb only_on_device spowoduje jednak błąd.

  • Przesyłanie plików za pomocą adresów URL w żądaniach multimodalnych. Musisz przesłać pliki jako dane wbudowane w modele na urządzeniu.

  • Czat wieloetapowy

    • Może korzystać z modelu hostowanego w chmurze. Tryb only_on_device spowoduje jednak błąd.

  • Transmisja dwukierunkowa z urządzeniem Gemini Live API

    • Pamiętaj, że pakiet SDK klienta Firebase AI Logic na potrzeby przeglądarki nie obsługuje tej funkcji nawet w przypadku modeli hostowanych w chmurze.

  • Wywoływanie funkcji

    • Już wkrótce!

  • Liczba tokenów

    • Zawsze zwraca błąd. Liczba wyświetleń będzie się różnić w przypadku modeli hostowanych w chmurze i na urządzeniu, więc nie ma intuicyjnego rozwiązania zastępczego.

  • Monitorowanie AI w konsoli Firebase do wnioskowania na urządzeniu.

    • Pamiętaj, że wszelkie wnioskowanie z użyciem modeli hostowanych w chmurze można monitorować tak samo jak inne wnioskowanie z użyciem pakietu SDK klienta Firebase AI Logic na potrzeby sieci Web.


Prześlij opinię o swoich wrażeniach związanych z usługą Firebase AI Logic