Hadiri Simposium Women in ML pada 7 Desember Daftar sekarang

Panduan Memulai untuk Android

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

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

Demo animasi deteksi objek

Siapkan dan jalankan contoh

Untuk bagian pertama latihan ini, unduh kode contoh dari GitHub dan jalankan menggunakan Android Studio . Bagian berikut dari dokumen 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 atau lebih tinggi
  • Android SDK versi 21 atau lebih tinggi

Dapatkan kode contoh

Buat salinan lokal dari kode contoh sehingga Anda dapat membangun 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 sparse checkout, jadi 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, membangun proyek, dan menjalankannya.

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. Navigasikan ke direktori kode contoh yang berisi file build.gradle ( ...examples/lite/examples/object_detection/android_play_services/build.gradle ) dan pilih direktori itu.

Setelah Anda memilih direktori ini, Android Studio 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

Aplikasi contoh menggunakan model deteksi objek yang telah dilatih sebelumnya, 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-file ini:

  • 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 berikutnya menunjukkan kepada Anda komponen kunci dari file kode ini, sehingga Anda dapat memodifikasi aplikasi Android untuk menambahkan fungsi ini.

Bangun aplikasi

Bagian berikut menjelaskan langkah-langkah utama untuk membuat aplikasi Android Anda sendiri dan menjalankan model yang ditampilkan dalam contoh aplikasi. Instruksi ini menggunakan aplikasi contoh yang ditunjukkan 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 penglihatan dari layanan Google Play guna mengaktifkan eksekusi model pembelajaran mesin deteksi objek. Petunjuk berikut menjelaskan cara menambahkan dependensi pustaka yang diperlukan ke proyek aplikasi Android Anda sendiri.

Untuk menambahkan dependensi modul:

  1. Dalam 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 menggunakan layanan Google Play untuk menjalankan model TensorFlow Lite, Anda harus menginisialisasi layanan sebelum dapat menggunakannya. Jika Anda ingin menggunakan dukungan akselerasi perangkat keras dengan layanan, 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 ubah untuk mengaktifkan dukungan GPU:

    val options = TfLiteInitializationOptions.builder()
        .setEnableGpuDelegateSupport(true)
        .build()
    
  2. Gunakan metode TfLiteVision.initialize() untuk mengaktifkan penggunaan runtime layanan Play, dan setel listener untuk memverifikasi bahwa itu 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 dari proyek pengembangan Anda, misalnya:

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

Untuk menginisialisasi model:

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

    val modelName = "mobilenetv1.tflite"
    
  3. Setel opsi untuk model, seperti ambang prediksi dan ukuran set hasil:

    val optionsBuilder =
        ObjectDetector.ObjectDetectorOptions.builder()
            .setScoreThreshold(threshold)
            .setMaxResults(maxResults)
    
  4. Aktifkan akselerasi GPU dengan opsi dan biarkan kode gagal dengan lancar 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 menggunakan delegasi akselerasi perangkat keras dengan TensorFlow Lite, lihat Delegasi TensorFlow Lite .

Siapkan data untuk model

Anda menyiapkan data untuk interpretasi 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 cocok 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. 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 dibutuhkan oleh model, dan berikan 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, ini menghasilkan daftar hasil prediksi yang harus ditangani oleh kode aplikasi Anda dengan menjalankan logika bisnis tambahan, menampilkan hasil kepada pengguna, atau mengambil tindakan lain. Model deteksi objek dalam 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 listener untuk meneruskan hasil ke kode aplikasi atau objek antarmuka pengguna Anda. Aplikasi contoh 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 hasil, seperti menampilkan prediksi kepada pengguna. Aplikasi contoh 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