在 Android 上使用 TensorFlow Lite 模型透過 ML Kit 進行推理

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

此 API 需要 Android SDK 等級 16 (Jelly Bean) 或更高版本。

在你開始之前

  1. 如果您尚未將 Firebase 新增至您的 Android 專案中,請將其新增至您的 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 上託管模型,您可以更新模型而無需發布新的應用版本,並且可以使用遠端配置和 A/B 測試向不同的使用者群組動態提供不同的模型。

如果您選擇僅透過 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/資料夾,然後按一下新建 > 資料夾 > 資產資料夾來建立資料夾。)

然後,將以下內容新增至應用程式的build.gradle檔案中,以確保 Gradle 在建置應用程式時不會壓縮模型:

android {

    // ...

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

模型檔案將包含在應用程式套件中,並可作為原始資產提供給 ML Kit。

載入模型

若要在應用程式中使用 TensorFlow Lite 模型,請先使用模型可用的位置設定 ML Kit:遠端使用 Firebase、在本機儲存中或兩者兼而有之。如果您同時指定本機模型和遠端模型,則可以使用遠端模型(如果可用);如果遠端模型不可用,則可以回退到本機儲存的模型。

配置 Firebase 託管模型

如果您使用 Firebase 託管模型,請建立一個FirebaseCustomRemoteModel對象,並指定您上傳模型時為該模型指派的名稱:

Java

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

Kotlin+KTX

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+KTX

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+KTX

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+KTX

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

如果您只有遠端託管模型,則應停用與模型相關的功能(例如,灰顯或隱藏部分 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+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.
    }

指定模型的輸入和輸出

接下來,配置模型解釋器的輸入和輸出格式。

TensorFlow Lite 模型將一個或多個多維數組作為輸入並產生輸出。這些陣列包含byteintlongfloat值。您必須使用模型使用的陣列的數量和維度(「形狀」)來配置 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物件來配置套用的模型解釋器。

例如,浮點影像分類模型可能將N x224x224x3 float值數組作為輸入,表示一批N 224x224 三通道 (RGB) 影像,並產生 1000 個float值清單作為輸出,每個浮點值表示影像屬於模型預測的1000 個類別之一的機率。

對於這樣的模型,您將配置模型解釋器的輸入和輸出,如下所示:

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()

對輸入資料進行推理

最後,要使用模型執行推理,請取得輸入資料並對資料執行必要的轉換,以獲得適合模型的輸入數組。

例如,如果您有一個輸入形狀為 [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+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
    }
}

然後,使用輸入資料建立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+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
            // ...
        }

如果呼叫成功,您可以透過呼叫傳遞給成功偵聽器的物件的getOutput()方法來取得輸出。例如:

Java

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

Kotlin+KTX

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

附錄:模型安全性

無論您如何使 TensorFlow Lite 模型可供 ML Kit 使用,ML Kit 都會將它們以標準序列化 protobuf 格式儲存在本地儲存中。

從理論上講,這意味著任何人都可以複製您的模型。然而,在實踐中,大多數模型都是特定於應用程式的,並且由於最佳化而變得模糊,因此風險類似於競爭對手反彙編和重複使用您的程式碼。儘管如此,在應用程式中使用自訂模型之前,您應該意識到這種風險。

在 Android API 等級 21 (Lollipop) 及更高版本上,模型將下載到自動備份中排除的目錄。

在 Android API 等級 20 及更早版本上,模型將下載到應用程式私有內部儲存中名為com.google.firebase.ml.custom.models的目錄中。如果您使用BackupAgent啟用檔案備份,您可以選擇排除此目錄。