在 Android 上使用 TensorFlow Lite 模型進行推論

您可以使用 ML Kit，透過 TensorFlow Lite 模型在裝置上執行推論。

這個 API 需要 Android SDK 級別 16 (Jelly Bean) 以上版本。

事前準備

  1. 如果您尚未將 Firebase 新增至 Android 專案，請先新增。
  2. 將 ML Kit Android 程式庫的依附元件新增至模組 (應用程式層級) Gradle 檔案 (通常為 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'
}
  3. 將要使用的 TensorFlow 模型轉換為 TensorFlow Lite 格式。 請參閱 TOCO：TensorFlow Lite 最佳化轉換工具。

託管或組合模型

如要在應用程式中使用 TensorFlow Lite 模型進行推論，必須先讓 ML Kit 存取該模型。ML Kit 可以使用 Firebase 遠端代管的 TensorFlow Lite 模型、與應用程式二進位檔一併封裝的模型，或兩者皆是。

在 Firebase 上代管模型後，您不必發布新版應用程式即可更新模型，還能使用 Remote Config 和 A/B Testing，動態為不同使用者群組提供不同模型。

如果您選擇只透過 Firebase 代管模型，而不將模型與應用程式一併封裝，即可縮減應用程式的初始下載大小。不過請注意，如果模型未與應用程式一併封裝，應用程式必須先下載模型，才能使用任何與模型相關的功能。

將模型與應用程式一併封裝，可確保應用程式的 ML 功能在 Firebase 代管模型無法使用時，仍能正常運作。

在 Firebase 上託管模型

如要在 Firebase 上代管 TensorFlow Lite 模型，請按照下列步驟操作：

  1. 在 Firebase 控制台的「ML Kit」部分，按一下「自訂」分頁標籤。
  2. 按一下「新增自訂模型」 (或「新增其他模型」)。
  3. 指定用於在 Firebase 專案中識別模型的名稱，然後上傳 TensorFlow Lite 模型檔案 (通常以 .tflite 或 .lite 結尾)。
  4. 在應用程式的資訊清單中，宣告需要 INTERNET 權限： 
    <uses-permission android:name="android.permission.INTERNET" />

將自訂模型新增至 Firebase 專案後，您可以使用指定的名稱在應用程式中參照模型。您可以隨時上傳新的 TensorFlow Lite 模型，應用程式會在下次重新啟動時下載並開始使用新模型。您可以定義應用程式嘗試更新模型時所需的裝置條件 (請參閱下文)。

將模型與應用程式組合

如要將 TensorFlow Lite 模型與應用程式組合，請將模型檔案 (通常以 .tflite 或 .lite 結尾) 複製到應用程式的 assets/ 資料夾。(你可能需要先建立資料夾，方法是在 app/ 資料夾上按一下滑鼠右鍵，然後依序點選「New」>「Folder」>「Assets Folder」)。

然後在應用程式的 build.gradle 檔案中新增下列程式碼，確保 Gradle 在建構應用程式時不會壓縮模型：

android {

    // ...

    aaptOptions {
        noCompress "tflite"  // Your model's file extension: "tflite", "lite", etc.
    }
}

模型檔案會納入應用程式套件，並以原始資產的形式提供給 ML Kit。

載入模型

如要在應用程式中使用 TensorFlow Lite 模型，請先透過 Firebase 遠端、本機儲存空間或兩者，設定模型可用的位置，然後設定機器學習套件。如果您同時指定本機和遠端模型，則可使用遠端模型 (如有)，並在遠端模型無法使用時改用本機儲存的模型。

設定 Firebase 託管模型

如果您使用 Firebase 代管模型，請建立 FirebaseCustomRemoteModel 物件，並指定您上傳模型時指派的名稱：

Java 

FirebaseCustomRemoteModel remoteModel =
        new FirebaseCustomRemoteModel.Builder("your_model").build();

Kotlin 

val remoteModel = FirebaseCustomRemoteModel.Builder("your_model").build()

接著啟動模型下載工作，並指定允許下載的條件。如果裝置上沒有模型，或是有更新版本的模型可用，工作會從 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 

val conditions = FirebaseModelDownloadConditions.Builder()
    .requireWifi()
    .build()
FirebaseModelManager.getInstance().download(remoteModel, conditions)
    .addOnCompleteListener {
        // Success.
    }

許多應用程式會在初始化程式碼中啟動下載工作，但您可以在需要使用模型前的任何時間點執行這項操作。

設定本機模型

如果您將模型與應用程式一併封裝，請建立 FirebaseCustomLocalModel 物件，並指定 TensorFlow Lite 模型的檔案名稱：

Java 

FirebaseCustomLocalModel localModel = new FirebaseCustomLocalModel.Builder()
        .setAssetFilePath("your_model.tflite")
        .build();

Kotlin 

val localModel = FirebaseCustomLocalModel.Builder()
    .setAssetFilePath("your_model.tflite")
    .build()

從模型建立解譯器

設定模型來源後，請從其中一個來源建立 FirebaseModelInterpreter 物件。

如果只有本機綁定的模型，只要從 FirebaseCustomLocalModel 物件建立解譯器即可：

Java 

FirebaseModelInterpreter interpreter;
try {
    FirebaseModelInterpreterOptions options =
            new FirebaseModelInterpreterOptions.Builder(localModel).build();
    interpreter = FirebaseModelInterpreter.getInstance(options);
} catch (FirebaseMLException e) {
    // ...
}

Kotlin 

val options = FirebaseModelInterpreterOptions.Builder(localModel).build()
val interpreter = FirebaseModelInterpreter.getInstance(options)

如果您使用遠端代管模型，必須先確認模型已下載，才能執行。您可以使用模型管理工具的 isModelDownloaded() 方法，檢查模型下載工作的狀態。

雖然您只需要在執行解譯器前確認這項設定，但如果您同時有遠端代管模型和本機套裝模型，在例項化模型解譯器時執行這項檢查可能會有意義：如果已下載遠端模型，請從該模型建立解譯器，否則請從本機模型建立解譯器。

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 

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded -> 
    val options =
        if (isDownloaded) {
            FirebaseModelInterpreterOptions.Builder(remoteModel).build()
        } else {
            FirebaseModelInterpreterOptions.Builder(localModel).build()
        }
    val interpreter = FirebaseModelInterpreter.getInstance(options)
}

如果只有遠端代管模型，您應停用模型相關功能 (例如將部分 UI 設為灰色或隱藏)，直到確認模型已下載為止。方法是在模型管理員的 download() 方法中附加監聽器：

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 

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.
    }

指定模型的輸入和輸出內容

接著，請設定模型解譯器的輸入和輸出格式。

TensorFlow Lite 模型會將一或多個多維度陣列做為輸入內容，並產生一或多個多維度陣列做為輸出內容。這些陣列包含 byte、int、long 或 float 值。您必須使用模型所用陣列的數字和維度 (「形狀」) 設定 ML Kit。

如果您不知道模型輸入和輸出的形狀和資料類型，可以使用 TensorFlow Lite Python 解譯器檢查模型。例如：

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'>

決定模型輸入和輸出的格式後，您就可以建立 FirebaseModelInputOutputOptions 物件，設定應用程式的模型解譯器。

舉例來說，浮點數圖片分類模型可能會將 Nx224x224x3 陣列的 float 值做為輸入內容，代表一批 224x224 三通道 (RGB) 圖片，並產生 1000 個 float 值做為輸出內容，每個值代表圖片屬於模型預測的 1000 個類別之一的機率。N

如果是這類模型，您會設定模型解譯器的輸入和輸出，如下所示：

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 

val inputOutputOptions = FirebaseModelInputOutputOptions.Builder()
        .setInputFormat(0, FirebaseModelDataType.FLOAT32, intArrayOf(1, 224, 224, 3))
        .setOutputFormat(0, FirebaseModelDataType.FLOAT32, intArrayOf(1, 5))
        .build()

對輸入資料執行推論

最後，如要使用模型執行推論，請取得輸入資料，並對資料執行任何必要的轉換，以取得適合模型的輸入陣列。

舉例來說，如果您有輸入形狀為 [1 224 224 3] 浮點數值的圖片分類模型，可以從 Bitmap 物件產生輸入陣列，如下列範例所示：

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 

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
    }
}

接著，使用輸入資料建立 FirebaseModelInputs 物件，並將該物件和模型的輸入/輸出規格傳遞至模型解譯器的 run 方法：

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 

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
            // ...
        }

如果呼叫成功，您可以呼叫傳遞至成功事件監聽器的物件的 getOutput() 方法，取得輸出內容。例如：

Java 

float[][] output = result.getOutput(0);
float[] probabilities = output[0];

Kotlin 

val output = result.getOutput<Array<FloatArray>>(0)
val probabilities = output[0]

輸出內容的使用方式取決於使用的模型。

舉例來說，如果您要執行分類作業，下一步可能是將結果的索引對應至代表的標籤：

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 

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]))
}

附錄：模型安全性

無論您如何將 TensorFlow Lite 模型提供給 ML Kit，ML Kit 都會以標準序列化 protobuf 格式將模型儲存在本機儲存空間。

從理論上來說，這表示任何人都能複製你的模型。不過，實際上大多數模型都經過最佳化，因此會針對特定應用程式進行混淆處理，風險與競爭對手拆解及重複使用您程式碼的風險類似。不過，在應用程式中使用自訂模型前，請務必瞭解這項風險。

在 Android API 級別 21 (Lollipop) 以上版本中，模型會下載至 自動備份排除的目錄。

在 Android API 級別 20 以下版本中，模型會下載至應用程式私有內部儲存空間中名為 com.google.firebase.ml.custom.models 的目錄。如果您使用 BackupAgent 啟用檔案備份功能，可以選擇排除這個目錄。