Panduan Memulai untuk Android

Halaman ini menunjukkan cara membuat aplikasi Android dengan TensorFlow Lite untuk menganalisis feed kamera langsung dan mengidentifikasi objek. Kasus penggunaan pembelajaran mesin ini disebut deteksi objek . Contoh aplikasi menggunakan pustaka Tugas TensorFlow Lite untuk vision melalui layanan Google Play guna mengaktifkan eksekusi model pembelajaran mesin pendeteksi objek, yang merupakan pendekatan yang direkomendasikan untuk membangun aplikasi ML dengan TensorFlow Lite.

Demo animasi deteksi objek

Siapkan dan jalankan contohnya

Untuk bagian pertama latihan ini, unduh kode contoh dari GitHub dan jalankan menggunakan Android Studio . Bagian berikut dari dokumen ini mengeksplorasi bagian contoh kode yang relevan, sehingga Anda dapat menerapkannya ke aplikasi Android Anda sendiri. Anda perlu menginstal versi alat berikut ini:

  • Android Studio 4.2 atau lebih tinggi
  • Android SDK versi 21 atau lebih tinggi

Dapatkan kode contoh

Buat salinan lokal dari kode contoh sehingga Anda dapat membuat dan menjalankannya.

Untuk mengkloning dan mengatur kode contoh:

  1. Kloning repositori git
    git clone https://github.com/tensorflow/examples.git
    
  2. Konfigurasikan instance git Anda untuk menggunakan checkout jarang, sehingga Anda hanya memiliki file untuk aplikasi contoh deteksi objek:
    cd examples
    git sparse-checkout init --cone
    git sparse-checkout set lite/examples/object_detection/android_play_services
    

Impor dan jalankan proyek

Gunakan Android Studio untuk membuat proyek dari kode contoh yang diunduh, buat proyek, dan jalankan.

Untuk mengimpor dan membuat proyek kode contoh:

  1. Mulai Android Studio .
  2. Dari halaman Selamat Datang Android Studio, pilih Impor Proyek , atau pilih File > Baru > Impor Proyek .
  3. Navigasikan ke direktori kode contoh yang berisi file build.gradle ( ...examples/lite/examples/object_detection/android_play_services/build.gradle ) dan pilih direktori tersebut.

Setelah Anda memilih direktori ini, Android Studio akan membuat proyek baru dan membangunnya. Saat build selesai, Android Studio menampilkan pesan BUILD SUCCESSFUL di panel status Build Output .

Untuk menjalankan proyek:

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

Cara kerja aplikasi contoh

Contoh aplikasi menggunakan model deteksi objek terlatih, seperti mobilenetv1.tflite , dalam format TensorFlow Lite, mencari objek dalam streaming video langsung dari kamera perangkat Android. Kode untuk fitur ini terutama ada di file berikut:

  • ObjectDetectorHelper.kt - Menginisialisasi lingkungan runtime, mengaktifkan akselerasi perangkat keras, dan menjalankan model ML deteksi objek.
  • CameraFragment.kt - Membangun aliran data gambar kamera, menyiapkan data untuk model, dan menampilkan hasil deteksi objek.

Bagian selanjutnya menunjukkan komponen utama file kode ini, sehingga Anda dapat memodifikasi aplikasi Android untuk menambahkan fungsi ini.

Bangun aplikasinya

Bagian berikut menjelaskan langkah-langkah penting untuk membuat aplikasi Android Anda sendiri dan menjalankan model yang ditunjukkan dalam contoh aplikasi. Petunjuk ini menggunakan contoh aplikasi yang ditampilkan sebelumnya sebagai titik referensi.

Tambahkan dependensi proyek

Di aplikasi Android dasar Anda, tambahkan dependensi proyek untuk menjalankan model machine learning TensorFlow Lite dan mengakses fungsi utilitas data ML. Fungsi utilitas ini mengubah data seperti gambar menjadi format data tensor yang dapat diproses oleh model.

Aplikasi contoh menggunakan pustaka Tugas TensorFlow Lite untuk vision dari layanan Google Play guna mengaktifkan eksekusi model pembelajaran mesin pendeteksi objek. Petunjuk berikut menjelaskan cara menambahkan dependensi perpustakaan yang diperlukan ke proyek aplikasi Android Anda sendiri.

Untuk menambahkan dependensi modul:

  1. Pada modul aplikasi Android yang menggunakan TensorFlow Lite, perbarui file build.gradle modul untuk menyertakan dependensi berikut. Dalam kode contoh, file ini terletak di sini: ...examples/lite/examples/object_detection/android_play_services/app/build.gradle

    ...
    dependencies {
    ...
        // Tensorflow Lite dependencies
        implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
        implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
    ...
    }
    
  2. Di Android Studio, sinkronkan dependensi proyek dengan memilih: File > Sync Project with Gradle Files .

Inisialisasi layanan Google Play

Saat Anda menggunakan layanan Google Play untuk menjalankan model TensorFlow Lite, Anda harus menginisialisasi layanan tersebut sebelum dapat menggunakannya. Jika Anda ingin menggunakan dukungan akselerasi perangkat keras dengan layanan ini, seperti akselerasi GPU, Anda juga mengaktifkan dukungan tersebut sebagai bagian dari inisialisasi ini.

Untuk menginisialisasi TensorFlow Lite dengan layanan Google Play:

  1. Buat objek TfLiteInitializationOptions dan modifikasi untuk mengaktifkan dukungan GPU:

    val options = TfLiteInitializationOptions.builder()
        .setEnableGpuDelegateSupport(true)
        .build()
    
  2. Gunakan metode TfLiteVision.initialize() untuk mengaktifkan penggunaan runtime layanan Play, dan setel pemroses untuk memverifikasi bahwa layanan tersebut berhasil dimuat:

    TfLiteVision.initialize(context, options).addOnSuccessListener {
        objectDetectorListener.onInitialized()
    }.addOnFailureListener {
        // Called if the GPU Delegate is not supported on the device
        TfLiteVision.initialize(context).addOnSuccessListener {
            objectDetectorListener.onInitialized()
        }.addOnFailureListener{
            objectDetectorListener.onError("TfLiteVision failed to initialize: "
                    + it.message)
        }
    }
    

Inisialisasi penerjemah model ML

Inisialisasi penerjemah model machine learning TensorFlow Lite dengan memuat file model dan menyetel parameter model. Model TensorFlow Lite menyertakan file .tflite yang berisi kode model. Anda harus menyimpan model Anda di direktori src/main/assets proyek pengembangan Anda, misalnya:

.../src/main/assets/mobilenetv1.tflite`

Untuk menginisialisasi model:

  1. Tambahkan file model .tflite ke direktori src/main/assets proyek pengembangan Anda, seperti ssd_mobilenet_v1 .
  2. Atur variabel modelName untuk menentukan nama file model ML Anda:

    val modelName = "mobilenetv1.tflite"
    
  3. Tetapkan opsi untuk model, seperti ambang batas prediksi dan ukuran kumpulan hasil:

    val optionsBuilder =
        ObjectDetector.ObjectDetectorOptions.builder()
            .setScoreThreshold(threshold)
            .setMaxResults(maxResults)
    
  4. Aktifkan akselerasi GPU dengan opsi dan izinkan kode gagal dengan baik jika akselerasi tidak didukung pada perangkat:

    try {
        optionsBuilder.useGpu()
    } catch(e: Exception) {
        objectDetectorListener.onError("GPU is not supported on this device")
    }
    
    
  5. Gunakan pengaturan dari objek ini untuk membuat objek TensorFlow Lite ObjectDetector yang berisi model:

    objectDetector =
        ObjectDetector.createFromFileAndOptions(
            context, modelName, optionsBuilder.build())
    

Untuk informasi selengkapnya tentang penggunaan delegasi akselerasi perangkat keras dengan TensorFlow Lite, lihat Delegasi TensorFlow Lite .

Siapkan data untuk model

Anda mempersiapkan data untuk diinterpretasikan oleh model dengan mengubah data yang ada seperti gambar ke dalam format data Tensor , sehingga dapat diproses oleh model Anda. Data dalam Tensor harus memiliki dimensi atau bentuk tertentu yang sesuai dengan format data yang digunakan untuk melatih model. Bergantung pada model yang Anda gunakan, Anda mungkin perlu mengubah data agar sesuai dengan apa yang diharapkan model tersebut. Aplikasi contoh menggunakan objek ImageAnalysis untuk mengekstrak bingkai gambar dari subsistem kamera.

Untuk menyiapkan data untuk diproses oleh model:

  1. Bangun objek ImageAnalysis untuk mengekstrak gambar dalam format yang diperlukan:

    imageAnalyzer =
        ImageAnalysis.Builder()
            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
            .setTargetRotation(fragmentCameraBinding.viewFinder.display.rotation)
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .setOutputImageFormat(OUTPUT_IMAGE_FORMAT_RGBA_8888)
            .build()
            ...
    
  2. Hubungkan penganalisis ke subsistem kamera dan buat buffer bitmap untuk menampung data yang diterima dari kamera:

            .also {
            it.setAnalyzer(cameraExecutor) { image ->
                if (!::bitmapBuffer.isInitialized) {
                    bitmapBuffer = Bitmap.createBitmap(
                        image.width,
                        image.height,
                        Bitmap.Config.ARGB_8888
                    )
                }
                detectObjects(image)
            }
        }
    
  3. Ekstrak data gambar spesifik yang diperlukan oleh model, dan teruskan informasi rotasi gambar:

    private fun detectObjects(image: ImageProxy) {
        // Copy out RGB bits to the shared bitmap buffer
        image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer) }
        val imageRotation = image.imageInfo.rotationDegrees
        objectDetectorHelper.detect(bitmapBuffer, imageRotation)
    }    
    
  4. Selesaikan semua transformasi data akhir dan tambahkan data gambar ke objek TensorImage , seperti yang ditunjukkan dalam metode ObjectDetectorHelper.detect() pada aplikasi contoh:

    val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
    
    // Preprocess the image and convert it into a TensorImage for detection.
    val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
    

Jalankan prediksi

Setelah membuat objek TensorImage dengan data gambar dalam format yang benar, Anda dapat menjalankan model terhadap data tersebut untuk menghasilkan prediksi atau inferensi . Dalam aplikasi contoh, kode ini terdapat dalam metode ObjectDetectorHelper.detect() .

Untuk menjalankan model dan menghasilkan prediksi dari data gambar:

  • Jalankan prediksi dengan meneruskan data gambar ke fungsi prediksi Anda:

    val results = objectDetector?.detect(tensorImage)
    

Menangani keluaran model

Setelah Anda menjalankan data gambar terhadap model deteksi objek, model ini akan menghasilkan daftar hasil prediksi yang harus ditangani oleh kode aplikasi Anda dengan menjalankan logika bisnis tambahan, menampilkan hasil kepada pengguna, atau mengambil tindakan lainnya. Model deteksi objek di aplikasi contoh menghasilkan daftar prediksi dan kotak pembatas untuk objek yang terdeteksi. Dalam aplikasi contoh, hasil prediksi diteruskan ke objek pendengar untuk diproses lebih lanjut dan ditampilkan kepada pengguna.

Untuk menangani hasil prediksi model:

  1. Gunakan pola pendengar untuk meneruskan hasil ke kode aplikasi atau objek antarmuka pengguna Anda. Contoh aplikasi menggunakan pola ini untuk meneruskan hasil deteksi dari objek ObjectDetectorHelper ke objek CameraFragment :

    objectDetectorListener.onResults( // instance of CameraFragment
        results,
        inferenceTime,
        tensorImage.height,
        tensorImage.width)
    
  2. Bertindak berdasarkan hasilnya, seperti menampilkan prediksi kepada pengguna. Contoh aplikasi menggambar overlay pada objek CameraPreview untuk menampilkan hasilnya:

    override fun onResults(
      results: MutableList<Detection>?,
      inferenceTime: Long,
      imageHeight: Int,
      imageWidth: Int
    ) {
        activity?.runOnUiThread {
            fragmentCameraBinding.bottomSheetLayout.inferenceTimeVal.text =
                String.format("%d ms", inferenceTime)
    
            // Pass necessary information to OverlayView for drawing on the canvas
            fragmentCameraBinding.overlay.setResults(
                results ?: LinkedList<Detection>(),
                imageHeight,
                imageWidth
            )
    
            // Force a redraw
            fragmentCameraBinding.overlay.invalidate()
        }
    }
    

Langkah selanjutnya