การตรวจจับวัตถุด้วย Android

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

ภาพรวมการตรวจจับวัตถุ

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

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

โมเดลและชุดข้อมูล

บทช่วยสอนนี้ใช้แบบจำลองที่ได้รับการฝึกโดยใช้ ชุดข้อมูล COCO COCO เป็นชุดข้อมูลการตรวจจับวัตถุขนาดใหญ่ที่ประกอบด้วยรูปภาพ 330,000 รายการ อินสแตนซ์ออบเจ็กต์ 1.5 ล้านรายการ และหมวดหมู่ออบเจ็กต์ 80 หมวดหมู่

คุณมีตัวเลือกในการใช้โมเดลที่ได้รับการฝึกล่วงหน้าอย่างใดอย่างหนึ่งต่อไปนี้:

• EfficientDet-Lite0 [แนะนำ] - โมเดลการตรวจจับวัตถุน้ำหนักเบาพร้อมตัวแยกคุณสมบัติ BiFPN ตัวทำนายกล่องที่ใช้ร่วมกัน และการสูญเสียโฟกัส mAP (ค่าเฉลี่ยความแม่นยำเฉลี่ย) สำหรับชุดข้อมูลการตรวจสอบ COCO 2017 คือ 25.69%

• EfficientDet-Lite1 - โมเดลการตรวจจับวัตถุ EfficientDet ขนาดกลาง mAP สำหรับชุดข้อมูลการตรวจสอบ COCO 2017 คือ 30.55%

• EfficientDet-Lite2 - โมเดลการตรวจจับวัตถุ EfficientDet ที่ใหญ่กว่า mAP สำหรับชุดข้อมูลการตรวจสอบ COCO 2017 คือ 33.97%

• MobileNetV1-SSD - รุ่นที่มีน้ำหนักเบาเป็นพิเศษซึ่งปรับให้ทำงานร่วมกับ TensorFlow Lite สำหรับการตรวจจับวัตถุ mAP สำหรับชุดข้อมูลการตรวจสอบ COCO 2017 คือ 21%

สำหรับบทช่วยสอนนี้ โมเดล EfficientDet-Lite0 มีความสมดุลที่ดีระหว่างขนาดและความแม่นยำ

การดาวน์โหลด การแตกไฟล์ และวางโมเดลลงในโฟลเดอร์ Asset จะได้รับการจัดการโดยอัตโนมัติโดยไฟล์ download.gradle ซึ่งทำงานในขณะสร้าง คุณไม่จำเป็นต้องดาวน์โหลดโมเดล TFLite ลงในโปรเจ็กต์ด้วยตนเอง

ตัวอย่างการติดตั้งและรัน

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

ความต้องการของระบบ

• Android Studio เวอร์ชัน 2021.1.1 (Bumblebee) หรือสูงกว่า
• Android SDK เวอร์ชัน 31 ขึ้นไป
• อุปกรณ์ Android ที่มีระบบปฏิบัติการเวอร์ชันขั้นต่ำ SDK 24 (Android 7.0 - Nougat) พร้อมเปิดใช้งานโหมดนักพัฒนาซอฟต์แวร์

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

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

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

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
   

นำเข้าและรันโครงการ

สร้างโปรเจ็กต์จากโค้ดตัวอย่างที่ดาวน์โหลด สร้างโปรเจ็กต์ จากนั้นรัน

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

1. เริ่ม Android สตูดิโอ
2. จาก Android Studio ให้เลือก File > New > Import Project
3. นำทางไปยังไดเร็กทอรีโค้ดตัวอย่างที่มีไฟล์ build.gradle ( .../examples/lite/examples/object_detection/android/build.gradle ) และเลือกไดเร็กทอรีนั้น
4. หาก Android Studio ขอ Gradle Sync ให้เลือกตกลง
5. ตรวจสอบให้แน่ใจว่าอุปกรณ์ Android ของคุณเชื่อมต่อกับคอมพิวเตอร์และเปิดใช้งานโหมดนักพัฒนาซอฟต์แวร์แล้ว คลิกลูก Run สีเขียว

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

ทางเลือก: หากต้องการแก้ไขข้อผิดพลาดของบิลด์โดยอัปเดตเวอร์ชันปลั๊กอิน Android:

1. เปิดไฟล์ build.gradle ในไดเร็กทอรีโปรเจ็กต์

2. เปลี่ยนเวอร์ชันเครื่องมือ Android ดังต่อไปนี้:

   // from: classpath
   'com.android.tools.build:gradle:4.2.2'
   // to: classpath
   'com.android.tools.build:gradle:4.1.2'
   

3. ซิงค์โปรเจ็กต์โดยเลือก: ไฟล์ > ซิงค์โปรเจ็กต์กับไฟล์ Gradle

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

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

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

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

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

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

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

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

1. ในโมดูลที่ใช้ TensorFlow Lite ให้อัปเดตไฟล์ build.gradle ของโมดูลเพื่อรวมการอ้างอิงต่อไปนี้ ในโค้ดตัวอย่าง ไฟล์นี้อยู่ที่นี่: ...examples/lite/examples/object_detection/android/app/build.gradle ( การอ้างอิงโค้ด )

   dependencies {
     ...
     implementation 'org.tensorflow:tensorflow-lite-task-vision:0.4.0'
     // Import the GPU delegate plugin Library for GPU inference
     implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.0'
     implementation 'org.tensorflow:tensorflow-lite-gpu:2.9.0'
   }
   

   โครงการจะต้องมีไลบรารีงาน Vision ( tensorflow-lite-task-vision ) ไลบรารีหน่วยประมวลผลกราฟิก (GPU) ( tensorflow-lite-gpu-delegate-plugin ) จัดเตรียมโครงสร้างพื้นฐานเพื่อเรียกใช้แอปบน GPU และ Delegate ( tensorflow-lite-gpu ) จัดเตรียมรายการความเข้ากันได้

2. ใน Android Studio ให้ซิงค์การขึ้นต่อกันของโปรเจ็กต์โดยเลือก: ไฟล์ > ซิงค์โปรเจ็กต์กับไฟล์ Gradle

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

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

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

ตัวอย่างนี้ดาวน์โหลดหลายโมเดลที่ระบุไว้ใน download_models.gradle และคลาส ObjectDetectorHelper มีตัวเลือกสำหรับโมเดล:

val modelName =
  when (currentModel) {
    MODEL_MOBILENETV1 -> "mobilenetv1.tflite"
    MODEL_EFFICIENTDETV0 -> "efficientdet-lite0.tflite"
    MODEL_EFFICIENTDETV1 -> "efficientdet-lite1.tflite"
    MODEL_EFFICIENTDETV2 -> "efficientdet-lite2.tflite"
    else -> "mobilenetv1.tflite"
  }

ในการเริ่มต้นโมเดลในแอปของคุณ:

1. เพิ่มไฟล์โมเดล .tflite ลงในไดเร็กทอรี src/main/assets ของโปรเจ็กต์การพัฒนาของคุณ เช่น: EfficientDet-Lite0
2. ตั้งค่าตัวแปรคงที่สำหรับชื่อไฟล์โมเดลของคุณ ในแอปตัวอย่าง คุณตั้งค่าตัวแปร modelName เป็น MODEL_EFFICIENTDETV0 เพื่อใช้โมเดลการตรวจจับ EfficientDet-Lite0

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

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

4. ใช้การตั้งค่าจากออบเจ็กต์นี้เพื่อสร้างออบเจ็กต์ TensorFlow Lite ObjectDetector ที่มีโมเดล:

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

setupObjectDetector จะตั้งค่าพารามิเตอร์โมเดลต่อไปนี้:

• เกณฑ์การตรวจจับ
• จำนวนผลลัพธ์การตรวจจับสูงสุด
• จำนวนเธรดการประมวลผลที่จะใช้ ( BaseOptions.builder().setNumThreads(numThreads) )
• รุ่นจริง ( modelName )
• วัตถุ ObjectDetector ( objectDetector )

กำหนดค่าตัวเร่งฮาร์ดแวร์

เมื่อเริ่มต้นโมเดล TensorFlow Lite ในแอปพลิเคชันของคุณ คุณสามารถใช้คุณลักษณะการเร่งด้วยฮาร์ดแวร์เพื่อเพิ่มความเร็วในการคำนวณการคาดการณ์ของโมเดลได้

ผู้ร่วมประชุม TensorFlow Lite คือโมดูลซอฟต์แวร์ที่เร่งการดำเนินการโมเดลการเรียนรู้ของเครื่องโดยใช้ฮาร์ดแวร์การประมวลผลเฉพาะทางบนอุปกรณ์เคลื่อนที่ เช่น หน่วยประมวลผลกราฟิก (GPU) หน่วยประมวลผล Tensor (TPU) และตัวประมวลผลสัญญาณดิจิทัล (DSP) แนะนำให้ใช้ผู้รับมอบสิทธิ์เพื่อเรียกใช้โมเดล TensorFlow Lite แต่ไม่จำเป็น

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

ผู้รับมอบสิทธิ์ถูกตั้งค่าภายในฟังก์ชัน ObjectDetectionHelper.setupObjectDetector() :

when (currentDelegate) {
    DELEGATE_CPU -> {
        // Default
    }
    DELEGATE_GPU -> {
        if (CompatibilityList().isDelegateSupportedOnThisDevice) {
            baseOptionsBuilder.useGpu()
        } else {
            objectDetectorListener?.onError("GPU is not supported on this device")
        }
    }
    DELEGATE_NNAPI -> {
        baseOptionsBuilder.useNnapi()
    }
}

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

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

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

โมเดล EfficientDet-Lite0 ที่ใช้ในตัวอย่างโค้ดนี้ยอมรับเทนเซอร์ที่แสดงรูปภาพที่มีขนาด 320 x 320 โดยมีสามแชนเนล (แดง น้ำเงิน และเขียว) ต่อพิกเซล แต่ละค่าในเทนเซอร์จะมีไบต์เดียวระหว่าง 0 ถึง 255 ดังนั้น เพื่อเรียกใช้การคาดการณ์กับรูปภาพใหม่ แอปของคุณต้องแปลงข้อมูลรูปภาพนั้นเป็นออบเจ็กต์ข้อมูล Tensor ที่มีขนาดและรูปร่างดังกล่าว Vision API ของไลบรารีงาน TensorFlow Lite จัดการการเปลี่ยนแปลงข้อมูลให้กับคุณ

แอปใช้ออบเจ็กต์ ImageAnalysis เพื่อดึงภาพจากกล้อง วัตถุนี้เรียกฟังก์ชัน detectObject ด้วยบิตแมปจากกล้อง ข้อมูลจะถูกปรับขนาดและหมุนโดยอัตโนมัติโดย ImageProcessor เพื่อให้ตรงตามข้อกำหนดข้อมูลรูปภาพของโมเดล จากนั้นภาพจะถูกแปลเป็นวัตถุ TensorImage

ในการเตรียมข้อมูลจากระบบย่อยของกล้องที่จะประมวลผลโดยรุ่น ML:

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

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

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

ในคลาส fragments/CameraFragment.kt ของแอปตัวอย่าง ออบเจ็กต์ imageAnalyzer ภายในฟังก์ชัน bindCameraUseCases จะส่งข้อมูลไปยังโมเดลโดยอัตโนมัติเพื่อการคาดการณ์เมื่อแอปเชื่อมต่อกับกล้อง

แอปใช้เมธอด cameraProvider.bindToLifecycle() เพื่อจัดการตัวเลือกกล้อง หน้าต่างแสดงตัวอย่าง และการประมวลผลโมเดล ML คลาส ObjectDetectorHelper.kt จัดการการส่งผ่านข้อมูลรูปภาพไปยังโมเดล หากต้องการรันโมเดลและสร้างการคาดการณ์จากข้อมูลรูปภาพ:

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

  val results = objectDetector?.detect(tensorImage)
  

ออบเจ็กต์ล่าม TensorFlow Lite รับข้อมูลนี้ รันกับโมเดล และสร้างรายการการคาดการณ์ สำหรับการประมวลผลข้อมูลอย่างต่อเนื่องโดยโมเดล ให้ใช้เมธอด runForMultipleInputsOutputs() เพื่อไม่ให้อ็อบเจ็กต์ Interpreter ถูกสร้างขึ้น และถูกลบออกโดยระบบสำหรับการรันการคาดการณ์แต่ละครั้ง

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

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

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

interface DetectorListener {
  fun onError(error: String)
  fun onResults(
    results: MutableList<Detection>?,
    inferenceTime: Long,
    imageHeight: Int,
    imageWidth: Int
  )
}

สำหรับแบบจำลองที่ใช้ในตัวอย่างนี้ การทำนายแต่ละรายการจะมีตำแหน่งของกรอบขอบเขตสำหรับออบเจ็กต์ ป้ายสำหรับออบเจ็กต์ และคะแนนการทำนายระหว่าง 0 ถึง 1 เป็นการลอยตัวที่แสดงถึงความเชื่อมั่นของการทำนาย โดย 1 คือคะแนนความเชื่อมั่นสูงสุด . โดยทั่วไป การทำนายที่มีคะแนนต่ำกว่า 50% (0.5) ถือว่าไม่สามารถสรุปได้ อย่างไรก็ตาม วิธีที่คุณจัดการกับผลลัพธ์การคาดการณ์ที่มีค่าต่ำนั้นขึ้นอยู่กับคุณและความต้องการของแอปพลิเคชันของคุณ

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

1. ใช้รูปแบบ Listener เพื่อส่งผลลัพธ์ไปยังโค้ดของแอปหรือออบเจ็กต์อินเทอร์เฟซผู้ใช้ แอปตัวอย่างใช้รูปแบบนี้เพื่อส่งผ่านผลลัพธ์การตรวจจับจากวัตถุ 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()
       }
   }
   

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

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

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