Możesz użyć ML Kit, aby przeprowadzić wnioskowanie na urządzeniu z modelem TensorFlow Lite .
Ten interfejs API wymaga zestawu SDK systemu Android na poziomie 16 (Jelly Bean) lub nowszego.
Zanim zaczniesz
- Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu na Androida .
- Dodaj zależności dla bibliotek ML Kit Android do pliku Gradle modułu (na poziomie aplikacji) (zwykle
app/build.gradle):apply plugin: 'com.android.application' apply plugin: 'com.google.gms.google-services' dependencies { // ... implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.3' } - Konwertuj model TensorFlow, którego chcesz użyć, do formatu TensorFlow Lite. Zobacz TOCO: Konwerter optymalizujący TensorFlow Lite .
Hostuj lub pakuj swój model
Zanim będziesz mógł użyć modelu TensorFlow Lite do wnioskowania w swojej aplikacji, musisz udostępnić model ML Kit. ML Kit może korzystać z modeli TensorFlow Lite hostowanych zdalnie przy użyciu Firebase, dołączonych do pliku binarnego aplikacji lub obu.
Hostując model w Firebase, możesz aktualizować model bez wydawania nowej wersji aplikacji, a także możesz używać zdalnej konfiguracji i testów A/B do dynamicznego udostępniania różnych modeli różnym grupom użytkowników.
Jeśli zdecydujesz się udostępnić model tylko poprzez hostowanie go w Firebase, a nie łączyć go z aplikacją, możesz zmniejszyć początkowy rozmiar pobieranej aplikacji. Pamiętaj jednak, że jeśli model nie jest dołączony do Twojej aplikacji, wszelkie funkcje związane z modelem nie będą dostępne, dopóki aplikacja nie pobierze modelu po raz pierwszy.
Łącząc model z aplikacją, możesz mieć pewność, że funkcje uczenia maszynowego w aplikacji będą nadal działać, gdy model hostowany przez Firebase nie będzie dostępny.
Hostuj modele w Firebase
Aby hostować model TensorFlow Lite w Firebase:
- W sekcji ML Kit konsoli Firebase kliknij kartę Niestandardowe .
- Kliknij opcję Dodaj model niestandardowy (lub Dodaj kolejny model ).
- Podaj nazwę, która będzie używana do identyfikacji Twojego modelu w projekcie Firebase, a następnie prześlij plik modelu TensorFlow Lite (zwykle kończący się na
.tflitelub.lite). - W manifeście aplikacji zadeklaruj, że wymagane jest pozwolenie na INTERNET:
<uses-permission android:name="android.permission.INTERNET" />
Po dodaniu niestandardowego modelu do projektu Firebase możesz odwoływać się do modelu w swoich aplikacjach, używając określonej nazwy. W dowolnym momencie możesz przesłać nowy model TensorFlow Lite, a Twoja aplikacja pobierze nowy model i zacznie go używać po ponownym uruchomieniu aplikacji. Możesz zdefiniować warunki urządzenia wymagane, aby Twoja aplikacja podjęła próbę aktualizacji modelu (patrz poniżej).
Połącz modele z aplikacją
Aby powiązać model TensorFlow Lite z aplikacją, skopiuj plik modelu (zwykle kończący się na .tflite lub .lite ) do folderu assets/ aplikacji. (Być może konieczne będzie najpierw utworzenie folderu poprzez kliknięcie app/ folderu prawym przyciskiem myszy, a następnie kliknięcie opcji Nowy > Folder > Folder zasobów ).
Następnie dodaj następujące elementy do pliku build.gradle swojej aplikacji, aby mieć pewność, że Gradle nie kompresuje modeli podczas tworzenia aplikacji:
android {
// ...
aaptOptions {
noCompress "tflite" // Your model's file extension: "tflite", "lite", etc.
}
}
Plik modelu zostanie zawarty w pakiecie aplikacji i będzie dostępny dla ML Kit jako surowy zasób.
Załaduj model
Aby używać modelu TensorFlow Lite w swojej aplikacji, najpierw skonfiguruj ML Kit z lokalizacjami, w których Twój model jest dostępny: zdalnie przy użyciu Firebase, w pamięci lokalnej lub w obu przypadkach. Jeśli określisz zarówno model lokalny, jak i zdalny, możesz użyć modelu zdalnego, jeśli jest on dostępny, i wrócić do modelu przechowywanego lokalnie, jeśli model zdalny nie jest dostępny.Skonfiguruj model hostowany w Firebase
Jeśli hostujesz swój model w Firebase, utwórz obiekt FirebaseCustomRemoteModel , podając nazwę, którą przypisałeś modelowi podczas jego przesyłania:
Java
FirebaseCustomRemoteModel remoteModel =
new FirebaseCustomRemoteModel.Builder("your_model").build();
Kotlin+KTX
val remoteModel = FirebaseCustomRemoteModel.Builder("your_model").build()
Następnie rozpocznij zadanie pobierania modelu, określając warunki, na jakich chcesz zezwolić na pobieranie. Jeśli modelu nie ma na urządzeniu lub jeśli dostępna jest nowsza wersja modelu, zadanie asynchronicznie pobierze model z Firebase:
Java
FirebaseModelDownloadConditions conditions = new FirebaseModelDownloadConditions.Builder()
.requireWifi()
.build();
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnCompleteListener(new OnCompleteListener<Void>() {
@Override
public void onComplete(@NonNull Task<Void> task) {
// Success.
}
});
Kotlin+KTX
val conditions = FirebaseModelDownloadConditions.Builder()
.requireWifi()
.build()
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnCompleteListener {
// Success.
}
Wiele aplikacji rozpoczyna zadanie pobierania w kodzie inicjującym, ale można to zrobić w dowolnym momencie, zanim będzie konieczne użycie modelu.
Skonfiguruj model lokalny
Jeśli połączyłeś model ze swoją aplikacją, utwórz obiekt FirebaseCustomLocalModel , określając nazwę pliku modelu TensorFlow Lite:
Java
FirebaseCustomLocalModel localModel = new FirebaseCustomLocalModel.Builder()
.setAssetFilePath("your_model.tflite")
.build();
Kotlin+KTX
val localModel = FirebaseCustomLocalModel.Builder()
.setAssetFilePath("your_model.tflite")
.build()
Utwórz interpreter na podstawie swojego modelu
Po skonfigurowaniu źródeł modelu utwórz obiekt FirebaseModelInterpreter z jednego z nich.
Jeśli masz tylko model powiązany lokalnie, po prostu utwórz interpreter na podstawie obiektu FirebaseCustomLocalModel :
Java
FirebaseModelInterpreter interpreter;
try {
FirebaseModelInterpreterOptions options =
new FirebaseModelInterpreterOptions.Builder(localModel).build();
interpreter = FirebaseModelInterpreter.getInstance(options);
} catch (FirebaseMLException e) {
// ...
}
Kotlin+KTX
val options = FirebaseModelInterpreterOptions.Builder(localModel).build()
val interpreter = FirebaseModelInterpreter.getInstance(options)
Jeśli masz model hostowany zdalnie, przed uruchomieniem musisz sprawdzić, czy został pobrany. Możesz sprawdzić status zadania pobierania modelu, korzystając z metody isModelDownloaded() menedżera modeli.
Chociaż musisz to potwierdzić jedynie przed uruchomieniem interpretera, jeśli masz zarówno model hostowany zdalnie, jak i model pakowany lokalnie, sensowne może być wykonanie tej kontroli podczas tworzenia instancji interpretera modelu: utwórz interpreter na podstawie modelu zdalnego, jeśli został pobrany, a w przeciwnym razie z modelu lokalnego.
Java
FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
.addOnSuccessListener(new OnSuccessListener<Boolean>() {
@Override
public void onSuccess(Boolean isDownloaded) {
FirebaseModelInterpreterOptions options;
if (isDownloaded) {
options = new FirebaseModelInterpreterOptions.Builder(remoteModel).build();
} else {
options = new FirebaseModelInterpreterOptions.Builder(localModel).build();
}
FirebaseModelInterpreter interpreter = FirebaseModelInterpreter.getInstance(options);
// ...
}
});
Kotlin+KTX
FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
.addOnSuccessListener { isDownloaded ->
val options =
if (isDownloaded) {
FirebaseModelInterpreterOptions.Builder(remoteModel).build()
} else {
FirebaseModelInterpreterOptions.Builder(localModel).build()
}
val interpreter = FirebaseModelInterpreter.getInstance(options)
}
Jeśli masz tylko model hostowany zdalnie, wyłącz funkcje związane z modelem — na przykład wyszarz lub ukryj część interfejsu użytkownika — do czasu potwierdzenia, że model został pobrany. Można to zrobić, dołączając odbiornik do metody download() menedżera modeli:
Java
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnSuccessListener(new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void v) {
// Download complete. Depending on your app, you could enable
// the ML feature, or switch from the local model to the remote
// model, etc.
}
});
Kotlin+KTX
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnCompleteListener {
// Download complete. Depending on your app, you could enable the ML
// feature, or switch from the local model to the remote model, etc.
}
Określ dane wejściowe i wyjściowe modelu
Następnie skonfiguruj formaty wejściowe i wyjściowe interpretera modelu.
Model TensorFlow Lite przyjmuje jako dane wejściowe i generuje jako dane wyjściowe jedną lub więcej tablic wielowymiarowych. Tablice te zawierają wartości byte , int , long lub float . Musisz skonfigurować ML Kit podając liczbę i wymiary („kształt”) tablic używanych przez Twój model.
Jeśli nie znasz kształtu i typu danych wejściowych i wyjściowych swojego modelu, możesz użyć interpretera TensorFlow Lite Python, aby sprawdzić swój model. Na przykład:
import tensorflow as tf interpreter = tf.lite.Interpreter(model_path="my_model.tflite") interpreter.allocate_tensors() # Print input shape and type print(interpreter.get_input_details()[0]['shape']) # Example: [1 224 224 3] print(interpreter.get_input_details()[0]['dtype']) # Example: <class 'numpy.float32'> # Print output shape and type print(interpreter.get_output_details()[0]['shape']) # Example: [1 1000] print(interpreter.get_output_details()[0]['dtype']) # Example: <class 'numpy.float32'>
Po określeniu formatu danych wejściowych i wyjściowych modelu możesz skonfigurować interpreter modelu aplikacji, tworząc obiekt FirebaseModelInputOutputOptions .
Na przykład zmiennoprzecinkowy model klasyfikacji obrazów może przyjmować jako dane wejściowe tablicę N x224x224x3 wartości float , reprezentującą partię N 224x224 obrazów trójkanałowych (RGB), i generować jako wynik listę 1000 wartości float , z których każda reprezentuje prawdopodobieństwo, że obraz należy do jednej z 1000 kategorii przewidywanych przez model.
W przypadku takiego modelu należy skonfigurować wejście i wyjście interpretera modelu, jak pokazano poniżej:
Java
FirebaseModelInputOutputOptions inputOutputOptions =
new FirebaseModelInputOutputOptions.Builder()
.setInputFormat(0, FirebaseModelDataType.FLOAT32, new int[]{1, 224, 224, 3})
.setOutputFormat(0, FirebaseModelDataType.FLOAT32, new int[]{1, 5})
.build();Kotlin+KTX
val inputOutputOptions = FirebaseModelInputOutputOptions.Builder()
.setInputFormat(0, FirebaseModelDataType.FLOAT32, intArrayOf(1, 224, 224, 3))
.setOutputFormat(0, FirebaseModelDataType.FLOAT32, intArrayOf(1, 5))
.build()Wykonaj wnioskowanie na danych wejściowych
Na koniec, aby przeprowadzić wnioskowanie przy użyciu modelu, pobierz dane wejściowe i wykonaj wszelkie przekształcenia danych, które są niezbędne, aby uzyskać tablicę wejściową o odpowiednim kształcie dla Twojego modelu. Na przykład, jeśli masz model klasyfikacji obrazów z wejściowym kształtem [1 224 224 3] wartości zmiennoprzecinkowych, możesz wygenerować tablicę wejściową z obiektu Bitmap , jak pokazano w poniższym przykładzie:
Java
Bitmap bitmap = getYourInputImage();
bitmap = Bitmap.createScaledBitmap(bitmap, 224, 224, true);
int batchNum = 0;
float[][][][] input = new float[1][224][224][3];
for (int x = 0; x < 224; x++) {
for (int y = 0; y < 224; y++) {
int pixel = bitmap.getPixel(x, y);
// Normalize channel values to [-1.0, 1.0]. This requirement varies by
// model. For example, some models might require values to be normalized
// to the range [0.0, 1.0] instead.
input[batchNum][x][y][0] = (Color.red(pixel) - 127) / 128.0f;
input[batchNum][x][y][1] = (Color.green(pixel) - 127) / 128.0f;
input[batchNum][x][y][2] = (Color.blue(pixel) - 127) / 128.0f;
}
}Kotlin+KTX
val bitmap = Bitmap.createScaledBitmap(yourInputImage, 224, 224, true)
val batchNum = 0
val input = Array(1) { Array(224) { Array(224) { FloatArray(3) } } }
for (x in 0..223) {
for (y in 0..223) {
val pixel = bitmap.getPixel(x, y)
// Normalize channel values to [-1.0, 1.0]. This requirement varies by
// model. For example, some models might require values to be normalized
// to the range [0.0, 1.0] instead.
input[batchNum][x][y][0] = (Color.red(pixel) - 127) / 255.0f
input[batchNum][x][y][1] = (Color.green(pixel) - 127) / 255.0f
input[batchNum][x][y][2] = (Color.blue(pixel) - 127) / 255.0f
}
} Następnie utwórz obiekt FirebaseModelInputs z danymi wejściowymi i przekaż go wraz ze specyfikacją wejścia i wyjścia modelu do metody run interpretera modelu :
Java
FirebaseModelInputs inputs = new FirebaseModelInputs.Builder()
.add(input) // add() as many input arrays as your model requires
.build();
firebaseInterpreter.run(inputs, inputOutputOptions)
.addOnSuccessListener(
new OnSuccessListener<FirebaseModelOutputs>() {
@Override
public void onSuccess(FirebaseModelOutputs result) {
// ...
}
})
.addOnFailureListener(
new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
// Task failed with an exception
// ...
}
});Kotlin+KTX
val inputs = FirebaseModelInputs.Builder()
.add(input) // add() as many input arrays as your model requires
.build()
firebaseInterpreter.run(inputs, inputOutputOptions)
.addOnSuccessListener { result ->
// ...
}
.addOnFailureListener { e ->
// Task failed with an exception
// ...
} Jeśli wywołanie się powiedzie, możesz uzyskać wynik, wywołując metodę getOutput() obiektu, który jest przekazywany do detektora powodzenia. Na przykład:
Java
float[][] output = result.getOutput(0); float[] probabilities = output[0];
Kotlin+KTX
val output = result.getOutput<Array<FloatArray>>(0) val probabilities = output[0]
Sposób wykorzystania danych wyjściowych zależy od używanego modelu.
Na przykład, jeśli przeprowadzasz klasyfikację, w następnym kroku możesz zmapować indeksy wyniku na etykiety, które reprezentują:
Java
BufferedReader reader = new BufferedReader(
new InputStreamReader(getAssets().open("retrained_labels.txt")));
for (int i = 0; i < probabilities.length; i++) {
String label = reader.readLine();
Log.i("MLKit", String.format("%s: %1.4f", label, probabilities[i]));
}Kotlin+KTX
val reader = BufferedReader(
InputStreamReader(assets.open("retrained_labels.txt")))
for (i in probabilities.indices) {
val label = reader.readLine()
Log.i("MLKit", String.format("%s: %1.4f", label, probabilities[i]))
}Dodatek: Bezpieczeństwo modelu
Niezależnie od tego, w jaki sposób udostępnisz modele TensorFlow Lite w ML Kit, ML Kit przechowuje je w standardowym serializowanym formacie protobuf w pamięci lokalnej.
Teoretycznie oznacza to, że każdy może skopiować Twój model. Jednak w praktyce większość modeli jest tak specyficzna dla aplikacji i zaciemniona optymalizacjami, że ryzyko jest podobne do ryzyka, jakie stwarza konkurencja, która demontuje i ponownie wykorzystuje Twój kod. Niemniej jednak powinieneś zdawać sobie sprawę z tego ryzyka, zanim użyjesz niestandardowego modelu w swojej aplikacji.
W systemie Android API poziomu 21 (Lollipop) i nowszych model jest pobierany do katalogu, który jest wykluczony z automatycznego tworzenia kopii zapasowych .
W przypadku interfejsu API systemu Android na poziomie 20 i starszych model jest pobierany do katalogu o nazwie com.google.firebase.ml.custom.models w prywatnej pamięci wewnętrznej aplikacji. Jeśli włączyłeś tworzenie kopii zapasowych plików za pomocą BackupAgent , możesz wykluczyć ten katalog.