Hybride Funktionen in Android-Apps mit On-Device- und Cloud-basierten Modellen entwickeln


Mit Firebase AI Logic können Sie KI-gestützte Android-Apps und ‑Funktionen mit hybrider Inferenz erstellen. Die hybride Inferenz ermöglicht die Ausführung von Inferenz mit On-Device-Modellen, sofern verfügbar, und den nahtlosen Rückgriff auf in der Cloud gehostete Modelle, falls nicht (und umgekehrt).

Auf dieser Seite wird beschrieben, wie Sie mit dem Client-SDK beginnen. Außerdem werden zusätzliche Konfigurationsoptionen und Funktionen wie die Temperatur erläutert.

Die Inferenz auf dem Gerät über Firebase AI Logic wird für Android-Apps unterstützt, die auf bestimmten Geräten ausgeführt werden, und unterliegt den ML Kit-Nutzungsbedingungen sowie den Nutzungsbedingungen für die KI-Aspekte von ML Kit.

Empfohlene Anwendungsfälle und unterstützte Funktionen

Empfohlene Anwendungsfälle

  • Die Verwendung eines On-Device-Modells für die Inferenz bietet folgende Vorteile:

    • Besserer Datenschutz
    • Lokaler Kontext
    • Kostenlose Inferenz
    • Offline-Funktionen

  • Die Verwendung von Hybrid-Funktionen bietet folgende Vorteile:

    • Mehr Nutzer erreichen, indem Sie die Verfügbarkeit von On-Device-Modellen und die Internetverbindung berücksichtigen

Unterstützte Funktionen für die Inferenz auf dem Gerät

Die Inferenz auf dem Gerät unterstützt nur die einmalige Textgenerierung (nicht Chat)> mit Streaming- oder Nicht-Streaming-Ausgabe. Die folgenden Funktionen zur Textgenerierung werden unterstützt:

Sehen Sie sich die Liste der Funktionen, die noch nicht für die Inferenz auf dem Gerät verfügbar sind, unten auf dieser Seite an.

Hinweis

Beachten Sie Folgendes:

  • Unterstützte APIs:

    • Bei der In-Cloud-Inferenz wird der von Ihnen ausgewählte Gemini API-Anbieter verwendet (entweder Gemini Developer API oder Vertex AI Gemini API).

    • Für die Inferenz auf dem Gerät wird die Prompt API aus ML Kit verwendet, die sich in der Betaphase befindet und nur auf bestimmten Geräten verfügbar ist.

  • Auf dieser Seite wird beschrieben, wie Sie loslegen.

    Nachdem Sie die Standardeinrichtung abgeschlossen haben, können Sie sich die zusätzlichen Konfigurationsoptionen und Funktionen ansehen, z. B. das Einstellen der Temperatur.

Unterstützte Android-Geräte und ihre On-Device-Modelle

Eine Liste der unterstützten Geräte und ihrer On-Device-Modelle für die Inferenz auf dem Gerät (die die Prompt API von ML Kit verwendet) finden Sie in der ML Kit-Dokumentation.

Jetzt starten

In dieser Anleitung werden die erforderlichen allgemeinen Einrichtungsschritte für alle unterstützten Prompts beschrieben, die Sie senden möchten.

Schritt 1: Firebase-Projekt einrichten und App mit Firebase verbinden

  1. Melden Sie sich in der Firebase Console an und wählen Sie Ihr Firebase-Projekt aus.

  2. Rufen Sie in der Firebase Console die Seite Firebase AI Logic auf.

  3. Klicken Sie auf Jetzt starten, um einen geführten Workflow zu starten, mit dem Sie die erforderlichen APIs und Ressourcen für Ihr Projekt einrichten können.

  4. Richten Sie Ihr Projekt für die Verwendung eines „Gemini API“-Anbieters ein.

    Wir empfehlen, mit der Gemini Developer API zu beginnen. Sie können jederzeit Vertex AI Gemini API einrichten (und die zugehörigen Abrechnungsanforderungen erfüllen).

    Für die Gemini Developer API werden in der Konsole die erforderlichen APIs aktiviert und ein Gemini-API-Schlüssel in Ihrem Projekt erstellt.
    Fügen Sie diesen Gemini-API-Schlüssel nicht in den Code Ihrer App ein. Weitere Informationen

  5. Folgen Sie der Anleitung auf dem Bildschirm, um Ihre App zu registrieren und mit Firebase zu verbinden.

  6. Fahren Sie mit dem nächsten Schritt in dieser Anleitung fort, um das SDK Ihrer App hinzuzufügen.

Schritt 2: Erforderliche SDKs hinzufügen

Das Firebase AI Logic SDK für Android (firebase-ai) und das Firebase AI Logic On-Device SDK (firebase-ai-ondevice) bieten Zugriff auf die APIs für die Interaktion mit generativen Modellen.

Fügen Sie in der Gradle-Datei Ihres Moduls (auf App-Ebene) (z. B. <project>/<app-module>/build.gradle.kts) die Abhängigkeiten für die Firebase AI Logic-Bibliotheken für Android hinzu:

Kotlin 

dependencies {
  // ... other androidx dependencies

  // Add the dependencies for the Firebase AI Logic libraries
  // Note that the on-device SDK is not yet included in the Firebase Android BoM
  implementation("com.google.firebase:firebase-ai:17.10.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta01")
}

Java

Für Java müssen Sie zwei zusätzliche Bibliotheken hinzufügen.

dependencies {
  // ... other androidx dependencies

  // Add the dependencies for the Firebase AI Logic libraries
  // Note that the on-device SDK is not yet included in the Firebase Android BoM
  implementation("com.google.firebase:firebase-ai:17.10.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta01")

  // Required for one-shot operations (to use `ListenableFuture` from Guava Android)
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations (to use `Publisher` from Reactive Streams)
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

Schritt 3: Prüfen, ob das On-Device-Modell verfügbar ist

Prüfen Sie mit FirebaseAIOnDevice, ob das On-Device-Modell verfügbar ist, und laden Sie es herunter, falls dies nicht der Fall ist.

Nach dem Herunterladen wird das Modell von AICore automatisch auf dem neuesten Stand gehalten. In den Notizen nach dem Snippet finden Sie weitere Informationen zu AICore und zum Verwalten des Downloads des On-Device-Modells.

Kotlin 

val status = FirebaseAIOnDevice.checkStatus()
when (status) {
  OnDeviceModelStatus.UNAVAILABLE -> {
    Log.w(TAG, "On-device model is unavailable")
  }

  OnDeviceModelStatus.DOWNLOADABLE -> {
    FirebaseAIOnDevice.download().collect { status ->
      when (status) {
        is DownloadStatus.DownloadStarted ->
          Log.w(TAG, "Starting download - ${status.bytesToDownload}")

        is DownloadStatus.DownloadInProgress ->
          Log.w(TAG, "Download in progress ${status.totalBytesDownloaded} bytes downloaded")

        is DownloadStatus.DownloadCompleted ->
          Log.w(TAG, "On-device model download complete")

        is DownloadStatus.DownloadFailed ->
          Log.e(TAG, "Download failed ${status}")
      }
    }
  }
  OnDeviceModelStatus.DOWNLOADING -> {
    Log.w(TAG, "On-device model is being downloaded")
  }

  OnDeviceModelStatus.AVAILABLE -> {
    Log.w(TAG, "On-device model is available")
  }
}

Java 

Checking for and downloading the model is not yet available for Java.

However, all other APIs and interactions in this guide are available for Java.

Beachten Sie beim Herunterladen des On-Device-Modells Folgendes:

  • Wie lange das Herunterladen des On-Device-Modells dauert, hängt von vielen Faktoren ab, unter anderem von Ihrem Netzwerk.

  • Wenn in Ihrem Code ein On-Device-Modell für die primäre oder Fallback-Inferenz verwendet wird, muss das Modell frühzeitig im Lebenszyklus Ihrer App heruntergeladen werden, damit es verfügbar ist, bevor Endnutzer auf den Code in Ihrer App stoßen.

  • Wenn das On-Device-Modell bei einer On-Device-Inferenzanfrage nicht verfügbar ist, wird der Download des On-Device-Modells nicht automatisch durch das SDK ausgelöst. Das SDK greift entweder auf das in der Cloud gehostete Modell zurück oder löst eine Ausnahme aus. Weitere Informationen zum Verhalten von Inferenzmodi.

  • AICore (ein Android-Systemdienst) verwaltet für Sie, welches Modell und welche Version heruntergeladen werden, hält das Modell auf dem neuesten Stand usw. Beachten Sie, dass auf dem Gerät nur ein Modell heruntergeladen wird. Wenn also eine andere App auf dem Gerät das On-Device-Modell bereits erfolgreich heruntergeladen hat, wird bei dieser Prüfung zurückgegeben, dass das Modell verfügbar ist.

Latenzoptimierung

Um den ersten Inferenzaufruf zu optimieren, kann Ihre App warmup() aufrufen. Dadurch wird das On-Device-Modell in den Arbeitsspeicher geladen und Laufzeitkomponenten werden initialisiert.

Schritt 4: Dienst initialisieren und Modellinstanz erstellen

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Richten Sie Folgendes ein, bevor Sie eine Prompts-Anfrage an das Modell senden.

  1. Initialisieren Sie den Dienst für den von Ihnen ausgewählten API-Anbieter.

  2. Erstellen Sie eine GenerativeModel-Instanz und legen Sie mode auf einen der folgenden Werte fest. Die Beschreibungen hier sind sehr allgemein gehalten. Details zum Verhalten dieser Modi finden Sie unter Inferenzmodus festlegen.

    • PREFER_ON_DEVICE: Versuch, das On-Device-Modell zu verwenden. Andernfalls auf das in der Cloud gehostete Modell zurückgreifen.

    • ONLY_ON_DEVICE: Versuche, das On-Device-Modell zu verwenden. Andernfalls wird eine Ausnahme ausgelöst.

    • PREFER_IN_CLOUD: Versuche, das in der Cloud gehostete Modell zu verwenden. Andernfalls greife auf das On-Device-Modell zurück.

    • ONLY_IN_CLOUD: Versuchen Sie, das in der Cloud gehostete Modell zu verwenden. Andernfalls wird eine Ausnahme ausgelöst.

Kotlin 

// Using this SDK to access on-device inference is an Experimental release and requires opt-in
@OptIn(PublicPreviewAPI::class)

// ...

// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "MODEL_NAME",
        onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE)
    )

Java 

// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .generativeModel(
        "MODEL_NAME",
        new OnDeviceConfig(InferenceMode.PREFER_ON_DEVICE)
    );

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

Schritt 5: Prompt-Anfrage an ein Modell senden

In diesem Abschnitt erfahren Sie, wie Sie verschiedene Arten von Eingaben senden, um unterschiedliche Arten von Ausgaben zu generieren, darunter:

Text aus reinen Texteingaben generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Erste Schritte dieser Anleitung durchgearbeitet haben.

Mit generateContent() können Sie Text aus einem Prompt generieren, der Text enthält:

Kotlin 

// Imports + initialization of Gemini API backend service + creation of model instance

// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
val response = model.generateContent(prompt)
print(response.text)

Java 

// Imports + initialization of Gemini API backend service + creation of model instance

// Provide a prompt that contains text
Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

// To generate text output, call generateContent with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Beachten Sie, dass Firebase AI Logic auch das Streamen von Textantworten mit generateContentStream (anstelle von generateContent) unterstützt.

Text aus multimodalen Eingaben (Text und Bild) generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Erste Schritte dieser Anleitung durchgearbeitet haben.

Mit generateContent() können Sie Text aus einem Prompt generieren, der Text und bis zu einer Bilddatei (nur Bitmap) enthält. Geben Sie dazu für jede Eingabedatei mimeType und die Datei selbst an.

Kotlin 

// Imports + initialization of Gemini API backend service + creation of model instance

// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)

Java 

// Imports + initialization of Gemini API backend service + creation of model instance

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Beachten Sie, dass Firebase AI Logic auch das Streamen von Textantworten mit generateContentStream (anstelle von generateContent) unterstützt.

Was kannst du sonst noch tun?

Für Ihre hybriden Lösungen stehen verschiedene zusätzliche Konfigurationsoptionen und Funktionen zur Verfügung:

Funktionen, die noch nicht für die Inferenz auf dem Gerät verfügbar sind

Da es sich um eine experimentelle Version handelt, sind nicht alle Funktionen von Cloud-Modellen für die Geräteinferenz verfügbar.

Die in diesem Abschnitt aufgeführten Funktionen sind noch nicht für die Inferenz auf dem Gerät verfügbar. Wenn Sie eine dieser Funktionen verwenden möchten, empfehlen wir Ihnen, den ONLY_IN_CLOUD-Inferenzmodus zu verwenden, um eine konsistentere Erfahrung zu erzielen.

  • Strukturierte Ausgaben generieren (z. B. JSON oder Enums)

  • Text aus anderen Bilddateieingabetypen als Bitmap generieren (Bild in den Arbeitsspeicher geladen)

  • Text aus mehreren Bilddateien generieren

  • Text aus Audio-, Video- und Dokumenteingaben (z. B. PDFs) generieren

  • Bilder mit Gemini- oder Imagen-Modellen generieren

  • Dateien über URLs in multimodalen Anfragen bereitstellen Sie müssen Dateien als Inline-Daten für On-Device-Modelle bereitstellen

  • Anfragen mit mehr als 4.000 Tokens (ca. 3.000 Wörter auf Englisch) senden.

  • Wechselseitiger Chat

  • Das Modell mit Tools ausstatten, die ihm bei der Generierung seiner Antwort helfen (z. B. Funktionsaufrufe, Codeausführung, URL-Kontext und Fundierung mit der Google Suche)

Beim KI-Monitoring in der Firebase Console werden keine Daten für die Inferenz auf dem Gerät angezeigt, einschließlich der Logs auf dem Gerät. Alle Inferenzen, für die ein in der Cloud gehostetes Modell verwendet wird, können jedoch wie andere Inferenzen über Firebase AI Logic überwacht werden.

Zusätzliche Einschränkungen

Zusätzlich zu den oben genannten Einschränkungen hat die Geräteinferenz die folgendenEinschränkungen(weitere Informationen finden Sie in der ML Kit-Dokumentation):

  • Der Endnutzer Ihrer App muss ein unterstütztes Gerät für die Inferenz auf dem Gerät verwenden.

  • Ihre App kann die Inferenz auf dem Gerät nur ausführen, wenn sie im Vordergrund ausgeführt wird.

  • Nur Englisch und Koreanisch wurden für die Inferenz auf dem Gerät validiert.

  • Das maximale Tokenlimit für die gesamte On-Device-Inferenzanfrage beträgt 4.000 Tokens. Wenn Ihre Anfragen dieses Limit überschreiten könnten, müssen Sie einen Inferenzmodus konfigurieren, der ein in der Cloud gehostetes Modell verwenden kann.

  • Wir empfehlen, Anwendungsfälle für die Inferenz auf dem Gerät zu vermeiden, die eine lange Ausgabe (mehr als 256 Tokens) erfordern.

  • AICore (ein Android-Systemdienst, der die On-Device-Modelle verwaltet) erzwingt ein Inferenzkontingent pro App. Wenn in kurzer Zeit zu viele API-Anfragen gestellt werden, wird eine ErrorCode.BUSY-Antwort zurückgegeben. Wenn Sie diesen Fehler erhalten, sollten Sie die Anfrage mit exponentiellem Backoff wiederholen. Außerdem kann ErrorCode.PER_APP_BATTERY_USE_QUOTA_EXCEEDED zurückgegeben werden, wenn eine App ein Kontingent für lange Zeiträume (z. B. Tageskontingent) überschreitet.


Feedback zu Firebase AI Logic geben