1. Opis
|
|
Witamy na kursie Rekomendacje dotyczące TensorFlow Lite i Firebase Codelabs. Z tego ćwiczenia w Codelabs dowiesz się, jak użyć TensorFlow Lite i Firebase do wdrożenia modelu rekomendacji w aplikacji. To ćwiczenie w Codelabs opiera się na tym przykładzie TensorFlow Lite.
Rekomendacje umożliwiają aplikacjom korzystanie z systemów uczących się, aby wyświetlać użytkownikom najtrafniejsze treści. biorą pod uwagę wcześniejsze zachowania użytkowników, aby sugerować treści aplikacji, z którymi użytkownik może chcieć wejść w przyszłości. Wykorzystuje do tego model wytrenowany na zbiorczym zachowaniu dużej liczby innych użytkowników.
Z tego samouczka dowiesz się, jak za pomocą Firebase Analytics zbierać dane od użytkowników aplikacji, utworzyć model systemów uczących się na podstawie tych danych, a potem używać go w aplikacji na iOS do wnioskowania i uzyskiwania rekomendacji. Nasze rekomendacje wskazują przede wszystkim, które filmy użytkownik najprawdopodobniej chętnie obejrzy, biorąc pod uwagę listę filmów, które wcześniej mu się spodobały.
Czego się nauczysz
- Integracja Firebase Analytics z aplikacją na Androida w celu zbierania danych o zachowaniu użytkowników
- eksportować te dane do Google Big Query,
- Wstępne przetwarzanie danych i wytrenowanie modelu rekomendacji TF Lite
- Wdróż model TF Lite w Firebase ML i uzyskaj do niego dostęp z aplikacji
- Przeprowadź wnioskowanie na urządzeniu z wykorzystaniem modelu, aby proponować użytkownikom rekomendacje
Czego potrzebujesz
- Xcode 11 (lub nowszy)
- CocoaPods w wersji 1.9.1 (lub nowszej)
Jak wykorzystasz ten samouczek?
Jak oceniasz swoje doświadczenia z tworzeniem aplikacji na iOS?
2. Utwórz projekt konsoli Firebase
Dodaj Firebase do projektu
- Otwórz konsolę Firebase.
- Wybierz Utwórz nowy projekt i nazwij swój projekt „Ćwiczenie z programowania w Firebase ML na iOS”.
3. Pobierz przykładowy projekt
Pobierz kod
Zacznij od sklonowania przykładowego projektu i uruchomienia pod update w katalogu projektu:
git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-ios.git cd codelab-contentrecommendation-ios/start pod install --repo-update
Jeśli nie masz zainstalowanej aplikacji git, możesz też pobrać przykładowy projekt ze strony GitHuba lub kliknąć ten link. Po pobraniu projektu uruchom go w Xcode i zapoznaj się z rekomendacjami, aby zobaczyć, jak to działa.
Skonfiguruj Firebase
Aby utworzyć nowy projekt Firebase, postępuj zgodnie z dokumentacją. Gdy otrzymasz projekt, pobierz jego plik GoogleService-Info.plist z konsoli Firebase i przeciągnij go do katalogu głównego projektu Xcode.
Dodaj Firebase do pliku Podfile i uruchom instalację poda.
pod 'FirebaseAnalytics' pod 'FirebaseMLModelDownloader', '9.3.0-beta' pod 'TensorFlowLiteSwift'
W metodzie didFinishLaunchingWithOptions w swoim urządzeniu AppDelegate zaimportuj Firebase na początku pliku
import FirebaseCore
Dodaj wywołanie, aby skonfigurować Firebase.
FirebaseApp.configure()
Uruchom projekt jeszcze raz, aby upewnić się, że aplikacja jest prawidłowo skonfigurowana i nie ulega awarii przy uruchamianiu.
- Upewnij się, że opcja „Włącz Google Analytics dla tego projektu” jest włączona.
- Wykonaj pozostałe kroki konfiguracji w konsoli Firebase, a potem kliknij Utwórz projekt (lub Dodaj Firebase, jeśli używasz istniejącego projektu Google).
4. Dodaj Firebase Analytics do aplikacji
W tym kroku dodasz do aplikacji Firebase Analytics, aby rejestrować dane o zachowaniu użytkowników (w tym przypadku oznacza to, które filmy mu się podobają). Te dane będą używane w formie zbiorczej w kolejnych krokach do trenowania modelu rekomendacji.
Konfigurowanie Firebase Analytics w aplikacji
Obiekt LikeMoviesViewModel zawiera funkcje do przechowywania filmów, które spodobały się użytkownikowi. Za każdym razem, gdy użytkownikowi spodoba się nowy film, chcemy też wysłać zdarzenie z dziennika narzędzia analitycznego, aby to zarejestrować.
Dodaj poniższy kod, aby rejestrować zdarzenie analityczne, gdy użytkownik kliknie przycisk „Podoba mi się” film.
AllMoviesCollectionViewController.swift
import FirebaseAnalytics
//
override func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
//
if movie.liked == nil {
movie.liked = true
Analytics.logEvent(AnalyticsEventSelectItem, parameters: [AnalyticsParameterItemID: movie.id])
} else {
movie.liked?.toggle()
}
}
5. Testowanie integracji z Analytics
W tym kroku wygenerujemy zdarzenia Analytics w aplikacji i sprawdzimy, czy są wysyłane do konsoli Firebase.
Włącz logowanie debugowania Analytics.
Ogólnie zdarzenia rejestrowane przez aplikację są grupowane w ciągu około godziny i przesyłane razem. Takie podejście pozwala oszczędzać baterię użytkowników urządzeń i zmniejsza użycie danych w sieci. Jednak na potrzeby weryfikacji implementacji analityki (oraz wyświetlania statystyk w raporcie DebugView) możesz włączyć tryb debugowania na urządzeniu, którego używasz do programowania, i przesyłać zdarzenia z minimalnym opóźnieniem.
Aby włączyć tryb debugowania Analytics na urządzeniu, którego używasz do programowania, wpisz w Xcode ten argument wiersza poleceń:
-FIRDebugEnabled
Udało Ci się zintegrować Firebase Analytics ze swoją aplikacją. W miarę jak użytkownicy korzystają z Twojej aplikacji lub oglądają filmy, będą one rejestrowane zbiorczo. Wykorzystamy te dane zbiorcze w pozostałej części tego ćwiczenia z programowania do wytrenowania naszego modelu rekomendacji. Wykonaj jeszcze opcjonalny krok, aby wyświetlić w konsoli Firebase te same zdarzenia Analytics, które pojawiły się w narzędziu Logcat. Możesz przejść do następnej strony.
Opcjonalnie: potwierdzaj zdarzenia Analytics w konsoli Firebase
- Otwórz konsolę Firebase.
- W sekcji Analytics wybierz DebugView.
- W Xcode wybierz Uruchom, aby uruchomić aplikację i dodać filmy do listy Polubionych.
- W raporcie DebugView w konsoli Firebase sprawdź, czy te zdarzenia są rejestrowane podczas dodawania filmów do aplikacji.
6. Eksportowanie danych Analytics do BigQuery
Big Query to usługa Google Cloud, która umożliwia badanie i przetwarzanie dużych ilości danych. W tym kroku połączysz swój projekt w konsoli Firebase z Big Query, dzięki czemu dane Analytics generowane przez Twoją aplikację będą automatycznie eksportowane do BigQuery.
Włączanie eksportu do BigQuery
- Otwórz konsolę Firebase.
- Kliknij ikonę ustawień z kołem zębatym obok opcji Przegląd projektu, a potem kliknij Ustawienia projektu.
- Kliknij kartę Integrations (Integracje).
- Kliknij Połącz (lub Zarządzaj) w bloku BigQuery.
- Kliknij Dalej w kroku Łączenie Firebase z BigQuery.
- W sekcji Skonfiguruj integrację kliknij przełącznik, aby włączyć wysyłanie danych Google Analytics, i wybierz Połącz z BigQuery.
W ramach projektu konsoli Firebase masz teraz włączone automatyczne wysyłanie danych o zdarzeniach z Firebase Analytics do BigQuery. Dzieje się to automatycznie i bez dalszej interakcji, jednak pierwszy eksport, który utworzy zbiór danych analitycznych w BigQuery, może nastąpić dopiero po upływie 24 godzin. Po utworzeniu zbioru danych Firebase stale eksportuje nowe zdarzenia Analytics do BigQuery do tabeli danych częściowych i grupuje zdarzenia z poprzednich dni w tabeli zdarzeń.
Wytrenowanie modelu rekomendacji wymaga dużych ilości danych. Nie mamy jeszcze aplikacji generującej duże ilości danych, więc w następnym kroku zaimportujemy do BigQuery przykładowy zbiór danych, którego będziemy używać w dalszej części tego samouczka.
7. Użyj BigQuery, aby uzyskać dane do trenowania modelu
Po połączeniu konsoli Firebase z funkcją eksportowania do BigQuery dane o zdarzeniach analityki aplikacji po pewnym czasie automatycznie pojawią się w konsoli BigQuery. Aby uzyskać dane początkowe na potrzeby tego samouczka, w tym kroku zaimportujemy istniejący przykładowy zbiór danych do Twojej konsoli BigQuery, aby wykorzystać go do wytrenowania modelu rekomendacji.
Importowanie przykładowego zbioru danych do BigQuery
- Otwórz panel BigQuery w konsoli Google Cloud.
- Wybierz nazwę projektu z menu.
- Aby zobaczyć szczegóły, wybierz nazwę projektu u dołu menu nawigacyjnego BigQuery po lewej stronie.
- Wybierz Utwórz zbiór danych, aby otworzyć panel tworzenia zbioru danych.
- Wpisz „firebase_recommendations_dataset” jako Identyfikator zbioru danych i wybierz Utwórz zbiór danych.
- Nowy zbiór danych pojawi się w menu po lewej stronie pod nazwą projektu. Kliknij ją.
- Kliknij Utwórz tabelę, aby otworzyć panel tworzenia tabeli.
- W polu Utwórz tabelę z wybierz „Google Cloud Storage”.
- W polu Wybierz plik z zasobnika GCS wpisz „gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt”.
- Wybierz „JSONL”. z menu Format pliku.
- Wpisz „recommendations_table” (tabela rekomendacji) w polu Nazwa tabeli.
- Zaznacz pole w sekcji Schemat > Wykryj automatycznie > Schemat i parametry wejściowe
- Wybierz Utwórz tabelę.
Zobacz przykładowy zbiór danych
W tym momencie możesz opcjonalnie zapoznać się ze schematem i wyświetlić podgląd tego zbioru danych.
- W menu po lewej stronie wybierz firebase-recommendations-dataset, aby rozwinąć znajdujące się w nim tabele.
- Wybierz tabelę recommendations-table, aby wyświetlić schemat tabeli.
- Kliknij Podgląd, aby zobaczyć rzeczywiste dane zdarzeń Analytics zawarte w tej tabeli.
Utwórz dane logowania do konta usługi
Teraz w projekcie w konsoli Google Cloud utworzymy dane logowania do konta usługi, których w kolejnym kroku będzie można używać w środowisku Colab do uzyskiwania dostępu do danych BigQuery i ich wczytywania.
- Sprawdź, czy w projekcie Google Cloud włączone są płatności.
- włączyć interfejsy BigQuery Storage API i BigQuery Storage API, < kliknij tutaj>
- Otwórz stronę tworzenia klucza konta usługi.
- Z listy Konto usługi wybierz Nowe konto usługi.
- W polu Nazwa konta usługi wpisz nazwę.
- Z listy Rola wybierz Projekt > Właściciel.
- Kliknij Utwórz. Na komputer zostanie pobrany plik JSON zawierający klucz.
W następnym kroku użyjemy Google Colab, aby wstępnie przetworzyć te dane i wytrenować nasz model rekomendacji.
8. Wstępne przetwarzanie danych i trenowanie modelu rekomendacji
W tym kroku wykorzystamy notatnik Colab, aby wykonać te czynności:
- zaimportować dane BigQuery do notatnika Colab
- wstępne przetwarzanie danych w celu przygotowania ich do trenowania modelu
- wytrenowanie modelu rekomendacji na danych analitycznych
- wyeksportuj model jako model TF Lite
- wdrożymy model w konsoli Firebase, abyśmy mogli używać go w naszej aplikacji
Zanim wprowadzimy notatnik treningowy Colab, najpierw włączymy interfejs Firebase Model Management API, aby usługa Colab mogła wdrożyć wytrenowany model w konsoli Firebase.
Włącz interfejs Firebase Model Management API
Tworzenie zasobnika do przechowywania modeli ML
W konsoli Firebase otwórz Pamięć i kliknij Rozpocznij. 
Postępuj zgodnie z instrukcjami wyświetlanymi w oknie, aby skonfigurować zasobnik.
Włączanie interfejsu Firebase ML API
Otwórz stronę interfejsu Firebase ML API w konsoli Google Cloud i kliknij Włącz.
Użyj notatnika Colab do wytrenowania i wdrożenia modelu
Otwórz notatnik Colab, korzystając z tego linku, i wykonaj podane instrukcje. Po wykonaniu czynności w notatniku Colab w konsoli Firebase wdrożysz plik modelu TF Lite, który będziemy mogli zsynchronizować z naszą aplikacją.
Otwórz w Colab
9. Pobierz model w aplikacji
W tym kroku zmodyfikujemy aplikację, aby pobrać model, który właśnie wytrenowaliśmy z użyciem systemów uczących się Firebase.
Dodaj zależność Firebase ML
Aby można było używać w aplikacji modeli systemów uczących się Firebase, wymagana jest zależność poniżej. Powinien już zostać dodany (weryfikacja).
Plik Podfile
import FirebaseCore
import FirebaseMLModelDownloader
Pobieranie modelu za pomocą interfejsu Firebase Model Manager API
Skopiuj poniższy kod do pliku ModelLoader.swift, aby skonfigurować warunki pobierania modelu, a następnie utwórz zadanie pobierania, aby zsynchronizować model zdalny z naszą aplikacją.
ModelLoader.swift
static func downloadModel(named name: String,
completion: @escaping (CustomModel?, DownloadError?) -> Void) {
guard FirebaseApp.app() != nil else {
completion(nil, .firebaseNotInitialized)
return
}
guard success == nil && failure == nil else {
completion(nil, .downloadInProgress)
return
}
let conditions = ModelDownloadConditions(allowsCellularAccess: false)
ModelDownloader.modelDownloader().getModel(name: name, downloadType: .localModelUpdateInBackground, conditions: conditions) { result in
switch (result) {
case .success(let customModel):
// Download complete.
// The CustomModel object contains the local path of the model file,
// which you can use to instantiate a TensorFlow Lite classifier.
return completion(customModel, nil)
case .failure(let error):
// Download was unsuccessful. Notify error message.
completion(nil, .downloadFailed(underlyingError: error))
}
}
}
10. Zintegruj model rekomendacji Tensorflow Lite z aplikacją
Środowisko wykonawcze Tensorflow Lite pozwoli Ci używać modelu w aplikacji do generowania rekomendacji. W poprzednim kroku zainicjowaliśmy interpreter TFlite z pobranym przez nas plikiem modelu. W tym kroku najpierw wczytamy słownik i etykiety, które będą towarzyszyć naszemu modelowi w kroku wnioskowania. Potem dodamy do modelu wstępne przetwarzanie w celu generowania danych wejściowych i przetwarzanie, na którym wyodrębnimy wyniki z naszego wnioskowania.
Wczytaj słownik i etykiety
Etykiety używane do generowania kandydatów do rekomendacji przez model rekomendacji są wymienione w pliku sorted_movie_vocab.json w folderze zasobów. Skopiuj poniższy kod, aby wczytać tych kandydatów.
RecommendationsViewController.swift
func getMovies() -> [MovieItem] {
let barController = self.tabBarController as! TabBarController
return barController.movies
}
Wdrażanie wstępnego przetwarzania
Na etapie wstępnego przetwarzania zmieniamy formę danych wejściowych, tak aby była zgodna z oczekiwaniami naszego modelu. Jeśli nie uzyskaliśmy jeszcze dużej liczby polubień, dodajemy tutaj długość wejściową wartością zmiennej. Skopiuj poniższy kod:
RecommendationsViewController.swift
// Given a list of selected items, preprocess to get tflite input.
func preProcess() -> Data {
let likedMovies = getLikedMovies().map { (MovieItem) -> Int32 in
return MovieItem.id
}
var inputData = Data(copyingBufferOf: Array(likedMovies.prefix(10)))
// Pad input data to have a minimum of 10 context items (4 bytes each)
while inputData.count < 10*4 {
inputData.append(0)
}
return inputData
}
Uruchamianie tłumaczenia rozmowy w celu wygenerowania rekomendacji
W tym przykładzie używamy modelu pobranego w poprzednim kroku, aby wnioskować na podstawie wstępnie przetworzonych danych wejściowych. Określamy typ danych wejściowych i wyjściowych dla naszego modelu i uruchamiamy wnioskowanie, aby generować rekomendacje dotyczące filmów. Skopiuj ten kod do aplikacji.
RecommendationsViewController.swift
import TensorFlowLite
RecommendationsViewController.swift
private var interpreter: Interpreter?
func loadModel() {
// Download the model from Firebase
print("Fetching recommendations model...")
ModelDownloader.fetchModel(named: "recommendations") { (filePath, error) in
guard let path = filePath else {
if let error = error {
print(error)
}
return
}
print("Recommendations model download complete")
self.loadInterpreter(path: path)
}
}
func loadInterpreter(path: String) {
do {
interpreter = try Interpreter(modelPath: path)
// Allocate memory for the model's input `Tensor`s.
try interpreter?.allocateTensors()
let inputData = preProcess()
// Copy the input data to the input `Tensor`.
try self.interpreter?.copy(inputData, toInputAt: 0)
// Run inference by invoking the `Interpreter`.
try self.interpreter?.invoke()
// Get the output `Tensor`
let confidenceOutputTensor = try self.interpreter?.output(at: 0)
let idOutputTensor = try self.interpreter?.output(at: 1)
// Copy output to `Data` to process the inference results.
let confidenceOutputSize = confidenceOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})
let idOutputSize = idOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})
let confidenceResults =
UnsafeMutableBufferPointer<Float32>.allocate(capacity: confidenceOutputSize!)
let idResults =
UnsafeMutableBufferPointer<Int32>.allocate(capacity: idOutputSize!)
_ = confidenceOutputTensor?.data.copyBytes(to: confidenceResults)
_ = idOutputTensor?.data.copyBytes(to: idResults)
postProcess(idResults, confidenceResults)
print("Successfully ran inference")
DispatchQueue.main.async {
self.tableView.reloadData()
}
} catch {
print("Error occurred creating model interpreter: \(error)")
}
}
Wdrażanie przetwarzania końcowego
Na koniec przetwarzamy dane wyjściowe naszego modelu, wybierając je o największym stopniu pewności i usuwając wartości zawarte (filmy, które użytkownik już polubił). Skopiuj ten kod do aplikacji.
RecommendationsViewController.swift
// Postprocess to get results from tflite inference.
func postProcess(_ idResults: UnsafeMutableBufferPointer<Int32>, _ confidenceResults: UnsafeMutableBufferPointer<Float32>) {
for i in 0..<10 {
let id = idResults[i]
let movieIdx = getMovies().firstIndex { $0.id == id }
let title = getMovies()[movieIdx!].title
recommendations.append(Recommendation(title: title, confidence: confidenceResults[i]))
}
}
Przetestuj aplikację
Ponownie uruchom aplikację. Po wybraniu kilku filmów nowy model powinien automatycznie pobrać nowy model i zacząć generować rekomendacje.
11. Gratulacje!
Masz wbudowaną w swoją aplikację funkcję rekomendacji za pomocą TensorFlow Lite i Firebase. Pamiętaj, że techniki i potok pokazane w tym ćwiczeniu z programowania można uogólnić i wykorzystać również do obsługi innych typów rekomendacji.
Omówione zagadnienia
- Firebase ML
- Firebase Analytics
- Eksportowanie zdarzeń analitycznych do BigQuery
- Zdarzenia analizy wstępnej przetwarzania
- Trenowanie rekomendacji w modelu TensorFlow
- Wyeksportuj model i wdróż go w konsoli Firebase
- Wyświetlanie rekomendacji filmów w aplikacji
Następne kroki
- Wdrażaj rekomendacje systemów uczących się w Firebase w swojej aplikacji.
Więcej informacji
Masz pytanie?
Zgłoś problemy