Bantuan melindungi Great Barrier Reef dengan TensorFlow pada Kaggle Bergabung Tantangan

Hasilkan antarmuka model menggunakan metadata

Dengan menggunakan TensorFlow Lite Metadata , developer dapat membuat kode pembungkus untuk mengaktifkan integrasi di Android. Bagi sebagian besar developer, antarmuka grafis Android Studio ML Model Binding adalah yang paling mudah digunakan. Jika Anda memerlukan lebih banyak penyesuaian atau menggunakan alat baris perintah, TensorFlow Lite Codegen juga tersedia.

Gunakan Pengikatan Model ML Android Studio

Untuk model TensorFlow Lite yang disempurnakan dengan metadata , developer dapat menggunakan Pengikatan Model ML Android Studio untuk secara otomatis mengonfigurasi setelan proyek dan menghasilkan kelas pembungkus berdasarkan metadata model. Kode pembungkus menghilangkan kebutuhan untuk berinteraksi langsung dengan ByteBuffer . Sebaliknya, developer dapat berinteraksi dengan model TensorFlow Lite dengan objek yang diketik seperti Bitmap dan Rect .

Impor model TensorFlow Lite di Android Studio

  1. Klik kanan pada modul yang ingin Anda gunakan model TFLite atau klik File , lalu New > Other > TensorFlow Lite Model Menu klik kanan untuk mengakses fungsi impor TensorFlow Lite

  2. Pilih lokasi file TFLite Anda. Perhatikan bahwa fitur tersebut akan mengonfigurasi dependensi modul atas nama Anda dengan pengikatan Model ML dan semua dependensi secara otomatis dimasukkan ke dalam file build.gradle modul Android Anda.

    Opsional: Pilih kotak centang kedua untuk mengimpor TensorFlow GPU jika Anda ingin menggunakan akselerasi GPU. Dialog impor untuk model TFLite

  3. Klik Finish .

  4. Layar berikut akan muncul setelah impor berhasil. Untuk mulai menggunakan model, pilih Kotlin atau Java, salin dan tempel kode di bawah bagian Sample Code . Anda bisa kembali ke layar ini dengan mengklik dua kali model TFLite di bawah direktori ml di Android Studio. Halaman detail model di Android Studio

Mempercepat inferensi model

ML Model Binding menyediakan cara bagi pengembang untuk mempercepat kode mereka melalui penggunaan delegasi dan jumlah utas.

Langkah 1. Periksa file modul build.gradle yang berisi dependensi berikut:

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
    }

Langkah 2. Deteksi apakah GPU yang berjalan di perangkat kompatibel dengan delegasi GPU TensorFlow, jika tidak menjalankan model menggunakan beberapa utas CPU:

Kotlin

    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice) {
        // if the device has a supported GPU, add the GPU delegate
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        // if the GPU is not supported, run on 4 threads
        Model.Options.Builder().setNumThreads(4).build()
    }

    // Initialize the model as usual feeding in the options object
    val myModel = MyModel.newInstance(context, options)

    // Run inference per sample code
      

Jawa

    import org.tensorflow.lite.support.model.Model
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Model.Options options;
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        options = Model.Options.Builder().setDevice(Model.Device.GPU).build();
    } else {
        // if the GPU is not supported, run on 4 threads
        options = Model.Options.Builder().setNumThreads(4).build();
    }

    MyModel myModel = new MyModel.newInstance(context, options);

    // Run inference per sample code
      

Buat antarmuka model dengan pembuat kode TensorFlow Lite

Untuk model TensorFlow Lite yang disempurnakan dengan metadata , developer dapat menggunakan pembuat kode pembungkus Android TensorFlow Lite untuk membuat kode pembungkus khusus platform. Kode pembungkus menghilangkan kebutuhan untuk berinteraksi langsung dengan ByteBuffer . Sebaliknya, developer dapat berinteraksi dengan model TensorFlow Lite dengan objek yang diketik seperti Bitmap dan Rect .

Kegunaan pembuat kode bergantung pada kelengkapan entri metadata model TensorFlow Lite. Lihat bagian <Codegen usage> kode <Codegen usage> di bawah bidang yang relevan di metadata_schema.fbs , untuk melihat bagaimana alat codegen mem-parsing setiap bidang.

Hasilkan Kode pembungkus

Anda perlu menginstal perkakas berikut di terminal Anda:

pip install tflite-support

Setelah selesai, pembuat kode dapat digunakan menggunakan sintaks berikut:

tflite_codegen --model=./model_with_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --package_name=org.tensorflow.lite.classify \
    --model_class_name=MyClassifierModel \
    --destination=./classify_wrapper

Kode yang dihasilkan akan ditempatkan di direktori tujuan. Jika Anda menggunakan Google Colab atau lingkungan jarak jauh lainnya, mungkin lebih mudah untuk membuat zip hasilnya dalam arsip zip dan mengunduhnya ke proyek Android Studio Anda:

# Zip up the generated code
!zip -r classify_wrapper.zip classify_wrapper/

# Download the archive
from google.colab import files
files.download('classify_wrapper.zip')

Menggunakan kode yang dihasilkan

Langkah 1: Impor kode yang dihasilkan

Buka zip kode yang dihasilkan jika perlu ke dalam struktur direktori. Akar dari kode yang dihasilkan diasumsikan SRC_ROOT .

Buka proyek Android Studio tempat Anda ingin menggunakan model ringan TensorFlow dan impor modul yang dihasilkan dengan: And File -> New -> Import Module -> pilih SRC_ROOT

Menggunakan contoh di atas, direktori dan modul yang diimpor akan disebut classify_wrapper .

Langkah 2: Perbarui file build.gradle aplikasi

Dalam modul aplikasi yang akan menggunakan modul perpustakaan yang dihasilkan:

Di bawah bagian android, tambahkan yang berikut ini:

aaptOptions {
   noCompress "tflite"
}

Di bawah bagian dependensi, tambahkan yang berikut ini:

implementation project(":classify_wrapper")

Langkah 3: Menggunakan model

// 1. Initialize the model
MyClassifierModel myImageClassifier = null;

try {
    myImageClassifier = new MyClassifierModel(this);
} catch (IOException io){
    // Error reading the model
}

if(null != myImageClassifier) {

    // 2. Set the input with a Bitmap called inputBitmap
    MyClassifierModel.Inputs inputs = myImageClassifier.createInputs();
    inputs.loadImage(inputBitmap));

    // 3. Run the model
    MyClassifierModel.Outputs outputs = myImageClassifier.run(inputs);

    // 4. Retrieve the result
    Map<String, Float> labeledProbability = outputs.getProbability();
}

Mempercepat inferensi model

Kode yang dihasilkan menyediakan cara bagi pengembang untuk mempercepat kode mereka melalui penggunaan delegasi dan jumlah utas. Ini dapat disetel saat memulai objek model karena memerlukan tiga parameter:

  • Context : Konteks dari Aktivitas atau Layanan Android
  • (Opsional) Device : Delegasi akselerasi TFLite misalnya GPUDelegate atau NNAPIDelegate
  • (Opsional) numThreads : Jumlah utas yang digunakan untuk menjalankan model - default adalah satu.

Misalnya, untuk menggunakan delegasi NNAPI dan hingga tiga utas, Anda dapat menginisialisasi model seperti ini:

try {
    myImageClassifier = new MyClassifierModel(this, Model.Device.NNAPI, 3);
} catch (IOException io){
    // Error reading the model
}

Penyelesaian masalah

Jika Anda mendapatkan 'java.io.FileNotFoundException: File ini tidak dapat dibuka sebagai deskriptor file; itu mungkin kesalahan terkompresi ', masukkan baris berikut di bawah bagian android dari modul aplikasi yang akan menggunakan modul perpustakaan:

aaptOptions {
   noCompress "tflite"
}