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 iOS 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ł
- Xcode 11 (lub nowszy)
- CocoaPods 1.9.1 (lub nowszy)
Jak będziesz korzystać z tego samouczka?
Jak oceniasz swoje doświadczenia z tworzeniem aplikacji na iOS?
2. Utwórz projekt konsoli Firebase
Dodaj Firebase do projektu
- Przejdź do konsoli Firebase .
- Wybierz opcję Utwórz nowy projekt i nazwij swój projekt „Firebase ML iOS Codelab”.
3. Pobierz przykładowy projekt
Pobierz kod
Rozpocznij 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 zainstalowanego gita, możesz także pobrać przykładowy projekt ze strony GitHub lub klikając ten link . Po pobraniu projektu uruchom go w Xcode i pobaw się zaleceniami, aby przekonać się, jak to działa.
Skonfiguruj Firebase
Postępuj zgodnie z dokumentacją , aby utworzyć nowy projekt Firebase. Gdy już masz projekt, pobierz plik GoogleService-Info.plist swojego projektu z konsoli Firebase i przeciągnij go do katalogu głównego projektu Xcode.
Dodaj Firebase do swojego Podfile i uruchom instalację pod.
pod 'FirebaseAnalytics' pod 'FirebaseMLModelDownloader', '9.3.0-beta' pod 'TensorFlowLiteSwift'
W metodzie didFinishLaunchingWithOptions aplikacji AppDelegate zaimportuj Firebase na górze pliku
import FirebaseCore
I dodaj wywołanie, aby skonfigurować Firebase.
FirebaseApp.configure()
Uruchom projekt ponownie, aby upewnić się, że aplikacja jest poprawnie skonfigurowana i nie ulega awarii podczas uruchamiania.
- Upewnij się, że opcja „Włącz Google Analytics dla tego projektu” jest włączona.
- 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).
4. 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.
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 poniższy kod, aby zarejestrować zdarzenie analityczne, gdy użytkownik kliknie „Polub 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. 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
Ogólnie rzecz biorąc, zdarzenia rejestrowane przez Twoją aplikację są grupowane w okresie około jednej godziny i przesyłane razem. Takie podejście oszczędza baterię urządzeń użytkowników końcowych i zmniejsza zużycie danych w sieci. Jednakże w celu sprawdzenia poprawności implementacji analiz (oraz w celu wyświetlenia statystyk w raporcie DebugView) możesz włączyć tryb debugowania na swoim urządzeniu programistycznym, aby przesyłać zdarzenia z minimalnym opóźnieniem.
Aby włączyć tryb debugowania Analytics na urządzeniu programistycznym, określ następujący argument wiersza poleceń w Xcode:
-FIRDebugEnabled
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, również będą przesyłane strumieniowo do konsoli Firebase. Zachęcamy do przejścia do następnej strony.
Opcjonalnie: Potwierdź zdarzenia Analytics w konsoli Firebase
- Przejdź do konsoli Firebase .
- Wybierz opcję DebugView w obszarze Analytics
- W Xcode wybierz Uruchom , aby uruchomić aplikację i dodać kilka filmów do listy Polubione.
- W DebugView konsoli Firebase sprawdź, czy te zdarzenia są rejestrowane podczas dodawania filmów w aplikacji.
6. 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
- Przejdź do konsoli Firebase .
- Wybierz ikonę koła zębatego Ustawienia obok Przeglądu projektu , a następnie wybierz Ustawienia projektu
- Wybierz zakładkę Integracje .
- Wybierz opcję Link (lub Zarządzaj ) w bloku BigQuery .
- Wybierz Dalej w kroku Informacje o łączeniu Firebase z BigQuery .
- 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.
7. 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
- Przejdź do panelu BigQuery w konsoli Google Cloud.
- Wybierz nazwę projektu w menu.
- Wybierz nazwę projektu na dole lewego panelu nawigacyjnego BigQuery, aby zobaczyć szczegóły.
- Wybierz opcję Utwórz zbiór danych , aby otworzyć panel tworzenia zbioru danych.
- Wpisz „firebase_recommendations_dataset” jako identyfikator zbioru danych i wybierz opcję Utwórz zbiór danych .
- Nowy zbiór danych pojawi się w lewym menu pod nazwą projektu. Kliknij to.
- Wybierz opcję Utwórz tabelę , aby otworzyć panel tworzenia tabeli.
- W obszarze Utwórz tabelę z wybierz opcję „Google Cloud Storage”.
- W polu Wybierz plik z segmentu GCS wpisz „gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt”.
- Z listy rozwijanej Format pliku wybierz opcję „JSONL”.
- Wpisz „tabela_rekomendacji” jako nazwę tabeli .
- Zaznacz pole w obszarze Schemat > Automatyczne wykrywanie > Schemat i parametry wejściowe
- 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.
- Wybierz zestaw danych Firebase-Recommendations w lewym menu, aby rozwinąć zawarte w nim tabele.
- Wybierz tabelę tabeli rekomendacji , aby wyświetlić schemat tabeli.
- 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ć.
- Upewnij się, że w Twoim projekcie Google Cloud są włączone rozliczenia.
- Włącz interfejsy API BigQuery i BigQuery Storage API. < kliknij tutaj >
- Przejdź do strony Utwórz klucz konta usługi .
- Z listy Konto usługi wybierz Nowe konto usługi .
- W polu Nazwa konta usługi wprowadź nazwę.
- Z listy Rola wybierz Projekt > Właściciel .
- 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.
8. Wstępnie przetwarzaj dane i trenuj model rekomendacji
Na tym etapie użyjemy notatnika Colab do wykonania następujących kroków:
- zaimportuj dane BigQuery do notatnika Colab
- wstępnie przetworzyć dane, aby przygotować je do uczenia modelu
- trenuj model rekomendacji na danych analitycznych
- wyeksportuj model jako model TF Lite
- 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ć wytrenowany 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. 
Postępuj zgodnie z instrukcjami, aby skonfigurować wiadro.
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
9. 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ź).
Podplik
import FirebaseCore
import FirebaseMLModelDownloader
Pobierz model za pomocą interfejsu API Firebase Model Manager
Skopiuj poniższy kod do pliku ModelLoader.swift , aby skonfigurować warunki pobierania modelu i utworzyć zadanie pobierania w celu zsynchronizowania zdalnego modelu 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 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 zasobów. Skopiuj poniższy kod, aby załadować tych kandydatów.
ZaleceniaViewController.swift
func getMovies() -> [MovieItem] {
let barController = self.tabBarController as! TabBarController
return barController.movies
}
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:
ZaleceniaViewController.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
}
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.
ZaleceniaViewController.swift
import TensorFlowLite
ZaleceniaViewController.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ż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.
ZaleceniaViewController.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 swoją aplikację!
Uruchom ponownie aplikację. Po wybraniu kilku filmów powinien automatycznie pobrać nowy model i zacząć generować rekomendacje!
11. 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