Tworzenie hybrydowych funkcji w aplikacjach na Androida za pomocą modeli na urządzeniu i hostowanych w chmurze


Możesz tworzyć aplikacje i funkcje na Androida oparte na AI, korzystając z wnioskowania hybrydowego za pomocą Firebase AI Logic. Wnioskowanie hybrydowe umożliwia wnioskowanie przy użyciu modeli na urządzeniu, gdy są one dostępne, i płynne przełączanie się na modele hostowane w chmurze w innych przypadkach (i odwrotnie).

Na tej stronie znajdziesz informacje o tym, jak zacząć korzystać z pakietu SDK klienta, a także dodatkowe opcje konfiguracji i możliwości, takie jak temperatura.

Pamiętaj, że wnioskowanie na urządzeniu za pomocą Firebase AI Logic jest obsługiwane w przypadku aplikacji na Androida działających na określonych urządzeniach i podlega warunkom ML Kit oraz warunkom dotyczącym aspektów generatywnej AI w ML Kit.

Zalecane przypadki użycia i obsługiwane funkcje

Zalecane przypadki użycia

  • Korzystanie z modelu na urządzeniu do wnioskowania zapewnia:

    • Zwiększona prywatność
    • Kontekst lokalny
    • Wnioskowanie bez opłat
    • Funkcje offline

  • Korzystanie z funkcji hybrydowej zapewnia:

    • Docieranie do większej liczby odbiorców dzięki uwzględnianiu dostępności modelu na urządzeniu i połączenia z internetem

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

Wnioskowanie na urządzeniu obsługuje tylko generowanie tekstu w jednej turze (nie czat) z przesyłaniem strumieniowym lub bez niego. Obsługuje te funkcje generowania tekstu:

Zapoznaj się z listą funkcji wnioskowania na urządzeniu, które nie są jeszcze dostępne, u dołu tej strony.

Zanim zaczniesz

Zwróć uwagę na te kwestie:

Obsługiwane urządzenia z Androidem i ich modele

W przypadku wnioskowania na urządzeniu (które korzysta z interfejsu Prompt API w ML Kit) listę obsługiwanych urządzeń i ich modeli na urządzeniu znajdziesz w dokumentacji ML Kit.

Rozpocznij

Te instrukcje opisują ogólną konfigurację wymaganą w przypadku każdego obsługiwanego żądania prompta, które chcesz wysłać.

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

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

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

  3. Kliknij Rozpocznij, aby uruchomić przepływ pracy z instrukcjami, który pomoże Ci skonfigurować wymagane interfejsy API i zasoby w projekcie.

  4. Skonfiguruj projekt, aby korzystać z dostawcy „Gemini API”.

    Zalecamy rozpoczęcie od Gemini Developer API. W każdej chwili możesz skonfigurować Vertex AI Gemini API (i jego wymagania dotyczące płatności).

    W przypadku Gemini Developer API 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

  5. Jeśli w procesie w konsoli pojawi się odpowiedni monit, 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 2. Dodaj wymagane pakiety SDK

Firebase AI Logic Pakiet SDK na Androidafirebase-ai oraz Firebase AI Logic On-Device pakiet SDKfirebase-ai-ondevice umożliwiają dostęp do interfejsów API do interakcji z modelami generatywnymi.

W pliku Gradle na poziomie modułu (aplikacji) (np. <project>/<app-module>/build.gradle.kts) dodaj zależności bibliotek Firebase AI Logic na Androida:

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

W przypadku Javy musisz dodać 2 dodatkowe biblioteki.

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")
}

Krok 3. Sprawdź, czy model na urządzeniu jest dostępny

Za pomocą FirebaseAIOnDevice sprawdź, czy model na urządzeniu jest dostępny, i pobierz go, jeśli nie jest.

Po pobraniu AICore będzie automatycznie aktualizować model. Więcej informacji o AICore i zarządzaniu pobieraniem modelu na urządzenie znajdziesz w uwagach pod fragmentem.

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.

Ważne informacje o pobieraniu modelu na urządzenie:

  • Czas pobierania modelu na urządzenie zależy od wielu czynników, w tym od sieci.

  • Jeśli Twój kod używa modelu na urządzeniu do wnioskowania podstawowego lub rezerwowego, upewnij się, że model jest pobierany na wczesnym etapie cyklu życia aplikacji, aby był dostępny, zanim użytkownicy końcowi napotkają kod w aplikacji.

  • Jeśli model na urządzeniu nie jest dostępny w momencie wysłania żądania wnioskowania na urządzeniu, pakiet SDK nie uruchomi automatycznie pobierania modelu na urządzeniu. Pakiet SDK przełączy się na model hostowany w chmurze lub zgłosi wyjątek (szczegółowe informacje o działaniu trybów wnioskowania).

  • AICore (usługa systemowa Androida) zarządza pobranym modelem i jego wersją, dba o aktualizowanie modelu itp. Pamiętaj, że na urządzeniu będzie pobrany tylko jeden model. Jeśli inna aplikacja na urządzeniu wcześniej pobrała model na urządzenie, ten test zwróci informację, że model jest dostępny.

Optymalizacja czasu oczekiwania

Aby zoptymalizować pierwsze wywołanie wnioskowania, możesz skonfigurować aplikację tak, aby wywoływała warmup(). Spowoduje to załadowanie modelu na urządzeniu do pamięci i zainicjowanie komponentów środowiska wykonawczego.

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

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

Zanim wyślesz do modelu żądanie prompta, skonfiguruj te elementy:

  1. Zainicjuj usługę dla wybranego dostawcy interfejsu API.

  2. Utwórz instancję GenerativeModel i ustaw mode na jedną z tych wartości: Opisy tutaj są bardzo ogólne, ale szczegóły dotyczące działania tych trybów znajdziesz w artykule Ustawianie trybu wnioskowania.

    • PREFER_ON_DEVICE: próba użycia modelu na urządzeniu; w przeciwnym razie powrót do modelu hostowanego w chmurze.

    • ONLY_ON_DEVICE: spróbuj użyć modelu na urządzeniu; w przeciwnym razie zgłoś wyjątek.

    • PREFER_IN_CLOUD: próba użycia modelu hostowanego w chmurze; w przeciwnym razie powrót do modelu na urządzeniu.

    • ONLY_IN_CLOUD: próba użycia modelu hostowanego w chmurze; w przeciwnym razie zgłoszenie wyjątku.

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

Krok 5. Wyślij do modelu prośbę (prompt)

W tej sekcji dowiesz się, jak wysyłać różne typy danych wejściowych, aby generować różne typy danych wyjściowych, w tym:

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

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Pierwsze kroki w tym przewodniku.

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

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

Pamiętaj, że Firebase AI Logic obsługuje też strumieniowanie odpowiedzi tekstowych za pomocą generateContentStream (zamiast generateContent).

Generowanie tekstu na podstawie danych wejściowych w postaci tekstu i obrazu (multimodalnych)

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Pierwsze kroki w tym przewodniku.

Możesz użyć generateContent() do generowania tekstu na podstawie promptu zawierającego tekst i maksymalnie 1 plik obrazu (tylko bitmapa) – podając mimeType każdego pliku wejściowego i sam plik.

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

Pamiętaj, że Firebase AI Logic obsługuje też strumieniowanie odpowiedzi tekstowych za pomocą generateContentStream (zamiast generateContent).

Co jeszcze możesz zrobić?

W przypadku środowisk hybrydowych możesz korzystać z różnych dodatkowych opcji konfiguracji i funkcji:

Funkcje niedostępne jeszcze w przypadku wnioskowania na urządzeniu

W wersji eksperymentalnej nie wszystkie funkcje modeli w chmurze są dostępne w przypadku wnioskowania na urządzeniu.

Funkcje wymienione w tej sekcji nie są jeszcze dostępne w przypadku wnioskowania na urządzeniu. Jeśli chcesz korzystać z tych funkcji, zalecamy używanie ONLY_IN_CLOUDtrybu wnioskowania, aby zapewnić większą spójność.

  • generowanie danych wyjściowych o strukturze (np. JSON lub wyliczenia);

  • Generowanie tekstu z plików obrazów innych niż Bitmap (obraz wczytany do pamięci)

  • Generowanie tekstu z więcej niż 1 pliku obrazu

  • generowanie tekstu na podstawie danych wejściowych audio, wideo i dokumentów (np. plików PDF);

  • Generowanie obrazów za pomocą modeli Gemini lub Imagen

  • Przesyłanie plików za pomocą adresów URL w żądaniach multimodalnych. Musisz udostępniać pliki jako dane wbudowane w modelach na urządzeniu.

  • wysyłanie żądań przekraczających 4000 tokenów (czyli około 3000 słów w języku angielskim);

  • Czat wieloetapowy

  • Udostępnianie modelowi narzędzi, które pomogą mu generować odpowiedzi (takich jak wywoływanie funkcji, wykonywanie kodu, kontekst adresu URL i grounding w wyszukiwarce Google).

Monitorowanie AI w Firebase konsoli nie wyświetla żadnych danych dotyczących wnioskowania na urządzeniu (w tym dzienników na urządzeniu). Każde wnioskowanie, które korzysta z modelu hostowanego w chmurze, można jednak monitorować tak samo jak inne wnioskowania za pomocą Firebase AI Logic.

Dodatkowe ograniczenia

Oprócz powyższych wnioskowanie na urządzeniu ma teograniczenia (więcej informacji znajdziesz w dokumentacji ML Kit):

  • Użytkownik końcowy aplikacji musi korzystać z obsługiwanego urządzenia, aby wnioskowanie odbywało się na urządzeniu.

  • Aplikacja może przeprowadzać wnioskowanie na urządzeniu tylko wtedy, gdy działa na pierwszym planie.

  • Wnioskowanie na urządzeniu zostało zweryfikowane tylko w przypadku języka angielskiego i koreańskiego.

  • Maksymalny limit tokenów dla całego żądania wnioskowania na urządzeniu to 4000 tokenów. Jeśli Twoje żądania mogą przekroczyć ten limit, skonfiguruj tryb wnioskowania, który może korzystać z modelu hostowanego w chmurze.

  • Zalecamy unikanie przypadków użycia wnioskowania na urządzeniu, które wymagają długiego wyniku (ponad 256 tokenów).

  • AICore (usługa systemowa Androida, która zarządza modelami na urządzeniu) wymusza limit wnioskowania w przypadku każdej aplikacji. Zbyt duża liczba żądań do interfejsu API w krótkim czasie spowoduje wyświetlenie odpowiedzi ErrorCode.BUSY. Jeśli widzisz ten błąd, spróbuj ponownie wysłać żądanie, stosując wzrastający czas do ponowienia. Może też zostać zwrócony, jeśli aplikacja przekroczy limit długoterminowy (np. dzienny).ErrorCode.PER_APP_BATTERY_USE_QUOTA_EXCEEDED


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