Halo, kembali kembali bersama Series Machine Learning di Android. Pada artikel sebelumnya, kami telah membicarakan Macam Cara Implementasi Machine Learning/AI di Aplikasi Android. Pada blog kali ini, kami bakal mempraktikkan secara langsung tidak benar satu framework yang disebutkan, yaitu TensorFlow Lite (TFLite).
logo tensorflow lite, framework machine learning
TensorFlow Lite adalah versi enteng dan efektif berasal dari framework Tensorflow yang kerap digunakan Machine Learning Developer untuk mengembangkan dan men-deploy model. Ia didesain sedemikian rupa supaya terlalu mungkin kami untuk mobilisasi type terhadap perangkat bersama resource yang terbatas, layaknya handphone dan embedded system.
Beberapa perumpamaan aplikasi yang manfaatkan TensorFlow Lite adalah Gmail, Google Assistant, Google Nest, dan Shazam. Tentu nama-nama yang tidak asing, bukan?
Untuk yang telah punya kebiasaan berkecimpung di dunia Android dan tak sudi ketinggalan hype teknologi AI, anda tentu tidak cuma idamkan jadi pemakai saja, kan? Kamu tentu sudi tahu dong langkah mengimplementasikan machine learning di Android.
Nah, terhadap tutorial ini, kami bakal memicu aplikasi klasifikasi objek bersama manfaatkan TFLite. Menariknya, anda tidak wajib tahu pemahaman machine learning yang mendalam untuk mengikuti tutorial ini. Penasaran? Yuk, lihat langkah-langkahnya dan membuat aplikasi AI pertamamu!
Persiapan Project
Supaya anda mampu fokus praktek tentang penerapan TFLite, kami telah sedia kan starter project yang memuat kegunaan dasar kamera bersama manfaatkan CameraX, sebuah library berasal dari Android Jetpack untuk menampilkan kamera di di dalam aplikasi secara langsung bersama lebih mudah.
Sebenarnya ada banyak langkah untuk mendapatkan gambar di di dalam aplikasi, layaknya menentukan gambar berasal dari galeri atau manfaatkan kamera bawaan manfaatkan Camera Intent. Namun, di sini kami manfaatkan CameraX supaya mampu menganalisis gambar secara real-time. Selain itu, di di dalam CameraX termasuk terkandung ImageAnalysis yang mampu kami integrasikan bersama TFLite.
Mau bikin project aplikasi smartphone? Rekomendasi saya serahkan pada
Okay, sekarang silakan langsung unduh atau clone proyek awal berikut: ade prasetyo
Starter project CameraX
Silakan buka proyek tersebut bersama manfaatkan Android Studio. Jika kami perhatikan, di dalamnya telah ada beberapa menambahkan kode layaknya berikut.
Dependensi library CameraX di di dalam build.gradle.kts.
PreviewView berasal dari CameraX dan TextView terhadap activity_main.xml.
Pendefinisian Camera permission di di dalam AndroidManifest.xml.
Proses request Camera permission, inisialisasi ProcessCameraProvider untuk menampilkan kamera, dan implementasi ViewBinding di di dalam MainActivity.
Berikut adalah tampilan aplikasi berasal dari starter project kalau dijalankan.
starter project camera tensorflow lite, frame work machine learning
Setelah memberikan akses kamera, aplikasi mampu menampilkan kamera secara langsung.
Persiapan Model TFLite
Jika anda telah memiliki TensorFlow Model, konversi lebih-lebih dahulu jadi TensorFlow Lite Model bersama ekstensi .tflite. Alhasil, ukurannya jadi lebih kecil, lebih efisien, dan menunjang framework TensorFlow Lite.
Apabila tidak memiliki type sendiri, anda mampu manfaatkan TensorFlow Lite Model Maker untuk melakukan transfer learning. Transfer learning adalah pendekatan untuk manfaatkan type yang telah dilatih sebelumnya di dalam mengerjakan tugas tertentu. Ini digunakan sebagai titik awal untuk memicu type baru bersama tugas serupa.
Jika anda tidak memiliki latar belakang machine learning sebelumnya, anda termasuk mampu manfaatkan TensorFlow Hub untuk mencari referensi type yang telah paten. Nah, terhadap latihan ini kami bakal manfaatkan type tersebut untuk melakukan deteksi objek.
Mobilenet_v1_1.0_224_quantized_1_metadata_1.tflite
Silakan unduh type tersebut dan import ke di dalam Android Studio bersama langkah klik kanan terhadap folder app dan menentukan New → Other → TensorFlow Lite Model. Dari sini, Anda jadi tahu kan bahwa sebetulnya Android Studio telah bersahabat baik, lo bersama TFLite. Buktinya telah ada fiturnya langsung untuk import di dalam Android Studio.
import TensorFlow Lite Model in Android Studio
Kemudian, menentukan file tadi yangsudah diunduh terhadap Model location dan beri centang terhadap semua opsi.
Import TensorFlow Lite model
Klik Finish dan lihatlah sekarang file tersebut terkandung di folder app/ml. Kamu pun mampu membaca metadata berasal dari file tersebut berkat library yang ditambahkan sebelumnya.
Model Metadata in Android Studio
File ini nanti mampu diakses layaknya asset bersama adanya menambahkan konfigurasi terhadap build.gradle.kts.
android {
…
buildFeatures {
viewBinding = true
mlModelBinding = true
}
}
Oke, sekarang type telah siap, saatnya memberikan library utama berasal dari TensorFlow Lite untuk pemrosesan machine learning. Karena klasifikasi objek termasuk di dalam kategori task-vision, tambahkan dependensi tersebut terhadap build.gradle.kts.
dependencies {
…
implementation(“org.tensorflow:tensorflow-lite-gpu:2.13.0”)
implementation(“org.tensorflow:tensorflow-lite-task-vision:0.4.4”)
}
Jangan lupa untuk melakukan Sync Now setiap kali memberikan library baru terhadap konfigurasi Gradle untuk mengunduhnya.
Membuat Helper TFLite
Setelah semua persiapan usai, kami bakal memicu kelas helper untuk memudahkan kami mengelompokkan kegunaan yang digunakan untuk melakukan sistem ML. Selain itu, kode jadi lebih rapi dan bersih bersama pemisahan ini.
Pertama, membuat pernah class baru bersama langkah klik kanan terhadap nama package dan menentukan new → Kotlin Class/File. Kemudian tambahkan parameter dan listener layaknya berikut.
class ImageClassifierHelper(
var threshold: Float = 0.1f,
var maxResults: Int = 3,
var numThreads: Int = 4,
val modelName: String = “mobilenet_v1_1.0_224_quantized_1_metadata_1.tflite”,
val context: Context,
val imageClassifierListener: ClassifierListener?
) {
private var imageClassifier: ImageClassifier? = null
interface ClassifierListener {
fun onError(error: String)
fun onResults(
results: List<Classifications>?,
inferenceTime: Long
)
}
}
Listener di sini berguna untuk memberi tahu class utama saat sistem yang dilakukan berhasil atau gagal. Apabila sistem berhasil, kegunaan onResults yang dipanggil. Namun kalau sistem gagal, kegunaan onError yang dipanggil. Inilah yang disebut bersama callback.
Selanjutnya, membuat kegunaan baru bernama setupImageClassifier dan panggil di di dalam init supaya kegunaan ini terpanggil setiap kali kelas ini dibuat.
init {
setupImageClassifier()
}
fun setupImageClassifier() {
val optionsBuilder = ImageClassifier.ImageClassifierOptions.builder()
.setScoreThreshold(threshold)
.setMaxResults(maxResults)
val baseOptionsBuilder = BaseOptions.builder().setNumThreads(numThreads)
optionsBuilder.setBaseOptions(baseOptionsBuilder.build())
try {
imageClassifier =
ImageClassifier.createFromFileAndOptions(context, modelName, optionsBuilder.build())
} catch (e: IllegalStateException) {
imageClassifierListener?.onError(
“Image classifier failed to initialize. See error logs for details”
)
Log.e(“ImageClassifierHelper”, “TFLite failed to load type with error: ” + e.message)
}
}
Di sini kami mempersiapkan beberapa konfigurasi terhadap TensorFlow Lite sebelum melakukan pemrosesan. Berikut adalah kegunaan yang digunakan.
setScoreThreshold: Menentukan batas sedikitnya keakuratan berasal dari hasil yang ditampilkan. 0.1 berarti 10%.
setMaxResults: Menentukan batas maksimal jumlah hasil yang ditampilkan.
setNumThreads: Menentukan jumlah thread yang digunakan untuk melakukan pemrosesan ML.
createFromFileAndOptions: Membuat ImageClassifier berdasarkan asset file type dan option yang didefinisikan sebelumnya.
Catatan:
Sebenarnya termasuk ada kegunaan baseOptionsBuilder.useGpu() kalau anda idamkan menentukan jalannya pemrosesan dilakukan di GPU, alih-alih di CPU. Namun, anda wajib memberikan library tensorflow-lite-gpu.
Mari kami lanjutkan penulisan kodenya. Masih terhadap berkas ImageClassifierHelper, membuat sebuah kegunaan baru untuk melakukan pemrosesan klasifikasi layaknya berikut.
fun classify(image: ImageProxy) {
if (imageClassifier == null) {
setupImageClassifier()
}
val bitmapBuffer = Bitmap.createBitmap(
image.width,
image.height,
Bitmap.Config.ARGB_8888
)
image.use bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)
image.close()
var inferenceTime = SystemClock.uptimeMillis()
val imageProcessor = ImageProcessor.Builder().build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(bitmapBuffer))
val imageProcessingOptions = ImageProcessingOptions.builder()
.setOrientation(getOrientationFromRotation(image.imageInfo.rotationDegrees))
.build()
val results = imageClassifier?.classify(tensorImage, imageProcessingOptions)
inferenceTime = SystemClock.uptimeMillis() – inferenceTime
imageClassifierListener?.onResults(
results,
inferenceTime
)
}
private fun getOrientationFromRotation(rotation: Int): ImageProcessingOptions.Orientation {
return when (rotation) {
Surface.ROTATION_270 -> ImageProcessingOptions.Orientation.BOTTOM_RIGHT
Surface.ROTATION_180 -> ImageProcessingOptions.Orientation.RIGHT_BOTTOM
Surface.ROTATION_90 -> ImageProcessingOptions.Orientation.TOP_LEFT
else -> ImageProcessingOptions.Orientation.RIGHT_TOP
}
}
Di awal, kami periksa pernah instance ImageClassifier masih null atau tidak. Jika tidak, kami lanjut mengubah image buffer jadi Bitmap bersama kegunaan createBitmap. Setelah itu, membuat TensorImage berasal dari Bitmap tadi manfaatkan kegunaan process.
Setelah itu, kami siapkan termasuk ImageProcessingOptions untuk menyesuaikan orientasi gambar input sesuai bersama gambar yang ada terhadap model. Hal ini diperlukan supaya hasil yang diberikan akurat.
Sebagai catatan, karena kegunaan yang dihidangkan adalah setOrientation, kami wajib memicu kegunaan baru untuk mengonversi rotationDegress jadi orientation layaknya perumpamaan di atas.
Setelah ke dua objek tersebut siap, anda mampu memanggil kegunaan classify untuk memulai sistem pengklasifikasian. Selain itu, anda termasuk memicu variabel inferenceTime manfaat menghitung saat yang diperlukan untuk melakukan pemrosesan.