Panduan Memulai untuk Android

Tutorial ini menunjukkan kepada Anda cara membuat aplikasi Android menggunakan TensorFlow Lite untuk menganalisis umpan kamera langsung dan mengidentifikasi objek menggunakan model pembelajaran mesin, menggunakan sedikit kode. Jika Anda memperbarui proyek yang sudah ada, Anda dapat menggunakan contoh kode sebagai referensi dan langsung ke petunjuk untuk memodifikasi proyek Anda .

Deteksi objek dengan pembelajaran mesin

Demo animasi deteksi objek Model pembelajaran mesin dalam tutorial ini melakukan deteksi objek. Model deteksi objek mengambil data gambar dalam format tertentu, menganalisisnya, dan mencoba mengkategorikan item dalam gambar sebagai salah satu dari sekumpulan kelas yang diketahui yang dilatih untuk dikenali. Kecepatan di mana model dapat mengidentifikasi objek yang diketahui (disebut prediksi objek atau inferensi ) biasanya diukur dalam milidetik. Dalam praktiknya, kecepatan inferensi bervariasi berdasarkan perangkat keras yang menghosting model, ukuran data yang sedang diproses, dan ukuran model pembelajaran mesin.

Siapkan dan jalankan contoh

Untuk bagian pertama dari tutorial ini, unduh sampel dari GitHub dan jalankan menggunakan Android Studio . Bagian berikut dari tutorial ini mengeksplorasi bagian yang relevan dari contoh kode, sehingga Anda dapat menerapkannya ke aplikasi Android Anda sendiri. Anda memerlukan versi berikut dari alat-alat ini yang diinstal:

  • Android Studio 4.2.2 atau lebih tinggi
  • Android SDK versi 31 atau lebih tinggi

Dapatkan kode contoh

Buat salinan lokal dari kode contoh. Anda akan menggunakan kode ini untuk membuat proyek di Android Studio dan menjalankan aplikasi contoh.

Untuk mengkloning dan mengatur kode contoh:

  1. Kloning repositori git
    git clone https://github.com/android/camera-samples.git
    
  2. Konfigurasikan instance git Anda untuk menggunakan sparse checkout, jadi Anda hanya memiliki file untuk aplikasi contoh deteksi objek:

    cd camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

Impor dan jalankan proyek

Buat proyek dari kode contoh yang diunduh, buat proyek, lalu jalankan.

Untuk mengimpor dan membangun proyek kode contoh:

  1. Mulai Android Studio .
  2. Dari halaman Selamat Datang Android Studio, pilih Import Project , atau pilih File > New > Import Project .
  3. Arahkan ke direktori kode contoh yang berisi file build.gradle ( .../android/camera-samples/CameraXAdvanced/build.gradle ) dan pilih direktori itu.

Jika Anda memilih direktori yang benar, Android Studio akan membuat proyek baru dan membangunnya. Proses ini dapat memakan waktu beberapa menit, tergantung pada kecepatan komputer Anda dan jika Anda telah menggunakan Android Studio untuk proyek lain. Saat build selesai, Android Studio menampilkan pesan BUILD SUCCESSFUL di panel status Build Output .

Opsional: Untuk memperbaiki kesalahan build dengan memperbarui versi plugin Android:

  1. Buka file build.gradle di direktori proyek.
  2. Ubah versi alat Android sebagai berikut:

    // from:
    classpath 'com.android.tools.build:gradle:4.2.2'
    // to:
    classpath 'com.android.tools.build:gradle:4.1.2'
    
  3. Sinkronkan proyek dengan memilih: File > Sync Project with Gradle Files .

Untuk menjalankan proyek:

  1. Dari Android Studio, jalankan proyek dengan memilih Run > Run… dan CameraActivity .
  2. Pilih perangkat Android yang terpasang dengan kamera untuk menguji aplikasi.

Bagian berikutnya menunjukkan modifikasi yang perlu Anda buat pada proyek yang ada untuk menambahkan fungsionalitas ini ke aplikasi Anda sendiri, menggunakan aplikasi contoh ini sebagai titik referensi.

Tambahkan dependensi proyek

Dalam aplikasi Anda sendiri, Anda harus menambahkan dependensi proyek tertentu untuk menjalankan model pembelajaran mesin TensorFlow Lite, dan mengakses fungsi utilitas yang mengonversi data seperti gambar, menjadi format data tensor yang dapat diproses oleh model yang Anda gunakan.

Aplikasi contoh menggunakan beberapa library TensorFlow Lite untuk mengaktifkan eksekusi model machine learning deteksi objek:

  • Pustaka utama TensorFlow Lite - Menyediakan kelas input data yang diperlukan, eksekusi model pembelajaran mesin, dan hasil keluaran dari pemrosesan model.
  • Pustaka Dukungan TensorFlow Lite - Pustaka ini menyediakan kelas pembantu untuk menerjemahkan gambar dari kamera menjadi objek data TensorImage yang dapat diproses oleh model pembelajaran mesin.
  • Pustaka GPU TensorFlow Lite - Pustaka ini menyediakan dukungan untuk mempercepat eksekusi model menggunakan prosesor GPU pada perangkat, jika tersedia.

Petunjuk berikut menjelaskan cara menambahkan proyek dan dependensi modul yang diperlukan ke proyek aplikasi Android Anda sendiri.

Untuk menambahkan dependensi modul:

  1. Dalam modul yang menggunakan TensorFlow Lite, perbarui file build.gradle modul untuk menyertakan dependensi berikut. Dalam kode contoh, file ini terletak di sini: .../android/camera-samples/CameraXAdvanced/tflite/build.gradle ( referensi kode )

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. Di Android Studio, sinkronkan dependensi proyek dengan memilih: File > Sync Project with Gradle Files .

Inisialisasi penerjemah model ML

Di aplikasi Android, Anda harus menginisialisasi penafsir model machine learning TensorFlow Lite dengan parameter sebelum menjalankan prediksi dengan model. Parameter inisialisasi ini bergantung pada model yang Anda gunakan, dan dapat mencakup pengaturan seperti ambang batas akurasi minimum untuk prediksi dan label untuk kelas objek yang diidentifikasi.

Model TensorFlow Lite menyertakan file .tflite yang berisi kode model dan sering kali menyertakan file label yang berisi nama kelas yang diprediksi oleh model. Dalam kasus deteksi objek, kelas adalah objek seperti orang, anjing, kucing, atau mobil. Model umumnya disimpan di direktori src/main/assets dari modul utama, seperti pada contoh kode:

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

Untuk kenyamanan dan keterbacaan kode, contoh mendeklarasikan objek pendamping yang mendefinisikan pengaturan untuk model.

Untuk menginisialisasi model di aplikasi Anda:

  1. Buat objek pendamping untuk menentukan pengaturan model: ( referensi kode )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. Gunakan pengaturan dari objek ini untuk membuat objek TensorFlow Lite Interpreter yang berisi model: ( referensi kode )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

Konfigurasikan akselerator perangkat keras

Saat menginisialisasi model TensorFlow Lite di aplikasi, Anda dapat menggunakan fitur akselerasi perangkat keras untuk mempercepat penghitungan prediksi model. Contoh kode di atas menggunakan NNAPI Delegate untuk menangani akselerasi perangkat keras dari eksekusi model:

Interpreter.Options().addDelegate(nnApiDelegate)

Delegasi TensorFlow Lite adalah modul perangkat lunak yang mempercepat eksekusi model pembelajaran mesin menggunakan perangkat keras pemrosesan khusus pada perangkat seluler, seperti GPU, TPU, atau DSP. Dianjurkan untuk menggunakan delegasi untuk menjalankan model TensorFlow Lite, tetapi tidak wajib.

Untuk informasi selengkapnya tentang menggunakan delegasi dengan TensorFlow Lite, lihat Delegasi TensorFlow Lite .

Berikan data ke model

Di aplikasi Android, kode Anda menyediakan data ke model untuk interpretasi dengan mengubah data yang ada seperti gambar menjadi format data Tensor yang dapat diproses oleh model Anda. Data dalam Tensor harus memiliki dimensi, atau bentuk tertentu, yang cocok dengan format data yang digunakan untuk melatih model.

Untuk menentukan bentuk tensor yang diperlukan untuk model:

  • Gunakan objek Interpreter yang diinisialisasi untuk menentukan bentuk tensor yang digunakan oleh model Anda, seperti yang ditunjukkan dalam cuplikan kode di bawah ini: ( referensi kode )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

Model deteksi objek yang digunakan dalam kode contoh mengharapkan gambar persegi dengan ukuran 300 kali 300 piksel.

Sebelum Anda dapat memberikan gambar dari kamera, aplikasi Anda harus mengambil gambar, membuatnya sesuai dengan ukuran yang diharapkan, menyesuaikan rotasinya, dan menormalkan data gambar. Saat memproses gambar dengan model TensorFlow Lite, Anda dapat menggunakan class ImageProcessor Pustaka Dukungan TensorFlow Lite untuk menangani pra-pemrosesan data ini, seperti yang ditunjukkan di bawah ini.

Untuk mengubah data gambar untuk model:

  1. Gunakan ImageProcessor Pustaka Dukungan untuk membuat objek untuk mengubah data gambar menjadi format yang dapat digunakan model Anda untuk menjalankan prediksi: ( referensi kode )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. Salin data gambar dari sistem kamera Android dan siapkan untuk analisis dengan objek ImageProcessor Anda: ( referensi kode )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

Jalankan prediksi

Di aplikasi Android, setelah membuat objek TensorImage dengan data gambar dalam format yang benar, Anda dapat menjalankan model terhadap data tersebut untuk menghasilkan prediksi, atau inferensi . Contoh kode untuk tutorial ini menggunakan kelas ObjectDetectionHelper yang merangkum kode ini dalam metode predict predict() .

Untuk menjalankan prediksi pada kumpulan data gambar:

  1. Jalankan prediksi dengan meneruskan data gambar ke fungsi prediksi Anda: ( referensi kode )

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. Panggil metode run pada instance objek tflite Anda dengan data gambar untuk menghasilkan prediksi: ( referensi kode )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

Objek TensorFlow Lite Interpreter menerima data ini, menjalankannya terhadap model, dan menghasilkan daftar prediksi. Untuk pemrosesan data berkelanjutan oleh model, gunakan metode runForMultipleInputsOutputs() sehingga objek Interpreter tidak dibuat dan kemudian dihapus oleh sistem untuk setiap prediksi yang dijalankan.

Menangani keluaran model

Di aplikasi Android Anda, setelah Anda menjalankan data gambar terhadap model deteksi objek, ini menghasilkan daftar prediksi yang harus ditangani oleh kode aplikasi Anda dengan menjalankan logika bisnis tambahan, menampilkan hasil kepada pengguna, atau mengambil tindakan lain.

Output dari model TensorFlow Lite yang diberikan bervariasi dalam hal jumlah prediksi yang dihasilkannya (satu atau banyak), dan informasi deskriptif untuk setiap prediksi. Dalam kasus model deteksi objek, prediksi biasanya menyertakan data untuk kotak pembatas yang menunjukkan di mana objek terdeteksi dalam gambar. Dalam kode contoh, data yang dikembalikan diformat sebagai daftar objek ObjectPrediction , seperti yang ditunjukkan di bawah ini: ( referensi kode )

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

Tangkapan layar deteksi objek Untuk model yang digunakan dalam contoh ini, setiap prediksi menyertakan lokasi kotak pembatas untuk objek, label untuk objek, dan skor prediksi antara 0 dan 1 sebagai Float yang mewakili keyakinan prediksi, dengan 1 sebagai peringkat keyakinan tertinggi . Secara umum, prediksi dengan skor di bawah 50% (0,5) dianggap tidak meyakinkan. Namun, bagaimana Anda menangani hasil prediksi bernilai rendah terserah Anda dan kebutuhan aplikasi Anda.

Setelah model mengembalikan hasil prediksi, aplikasi Anda dapat bertindak berdasarkan prediksi tersebut dengan menyajikan hasilnya kepada pengguna Anda atau menjalankan logika tambahan. Dalam kasus kode contoh, aplikasi menggambar kotak pembatas di sekitar objek yang diidentifikasi dan menampilkan nama kelas di layar. Tinjau fungsi CameraActivity.reportPrediction() dalam kode contoh untuk detailnya.

Langkah selanjutnya

  • Jelajahi berbagai penggunaan TensorFlow Lite dalam contoh .
  • Pelajari lebih lanjut tentang menggunakan model pembelajaran mesin dengan TensorFlow Lite di bagian Model .
  • Pelajari lebih lanjut tentang menerapkan pembelajaran mesin di aplikasi seluler Anda di Panduan Pengembang TensorFlow Lite .