Dodaj rekomendacje do swojej aplikacji za pomocą TensorFlow Lite i Firebase — laboratorium kodowania na Androida

1. Przegląd

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

Rekomendacje umożliwiają aplikacjom korzystanie z uczenia maszynowego w celu inteligentnego wyświetlania najbardziej odpowiednich treści dla każdego użytkownika. Uwzględniają zachowanie użytkowników w przeszłości, aby sugerować zawartość aplikacji, z którą użytkownik może chcieć wchodzić w interakcję w przyszłości, przy użyciu modelu wyszkolonego na zagregowanym zachowaniu 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 dla rekomendacji na podstawie tych danych, a następnie użyć tego modelu w aplikacji na Androida do uruchamiania wnioskowania i uzyskiwania rekomendacji. W szczególności nasze rekomendacje zasugerują, które filmy użytkownik najprawdopodobniej obejrzałby, biorąc pod uwagę listę filmów, które użytkownik lubił wcześniej.

Czego się nauczysz

  • Zintegruj Firebase Analytics z aplikacją na Androida, aby zbierać dane o zachowaniu użytkowników
  • Eksportuj te dane do Google Big Query
  • Wstępne przetwarzanie danych i trenowanie modelu rekomendacji TF Lite
  • Wdróż model TF Lite w Firebase ML i uzyskaj do niego dostęp ze swojej aplikacji
  • Uruchom wnioskowanie na urządzeniu, korzystając z modelu, aby sugerować użytkownikom rekomendacje

Co będziesz potrzebował

  • Android Studio w wersji 3.4+.
  • Przykładowy kod.
  • Urządzenie testowe z systemem Android 2.3+ 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 to tylko Przeczytaj i uzupełnij ć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 codelab-recommendations-android ( android_studio_folder.png ) z pobrania przykładowego kodu ( 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 Dodaj projekt (lub Utwórz projekt , jeśli jest to pierwszy projekt).
  3. Wybierz lub wprowadź nazwę projektu i kliknij przycisk 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 ćwiczeń z programowania: com.google.firebase.codelabs.recommendations
  3. Wybierz Zarejestruj aplikację .

Dodaj plik google-services.json do swojej aplikacji

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

Dodaj wtyczkę google-services do swojej aplikacji

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

app/build.grade

apply plugin: 'com.google.gms.google-services'

build.grade

classpath 'com.google.gms:google-services:4.3.4'

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 Plik > Synchronizuj projekt z plikami Gradle z paska narzędzi Android Studio.

6. Uruchom aplikację startową

Po zaimportowaniu projektu do Android Studio i skonfigurowaniu wtyczki google-services za pomocą pliku JSON, jesteś gotowy do uruchomienia aplikacji po raz pierwszy. Podłącz swoje urządzenie z Androidem i kliknij Uruchom ( wykonać.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 pokazuje kartę 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 lubianych. Po wykonaniu pozostałych kroków codelab będziemy mogli wygenerować rekomendacje filmów w zakładce Rekomendacje.

7. Dodaj Firebase Analytics do aplikacji

Na tym etapie dodasz Firebase Analytics do aplikacji, aby rejestrować dane dotyczące zachowania użytkowników (w tym przypadku filmy, które użytkownik lubi). Te dane będą używane łącznie w przyszłych krokach do trenowania modelu rekomendacji.

Dodaj zależność Firebase Analytics

Aby dodać Firebase Analytics do swojej aplikacji, musisz mieć następującą zależność. Powinien już być zawarty w pliku app/build.gradle (zweryfikuj).

app/build.grade

implementation 'com.google.firebase:firebase-analytics-ktx:17.6.0'

Skonfiguruj Firebase Analytics w aplikacji

LikedMoviesViewModel zawiera funkcje do przechowywania filmów, które lubi użytkownik. Za każdym razem, gdy użytkownik polubi nowy film, chcemy również wysłać zdarzenie z dziennika analitycznego, aby go nagrać.

Dodaj funkcję onMovieLiked z poniższym kodem, aby zarejestrować zdarzenie analityczne, gdy użytkownik kliknie jak film.

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, gdy film zostanie dodany 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 swoją integrację z Analytics

W tym kroku wygenerujemy zdarzenia Analytics w aplikacji i zweryfikujemy, czy są one wysyłane do Konsoli Firebase.

Włącz rejestrowanie debugowania Analytics

Firebase Analytics ma na celu maksymalizację czasu pracy użytkownika na baterii i grupuje zdarzenia na urządzeniu i wysyła je do Firebase tylko od czasu do czasu. W celu debugowania możemy wyłączyć to zachowanie, aby zobaczyć zdarzenia, które są 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 Android Studio otwórz okno Logcat, aby sprawdzić rejestrowanie w aplikacji.
  2. Ustaw filtr Logcat na ciąg „Zdarzenie rejestrowania”.
  3. Sprawdź, czy zdarzenia Analytics „select_item” są emitowane za każdym razem, gdy polubisz film w aplikacji.

Na tym etapie udało Ci się zintegrować Firebase Analytics ze swoją aplikacją. Gdy użytkownicy korzystają z Twojej aplikacji i lubią filmy, ich polubienia będą rejestrowane łącznie. Użyjemy tych zagregowanych danych w pozostałej części tego ćwiczenia z programowania, aby wytrenować nasz model rekomendacji. Poniżej znajduje się opcjonalny krok, aby zobaczyć te same zdarzenia Analytics, które widziałeś w Logcat, również przesyłane strumieniowo do konsoli Firebase. Przejdź do następnej strony.

Opcjonalnie: potwierdź zdarzenia Analytics w konsoli Firebase

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

9. Eksportuj dane analityczne do Big Query

Big Query to usługa Google Cloud, która umożliwia badanie i przetwarzanie dużych ilości danych. W tym kroku 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ąd projektu , a następnie wybierz Ustawienia projektu
  3. Wybierz zakładkę Integracje .
  4. Wybierz Połącz (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 Połącz z BigQuery .

W projekcie konsoli Firebase włączono automatyczne wysyłanie danych zdarzeń Firebase Analytics do Big Query. Dzieje się to automatycznie bez dalszej interakcji, jednak pierwszy eksport, który tworzy zbiór danych analitycznych w BigQuery, może nie nastąpić przez 24 godziny. Po utworzeniu zbioru danych Firebase stale eksportuje nowe zdarzenia Analytics do Big Query do tabeli intraday i grupuje zdarzenia z ostatnich dni w tabeli zdarzeń.

Trenowanie 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 treningowe modelu

Teraz, gdy połączyliśmy naszą konsolę Firebase w celu wyeksportowania do BigQuery, nasze dane o zdarzeniach analizy 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 trenowania naszego modelu rekomendacji.

Zaimportuj przykładowy zbiór danych do BigQuery

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

Przeglądaj przykładowy zbiór danych

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

  1. Wybierz zbiór danych-rekomendacji Firebase w menu po lewej stronie, aby rozwinąć zawarte w nim tabele.
  2. Wybierz tabelę zaleceń, aby wyświetlić schemat tabeli.
  3. Wybierz Podgląd , aby zobaczyć rzeczywiste dane zdarzeń Analytics, które zawiera ta tabela.

Utwórz dane logowania do konta usługi

Teraz utworzymy poświadczenia konta usługi w naszym projekcie konsoli Google Cloud, których będziemy mogli użyć w środowisku Colab w następnym kroku, aby uzyskać dostęp i załadować nasze dane BigQuery.

  1. Upewnij się, że płatności są włączone w Twoim projekcie Google Cloud.
  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 ról wybierz pozycję projekt > właściciel .
  7. Kliknij Utwórz . Plik JSON zawierający klucze do pobrania na Twój komputer.

W następnym kroku użyjemy Google Colab do wstępnego przetworzenia tych danych i przeszkolenia naszego modelu rekomendacji.

11. Model danych preprocesowych i rekomendacji pociągów

W tym kroku użyjemy notatnika Colab, aby wykonać następujące czynności:

  1. zaimportuj dane z BigQuery do notatnika Colab
  2. wstępnie przetworzyć dane, aby przygotować je do szkolenia modelu
  3. wytrenuj model rekomendacji na danych analitycznych
  4. wyeksportuj model jako model TF lite
  5. wdrożyć model w konsoli Firebase, abyśmy mogli używać go w naszej aplikacji

Przed uruchomieniem notesu szkoleniowego Colab najpierw włączymy interfejs API zarządzania modelami Firebase, aby firma Colab mogła wdrożyć przeszkolony model w naszej konsoli Firebase.

Włącz interfejs API zarządzania modelami Firebase

Utwórz wiadro do przechowywania modeli ML

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

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

19517c0d6d2aa14d.png

Włącz interfejs Firebase ML API

Wejdź na stronę Firebase ML API w Google Cloud Console i kliknij Włącz.

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

Otwórz notatnik colab, korzystając z poniższego łącza i wykonaj zawarte w nim czynności. Po wykonaniu kroków w notatniku Colab będziesz mieć plik modelu TF lite wdrożony w konsoli Firebase, który możemy 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 wyszkoliliśmy z systemu Firebase Machine Learning.

Dodaj zależność Firebase ML

Aby korzystać z modeli uczenia maszynowego Firebase w Twojej aplikacji, potrzebna jest następująca zależność. Powinien już zostać dodany (zweryfikuj).

app/build.grade

implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.4'

Pobierz model za pomocą interfejsu Firebase Model Manager API

Skopiuj poniższy kod do RecommendationClient.kt , aby skonfigurować warunki, w jakich odbywa się pobieranie modelu, i utwórz zadanie pobierania, aby zsynchronizować model zdalny z naszą aplikacją.

RekomendacjaKlient.kt

    private fun downloadModel(modelName: String) {
        val remoteModel = FirebaseCustomRemoteModel.Builder(modelName).build()
        val firebaseModelManager = FirebaseModelManager.getInstance()
        firebaseModelManager
            .isModelDownloaded(remoteModel)
            .continueWithTask { task ->
                // Create update condition if model is already downloaded, otherwise create download
                // condition.
                val conditions = if (task.result != null && task.result == true) {
                    FirebaseModelDownloadConditions.Builder()
                        .requireWifi()
                        .build() // Update condition that requires wifi.
                } else {
                    FirebaseModelDownloadConditions.Builder().build(); // Download condition.
                }
                firebaseModelManager.download(remoteModel, conditions)
            }
            .addOnSuccessListener {
                firebaseModelManager.getLatestModelFile(remoteModel)
                    .addOnCompleteListener {
                        val model = it.result
                        if (model == null) {
                            showToast(context, "Failed to get model file.")
                        } else {
                            showToast(context, "Downloaded remote model")
                            GlobalScope.launch { initializeInterpreter(model) }
                        }
                    }
            }
            .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 zainicjalizowaliśmy interpreter TFlite z pobranym plikiem modelu. W tym kroku najpierw załadujemy słownik i etykiety towarzyszące naszemu modelowi na etapie wnioskowania, a następnie dodamy przetwarzanie wstępne, aby wygenerować dane wejściowe do naszego modelu i przetwarzanie końcowe, w którym wyodrębnimy wyniki z naszego wnioskowania .

Załaduj słownik i etykiety

Etykiety używane do generowania kandydatów rekomendacji przez model rekomendacji są wymienione w pliku sorted_movie_vocab.json w folderze res/assets. Skopiuj następujący kod, aby załadować tych kandydatów.

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

Implementuj przetwarzanie wstępne

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

RekomendacjaKlient.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 tłumacza, aby wygenerować rekomendacje

Tutaj używamy modelu, który pobraliśmy w poprzednim kroku, aby uruchomić wnioskowanie na naszych wstępnie przetworzonych danych wejściowych. Ustawiamy typ danych wejściowych i wyjściowych dla naszego modelu i uruchamiamy wnioskowanie, aby wygenerować nasze rekomendacje filmów. Skopiuj następujący kod do swojej aplikacji.

RekomendacjaKlient.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()
            }
        }
    }



Implementuj przetwarzanie końcowe

Na koniec, na tym etapie, przetwarzamy dane wyjściowe z naszego modelu, wybierając wyniki z największą pewnością i usuwając zawarte wartości (filmy, które użytkownik już polubił). Skopiuj następujący kod do swojej aplikacji.

RekomendacjaKlient.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 swoją aplikację. Po wybraniu kilku filmów powinien automatycznie pobrać nowy model i zacząć generować rekomendacje!

14. Gratulacje!

Masz wbudowaną funkcję rekomendacji w swojej aplikacji za pomocą TensorFlow Lite i Firebase. Należy zauważyć, że techniki i potok pokazane w tym ćwiczeniu z programowania mogą być uogólnione i wykorzystywane również do obsługi innych typów zaleceń.

Co omówiliśmy

  • Firebase ML
  • Firebase Analytics
  • Eksportuj zdarzenia analityczne do BigQuery
  • Zdarzenia analizy przedprocesowej
  • Zalecenia dotyczące pociągu Model TensorFlow
  • Eksportuj model i wdrażaj w Firebase Console
  • Wyświetlaj rekomendacje filmów w aplikacji

Następne kroki

  • Zaimplementuj w swojej aplikacji rekomendacje Firebase ML.

Ucz się więcej

Mam pytanie?

Zgłoś problemy