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

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

การตรวจจับวัตถุด้วยการเรียนรู้ของเครื่อง

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

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

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

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

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

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

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

  1. โคลนที่เก็บ git
    git clone https://github.com/android/camera-samples.git
    
  2. กำหนดค่าอินสแตนซ์ git ของคุณให้ใช้การเช็คเอาท์แบบกระจัดกระจาย ดังนั้นคุณจึงมีเฉพาะไฟล์สำหรับแอปตัวอย่างการตรวจหาวัตถุ:

    cd camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

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

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

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

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

หากคุณเลือกไดเร็กทอรีที่ถูกต้อง 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 Files

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

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

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

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

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

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

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

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

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

  1. ในโมดูลที่ใช้ TensorFlow Lite ให้อัพเดตไฟล์ build.gradle ของโมดูลเพื่อรวมการพึ่งพาต่อไปนี้ ในโค้ดตัวอย่าง ไฟล์นี้จะอยู่ที่นี่: .../android/camera-samples/CameraXAdvanced/tflite/build.gradle ( การอ้างอิงโค้ด )

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. ใน Android Studio ซิงค์การพึ่งพาโปรเจ็กต์โดยเลือก: File > Sync Project with Gradle Files

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

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

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

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

เพื่อความสะดวกและอ่านโค้ดได้ ตัวอย่างจะประกาศอ็อบเจ็กต์ที่แสดงร่วมที่กำหนดการตั้งค่าสำหรับโมเดล

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

  1. สร้างอ็อบเจ็กต์ที่แสดงร่วมเพื่อกำหนดการตั้งค่าสำหรับโมเดล: ( การอ้างอิงโค้ด )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. ใช้การตั้งค่าจากวัตถุนี้เพื่อสร้างอ็อบเจ็กต์ ล่าม TensorFlow Lite ที่มีโมเดล: ( การอ้างอิงโค้ด )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

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

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

Interpreter.Options().addDelegate(nnApiDelegate)

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

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

ให้ข้อมูลกับโมเดล

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

ในการกำหนดรูปร่างเทนเซอร์ที่จำเป็นสำหรับแบบจำลอง:

  • ใช้อ็อบเจ็กต์ ล่าม เริ่มต้นเพื่อกำหนดรูปร่างของเทนเซอร์ที่ใช้โดยโมเดลของคุณ ดังที่แสดงในข้อมูลโค้ดด้านล่าง: ( การอ้างอิงโค้ด )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

โมเดลการตรวจจับวัตถุที่ใช้ในโค้ดตัวอย่างต้องการภาพสี่เหลี่ยมจัตุรัสที่มีขนาด 300 x 300 พิกเซล

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

ในการแปลงข้อมูลรูปภาพสำหรับโมเดล:

  1. ใช้ Support Library ImageProcessor เพื่อสร้างออบเจ็กต์สำหรับแปลงข้อมูลรูปภาพให้อยู่ในรูปแบบที่โมเดลของคุณสามารถใช้เพื่อรันการคาดคะเน: ( การอ้างอิงโค้ด )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. คัดลอกข้อมูลรูปภาพจากระบบกล้อง Android และเตรียมสำหรับการวิเคราะห์ด้วยวัตถุ ImageProcessor ของคุณ: ( การอ้างอิงโค้ด )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

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

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

ในการเรียกใช้การคาดคะเนชุดข้อมูลภาพ:

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

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. เรียกใช้เมธอด run บนอินสแตนซ์อ็อบเจ็กต์ tflite ของคุณด้วยข้อมูลรูปภาพเพื่อสร้างการคาดคะเน: ( การอ้างอิงโค้ด )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

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

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

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

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

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

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

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

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

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