สร้างและทําให้โมเดลการตรวจจับออบเจ็กต์ที่กําหนดเองใช้งานได้ด้วย TensorFlow Lite (Android)

1. ข้อควรทราบก่อนที่จะเริ่มต้น

ใน Codelab นี้ คุณจะได้เรียนรู้วิธีฝึกโมเดลการตรวจจับออบเจ็กต์ที่กําหนดเองโดยใช้ชุดรูปภาพการฝึกด้วย TFLite Model Maker จากนั้นนําโมเดลของคุณไปใช้ในแอป Android โดยใช้ TFLite Task Library คุณจะ

• สร้างแอป Android ที่ตรวจหาส่วนผสมในรูปภาพอาหาร
• ผสานรวมโมเดลการตรวจจับออบเจ็กต์ที่ฝึกไว้ล่วงหน้า TFLite และดูขีดจํากัดของสิ่งที่โมเดลตรวจจับได้
• ฝึกโมเดลการตรวจจับวัตถุที่กําหนดเองเพื่อตรวจจับส่วนผสม/ส่วนประกอบของอาหารโดยใช้ชุดข้อมูลที่กําหนดเองที่ชื่อ salad และ TFLite Model Maker
• ทําให้โมเดลที่กําหนดเองใช้งานได้ในแอป Android โดยใช้ไลบรารีงานของ TFLite

ในท้ายที่สุด คุณจะต้องสร้างบางสิ่งที่คล้ายกับรูปภาพด้านล่างนี้

ข้อกำหนดเบื้องต้น

Codelab นี้ได้รับการออกแบบมาสําหรับนักพัฒนาแอปบนอุปกรณ์เคลื่อนที่ที่มีประสบการณ์ซึ่งต้องการมีประสบการณ์เกี่ยวกับแมชชีนเลิร์นนิง คุณควรทําความคุ้นเคยกับสิ่งต่อไปนี้

• การพัฒนาแอป Android โดยใช้ Kotlin และ Android Studio
• ไวยากรณ์ Python พื้นฐาน

สิ่งที่จะได้เรียนรู้

• วิธีฝึกโมเดลการตรวจจับออบเจ็กต์ที่กําหนดเองโดยใช้ TFLite Model Maker
• วิธีทําให้โมเดลการตรวจจับออบเจ็กต์ TFLite ใช้งานได้โดยใช้ไลบรารีงานของ TFLite

สิ่งที่ต้องมี

• Android Studio เวอร์ชันล่าสุด (v4.2+)
• โปรแกรมจําลอง Android Studio หรืออุปกรณ์ Android จริง
• โค้ดตัวอย่าง
• ความรู้เบื้องต้นเกี่ยวกับการพัฒนา Android ใน Kotlin

2. การตรวจจับออบเจ็กต์

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

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

หากคุณเพียงต้องการตรวจหาออบเจ็กต์ทั่วไปโดยไม่ต้องฝึกโมเดลของคุณเอง โปรดดู codelab นี้เพื่อเรียนรู้วิธีใช้ ML Kit Object Detection และ Tracking API เพื่อสร้างตัวตรวจจับออบเจ็กต์โดยใช้โค้ดเพียงไม่กี่บรรทัด

TensorFlow Lite

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

TensorFlow Lite เป็นเครื่องมือหลักที่ใช้ภายใน ML Kit เพื่อเรียกใช้โมเดลแมชชีนเลิร์นนิง มี 2 คอมโพเนนต์ในระบบนิเวศ TensorFlow Lite ที่ช่วยให้การฝึกและใช้งานโมเดลแมชชีนเลิร์นนิงบนอุปกรณ์เคลื่อนที่เป็นเรื่องง่าย ดังนี้

• Model Maker เป็นไลบรารี Python ที่ช่วยให้คุณฝึกโมเดล TensorFlow Lite ได้อย่างง่ายดายโดยใช้ข้อมูลของคุณเองโดยใช้โค้ดเพียงไม่กี่บรรทัดและไม่จําเป็นต้องมีความเชี่ยวชาญด้านแมชชีนเลิร์นนิง
• Task Library เป็นไลบรารีแบบข้ามแพลตฟอร์มที่ช่วยให้การนําโมเดล TensorFlow Lite ไปใช้งานได้ง่ายด้วยโค้ดเพียงไม่กี่บรรทัดในแอปบนอุปกรณ์เคลื่อนที่

Codelab นี้มุ่งเน้นที่ TFLite ทั้งนี้ เราไม่ได้อธิบายแนวคิดและการบล็อกโค้ดที่ไม่เกี่ยวข้องกับ TFLite และการตรวจหาออบเจ็กต์ รวมถึงมีไว้สําหรับการคัดลอกและวางเท่านั้น

3. ตั้งค่า

ดาวน์โหลดโค้ด

คลิกลิงก์ต่อไปนี้เพื่อดาวน์โหลดโค้ดทั้งหมดสําหรับ Codelab นี้:

ดาวน์โหลดซอร์สโค้ด

คลายการคลายไฟล์ ZIP ที่ดาวน์โหลด การดําเนินการนี้จะเปิดเผยโฟลเดอร์รูท (odml-pathways-main) พร้อมทรัพยากรทั้งหมดที่จําเป็น แต่สําหรับ Codelab นี้ คุณจะต้องใช้แหล่งที่มาในไดเรกทอรีย่อยของ object-detection/codelab2/android เท่านั้น

ไดเรกทอรีย่อย android ในที่เก็บ object-detection/codelab2/android จะมีไดเรกทอรี 2 ไดเรกทอรี ดังนี้

• เงื่อนไขเริ่มต้น - โค้ดเริ่มต้นที่สร้างขึ้นสําหรับ Codelab นี้
• final - โค้ดเสร็จสมบูรณ์สําหรับแอปตัวอย่างที่เสร็จสมบูรณ์

นําเข้าแอปเริ่มต้น

มาเริ่มกันด้วยการนําเข้าแอปเริ่มต้นไปยัง Android Studio

1. เปิด Android Studio และเลือกนําเข้าโปรเจ็กต์ (Gradle, Eclipse ADT ฯลฯ)
2. เปิดโฟลเดอร์ starter จากซอร์สโค้ดที่คุณดาวน์โหลดไว้ก่อนหน้านี้

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

3. เลือกซิงค์โปรเจ็กต์กับไฟล์ Gradle ( ) จากแถบเครื่องมือ Android Studio นําเข้า default/app/build.gradle

หากใช้ปุ่มนี้ อย่าลืมนําเข้าเฉพาะ default/app/build.gradle ไม่ใช่ทั้งที่เก็บ

เรียกใช้แอปเริ่มต้น

หลังจากที่นําเข้าโปรเจ็กต์ไปยัง Android Studio แล้ว คุณก็พร้อมที่จะเรียกใช้แอปเป็นครั้งแรก

เชื่อมต่ออุปกรณ์ Android ผ่าน USB กับคอมพิวเตอร์ หรือเริ่มโปรแกรมจําลอง Android Studio แล้วคลิกเรียกใช้ ( ) ในแถบเครื่องมือ Android Studio

4. ทําความเข้าใจแอปเริ่มต้น

โค้ดเริ่มต้นมีโค้ด Boilerplate บางส่วนที่ทําสิ่งต่างๆ ต่อไปนี้เพื่อให้ Codelab นี้ทํางานง่ายและมุ่งเน้นที่บิตของแมชชีนเลิร์นนิง

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

คุณมักจะโต้ตอบกับวิธีการเหล่านี้ในโครงกระดูกของแอป:

• fun runObjectDetection(bitmap: Bitmap) ระบบจะเรียกใช้วิธีการนี้เมื่อคุณเลือกรูปภาพที่กําหนดไว้ล่วงหน้าหรือถ่ายภาพ bitmap คือรูปภาพอินพุตสําหรับการตรวจหาออบเจ็กต์ หลังจากนั้นคุณจะต้องเพิ่มโค้ด "การตรวจหาออบเจ็กต์" ใน Codelab นี้
• data class DetectionResult(val boundingBoxes: Rect, val text: String) คลาสข้อมูลซึ่งแสดงผลลัพธ์ของการตรวจจับออบเจ็กต์สําหรับการแสดงภาพ boundingBoxes คือสี่เหลี่ยมผืนผ้าที่ออบเจ็กต์ระบุตําแหน่ง และ text คือสตริงผลการตรวจหาที่อยู่ที่จะแสดงพร้อมกับกล่องล้อมรอบของออบเจ็กต์
• fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<DetectionResult>): Bitmap การดําเนินการนี้จะวาดผลลัพธ์ของการตรวจจับออบเจ็กต์ใน detectionResults ของอินพุต bitmap และแสดงผลสําเนาที่แก้ไขของออบเจ็กต์นั้น

ต่อไปนี้คือตัวอย่างเอาต์พุตของเมธอดยูทิลิตี drawDetectionResult

5. เพิ่มการตรวจหาออบเจ็กต์ในอุปกรณ์

ตอนนี้คุณจะสร้างต้นแบบได้โดยผสานรวมโมเดล TFLite ที่ได้รับการฝึกล่วงหน้าซึ่งจะตรวจจับออบเจ็กต์ทั่วไปในแอปเริ่มต้นได้

ดาวน์โหลดโมเดลการตรวจจับออบเจ็กต์ TFLite ก่อนการฝึก

มีโมเดลตัวตรวจจับออบเจ็กต์ใน TensorFlow Hub มากมายที่คุณใช้ได้ สําหรับ Codelab นี้ คุณจะต้องดาวน์โหลดโมเดลการตรวจจับออบเจ็กต์ EfficientDet-Lite ที่ได้รับการฝึกอบรมในชุดข้อมูล COCO 2017 ซึ่งได้รับการเพิ่มประสิทธิภาพสําหรับ TFLite และออกแบบมาเพื่อประสิทธิภาพบน CPU, GPU และ EdgeTPU บนอุปกรณ์เคลื่อนที่

ดาวน์โหลดโมเดล

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

ไลบรารีงานของ TFLite รองรับเฉพาะโมเดล TFLite ที่มีข้อมูลเมตาที่ถูกต้อง ดูโมเดลการตรวจจับออบเจ็กต์ที่รองรับได้มากขึ้นจากคอลเล็กชัน TensorFlow Hub นี้

เพิ่มโมเดลลงในแอปเริ่มต้น

1. คัดลอกโมเดลที่คุณเพิ่งดาวน์โหลดไปยังโฟลเดอร์ assets ของแอปเริ่มต้น คุณดูโฟลเดอร์ได้ในแผงการนําทางของโปรเจ็กต์ใน Android Studio

2. ตั้งชื่อไฟล์ว่า model.tflite

อัปเดตทรัพยากร Dependency ของไลบรารีไฟล์ Gradle

ไปที่ไฟล์ app/build.gradle และเพิ่มบรรทัดนี้ลงในการกําหนดค่า dependencies

implementation 'org.tensorflow:tensorflow-lite-task-vision:0.3.1'

ซิงค์โปรเจ็กต์ด้วยไฟล์ Gradle

คุณควรซิงค์โปรเจ็กต์กับไฟล์ Gradle ในขั้นตอนนี้เพื่อให้ทรัพยากร Dependency ทั้งหมดพร้อมใช้งานในแอป เลือกซิงค์โปรเจ็กต์กับไฟล์ Gradle () จากแถบเครื่องมือ Android Studio

(หากใช้ปุ่มนี้ โปรดตรวจสอบว่าคุณนําเข้าเฉพาะ เงื่อนไขเริ่มต้น/แอป/build.gradle ไม่ใช่ที่เก็บทั้งหมด)

ตั้งค่าและเรียกใช้การตรวจหาออบเจ็กต์ในอุปกรณ์ในรูปภาพ

มี 3 ขั้นตอนง่ายๆ และมี 3 API เพื่อโหลดและเรียกใช้โมเดลการตรวจจับออบเจ็กต์ดังนี้

• จัดเตรียมรูปภาพ / สตรีม: TensorImage
• สร้างออบเจ็กต์ตัวตรวจจับ: ObjectDetector
• เชื่อมต่อวัตถุ 2 อย่างข้างต้น: detect(image)

คุณจะบรรลุเป้าหมายเหล่านี้ได้ในฟังก์ชัน runObjectDetection(bitmap: Bitmap)ในไฟล์ MainActivity.kt

/**
* TFLite Object Detection Function
*/
private fun runObjectDetection(bitmap: Bitmap) {
    //TODO: Add object detection code here
}

ขณะนี้ฟังก์ชันว่างเปล่า ทําตามขั้นตอนต่อไปนี้เพื่อใช้ตัวตรวจจับออบเจ็กต์ TFLite ในระหว่างทาง Android Studio จะแจ้งให้คุณเพิ่มการนําเข้าที่จําเป็นดังนี้

• org.tensorflow.lite.support.image.TensorImage
• org.tensorflow.lite.task.vision.detector.ObjectDetector

สร้างออบเจ็กต์รูปภาพ

รูปภาพที่คุณใช้สําหรับ Codelab นี้จะมาจากกล้องในอุปกรณ์หรือรูปภาพที่กําหนดไว้ล่วงหน้าที่คุณเลือกใน UI ของแอป ระบบจะถอดรหัสรูปภาพอินพุตเป็นรูปแบบ Bitmap และส่งต่อไปยังเมธอด runObjectDetection

TFLite มี API แบบง่ายเพื่อสร้าง TensorImage จาก Bitmap เพิ่มโค้ดด้านล่างที่ด้านบนของ runObjectDetection(bitmap:Bitmap)

// Step 1: create TFLite's TensorImage object
val image = TensorImage.fromBitmap(bitmap)

สร้างอินสแตนซ์ตัวตรวจจับ

ไลบรารีงานของ TFLite เป็นไปตามรูปแบบการออกแบบของเครื่องมือสร้าง คุณส่งการกําหนดค่าไปยังเครื่องมือสร้างแล้วรับตัวตรวจจับจากเครื่องมือนั้น คุณกําหนดค่าได้หลายตัวเลือก ซึ่งรวมถึงตัวเลือกเพื่อปรับความไวของตัวตรวจจับวัตถุ ดังนี้

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

เริ่มอินสแตนซ์ตัวตรวจจับออบเจ็กต์โดยการระบุชื่อไฟล์โมเดล TFLite และตัวเลือกการกําหนดค่า

// Step 2: Initialize the detector object
val options = ObjectDetector.ObjectDetectorOptions.builder()
    .setMaxResults(5)
    .setScoreThreshold(0.5f)
    .build()
val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "model.tflite", // must be same as the filename in assets folder
    options
)

รูปภาพฟีดไปยังตัวตรวจจับ

เพิ่มโค้ดต่อไปนี้ลงใน fun runObjectDetection(bitmap:Bitmap) การดําเนินการนี้จะป้อนรูปภาพลงในตัวตรวจจับ

// Step 3: feed given image to the model and print the detection result
val results = detector.detect(image)

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

• boundingBox: รูปสี่เหลี่ยมผืนผ้าที่ประกาศวัตถุและตําแหน่งของวัตถุภายในรูปภาพ
• categories: ประเภทของออบเจ็กต์และความเชื่อมั่นของโมเดลกับผลการตรวจหา โมเดลจะแสดงผลหลายหมวดหมู่ และหมวดหมู่ที่มั่นใจที่สุดก่อนคือ
• label: ชื่อหมวดหมู่ออบเจ็กต์
• classificationConfidence: แบบลอยที่อยู่ระหว่าง 0.0 ถึง 1.0 โดย 1.0 แสดงถึง 100%

พิมพ์ผลการตรวจหา

เพิ่มโค้ดต่อไปนี้ลงใน fun runObjectDetection(bitmap:Bitmap) วิธีนี้เรียกใช้วิธีพิมพ์ผลการตรวจจับออบเจ็กต์ไปยัง Logcat

// Step 4: Parse the detection result and show it
debugPrint(results)

จากนั้นเพิ่ม debugPrint() เมธอดนี้ลงในชั้นเรียน MainActivity ดังนี้

private fun debugPrint(results : List<Detection>) {
    for ((i, obj) in results.withIndex()) {
        val box = obj.boundingBox

        Log.d(TAG, "Detected object: ${i} ")
        Log.d(TAG, "  boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")

        for ((j, category) in obj.categories.withIndex()) {
            Log.d(TAG, "    Label $j: ${category.label}")
            val confidence: Int = category.score.times(100).toInt()
            Log.d(TAG, "    Confidence: ${confidence}%")
        }
    }
} 

ตอนนี้ตัวตรวจจับออบเจ็กต์พร้อมใช้งานแล้ว คอมไพล์และเรียกใช้แอปโดยคลิกเรียกใช้ ( ) ในแถบเครื่องมือ Android Studio เมื่อแอปปรากฏขึ้นในอุปกรณ์แล้ว ให้แตะรูปภาพที่กําหนดล่วงหน้าเพื่อเริ่มตัวตรวจจับออบเจ็กต์ จากนั้นดูที่หน้าต่าง Logcat*(* *)* ภายใน IDE แล้วคุณจะเห็นคล้ายๆ กันดังนี้

D/TFLite-ODT: Detected object: 0 
D/TFLite-ODT:   boundingBox: (0.0, 15.0) - (2223.0,1645.0)
D/TFLite-ODT:     Label 0: dining table
D/TFLite-ODT:     Confidence: 77%
D/TFLite-ODT: Detected object: 1 
D/TFLite-ODT:   boundingBox: (702.0, 3.0) - (1234.0,797.0)
D/TFLite-ODT:     Label 0: cup
D/TFLite-ODT:     Confidence: 69%

วิธีนี้ช่วยให้ทราบว่าตัวตรวจจับเห็นออบเจ็กต์ 2 รายการ สิ่งแรกคือ

• วัตถุอยู่ภายในสี่เหลี่ยมผืนผ้า (0, 15) – (2223, 1645)
• ป้ายกํากับคือโต๊ะรับประทานอาหาร
• โมเดลมั่นใจว่ารุ่นที่ 1 คือโต๊ะรับประทานอาหาร (77%)

ทางเทคนิคคือสิ่งที่คุณต้องใช้เพื่อให้ TFLite Task Library ทํางานได้ เพียงเท่านี้ก็เรียบร้อย ยินดีด้วย

แต่ในฝั่ง UI คุณยังคงอยู่ที่จุดเริ่มต้น ตอนนี้คุณต้องใช้ผลลัพธ์ที่ตรวจพบใน UI ด้วยการประมวลผลผลลัพธ์ที่ตรวจพบหลังจากประมวลผล

6. วาดผลลัพธ์การตรวจจับบนรูปภาพอินพุต

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

• วาดกรอบล้อมรอบในรูปภาพ
• วาดชื่อหมวดหมู่และเปอร์เซ็นต์ความเชื่อมั่นภายในกรอบล้อมรอบ

1. แทนที่การเรียก debugPrint(results) ด้วยข้อมูลโค้ดต่อไปนี้

val resultToDisplay = results.map {
    // Get the top-1 category and craft the display text
    val category = it.categories.first()
    val text = "${category.label}, ${category.score.times(100).toInt()}%"

    // Create a data object to display the detection result
    DetectionResult(it.boundingBox, text)
}
// Draw the detection result on the bitmap and show it.
val imgWithResult = drawDetectionResult(bitmap, resultToDisplay)
runOnUiThread {
    inputImageView.setImageBitmap(imgWithResult)
}

หมายเหตุ: เนื่องจากการตรวจหาออบเจ็กต์เป็นกระบวนการที่เน้นการประมวลผลและ TFLite Task Library ทํางานในชุดข้อความเดียวกันกับที่มีการเรียกใช้การเรียกใช้เทรดบนเทรดพื้นหลัง จึงไม่ควรบล็อก UI ของแอป คุณจะเห็นว่าเราใช้ Kotlin Coroutine เพื่อเรียกเมธอด runObjectDetection

lifecycleScope.launch(Dispatchers.Default) { runObjectDetection(bitmap) }

2. จากนั้นคลิกเรียกใช้ ( ) ในแถบเครื่องมือ Android Studio
3. เมื่อแอปโหลด ให้แตะที่รูปภาพที่กําหนดไว้ล่วงหน้าเพื่อดูผลการตรวจหา

อยากลองใช้ภาพของตัวเองไหม แตะปุ่มถ่ายภาพและจับภาพวัตถุรอบตัวคุณ

7. ฝึกโมเดลการตรวจจับออบเจ็กต์ที่กําหนดเอง

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

นี่คือชุดข้อมูลที่มีรูปภาพและป้ายกํากับที่คุณสามารถใช้เพื่อฝึกการฝึกโมเดลที่กําหนดเองได้ สร้างขึ้นโดยใช้รูปภาพจาก Open Images Dataset V4

Colaboratory

ถัดไปให้ไปที่ Google Colab เพื่อฝึกโมเดลที่กําหนดเอง

ไปที่ Google Colab

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

สมุดบันทึก Colab จะเรียกใช้โค้ดในเซิร์ฟเวอร์ระบบคลาวด์ของ Google ซึ่งหมายความว่าคุณจะใช้ประโยชน์จากพลังของฮาร์ดแวร์ของ Google รวมถึง GPU และ TPU ได้ไม่ว่าเครื่องของคุณจะใช้พลังงานเท่าไร ใช้แค่เบราว์เซอร์เท่านั้น

หากเข้าถึง Colab ไม่ได้ คุณจะใช้สภาพแวดล้อมอื่นและเข้าถึงโค้ดผ่านลิงก์ GitHub นี้ได้

การฝึกโมเดลที่กําหนดเองจะใช้เวลาประมาณ 30 นาที

หากแบบเร่ง คุณสามารถดาวน์โหลดโมเดลที่เราฝึกล่วงหน้าสําหรับชุดข้อมูลที่คุณมี และดําเนินการต่อไปยังขั้นตอนถัดไป

ดาวน์โหลดโมเดลการตรวจจับสลัด

8. ผสานรวมโมเดล TFLite ที่กําหนดเองกับแอป Android

เมื่อคุณได้ฝึกโมเดลการตรวจจับสลัด ผสานรวม และเปลี่ยนแอปจากตัวตรวจจับวัตถุทั่วไป โดยเฉพาะตัวตรวจจับสลัดแล้ว

1. คัดลอกโมเดลสลัด TFLite ไปยังโฟลเดอร์ assets ตั้งชื่อโมเดลใหม่ salad.tflite

2. เปิดไฟล์ MainActivity.kt แล้วหาโค้ดการเริ่มต้นของ ObjectDetector
3. แทนที่โมเดล EfficientDet-Lite (model.tflite) ด้วยโมเดลสลัด (salad.tflite)

val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "salad.tflite", // must be same as the filename in assets folder
    options
)

4. คลิกเรียกใช้ () ในแถบเครื่องมือ Android Studio เพื่อเรียกใช้แอปอีกครั้งด้วยโมเดลใหม่ เรียบร้อย! แอปจะจดจําชีส สลัด และขนมอบได้

หากคุณเรียกใช้แอปในโปรแกรมจําลอง Android คุณอาจเห็นว่าโมเดลการตรวจจับวัตถุจะใช้เวลา 2-3 วินาทีในการแสดงผลลัพธ์ เนื่องจากโมเดลที่เล็กลงของ TFLite ไม่ได้รับการเพิ่มประสิทธิภาพเพื่อให้ทํางานบนโปรแกรมจําลองได้ คุณจะเห็นได้ว่าทํางานได้เร็วขึ้นในอุปกรณ์ Android จริง

9. ยินดีด้วย

คุณใช้ TFLite เพื่อฝึกโมเดลที่กําหนดเองและเพิ่มความสามารถของ Object Detection ไปยังแอปของคุณ นั่นคือทั้งหมดที่จําเป็นสําหรับการเริ่มต้นใช้งาน

สิ่งที่เราพูดถึง

• วิธีค้นหาโมเดลการตรวจจับออบเจ็กต์ TFLite ที่ได้รับการฝึกอบรมล่วงหน้าใน TensorFlow Hub
• วิธีผสานรวมโมเดลการตรวจจับการปฏิเสธลงในแอป Android โดยใช้ไลบรารีงานของ TFLite
• วิธีฝึกโมเดลการตรวจจับออบเจ็กต์ที่กําหนดเองด้วย TFLite Model Maker

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

• ใช้ Firebase เพื่อปรับปรุงการติดตั้งใช้งานโมเดล TFLite
• รวบรวมข้อมูลการฝึกอบรมเพื่อฝึกโมเดลของคุณเอง
• ใช้การตรวจจับออบเจ็กต์ในแอป Android ของคุณเอง

ดูข้อมูลเพิ่มเติม

• แมชชีนเลิร์นนิงในอุปกรณ์ด้วยเทคโนโลยีของ Google