Ćwiczenie z programowania dotyczące optymalizacji zakupów w aplikacji w czasie rzeczywistym na urządzeniu

1. Przegląd

Uwaga: w tym module używamy biblioteki TensorFlow Lite. Zalecamy, aby cały nowy kod korzystał z narzędzi biblioteki Google AI Edge LiteRT.

Witamy w samouczku dotyczącym optymalizacji zakupów w aplikacji na urządzeniu w czasie rzeczywistym. Z tych ćwiczeń z programowania dowiesz się, jak używać TensorFlow Lite i Firebase do trenowania i wdrażania w aplikacji niestandardowego modelu personalizacji.

Z tego samouczka dowiesz się, jak utworzyć model uczenia maszynowego do personalizacji, a w szczególności model, który na podstawie stanu bieżącego użytkownika przewiduje optymalną ofertę zakupu w aplikacji. Jest to przykład problemu z kontekstowym bandytą, czyli ważnego i powszechnie stosowanego rodzaju problemu uczenia maszynowego, o którym dowiesz się więcej w tym laboratorium.

Czego się nauczysz

• Zbieranie danych analitycznych za pomocą analityki Firebase
• Wstępne przetwarzanie danych analitycznych za pomocą BigQuery
• Trenowanie prostego modelu uczenia maszynowego na potrzeby optymalizacji zakupów w aplikacji na urządzeniu
• Wdrażanie modeli TFLite w Firebase ML i uzyskiwanie do nich dostępu z aplikacji
• Mierzenie i testowanie różnych modeli za pomocą Testów A/B Firebase
• Trenowanie i wdrażanie nowych modeli z wykorzystaniem najnowszych danych w regularnych odstępach czasu

Czego potrzebujesz

• Android Studio w wersji 3.4 lub nowszej
• fizyczne urządzenie testowe z Androidem 2.3 lub nowszym i Usługami Google Play w wersji 9.8 lub nowszej albo emulator z Usługami Google Play w wersji 9.8 lub nowszej;
• Jeśli używasz fizycznego urządzenia testowego, kabel połączeniowy
• Podstawowa wiedza o uczeniu maszynowym

Jak zamierzasz wykorzystać ten samouczek?

Tylko przeczytaj Przeczytaj i wykonaj ćwiczenia

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

Początkujący Średnio zaawansowany Zaawansowany

2. Omówienie problemu

Załóżmy, że jesteś deweloperem gier i chcesz wyświetlać spersonalizowane sugestie dotyczące zakupów w aplikacji na końcu każdego poziomu. Za każdym razem możesz wyświetlić tylko ograniczoną liczbę opcji zakupu w aplikacji i nie wiesz, które z nich będą miały najlepszy współczynnik konwersji. Każdy użytkownik i każda sesja są inne. Jak znaleźć ofertę zakupu w aplikacji, która przyniesie największą oczekiwaną nagrodę?

3. Pobieranie przykładowego kodu

Sklonuj repozytorium GitHub z wiersza poleceń.

git clone https://github.com/googlecodelabs/firebase-iap-optimization.git

To repozytorium zawiera:

1. Notatnik Jupyter (.ipynb), który trenuje model personalizacji i pakuje go w model TFLite.
2. Przykładowa aplikacja w języku Kotlin, która używa modelu TFLite do tworzenia prognoz na urządzeniu.

4. Uruchamianie aplikacji za pomocą Firebase

W tym ćwiczeniu z programowania zajmiemy się optymalizacją zakupów w aplikacji w naszej fikcyjnej grze – Flappy Sparky. Jest to gra platformowa, w której gracz steruje Sparkym i próbuje przelecieć między kolumnami ścian, nie uderzając w nie. Na początku poziomu użytkownikowi jest przedstawiana oferta zakupu w aplikacji, która zapewni mu wzmocnienie. W tym ćwiczeniu z programowania wdrożymy tylko część aplikacji związaną z optymalizacją zakupów w aplikacji.

Zdobyte tu informacje możesz wykorzystać w przypadku własnej aplikacji połączonej z projektem Firebase. Możesz też utworzyć nowy projekt Firebase na potrzeby tego samouczka. Jeśli potrzebujesz pomocy w rozpoczęciu korzystania z Firebase, zapoznaj się z naszymi samouczkami na ten temat ( Android i iOS).

5. Zbieranie zdarzeń Analytics w aplikacji

Zdarzenia Analytics dostarczają informacji o zachowaniu użytkowników i są wykorzystywane do trenowania modelu uczenia maszynowego. Model może się na przykład nauczyć, że użytkownicy, którzy grają dłużej, częściej dokonują zakupu w aplikacji, aby zdobyć dodatkowe życia. Aby nauczyć się tych informacji, model ML potrzebuje zdarzeń analitycznych jako danych wejściowych.

Oto niektóre zdarzenia Analytics, które możemy rejestrować:

• jak długo użytkownik gra w grę;
• poziom, na którym znajduje się użytkownik;
• Liczba monet wydanych przez użytkownika
• które produkty kupuje użytkownik;

Pobieranie przykładowych danych (opcjonalnie)

W kolejnych krokach użyjemy Firebase Analytics do rejestrowania zdarzeń analitycznych, które będą wykorzystywane w naszym modelu. Jeśli masz już dane analityczne, których chcesz użyć, przejdź do sekcji „Trenowanie modelu optymalizacji” w tym samouczku. Możesz też skorzystać z naszych przykładowych danych.

Zbieranie danych za pomocą pakietu SDK Firebase Analytics

Do zbierania tych zdarzeń analitycznych będziemy używać Firebase Analytics. Pakiet SDK Firebase Analytics automatycznie rejestruje wiele zdarzeń i właściwości użytkownika. Umożliwia też definiowanie własnych zdarzeń niestandardowych, aby mierzyć zdarzenia unikalne dla Twojej aplikacji.

Instalowanie pakietu SDK Firebase Analytics

Aby rozpocząć korzystanie z Firebase Analytics w aplikacji, postępuj zgodnie z instrukcjami w dokumentacji Google Analytics – pierwsze kroki. firebase-iap-optimization repozytorium sklonowane na początku tego samouczka zawiera już pakiet SDK Firebase Analytics.

Rejestrowanie zdarzeń niestandardowych

Po skonfigurowaniu pakietu SDK Firebase Analytics możemy zacząć rejestrować zdarzenia potrzebne do trenowania modelu.

Zanim to zrobimy, musimy ustawić identyfikator użytkownika w zdarzeniu analitycznym, abyśmy mogli powiązać dane analityczne tego użytkownika z jego dotychczasowymi danymi w aplikacji.

MainActivity.kt

firebaseAnalytics.setUserId("player1")

Następnie możemy rejestrować zdarzenia związane z odtwarzaczem. W przypadku optymalizacji zakupów w aplikacji chcemy rejestrować każdą ofertę zakupu w aplikacji wyświetlaną użytkownikowi oraz to, czy użytkownik ją kliknął. W ten sposób uzyskamy 2 zdarzenia analityczne: offer_iap i offer_accepted. Będziemy też śledzić unikalny identyfikator offer_id, aby później połączyć te dane i sprawdzić, czy oferta została zaakceptowana.

MainActivity.kt

predictButton?.setOnClickListener {
  predictionResult = iapOptimizer.predict()

  firebaseAnalytics.logEvent("offer_iap"){
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

acceptButton?.setOnClickListener {
  firebaseAnalytics.logEvent("offer_accepted") {
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

Więcej informacji o rejestrowaniu zdarzeń niestandardowych znajdziesz w dokumentacji Firebase Analytics dotyczącej rejestrowania zdarzeń.

6. Wstępne przetwarzanie danych w BigQuery

W ostatnim kroku zebraliśmy zdarzenia dotyczące tego, która oferta zakupu w aplikacji jest wyświetlana użytkownikowi i w którą ofertę użytkownik klika. W tym kroku połączymy dane zdarzeń z danymi użytkowników, aby nasz model mógł się uczyć na podstawie pełnego obrazu.

W tym celu musimy najpierw wyeksportować zdarzenia analityczne do BigQuery.

Łączenie projektu Firebase z BigQuery

Aby połączyć z BigQuery projekt Firebase i wchodzące w jego skład aplikacje:

1. Zaloguj się w Firebase.
2. Kliknij , a potem wybierz Ustawienia projektu.
3. Na stronie Ustawienia projektu kliknij kartę Integracje.
4. Na karcie BigQuery kliknij Połącz.

(Opcjonalnie) Eksportowanie kolekcji Firestore do BigQuery

W tym kroku możesz wyeksportować z Firestore do BigQuery dodatkowe dane użytkowników, które pomogą w trenowaniu modelu. Jeśli chcesz teraz pominąć ten krok, przejdź do sekcji „Przygotowywanie danych w BigQuery” w tym samouczku. Możesz tam śledzić zdarzenia Firebase Analytics zarejestrowane w ostatnim kroku.

W Firestore możesz przechowywać datę rejestracji użytkowników, zakupy w aplikacji, poziomy w grze, liczbę monet na koncie lub inne atrybuty, które mogą być przydatne podczas trenowania modelu.

Aby wyeksportować kolekcje Firestore do BigQuery, możesz zainstalować rozszerzenie Firestore BigQuery Export. Następnie połącz tabele w BigQuery, aby połączyć te dane z danymi z Google Analytics i użyć ich w modelu personalizacji oraz w pozostałej części tego samouczka.

Przygotowywanie danych w BigQuery

W kolejnych krokach użyjemy BigQuery, aby przekształcić nieprzetworzone dane analityczne w dane, które można wykorzystać do trenowania modelu.

Aby nasz model mógł się nauczyć, którą ofertę zakupu w aplikacji wyświetlać na podstawie użytkownika i stanu gry, musimy uporządkować dane dotyczące:

• użytkownik
• stan gry,
• przedstawioną ofertę,
• czy wyświetlona oferta została kliknięta;

Aby nasz model mógł przetworzyć te dane, muszą być one uporządkowane w jednym wierszu tabeli. Na szczęście BigQuery jest skonfigurowane tak, aby nam w tym pomóc.

BigQuery umożliwia tworzenie „widoków”, aby zachować porządek w zapytaniach. Widok to tabela wirtualna zdefiniowana przez zapytanie SQL. Gdy tworzysz widok, wysyłasz do niego zapytanie w taki sam sposób jak do tabeli. Dzięki temu możemy najpierw wyczyścić dane analityczne.

Aby sprawdzić, czy każda oferta zakupu w aplikacji została kliknięta, musimy połączyć zdarzenia offer_iap i offer_accepted, które zarejestrowaliśmy w poprzednim kroku.

all_offers_joined – widok BigQuery

SELECT
  iap_offers.*,
  CASE
    WHEN accepted_offers.accepted IS NULL THEN FALSE ELSE TRUE
  END
  is_clicked,
FROM
  `iap-optimization.ml_sample.accepted_offers` AS accepted_offers
RIGHT JOIN
  `iap-optimization.ml_sample.iap_offers` AS iap_offers
ON
 accepted_offers.offer_id =iap_offers.offer_id;

all_offers_with_user_data – widok BigQuery

SELECT
  offers.is_clicked,
  offers.presented_powerup,
  offers.last_run_end_reason,
  offers.event_timestamp,
  users.*
FROM
  `iap-optimization.ml_sample.all_offers_joined` AS offers
LEFT JOIN
  `iap-optimization.ml_sample.all_users` AS users
ON
  users.user_id = offers.user_id;

Eksportowanie zbioru danych BigQuery do Google Cloud Storage

Na koniec możemy wyeksportować zbiór danych BigQuery do GCS, aby użyć go do trenowania modelu.

7. Trenowanie modelu optymalizacji

Przykładowe dane

Aby wykonać pozostałe kroki tego laboratorium, użyj danych z poprzedniego kroku „Wstępne przetwarzanie danych w BigQuery” lub danych przykładowych, które możesz pobrać tutaj.

Definicja problemu

Zanim zaczniemy trenować model, poświęćmy trochę czasu na zdefiniowanie problemu z kontekstowymi bandytami.

Wyjaśnienie kontekstowych algorytmów bandyckich

Na początku każdego poziomu w grze Flappy Sparky użytkownikowi wyświetla się oferta zakupu w aplikacji, która zapewni mu ulepszenie. Za każdym razem możemy wyświetlić tylko 1 opcję zakupu w aplikacji i nie wiemy, która z nich będzie miała najlepszy wskaźnik konwersji. Każdy użytkownik i każda sesja są inne. Jak znaleźć ofertę zakupu w aplikacji, która przyniesie największą oczekiwaną nagrodę?

W tym przypadku nagroda będzie wynosić 0, jeśli użytkownik nie zaakceptuje oferty zakupu w aplikacji, a wartość zakupu w aplikacji, jeśli to zrobi. Aby zmaksymalizować nagrodę, możemy użyć danych historycznych do wytrenowania modelu, który będzie przewidywać oczekiwaną nagrodę za każde działanie użytkownika, i znajdować działanie z najwyższą nagrodą.

W prognozie użyjemy tych danych:

• Stan: informacje o użytkowniku i jego bieżącej sesji.
• Działanie: oferty zakupu w aplikacji, które możemy wyświetlać
• Nagroda: wartość oferty zakupu w aplikacji

Wykorzystywanie a odkrywanie

W przypadku wszystkich problemów z wielorękim bandytą algorytm musi zachować równowagę między eksploracją (zbieraniem większej ilości danych, aby dowiedzieć się, które działanie daje optymalny wynik) a eksploatacją (wykorzystywaniem optymalnego wyniku do uzyskania najwyższej nagrody).

W naszej wersji problemu uprościmy to do okresowego trenowania modelu w chmurze i wykonywania prognoz tylko wtedy, gdy model jest używany na urządzeniu użytkownika (w przeciwieństwie do trenowania również na urządzeniu użytkownika). Aby po użyciu modelu mieć wystarczającą ilość danych treningowych, musimy czasami wyświetlać użytkownikom aplikacji losowe wyniki (np. w 30% przypadków). Ta strategia równoważenia eksploracji i eksploatacji jest nazywana zachłanną strategią epsilon.

Trenowanie modelu

Aby rozpocząć, możesz użyć skryptu trenującego (training.ipynb) dostarczonego w ramach ćwiczeń z programowania. Naszym celem jest wytrenowanie modelu, który będzie prognozować oczekiwane nagrody za każde działanie w danym stanie. Następnie znajdujemy działanie, które daje nam najwyższe oczekiwane nagrody.

Trenowanie lokalne

Najłatwiej zacząć trenowanie własnego modelu od skopiowania notatnika w przykładowym kodzie do tego ćwiczenia.

Do tego ćwiczenia nie potrzebujesz procesora graficznego, ale jeśli chcesz użyć wydajniejszego urządzenia do eksplorowania własnych danych i trenowania własnego modelu, możesz skorzystać z instancji notatnika AI Platform, aby przyspieszyć trenowanie.

W dostarczonym skrypcie trenowania utworzyliśmy iterator, który generuje dane treningowe z plików CSV wyeksportowanych z BigQuery. Następnie użyliśmy tych danych, aby rozpocząć trenowanie modelu za pomocą Keras. Szczegółowe informacje o trenowaniu modelu znajdziesz w komentarzach w notatniku Pythona.

Mierzenie skuteczności modelu

Podczas trenowania modelu będziemy porównywać go z losowym agentem, który losowo wybiera oferty zakupu w aplikacji, aby sprawdzić, czy nasz model rzeczywiście się uczy. Ta logika znajduje się w sekcji ValidationCallback..

Po zakończeniu trenowania ponownie testujemy model, używając danych z test.csv. Model nigdy wcześniej nie widział tych danych, więc możemy mieć pewność, że wynik nie jest spowodowany nadmiernym dopasowaniem. W tym przypadku model uzyskuje wyniki o 28% lepsze niż losowy agent.

Eksportowanie modelu TFLite

Mamy już wytrenowany model gotowy do użycia, ale jest on obecnie w formacie TensorFlow. Model musimy wyeksportować w formacie TFLite, aby można go było uruchamiać na urządzeniach mobilnych.

train.ipynb

converter = tflite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with tf.io.gfile.GFile('iap-optimizer.tflite', 'wb') as f:
  f.write(tflite_model)

Stąd możesz pobrać model i połączyć go z aplikacją.

W przypadku aplikacji produkcyjnej zalecamy wdrożenie modelu w Firebase ML i hostowanie go w Firebase. Jest to przydatne z 2 głównych powodów:

1. Możemy zmniejszyć rozmiar instalacji aplikacji i pobierać model tylko w razie potrzeby.
2. Model można regularnie aktualizować w innym cyklu wydawniczym niż cała aplikacja.

Aby dowiedzieć się, jak wdrożyć model w Firebase ML, zapoznaj się z samouczkiem Dodawanie Firebase do aplikacji na Androida opartej na TFLite. Możesz wdrożyć model za pomocą konsoli Firebase lub interfejsu Python API.

8. Generowanie prognoz na urządzeniu

Kolejnym krokiem jest tworzenie prognoz przy użyciu modelu na urządzeniu. Przykładową aplikację, która pobiera model z Firebase ML, znajdziesz w folderze app pobranego kodu przykładowego. Możesz jej użyć do przeprowadzania wnioskowania na podstawie danych po stronie klienta.

Podczas trenowania modelu zastosowaliśmy pewne przetwarzanie wstępne, dlatego podczas uruchamiania modelu na urządzeniu musimy zastosować to samo przetwarzanie wstępne do danych wejściowych modelu. Prostym sposobem na to jest użycie niezależnego od platformy i języka formatu, takiego jak plik JSON zawierający mapę każdej funkcji z metadanymi dotyczącymi sposobu przeprowadzania wstępnego przetwarzania. Więcej informacji o tym, jak to zrobić, znajdziesz w przykładzie aplikacji.

Następnie podajemy modelowi dane wejściowe testu w ten sposób:

IapOptimzer.kt

  val testInput = mapOf(
    "coins_spent" to                       2048f,
    "distance_avg" to                      1234f,
    "device_os" to                         "ANDROID",
    "game_day" to                          10f,
    "geo_country" to                       "Canada",
    "last_run_end_reason" to               "laser"
  )

Model sugeruje, że sparky_armor to najlepszy dodatek do zakupów w aplikacji dla tego konkretnego użytkownika.

Pomiar dokładności modelu

Aby zmierzyć dokładność naszego modelu, możemy po prostu śledzić oferty zakupu w aplikacji przewidywane przez nasz model oraz to, czy są one klikane, za pomocą Firebase Analytics. Możesz używać tej funkcji w połączeniu z testami A/B Firebase, aby mierzyć rzeczywistą skuteczność modelu. Możesz też przeprowadzać testy A/B różnych wersji modelu. Więcej informacji o testach A/B w Firebase znajdziesz w dokumentacji Tworzenie eksperymentów Zdalnej konfiguracji Firebase z testami A/B.

9. (Opcjonalnie): regularne aktualizowanie modelu za pomocą nowych danych

Jeśli chcesz aktualizować model w miarę pojawiania się nowych danych, możesz skonfigurować potok, który będzie okresowo ponownie trenować model. Aby to zrobić, musisz najpierw mieć nowe dane do trenowania przy użyciu strategii epsilon-zachłanna, o której wspomnieliśmy powyżej. (np. w 70% przypadków używać wyniku prognozy modelu, a w 30% – wyników losowych).

Konfigurowanie potoku do trenowania i wdrażania z użyciem nowych danych wykracza poza zakres tego samouczka. Aby rozpocząć, zapoznaj się z Google Cloud AI Platform i TFX.

10. Gratulacje!

Z tych ćwiczeń z programowania dowiesz się, jak wytrenować i wdrożyć na urządzeniu model TFLite do optymalizacji zakupów w aplikacji za pomocą Firebase. Więcej informacji o TFLite i Firebase znajdziesz w innych przykładach TFLite i przewodnikach dla początkujących dotyczących Firebase.

Jeśli masz pytania, możesz je zadać na Stack Overflow #firebase-machine-learning.

Omówione zagadnienia

• TensorFlow Lite
• Firebase ML
• Firebase Analytics
• BigQuery

Następne kroki

• trenować i wdrażać model optymalizatora w swojej aplikacji,

Więcej informacji

• Dokumentacja Firebase Machine Learning
• Dokumentacja TensorFlow Lite
• Testowanie modeli A/B za pomocą Firebase