คู่มือเริ่มใช้งานฉบับย่อสําหรับ Android

หน้านี้แสดงวิธีสร้างแอป Android ด้วย TensorFlow Lite เพื่อวิเคราะห์ฟีดกล้องถ่ายทอดสดและระบุวัตถุ กรณีการใช้งานแมชชีนเลิร์นนิงนี้เรียกว่า การตรวจจับวัตถุ แอปตัวอย่างใช้ ไลบรารีงาน TensorFlow Lite สำหรับการมองเห็น ผ่าน บริการ Google Play เพื่อเปิดใช้งานการดำเนินการของโมเดลการเรียนรู้ของเครื่องตรวจจับวัตถุ ซึ่งเป็นแนวทางที่แนะนำสำหรับการสร้างแอปพลิเคชัน ML ด้วย TensorFlow Lite

ตั้งค่าและเรียกใช้ตัวอย่าง

สำหรับส่วนแรกของแบบฝึกหัดนี้ ให้ดาวน์โหลด โค้ดตัวอย่าง จาก GitHub และเรียกใช้โดยใช้ Android Studio ส่วนต่อไปนี้ของเอกสารนี้จะสำรวจส่วนที่เกี่ยวข้องของตัวอย่างโค้ด เพื่อให้คุณนำไปใช้กับแอป Android ของคุณเองได้ คุณต้องติดตั้งเครื่องมือเหล่านี้ในเวอร์ชันต่อไปนี้:

• Android Studio 4.2 หรือสูงกว่า
• Android SDK เวอร์ชัน 21 ขึ้นไป

รับโค้ดตัวอย่าง

สร้างสำเนาของโค้ดตัวอย่างในเครื่องเพื่อให้คุณสามารถสร้างและเรียกใช้ได้

ในการโคลนและตั้งค่าโค้ดตัวอย่าง:

1. โคลนที่เก็บ git

   git clone https://github.com/tensorflow/examples.git
   

2. กำหนดค่าอินสแตนซ์ git ของคุณเพื่อใช้การชำระเงินแบบกระจัดกระจาย เพื่อให้คุณมีเฉพาะไฟล์สำหรับแอปตัวอย่างการตรวจหาวัตถุ:

   cd examples
   git sparse-checkout init --cone
   git sparse-checkout set lite/examples/object_detection/android_play_services
   

นำเข้าและเรียกใช้โครงการ

ใช้ Android Studio เพื่อสร้างโปรเจ็กต์จากโค้ดตัวอย่างที่ดาวน์โหลด สร้างโปรเจ็กต์ และเรียกใช้

ในการนำเข้าและสร้างโปรเจ็กต์โค้ดตัวอย่าง:

1. เริ่ม Android Studio
2. จากหน้า ต้อนรับ ของ Android Studio ให้เลือก Import Project หรือเลือก File > New > Import Project
3. ไปที่ไดเร็กทอรีโค้ดตัวอย่างที่มีไฟล์ build.gradle ( ...examples/lite/examples/object_detection/android_play_services/build.gradle ) และเลือกไดเร็กทอรีนั้น

หลังจากที่คุณเลือกไดเร็กทอรีนี้ Android Studio จะสร้างโปรเจ็กต์ใหม่และสร้างขึ้นมา เมื่อการสร้างเสร็จสมบูรณ์ Android Studio จะแสดงข้อความ BUILD SUCCESSFUL ในแผงสถานะ Build Output

ในการดำเนินโครงการ:

1. จาก Android Studio ให้เรียกใช้โครงการโดยเลือก Run > Run… และ MainActivity
2. เลือกอุปกรณ์ Android ที่ต่อกับกล้องเพื่อทดสอบแอป

แอปตัวอย่างทำงานอย่างไร

แอปตัวอย่างใช้โมเดลการตรวจจับวัตถุที่ฝึกไว้ล่วงหน้า เช่น mobilenetv1.tflite ในรูปแบบ TensorFlow Lite ค้นหาวัตถุในสตรีมวิดีโอสดจากกล้องของอุปกรณ์ Android โค้ดสำหรับคุณลักษณะนี้มีอยู่ในไฟล์เหล่านี้เป็นหลัก:

• ObjectDetectorHelper.kt - เริ่มต้นสภาพแวดล้อมรันไทม์ เปิดใช้งานการเร่งฮาร์ดแวร์ และเรียกใช้โมเดล ML การตรวจจับวัตถุ
• CameraFragment.kt - สร้างสตรีมข้อมูลภาพของกล้อง เตรียมข้อมูลสำหรับโมเดล และแสดงผลการตรวจจับวัตถุ

ส่วนถัดไปจะแสดงองค์ประกอบหลักของไฟล์โค้ดเหล่านี้ คุณจึงสามารถแก้ไขแอป Android เพื่อเพิ่มฟังก์ชันนี้ได้

สร้างแอป

ส่วนต่อไปนี้จะอธิบายขั้นตอนสำคัญในการสร้างแอป Android ของคุณเองและเรียกใช้โมเดลที่แสดงในแอปตัวอย่าง คำแนะนำเหล่านี้ใช้แอปตัวอย่างที่แสดงไว้ก่อนหน้าเป็นจุดอ้างอิง

เพิ่มการพึ่งพาโครงการ

ในแอป Android พื้นฐานของคุณ ให้เพิ่มการพึ่งพาโปรเจ็กต์สำหรับการเรียกใช้โมเดลแมชชีนเลิร์นนิง TensorFlow Lite และการเข้าถึงฟังก์ชันยูทิลิตี้ข้อมูล ML ฟังก์ชันยูทิลิตี้เหล่านี้จะแปลงข้อมูล เช่น รูปภาพ ให้อยู่ในรูปแบบข้อมูลเทนเซอร์ที่โมเดลสามารถประมวลผลได้

แอปตัวอย่างใช้ ไลบรารีงาน TensorFlow Lite สำหรับการมองเห็น จาก บริการ Google Play เพื่อเปิดใช้งานการดำเนินการของโมเดลการเรียนรู้ของเครื่องตรวจจับวัตถุ คำแนะนำต่อไปนี้จะอธิบายวิธีเพิ่มการพึ่งพาไลบรารีที่จำเป็นให้กับโปรเจ็กต์แอป Android ของคุณเอง

ในการเพิ่มการพึ่งพาโมดูล:

1. ในโมดูลแอป Android ที่ใช้ TensorFlow Lite ให้อัปเดตไฟล์ build.gradle ของโมดูลเพื่อรวมการพึ่งพาต่อไปนี้ ในโค้ดตัวอย่าง ไฟล์นี้จะอยู่ที่นี่: ...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. ใน Android Studio ซิงค์การพึ่งพาโปรเจ็กต์โดยเลือก: File > Sync Project with Gradle Files

เริ่มต้นบริการ Google Play

เมื่อคุณใช้ บริการ Google Play เพื่อเรียกใช้รุ่น TensorFlow Lite คุณต้องเริ่มต้นบริการก่อนจึงจะสามารถใช้งานได้ หากคุณต้องการใช้การสนับสนุนการเร่งด้วยฮาร์ดแวร์กับบริการ เช่น การเร่งความเร็ว GPU แสดงว่าคุณเปิดใช้งานการสนับสนุนนั้นโดยเป็นส่วนหนึ่งของการเริ่มต้นนี้

ในการเริ่มต้น TensorFlow Lite ด้วยบริการ Google Play:

1. สร้างวัตถุ TfLiteInitializationOptions และแก้ไขเพื่อเปิดใช้งานการรองรับ GPU:

   val options = TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build()
   

2. ใช้ TfLiteVision.initialize() เพื่อเปิดใช้งานการใช้งานรันไทม์ของบริการ Play และตั้งค่า Listener เพื่อตรวจสอบว่าโหลดสำเร็จแล้ว:

   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)
       }
   }
   

เริ่มต้นล่ามโมเดล ML

เริ่มต้นตัวแปลโมเดลแมชชีนเลิร์นนิง TensorFlow Lite โดยการโหลดไฟล์โมเดลและตั้งค่าพารามิเตอร์โมเดล โมเดล TensorFlow Lite มีไฟล์ .tflite ที่มีรหัสโมเดล คุณควรเก็บโมเดลของคุณในไดเร็กทอรี src/main/assets ของโครงการพัฒนาของคุณ ตัวอย่างเช่น

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

ในการเริ่มต้นโมเดล:

1. เพิ่มไฟล์โมเดล .tflite ในไดเร็กทอรี src/main/assets ของโครงการพัฒนาของคุณ เช่น ssd_mobilenet_v1

2. ตั้งค่าตัวแปร modelName เพื่อระบุชื่อไฟล์ของโมเดล ML ของคุณ:

   val modelName = "mobilenetv1.tflite"
   

3. ตั้งค่าตัวเลือกสำหรับโมเดล เช่น เกณฑ์การคาดการณ์และขนาดชุดผลลัพธ์:

   val optionsBuilder =
       ObjectDetector.ObjectDetectorOptions.builder()
           .setScoreThreshold(threshold)
           .setMaxResults(maxResults)
   

4. เปิดใช้งานการเร่งความเร็ว GPU ด้วยตัวเลือกและอนุญาตให้โค้ดล้มเหลวอย่างงดงามหากอุปกรณ์ไม่รองรับการเร่งความเร็ว:

   try {
       optionsBuilder.useGpu()
   } catch(e: Exception) {
       objectDetectorListener.onError("GPU is not supported on this device")
   }
   
   

5. ใช้การตั้งค่าจากวัตถุนี้เพื่อสร้างวัตถุ TensorFlow Lite ObjectDetector ที่มีโมเดล:

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้ผู้รับมอบสิทธิ์การเร่งฮาร์ดแวร์กับ TensorFlow Lite โปรดดู ที่ ผู้รับมอบสิทธิ์ TensorFlow Lite

เตรียมข้อมูลสำหรับโมเดล

คุณเตรียมข้อมูลสำหรับการตีความโดยแบบจำลองโดยการแปลงข้อมูลที่มีอยู่ เช่น รูปภาพ ให้อยู่ในรูปแบบข้อมูล เทนเซอร์ เพื่อให้แบบจำลองของคุณประมวลผลได้ ข้อมูลในเทนเซอร์ต้องมีมิติหรือรูปร่างเฉพาะที่ตรงกับรูปแบบของข้อมูลที่ใช้ในการฝึกโมเดล คุณอาจต้องแปลงข้อมูลให้พอดีกับที่โมเดลคาดหวัง ทั้งนี้ขึ้นอยู่กับรุ่นที่คุณใช้ แอพตัวอย่างใช้วัตถุ ImageAnalysis เพื่อแยกเฟรมรูปภาพออกจากระบบย่อยของกล้อง

เพื่อเตรียมข้อมูลสำหรับการประมวลผลโดยแบบจำลอง:

1. สร้างวัตถุ ImageAnalysis เพื่อแยกภาพในรูปแบบที่ต้องการ:

   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. เชื่อมต่อเครื่องวิเคราะห์กับระบบย่อยของกล้องและสร้างบัฟเฟอร์บิตแมปเพื่อเก็บข้อมูลที่ได้รับจากกล้อง:

           .also {
           it.setAnalyzer(cameraExecutor) { image ->
               if (!::bitmapBuffer.isInitialized) {
                   bitmapBuffer = Bitmap.createBitmap(
                       image.width,
                       image.height,
                       Bitmap.Config.ARGB_8888
                   )
               }
               detectObjects(image)
           }
       }
   

3. ดึงข้อมูลภาพเฉพาะที่โมเดลต้องการ และส่งข้อมูลการหมุนภาพ:

   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. ทำการแปลงข้อมูลขั้นสุดท้ายและเพิ่มข้อมูลภาพไปยังวัตถุ TensorImage ดังที่แสดงใน ObjectDetectorHelper.detect() ของแอปตัวอย่าง:

   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))
   

เรียกใช้การคาดการณ์

เมื่อคุณสร้างวัตถุ TensorImage ด้วยข้อมูลรูปภาพในรูปแบบที่ถูกต้อง คุณสามารถเรียกใช้แบบจำลองกับข้อมูลนั้นเพื่อสร้างการคาดคะเน หรือการ อนุมาน ในแอปตัวอย่าง โค้ดนี้มีอยู่ใน ObjectDetectorHelper.detect()

ในการรันโมเดลและสร้างการคาดคะเนจากข้อมูลรูปภาพ:

• เรียกใช้การคาดคะเนโดยส่งข้อมูลภาพไปยังฟังก์ชันการทำนายของคุณ:

  val results = objectDetector?.detect(tensorImage)
  

จัดการโมเดลเอาท์พุต

หลังจากที่คุณเรียกใช้ข้อมูลรูปภาพกับโมเดลการตรวจจับวัตถุ จะสร้างรายการผลการคาดคะเนซึ่งโค้ดของแอปต้องจัดการโดยดำเนินการตามตรรกะทางธุรกิจเพิ่มเติม แสดงผลต่อผู้ใช้ หรือดำเนินการอื่นๆ โมเดลการตรวจจับวัตถุในแอปตัวอย่างจะสร้างรายการการคาดคะเนและกรอบสำหรับวัตถุที่ตรวจพบ ในแอปตัวอย่าง ผลการคาดคะเนจะถูกส่งไปยังออบเจ็กต์ Listener เพื่อการประมวลผลเพิ่มเติมและแสดงให้ผู้ใช้เห็น

ในการจัดการผลการทำนายแบบจำลอง:

1. ใช้รูปแบบผู้ฟังเพื่อส่งผลลัพธ์ไปยังโค้ดของแอปหรือออบเจ็กต์อินเทอร์เฟซผู้ใช้ แอปตัวอย่างใช้รูปแบบนี้เพื่อส่งผ่านผลการตรวจจับจากวัตถุ ObjectDetectorHelper ไปยังวัตถุ CameraFragment :

   objectDetectorListener.onResults( // instance of CameraFragment
       results,
       inferenceTime,
       tensorImage.height,
       tensorImage.width)
   

2. ดำเนินการตามผลลัพธ์ เช่น การแสดงคำทำนายแก่ผู้ใช้ แอปตัวอย่างจะดึงภาพซ้อนทับบนวัตถุ CameraPreview เพื่อแสดงผล:

   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()
       }
   }
   

ขั้นตอนถัดไป

• เรียนรู้เพิ่มเติมเกี่ยวกับ API ไลบรารีงาน
• เรียนรู้เพิ่มเติมเกี่ยวกับ Interpreter API
• สำรวจการใช้ TensorFlow Lite ใน ตัวอย่าง
• เรียนรู้เพิ่มเติมเกี่ยวกับการใช้และสร้างโมเดลแมชชีนเลิร์นนิงด้วย TensorFlow Lite ในส่วน โมเดล
• เรียนรู้เพิ่มเติมเกี่ยวกับการนำการเรียนรู้ของเครื่องไปใช้ในแอปพลิเคชันมือถือของคุณใน คู่มือสำหรับนักพัฒนา TensorFlow Lite