Dodaj rekomendacje do swojej aplikacji za pomocą TensorFlow Lite i Firebase — Android Codelab

1. Przegląd

Witamy w Zaleceniach dotyczących ćwiczeń z programowania TensorFlow Lite i Firebase. W tym laboratorium z programowania dowiesz się, jak używać TensorFlow Lite i Firebase do wdrażania modelu rekomendacji w swojej aplikacji. To ćwiczenie z programowania opiera się na przykładzie TensorFlow Lite.

Rekomendacje umożliwiają aplikacjom korzystanie z uczenia maszynowego w celu inteligentnego udostępniania najbardziej odpowiednich treści każdemu użytkownikowi. Uwzględniają przeszłe zachowania użytkowników, aby zasugerować zawartość aplikacji, z którą użytkownik może chcieć wejść w interakcję w przyszłości, korzystając z modelu wytrenowanego na podstawie zbiorczego zachowania dużej liczby innych użytkowników.

W tym samouczku pokazano, jak uzyskać dane od użytkowników aplikacji za pomocą Firebase Analytics, zbudować model uczenia maszynowego na potrzeby rekomendacji na podstawie tych danych, a następnie użyć tego modelu w aplikacji na Androida do wyciągania wniosków i uzyskiwania rekomendacji. W szczególności nasze rekomendacje podpowiedzą, które filmy użytkownik najprawdopodobniej obejrzy, biorąc pod uwagę listę filmów, które podobały mu się wcześniej.

Czego się dowiesz

  • Zintegruj Firebase Analytics z aplikacją na Androida, aby zbierać dane o zachowaniach użytkowników
  • Wyeksportuj te dane do Google Big Query
  • Wstępnie przetwórz dane i wytrenuj model rekomendacji TF Lite
  • Wdróż model TF Lite w Firebase ML i uzyskaj do niego dostęp ze swojej aplikacji
  • Uruchom na podstawie wnioskowania o urządzeniu, korzystając z modelu, aby sugerować rekomendacje użytkownikom

Co będziesz potrzebował

  • Najnowsza wersja Androida Studio .
  • Przykładowy kod.
  • Urządzenie testowe z Androidem 7 lub nowszym i Usługami Google Play 9.8 lub nowszymi lub Emulator z Usługami Google Play 9.8 lub nowszymi
  • Jeśli używasz urządzenia, kabel połączeniowy.

Jak będziesz korzystać z tego samouczka?

Przeczytaj tylko i wyłącznie Przeczytaj i wykonaj ćwiczenia

Jak oceniasz swoje doświadczenie w tworzeniu aplikacji na Androida?

Nowicjusz Mediator Biegły

2. Pobierz przykładowy kod

Sklonuj repozytorium GitHub z wiersza poleceń.

$ git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-android.git

3. Zaimportuj aplikację startową

W Android Studio wybierz katalog codelab-recommendations-android ( folder_studio_android.png ) z przykładowego kodu do pobrania ( Plik > Otwórz > .../codelab-recommendations-Android/start).

Powinieneś teraz mieć otwarty projekt startowy w Android Studio.

4. Utwórz projekt konsoli Firebase

Utwórz nowy projekt

  1. Przejdź do konsoli Firebase .
  2. Wybierz opcję Dodaj projekt (lub Utwórz projekt, jeśli jest to pierwszy).
  3. Wybierz lub wprowadź nazwę projektu i kliknij Kontynuuj .
  4. Upewnij się, że opcja „Włącz Google Analytics dla tego projektu” jest włączona.
  5. Wykonaj pozostałe kroki konfiguracji w konsoli Firebase, a następnie kliknij Utwórz projekt (lub Dodaj Firebase, jeśli używasz istniejącego projektu Google).

5. Dodaj Firebase

  1. Na ekranie przeglądu nowego projektu kliknij ikonę Androida, aby uruchomić proces konfiguracji.
  2. Wpisz nazwę pakietu codelab: com.google.firebase.codelabs.recommendations
  3. Wybierz opcję Zarejestruj aplikację .

Dodaj plik google-services.json do swojej aplikacji

Po dodaniu nazwy pakietu i wybraniu opcji Zarejestruj kliknij Pobierz google-services.json , aby uzyskać plik konfiguracyjny Firebase dla systemu Android, a następnie skopiuj plik google-services.json do katalogu app w swoim projekcie. Po pobraniu pliku możesz pominąć kolejne kroki wyświetlane w konsoli (zostały one już wykonane za Ciebie w projekcie build-Android-start).

Dodaj wtyczkę usług Google do swojej aplikacji

Wtyczka google-services używa pliku google-services.json do skonfigurowania aplikacji do korzystania z Firebase. Następujące linie powinny już zostać dodane do plików build.gradle.kts w projekcie (zaznacz, aby potwierdzić):

app/build.grade.kts

plugins {
    id("com.google.gms.google-services")
}

build.grade.kts

plugins {
    id("com.google.gms.google-services") version "4.3.15" apply false
}

Zsynchronizuj swój projekt z plikami gradle

Aby mieć pewność, że wszystkie zależności są dostępne dla Twojej aplikacji, powinieneś w tym momencie zsynchronizować swój projekt z plikami gradle. Wybierz opcję Plik > Synchronizuj projekt z plikami Gradle z paska narzędzi Android Studio.

6. Uruchom aplikację startową

Teraz, gdy zaimportowałeś projekt do Android Studio i skonfigurowałeś wtyczkę google-services za pomocą pliku JSON, możesz uruchomić aplikację po raz pierwszy. Podłącz urządzenie z Androidem i kliknij Uruchom ( wykonaj.png ) na pasku narzędzi Android Studio.

Aplikacja powinna uruchomić się na Twoim urządzeniu. W tym momencie możesz zobaczyć działającą aplikację, która wyświetla zakładkę z listą filmów, zakładkę Polubione filmy i zakładkę Rekomendacje. Możesz kliknąć film na liście filmów, aby dodać go do listy ulubionych. Po wykonaniu pozostałych kroków ćwiczeń z kodowania będziemy mogli wygenerować rekomendacje filmów w zakładce Rekomendacje.

7. Dodaj Firebase Analytics do aplikacji

Na tym etapie dodasz do aplikacji Firebase Analytics, aby rejestrować dane o zachowaniach użytkowników (w tym przypadku filmy, które użytkownik lubi). Dane te zostaną wykorzystane zbiorczo w przyszłych krokach w celu szkolenia modelu rekomendacji.

Dodaj listę materiałów Firebase i zależność Analytics

Aby dodać Firebase Analytics do swojej aplikacji, niezbędne są następujące zależności. Powinny już znajdować się w pliku app/build.gradle.kts (sprawdź).

app/build.grade.kts

implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")

Skonfiguruj Firebase Analytics w aplikacji

LikedMoviesViewModel zawiera funkcje umożliwiające przechowywanie filmów, które użytkownik lubi. Za każdym razem, gdy użytkownikowi podoba się nowy film, chcemy również wysłać zdarzenie do dziennika analitycznego, aby zarejestrować to polubienie.

Dodaj funkcję onMovieLiked z poniższym kodem, aby zarejestrować zdarzenie analityczne, gdy użytkownik kliknie „Lubię to” w filmie.

LikedMoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {

    ...

    fun onMovieLiked(movie: Movie) {
        movies.setLike(movie, true)
        logAnalyticsEvent(movie.id.toString())
    }
       
}

Dodaj następujące pole i funkcję, aby rejestrować zdarzenie Analytics po dodaniu filmu do listy Polubione użytkownika.

LikedMoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {
    ...
    private val firebaseAnalytics = Firebase.analytics

    ...

    /**
     * Logs an event in Firebase Analytics that is used in aggregate to train the recommendations
     * model.
     */
    private fun logAnalyticsEvent(id: String) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.SELECT_ITEM) {
            param(FirebaseAnalytics.Param.ITEM_ID, id)
        }
    }

8. Przetestuj integrację z Analytics

Na tym etapie wygenerujemy zdarzenia Analytics w aplikacji i sprawdzimy, czy są wysyłane do konsoli Firebase.

Włącz rejestrowanie debugowania Analytics

Firebase Analytics zaprojektowano tak, aby maksymalizować czas pracy baterii użytkownika, grupować zdarzenia na urządzeniu i wysyłać je do Firebase tylko okazjonalnie. Na potrzeby debugowania możemy wyłączyć to zachowanie, aby zobaczyć zdarzenia rejestrowane w czasie rzeczywistym, uruchamiając następujące polecenie w powłoce.

Terminal

adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations

Sprawdź, czy generowane są zdarzenia Analytics

  1. W studiu Androida otwórz okno Logcat, aby sprawdzić rejestrowanie z aplikacji.
  2. Ustaw filtr Logcat na ciąg „Zdarzenie rejestrowania”.
  3. Sprawdź, czy zdarzenia Analytics „select_item” są emitowane za każdym razem, gdy lubisz film w aplikacji.

W tym momencie pomyślnie zintegrowałeś Firebase Analytics ze swoją aplikacją. Gdy użytkownicy korzystają z Twojej aplikacji i lubią filmy, ich polubienia będą rejestrowane zbiorczo. Będziemy używać tych zagregowanych danych w pozostałej części tego ćwiczenia z programowania, aby szkolić nasz model rekomendacji. Poniżej znajduje się opcjonalny krok, dzięki któremu te same zdarzenia Analytics, które widziałeś w Logcat, są również przesyłane strumieniowo do konsoli Firebase. Zachęcamy do przejścia do następnej strony.

Opcjonalnie: Potwierdź zdarzenia Analytics w konsoli Firebase

  1. Przejdź do konsoli Firebase .
  2. Wybierz opcję DebugView w obszarze Analytics
  3. W Android Studio wybierz opcję Uruchom , aby uruchomić aplikację i dodać kilka filmów do listy Polubione.
  4. W DebugView konsoli Firebase sprawdź, czy te zdarzenia są rejestrowane podczas dodawania filmów w aplikacji.

9. Eksportuj dane Analytics do Big Query

Big Query to produkt Google Cloud, który pozwala badać i przetwarzać duże ilości danych. Na tym etapie połączysz projekt Firebase Console z Big Query, aby dane Analytics wygenerowane przez Twoją aplikację były automatycznie eksportowane do Big Query.

Włącz eksport Big Query

  1. Przejdź do konsoli Firebase .
  2. Wybierz ikonę koła zębatego Ustawienia obok Przeglądu projektu , a następnie wybierz Ustawienia projektu
  3. Wybierz zakładkę Integracje .
  4. Wybierz opcję Link (lub Zarządzaj ) w bloku BigQuery .
  5. Wybierz Dalej w kroku Informacje o łączeniu Firebase z BigQuery .
  6. W sekcji Konfiguruj integrację kliknij przełącznik, aby włączyć wysyłanie danych Google Analytics i wybierz opcję Połącz z BigQuery .

Włączyłeś teraz w swoim projekcie konsoli Firebase automatyczne wysyłanie danych zdarzeń Firebase Analytics do Big Query. Dzieje się to automatycznie, bez żadnej dalszej interakcji, jednak pierwszy eksport, który tworzy zbiór danych analitycznych w BigQuery, może nie nastąpić w ciągu 24 godzin. Po utworzeniu zbioru danych Firebase stale eksportuje nowe zdarzenia Analytics do Big Query do tabeli dziennej i grupuje w tabeli zdarzenia zdarzenia z poprzednich dni.

Uczenie modelu rekomendacji wymaga dużej ilości danych. Ponieważ nie mamy jeszcze aplikacji generującej duże ilości danych, w następnym kroku zaimportujemy przykładowy zbiór danych do BigQuery, aby wykorzystać go w dalszej części tego samouczka.

10. Użyj BigQuery, aby uzyskać dane do trenowania modelu

Teraz, gdy połączyliśmy naszą konsolę Firebase w celu eksportu do BigQuery, nasze dane zdarzeń związane z analityką aplikacji po pewnym czasie automatycznie pojawią się w konsoli BigQuery. Aby uzyskać wstępne dane na potrzeby tego samouczka, w tym kroku zaimportujemy istniejący przykładowy zbiór danych do Twojej konsoli BigQuery, aby wykorzystać go do uczenia naszego modelu rekomendacji.

Zaimportuj przykładowy zbiór danych do BigQuery

  1. Przejdź do panelu BigQuery w konsoli Google Cloud.
  2. Wybierz nazwę projektu w menu.
  3. Wybierz nazwę projektu na dole lewego panelu nawigacyjnego BigQuery, aby zobaczyć szczegóły.
  4. Wybierz opcję Utwórz zbiór danych , aby otworzyć panel tworzenia zbioru danych.
  5. Wpisz „firebase_recommendations_dataset” jako identyfikator zbioru danych i wybierz opcję Utwórz zbiór danych .
  6. Nowy zbiór danych pojawi się w lewym menu pod nazwą projektu. Kliknij to.
  7. Wybierz opcję Utwórz tabelę , aby otworzyć panel tworzenia tabeli.
  8. W obszarze Utwórz tabelę z wybierz opcję „Google Cloud Storage”.
  9. W polu Wybierz plik z segmentu GCS wpisz „gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt”.
  10. Z listy rozwijanej Format pliku wybierz opcję „JSONL”.
  11. Wpisz „tabela_rekomendacji” jako nazwę tabeli .
  12. Zaznacz pole w obszarze Schemat > Automatyczne wykrywanie > Schemat i parametry wejściowe
  13. Wybierz opcję Utwórz tabelę

Przeglądaj przykładowy zbiór danych

W tym momencie możesz opcjonalnie eksplorować schemat i wyświetlać podgląd tego zestawu danych.

  1. Wybierz zestaw danych Firebase-Recommendations w lewym menu, aby rozwinąć zawarte w nim tabele.
  2. Wybierz tabelę tabeli rekomendacji , aby wyświetlić schemat tabeli.
  3. Wybierz opcję Podgląd , aby zobaczyć rzeczywiste dane zdarzeń Analytics zawarte w tej tabeli.

Utwórz dane uwierzytelniające konta usługi

Teraz utworzymy dane uwierzytelniające konta usługi w naszym projekcie konsoli Google Cloud, których będziemy mogli używać w środowisku Colab w następnym kroku, aby uzyskać dostęp do naszych danych BigQuery i je załadować.

  1. Upewnij się, że w Twoim projekcie Google Cloud są włączone rozliczenia.
  2. Włącz interfejsy API BigQuery i BigQuery Storage API. < kliknij tutaj >
  3. Przejdź do strony Utwórz klucz konta usługi .
  4. Z listy Konto usługi wybierz Nowe konto usługi .
  5. W polu Nazwa konta usługi wprowadź nazwę.
  6. Z listy Rola wybierz Projekt > Właściciel .
  7. Kliknij opcję Utwórz . Plik JSON zawierający klucze do pobrania na komputer.

W kolejnym kroku wykorzystamy Google Colab do wstępnego przetworzenia tych danych i wytrenowania naszego modelu rekomendacji.

11. Przetwarzaj dane i trenuj model rekomendacji

Na tym etapie użyjemy notatnika Colab do wykonania następujących kroków:

  1. zaimportuj dane BigQuery do notatnika Colab
  2. wstępnie przetworzyć dane, aby przygotować je do uczenia modelu
  3. trenuj model rekomendacji na danych analitycznych
  4. wyeksportuj model jako model TF Lite
  5. wdróż model w konsoli Firebase, abyśmy mogli go używać w naszej aplikacji

Zanim uruchomimy notatnik szkoleniowy Colab, najpierw włączymy interfejs API zarządzania modelem Firebase, aby Colab mógł wdrożyć wyszkolony model w naszej konsoli Firebase.

Włącz interfejs API zarządzania modelem Firebase

Utwórz zasobnik do przechowywania modeli uczenia maszynowego

W konsoli Firebase przejdź do opcji Pamięć i kliknij Rozpocznij. fbbea78f0eb3dc9f.png

Postępuj zgodnie z instrukcjami, aby skonfigurować wiadro.

19517c0d6d2aa14d.png

Włącz interfejs API Firebase ML

Przejdź do strony Firebase ML API w Google Cloud Console i kliknij Włącz.

Użyj notatnika Colab do szkolenia i wdrażania modelu

Otwórz notatnik Colab, korzystając z poniższego łącza i wykonaj opisane w nim kroki. Po wykonaniu kroków w notatniku Colab w konsoli Firebase zostanie wdrożony plik modelu TF Lite, który będziemy mogli zsynchronizować z naszą aplikacją.

Otwórz w Colab

12. Pobierz model w swojej aplikacji

W tym kroku zmodyfikujemy naszą aplikację, aby pobrać model, który właśnie przeszkoliliśmy z Firebase Machine Learning.

Dodaj zależność Firebase ML

Aby móc korzystać z modeli uczenia maszynowego Firebase w aplikacji, wymagana jest następująca zależność. Powinien już zostać dodany (sprawdź).

app/build.grade.kts

implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")

Pobierz model za pomocą interfejsu API Firebase Model Manager

Skopiuj poniższy kod do pliku RekomendacjaClient.kt , aby skonfigurować warunki pobierania modelu i utwórz zadanie pobierania, aby zsynchronizować zdalny model z naszą aplikacją.

RekomendacjaClient.kt

    private fun downloadModel(modelName: String) {
        val conditions = CustomModelDownloadConditions.Builder()
            .requireWifi()
            .build()
        FirebaseModelDownloader.getInstance()
            .getModel(modelName, DownloadType.LOCAL_MODEL, conditions)
            .addOnCompleteListener {
                if (!it.isSuccessful) {
                    showToast(context, "Failed to get model file.")
                } else {
                    showToast(context, "Downloaded remote model: $modelName")
                    GlobalScope.launch { initializeInterpreter(it.result) }
                }
            }
            .addOnFailureListener {
                showToast(context, "Model download failed for recommendations, please check your connection.")
            }
    }

13. Zintegruj model rekomendacji Tensorflow Lite w swojej aplikacji

Środowisko wykonawcze Tensorflow Lite pozwoli Ci używać modelu w aplikacji do generowania rekomendacji. W poprzednim kroku zainicjowaliśmy interpreter TFlite pobranym plikiem modelu. W tym kroku najpierw załadujemy słownik i etykiety towarzyszące naszemu modelowi na etapie wnioskowania, następnie dodamy przetwarzanie wstępne w celu wygenerowania danych wejściowych do naszego modelu oraz przetwarzanie końcowe, podczas którego wyodrębnimy wyniki z naszego wnioskowania .

Załaduj słownik i etykiety

Etykiety używane do generowania kandydatów do rekomendacji według modelu rekomendacji są wymienione w pliku sorted_movie_vocab.json w folderze res/assets. Skopiuj poniższy kod, aby załadować tych kandydatów.

RekomendacjaClient.kt

    /** Load recommendation candidate list.  */
    private suspend fun loadCandidateList() {
        return withContext(Dispatchers.IO) {
            val collection = MovieRepository.getInstance(context).getContent()
            for (item in collection) {
                candidates[item.id] = item
            }
            Log.v(TAG, "Candidate list loaded.")
        }
    }

Wdrażaj przetwarzanie wstępne

Na etapie wstępnego przetwarzania zmieniamy formę danych wejściowych, aby odpowiadała oczekiwaniom naszego modelu. Tutaj dopełniamy długość wejściową wartością zastępczą, jeśli nie wygenerowaliśmy już wielu polubień użytkowników. Skopiuj poniższy kod:

RekomendacjaClient.kt

    /** Given a list of selected items, preprocess to get tflite input.  */
    @Synchronized
    private suspend fun preprocess(selectedMovies: List<Movie>): IntArray {
        return withContext(Dispatchers.Default) {
            val inputContext = IntArray(config.inputLength)
            for (i in 0 until config.inputLength) {
                if (i < selectedMovies.size) {
                    val (id) = selectedMovies[i]
                    inputContext[i] = id
                } else {
                    // Padding input.
                    inputContext[i] = config.pad
                }
            }
            inputContext
        }
    }


Uruchom interpreter, aby wygenerować rekomendacje

Tutaj używamy modelu, który pobraliśmy w poprzednim kroku, aby uruchomić wnioskowanie na podstawie wstępnie przetworzonych danych wejściowych. Ustawiamy typ danych wejściowych i wyjściowych dla naszego modelu i uruchamiamy wnioskowanie, aby wygenerować rekomendacje filmowe. Skopiuj poniższy kod do swojej aplikacji.

RekomendacjaClient.kt

    /** Given a list of selected items, and returns the recommendation results.  */
    @Synchronized
    suspend fun recommend(selectedMovies: List<Movie>): List<Result> {
        return withContext(Dispatchers.Default) {
            val inputs = arrayOf<Any>(preprocess(selectedMovies))

            // Run inference.
            val outputIds = IntArray(config.outputLength)
            val confidences = FloatArray(config.outputLength)
            val outputs: MutableMap<Int, Any> = HashMap()
            outputs[config.outputIdsIndex] = outputIds
            outputs[config.outputScoresIndex] = confidences
            tflite?.let {
                it.runForMultipleInputsOutputs(inputs, outputs)
                postprocess(outputIds, confidences, selectedMovies)
            } ?: run {
                Log.e(TAG, "No tflite interpreter loaded")
                emptyList()
            }
        }
    }



Wdrażaj przetwarzanie końcowe

Na koniec na tym etapie poddajemy obróbce końcowej dane wyjściowe naszego modelu, wybierając wyniki z największą pewnością i usuwając zawarte w nich wartości (filmy, które użytkownik już polubił). Skopiuj poniższy kod do swojej aplikacji.

RekomendacjaClient.kt

    /** Postprocess to gets results from tflite inference.  */
    @Synchronized
    private suspend fun postprocess(
        outputIds: IntArray, confidences: FloatArray, selectedMovies: List<Movie>
    ): List<Result> {
        return withContext(Dispatchers.Default) {
            val results = ArrayList<Result>()

            // Add recommendation results. Filter null or contained items.
            for (i in outputIds.indices) {
                if (results.size >= config.topK) {
                    Log.v(TAG, String.format("Selected top K: %d. Ignore the rest.", config.topK))
                    break
                }
                val id = outputIds[i]
                val item = candidates[id]
                if (item == null) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is null", i, id))
                    continue
                }
                if (selectedMovies.contains(item)) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is contained", i, id))
                    continue
                }
                val result = Result(
                    id, item,
                    confidences[i]
                )
                results.add(result)
                Log.v(TAG, String.format("Inference output[%d]. Result: %s", i, result))
            }
            results
        }
    }


Przetestuj swoją aplikację!

Uruchom ponownie aplikację. Po wybraniu kilku filmów powinien automatycznie pobrać nowy model i zacząć generować rekomendacje!

14. Gratulacje!

Wbudowałeś funkcję rekomendacji w swojej aplikacji przy użyciu TensorFlow Lite i Firebase. Należy pamiętać, że techniki i potok przedstawione w tym ćwiczeniu z programowania można uogólnić i wykorzystać również do obsługi innych typów rekomendacji.

Co omówiliśmy

  • Baza Firebase ML
  • Analityka Firebase
  • Eksportuj zdarzenia analityczne do BigQuery
  • Przetwarzaj wstępnie zdarzenia analityczne
  • Rekomendacje dotyczące pociągów Model TensorFlow
  • Eksportuj model i wdrażaj w konsoli Firebase
  • Wyświetlaj rekomendacje filmów w aplikacji

Następne kroki

  • Zaimplementuj rekomendacje Firebase ML w swojej aplikacji.

Ucz się więcej

Mam pytanie?

Zgłoś problemy