คู่มือเริ่มใช้งานฉบับย่อสําหรับ 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 สตูดิโอ
  2. จากหน้า ยินดีต้อนรับ ของ Android Studio ให้เลือก นำเข้าโครงการ หรือเลือก ไฟล์ > ใหม่ > นำเข้าโครงการ
  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 ให้ซิงค์การขึ้นต่อกันของโปรเจ็กต์โดยเลือก: ไฟล์ > ซิงค์โปรเจ็กต์กับไฟล์ Gradle

เริ่มต้นบริการ 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 Delegates

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

คุณเตรียมข้อมูลสำหรับการตีความโดยโมเดลโดยการแปลงข้อมูลที่มีอยู่ เช่น รูปภาพ ให้เป็นรูปแบบข้อมูล Tensor เพื่อให้โมเดลของคุณสามารถประมวลผลได้ ข้อมูลในเทนเซอร์ต้องมีขนาดหรือรูปร่างเฉพาะที่ตรงกับรูปแบบของข้อมูลที่ใช้ในการฝึกโมเดล ขึ้นอยู่กับรุ่นที่คุณใช้ คุณอาจต้องแปลงข้อมูลให้เหมาะสมกับสิ่งที่โมเดลคาดหวัง แอพตัวอย่างใช้ออบเจ็กต์ 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. ใช้รูปแบบ 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()
        }
    }
    

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

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