Ta strona została przetłumaczona przez Cloud Translation API.

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

1. Omówienie

Witamy w usłudze Codelab Optymalizacja zakupów w aplikacji w czasie rzeczywistym na urządzeniu. Z tych ćwiczeń z programowania dowiesz się, jak użyć TensorFlow Lite i Firebase do wytrenowania i wdrażania w aplikacji niestandardowego modelu personalizacji.

W tym samouczku pokazujemy, jak tworzyć model systemu uczącego się do personalizacji, w szczególności model, który prognozuje optymalną ofertę zakupu w aplikacji na podstawie stanu bieżącego użytkownika. To przykład problemu bandyty kontekstowego, ważnego i powszechnie stosowanego typu problemu z systemami uczącymi się, o którym dowiesz się więcej w tym laboratorium programistycznym.

Czego się nauczysz

Zbieranie danych analitycznych za pomocą Firebase Analytics
Wstępna obróbka danych analitycznych za pomocą BigQuery
Wytrenuj prosty model ML do optymalizacji zakupów w aplikacji na urządzeniu
Wdrażanie modeli TFLite w Firebase ML i dostęp do nich z aplikacji
Testowanie i eksperymentowanie z różnymi modelami za pomocą Testów A/B Firebase
trenować i wdrażać nowe modele na podstawie najnowszych danych w określonych odstępach czasowych;

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 9.8 lub nowszymi albo emulator z Usługami Google Play 9.8 lub nowszymi
Jeśli używasz fizycznego urządzenia testowego, potrzebny będzie kabel połączeniowy.
podstawowa wiedza o systemach uczących się,

Jak będziesz korzystać z tego samouczka?

Tylko przeczytać

Przeczytać i wykonać ćwiczenia

Jak oceniasz swoje wrażenia z tworzenia aplikacji na Androida?

Początkujący

Średnio zaawansowany

Zaawansowany

2. Omówienie problemu

Załóżmy, że jesteś twórcą gry i chcesz wyświetlać spersonalizowane sugestie zakupów w aplikacji na końcu każdego poziomu. Możesz wyświetlać tylko ograniczoną liczbę opcji mikropłatności za każdym razem i nie wiesz, które z nich przyniosą najlepsze wyniki. Ponieważ każdy użytkownik i każda sesja są inne, jak możemy znaleźć ofertę IAP, która daje najwyższą oczekiwaną nagrodę?

3. Pobieranie przykładowego kodu

Sklonuj repozytorium GitHub z poziomu wiersza poleceń.

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

To repozytorium zawiera:

notatnik Jupyter (.ipynb) z wytrenowanym modelem personalizacji i zapakowanym modelem TFLite;
Przykładowa aplikacja w języku Kotlin, która korzysta z modelu TFLite do tworzenia prognoz na urządzeniu

4. Uruchamianie aplikacji za pomocą Firebase

W tym ćwiczeniu z programowania zajmiemy się optymalizacją IAP fikcyjnej gry Flappy Sparky. Jest to gra typu side-scroller, w której gracz kieruje Sparkym, próbując przelecieć między kolumnami ścian bez zderzenia z nimi. Na początku poziomu użytkownikowi wyświetlana jest oferta treści dodatkowych, która zapewni mu dodatkowe punkty. W tym ćwiczeniu z kodem zaimplementujemy tylko część aplikacji dotyczącą optymalizacji IAP.

Poznane tu informacje możesz zastosować w swojej aplikacji połączonej z projektem Firebase. Możesz też utworzyć nowy projekt Firebase na potrzeby tego ćwiczenia. Jeśli potrzebujesz pomocy przy rozpoczynaniu pracy z Firebase, zapoznaj się z naszymi samouczkami na ten temat ( Android i iOS).

5. Rejestrowanie zdarzeń analitycznych w aplikacji

Zdarzenia Analytics dostarczają informacji o zachowaniu użytkowników i służą do trenowania modelu ML. Model może na przykład stwierdzić, że użytkownicy, którzy grają dłużej, są bardziej skłonni do dokonania zakupu w aplikacji, aby zdobyć dodatkowe życie. Aby się ich nauczyć, model ML potrzebuje jako danych wejściowych zdarzeń Analytics.

Oto niektóre zdarzenia analityczne, które warto rejestrować:

czas gry użytkownika;
Poziom, na który dociera użytkownik
Liczba monet wydanych przez użytkownika
jakie produkty kupuje użytkownik;

Pobieranie przykładowych danych (opcjonalnie)

W następnych krokach użyjemy Firebase Analytics do rejestrowania zdarzeń analitycznych, które będą używane w naszym modelu. Jeśli masz już dane analityczne, których chcesz użyć, przejdź do sekcji „Wytrenowanie modelu optymalizacji” w tym laboratorium kodu i wykonaj instrukcje z użyciem przykładowych danych.

Zbieranie danych za pomocą pakietu SDK Firebase Analytics

Zdarzenia analityczne będziemy zbierać za pomocą Firebase Analytics. Pakiet SDK Firebase Analytics rejestruje automatycznie pewną liczbę zdarzeń i właściwości użytkownika. Pozwala też definiować własne zdarzenia niestandardowe, aby mierzyć zdarzenia unikalne dla Twojej aplikacji.

Instalowanie pakietu SDK Firebase Analytics

Aby rozpocząć korzystanie z Analytics Firebase w aplikacji, postępuj zgodnie z dokumentacją Pierwsze kroki z Google Analytics. Repozytorium firebase-iap-optimization sklonowane na początku tego warsztatu zawiera już pakiet SDK Firebase Analytics.

Rejestrowanie zdarzeń niestandardowych

Po skonfigurowaniu pakietu SDK Analytics Firebase 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 dotychczasowymi danymi w aplikacji.

MainActivity.kt

firebaseAnalytics.setUserId("player1")

Następnie możemy rejestrować zdarzenia dotyczące odtwarzania. Aby zoptymalizować IAP, chcemy rejestrować każdą ofertę IAP wyświetlaną użytkownikowi oraz to, czy użytkownik kliknął tę ofertę. Spowoduje to powstanie 2 zdarzeni analitycznych: offer_iap i offer_accepted. Będziemy też śledzić unikalny identyfikator oferty (offer_id), aby później można było użyć go do połączenia tych danych i sprawdzenia, 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 na temat rejestrowania zdarzeń.

6. Wstępne przetwarzanie danych w BigQuery

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

Aby to zrobić, musisz 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:

Zaloguj się w Firebase.
Kliknij , a następnie wybierz Ustawienia projektu.
Na stronie Ustawienia projektu kliknij kartę Integracje.
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, aby wykorzystać je do trenowania modelu. Jeśli chcesz pominąć ten krok, przejdź do sekcji „Przygotowanie danych w BigQuery” w tym samouczku. W ostatnim kroku możesz zapoznać się z zdarzeniami Analytics Firebase zarejestrowanymi w dzienniku.

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

Aby eksportować zbiory Firestore do BigQuery, możesz zainstalować rozszerzenie BigQuery Export dla Firestore. Następnie złącz tabele w BigQuery, aby połączyć te dane z informacjami z Google Analytics. Następnie użyjesz ich w modelu personalizacji i w pozostałych częściach tego Codelab.

Przygotowanie danych w BigQuery

W kolejnych krokach użyjemy BigQuery do przekształcenia nieprzetworzonych danych analitycznych w dane, których można użyć do trenowania modelu.

Aby nasz model mógł określić, które oferty IAP wyświetlić na podstawie użytkownika i stanu gry, musimy uporządkować dane o:

użytkownika
stan gry.
oferty przedstawionej
czy użytkownik kliknął prezentowaną ofertę

Aby model mógł przetworzyć te dane, trzeba je uporządkować w jeden wiersz w tabeli. Na szczęście BigQuery jest tak skonfigurowany, aby nam w tym pomóc.

BigQuery umożliwia tworzenie „widoków” w celu uporządkowania zapytań. 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 oczyścić dane analityczne.

Aby sprawdzić, czy użytkownicy klikają każdą ofertę zakupu w aplikacji, musimy złączyć zdarzenia offer_iap i offer_accepted, które zostały zarejestrowane w poprzednim kroku.

all_offers_joined – widok w 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 kontynuować pracę z tym ćwiczeniem, możesz użyć danych z poprzedniego kroku („Przedwstępne przetwarzanie danych w BigQuery”) lub pobranych tutaj przykładowych danych.

Definicja problemu

Zanim zaczniemy trenować model, wyjaśnijmy sobie, na czym polega problem bandytów kontekstowych.

Omówienie bandytów kontekstowych

Na początku każdego poziomu w Flappy Sparky użytkownikowi wyświetlana jest oferta treści płatnych, która zapewni mu dodatkowe możliwości. Możemy wyświetlać tylko jedną opcję płatności w aplikacji za każdym razem i nie wiemy, która z nich zapewni największą liczbę konwersji. Ponieważ każdy użytkownik i każda sesja są inne, jak możemy znaleźć ofertę IAP, która daje najwyższą oczekiwaną nagrodę?

W tym przypadku nagroda będzie wynosić 0, jeśli użytkownik nie zaakceptuje oferty IAP, a w przeciwnym razie będzie to wartość IAP. Aby zmaksymalizować nagrodę, możemy użyć danych historycznych do wytrenowania modelu, który przewiduje oczekiwaną nagrodę za każde działanie użytkownika, i znalezie zadanie o najwyższej nagrodzie.

Do prognozowania używamy tych danych:

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

Wykorzystywanie a eksplorowanie

W przypadku wszystkich problemów z wieloma bandytami algorytm musi zachować równowagę między eksploracją (pozyskiwaniem kolejnych danych, aby dowiedzieć się, które działanie daje optymalny wynik) a eksploatacją (korzystaniem z optymalnego wyniku w celu uzyskania najwyższej nagrody).

W naszej wersji tego problemu uprościmy to, aby model był trenowany okresowo w chmurze i aby prognozy były tworzone tylko wtedy, gdy model jest używany na urządzeniu użytkownika (a nie również na urządzeniu użytkownika). Aby mieć pewność, że po użyciu modelu mamy wystarczające dane do trenowania, będziemy musieli czasami (np. w 30% przypadków) wyświetlać użytkownikom aplikacji losowe wyniki. Ta strategia równoważenia eksploracji i eksploatacji nosi nazwę Epsilon-greedy.

Trenowanie modelu

Aby rozpocząć, możesz użyć skryptu szkoleniowego (training.ipynb) dołączonego do ćwiczeń z programowania. Naszym celem jest wytrenowanie modelu, który przewiduje oczekiwane nagrody za każde działanie w danym stanie, a potem znajduje działanie, które daje nam najwyższe oczekiwane nagrody.

Trenowanie lokalnie

Najprostszym sposobem na rozpoczęcie trenowania własnego modelu jest utworzenie kopii notebooka w przykładowym kodzie tego ćwiczenia.

W tym ćwiczeniu nie potrzebujesz karty graficznej, ale jeśli potrzebujesz mocniejszego komputera do analizowania własnych danych i trenowania własnego modelu, możesz utworzyć instancję Notebooka AI Platform, aby przyspieszyć trenowanie.

W dostarczonym skrypcie treningowym utworzyliśmy iterator, który generuje dane treningowe z plików CSV wyeksportowanych z BigQuery. Następnie wykorzystaliśmy te dane do rozpoczęcia trenowania modelu za pomocą Keras. Szczegółowe informacje o trenowaniu modelu znajdziesz w komentarzach do notebooka Pythona.

Pomiar skuteczności modelu

Podczas trenowania modelu porównujemy go z losowym agentem, który losowo wybiera oferty IAP, aby sprawdzić, czy nasz model faktycznie się uczy. Ta logika znajduje się w .ValidationCallback

Na koniec trenowania używamy danych z test.csv, aby ponownie przetestować model. Model nigdy wcześniej nie widział tych danych, więc możemy być pewni, że wynik nie jest spowodowany nadmiernym dopasowaniem. W tym przypadku model osiąga o 28% lepsze wyniki niż losowy agent.

Eksportowanie modelu TFLite

Mamy już wytrenowany model gotowy do użycia, ale jest on obecnie w formacie TensorFlow. Musimy wyeksportować model w formacie TFLite, aby można było go uruchomić 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)

Możesz tu pobrać model i utworzyć pakiet z aplikacją.

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

Możemy zachować mały rozmiar aplikacji i pobierać model tylko w razie potrzeby
Model można aktualizować regularnie i z innym cyklem niż cała aplikacja.

Aby dowiedzieć się, jak wdrożyć model w Firebase ML, możesz skorzystać z laboratorium kodu Dodawanie Firebase do aplikacji na Androida korzystającej z TFLite. Możesz wdrożyć je za pomocą konsoli Firebase lub interfejsu Python API.

8. Generowanie prognoz na urządzeniu

Kolejnym krokiem jest prognozowanie na podstawie modelu na urządzeniu. W pliku app w folderze pobranego przykładowego kodu znajdziesz przykładową aplikację, która pobiera model z Firebase ML. Możesz jej użyć do wykonywania wnioskowania na podstawie niektórych danych po stronie klienta.

Ponieważ podczas trenowania modelu zastosowaliśmy pewne przetwarzanie wstępne, musimy zastosować to samo przetwarzanie wstępne do danych wejściowych modelu podczas jego uruchamiania na urządzeniu. Najprostszym sposobem jest użycie formatu niezależnego od platformy i języka, np. pliku JSON zawierającego mapę każdej funkcji z metadanymi o wykonywaniu wstępnej obróbki. Więcej informacji o tym, jak to zrobić, znajdziesz w przykładowej aplikacji.

Następnie podajemy modelowi dane testowe w ten sposób:

IapOptimizer.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 najlepsza opcja zakupów w aplikacji dla tego konkretnego użytkownika.

Pomiar dokładności modelu

Aby mierzyć dokładność modelu, możemy po prostu śledzić prognozowane przez niego oferty IAP i sprawdzać, czy są one klikane, za pomocą Firebase Analytics. Możesz go używać razem z testami A/B Firebase, aby mierzyć rzeczywistą skuteczność modelu. Możesz też przeprowadzać testy A/B różnych iteracji 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 o nowe dane

Jeśli chcesz aktualizować model wraz z przyrostem nowych danych, możesz skonfigurować potok, aby regularnie ponownie uczyć się modelu. Aby to zrobić, musisz najpierw mieć nowe dane, które będą używane do trenowania przy użyciu wspomnianej wcześniej strategii epsilon-greedy. (np. korzystanie z wyników prognozy modelu w 70% przypadków i z wyników losowych w 30% przypadków).

Konfigurowanie potoku do trenowania i wdrażania z nowymi danymi wykracza poza zakres tego Codelab. Aby rozpocząć, zapoznaj się z Google Cloud AI Platform i TFX.

10. Gratulacje!

Z tych ćwiczeń z programowania dowiesz się, jak trenować i wdrażać na urządzeniu model TFLite, który służy do optymalizowania zakupów w aplikacji za pomocą Firebase. Aby dowiedzieć się więcej o TFLite i Firebase, zapoznaj się z przykładami kodu TFLite i przewodnikami Firebase.

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