การรู้จำเสียงและคำศัพท์สำหรับ Android

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

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

การจัดหมวดหมู่เสียงด้วยการเรียนรู้ของเครื่อง

โมเดลการเรียนรู้ของเครื่องในบทช่วยสอนนี้จะจดจำเสียงหรือคำศัพท์จากตัวอย่างเสียงที่บันทึกด้วยไมโครโฟนบนอุปกรณ์ Android แอปตัวอย่างในบทช่วยสอนนี้ช่วยให้คุณสามารถสลับระหว่าง YAMNet/ลักษณนาม โมเดลที่จดจำเสียง และโมเดลที่จดจำคำพูดเฉพาะ ซึ่งได้ รับการฝึกฝน โดยใช้เครื่องมือ TensorFlow Lite Model Maker แบบจำลองคาดการณ์คลิปเสียงที่มีตัวอย่าง 15,600 ตัวอย่างต่อคลิป และมีความยาวประมาณ 1 วินาที

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

สำหรับส่วนแรกของบทช่วยสอนนี้ คุณจะดาวน์โหลดตัวอย่างจาก 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/audio_classification/android
   

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

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

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

1. เริ่ม Android สตูดิโอ
2. ใน Android Studio ให้เลือก ไฟล์ > ใหม่ > นำเข้าโครงการ
3. นำทางไปยังไดเร็กทอรีโค้ดตัวอย่างที่มีไฟล์ build.gradle ( .../examples/lite/examples/audio_classification/android/build.gradle ) และเลือกไดเร็กทอรีนั้น

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

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

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

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

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

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

แอปตัวอย่างใช้ไลบรารี TensorFlow Lite ต่อไปนี้:

• Audio API ของไลบรารีงาน TensorFlow Lite - จัดเตรียมคลาสอินพุตข้อมูลเสียงที่จำเป็น การดำเนินการของโมเดล Machine Learning และผลลัพธ์เอาต์พุตจากการประมวลผลโมเดล

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

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

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

   dependencies {
   ...
       implementation 'org.tensorflow:tensorflow-lite-task-audio'
   }
   

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

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

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

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

• <project>/src/main/assets/yamnet.tflite

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

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

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

   companion object {
     const val DISPLAY_THRESHOLD = 0.3f
     const val DEFAULT_NUM_OF_RESULTS = 2
     const val DEFAULT_OVERLAP_VALUE = 0.5f
     const val YAMNET_MODEL = "yamnet.tflite"
     const val SPEECH_COMMAND_MODEL = "speech.tflite"
   }
   

2. สร้างการตั้งค่าสำหรับโมเดลโดยการสร้างออบเจ็กต์ AudioClassifier.AudioClassifierOptions :

   val options = AudioClassifier.AudioClassifierOptions.builder()
     .setScoreThreshold(classificationThreshold)
     .setMaxResults(numOfResults)
     .setBaseOptions(baseOptionsBuilder.build())
     .build()
   

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

   classifier = AudioClassifier.createFromFileAndOptions(context, "yamnet.tflite", options)
   

เปิดใช้งานการเร่งด้วยฮาร์ดแวร์

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

val baseOptionsBuilder = BaseOptions.builder()
   .setNumThreads(numThreads)
...
when (currentDelegate) {
   DELEGATE_CPU -> {
       // Default
   }
   DELEGATE_NNAPI -> {
       baseOptionsBuilder.useNnapi()
   }
}

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

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

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

โมเดล YAMNet/ลักษณนาม และโมเดล คำสั่งคำพูด แบบกำหนดเองที่ใช้ในตัวอย่างโค้ดนี้ยอมรับออบเจ็กต์ข้อมูลเทนเซอร์ที่แสดงถึงคลิปเสียงช่องเดียวหรือโมโนที่บันทึกที่ 16kHz ในคลิป 0.975 วินาที (ตัวอย่าง 15600 ตัวอย่าง) เมื่อใช้การคาดการณ์ข้อมูลเสียงใหม่ แอปของคุณจะต้องแปลงข้อมูลเสียงนั้นเป็นออบเจ็กต์ข้อมูล Tensor ที่มีขนาดและรูปร่างดังกล่าว API เสียง ของไลบรารีงาน TensorFlow Lite จัดการการเปลี่ยนแปลงข้อมูลให้กับคุณ

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

หากต้องการให้ข้อมูลเสียงแก่โมเดล ML:

• ใช้วัตถุ AudioClassifier เพื่อสร้างวัตถุ TensorAudio และวัตถุ AudioRecord :

  fun initClassifier() {
  ...
    try {
      classifier = AudioClassifier.createFromFileAndOptions(context, currentModel, options)
      // create audio input objects
      tensorAudio = classifier.createInputTensorAudio()
      recorder = classifier.createAudioRecord()
    }
  

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

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

การดำเนินการกับโมเดลใช้ทรัพยากรจำนวนมาก ดังนั้นจึงเป็นเรื่องสำคัญที่จะต้องรันการคาดการณ์โมเดล ML บนเธรดเบื้องหลังที่แยกต่างหาก แอปตัวอย่างใช้อ [ScheduledThreadPoolExecutor](https://developer.android.com/reference/java/util/concurrent/ScheduledThreadPoolExecutor) เพื่อแยกการประมวลผลโมเดลออกจากฟังก์ชันอื่นๆ ของแอป

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

หากต้องการเริ่มใช้การคาดคะเนข้อมูลเสียง:

1. ใช้เมธอด AudioClassificationHelper.startAudioClassification() เพื่อเริ่มการบันทึกเสียงสำหรับโมเดล:

   fun startAudioClassification() {
     if (recorder.recordingState == AudioRecord.RECORDSTATE_RECORDING) {
       return
     }
     recorder.startRecording()
   }
   

2. ตั้งค่าความถี่ที่โมเดลสร้างการอนุมานจากคลิปเสียงโดยการตั้ง interval อัตราคงที่ในออบเจ็กต์ ScheduledThreadPoolExecutor :

   executor = ScheduledThreadPoolExecutor(1)
   executor.scheduleAtFixedRate(
     classifyRunnable,
     0,
     interval,
     TimeUnit.MILLISECONDS)
   

3. อ็อบเจ็กต์ classifyRunnable ในโค้ดด้านบนดำเนินการเมธอด AudioClassificationHelper.classifyAudio() ซึ่งจะโหลดข้อมูลเสียงล่าสุดที่มีอยู่จากเครื่องบันทึกและดำเนินการทำนาย:

   private fun classifyAudio() {
     tensorAudio.load(recorder)
     val output = classifier.classify(tensorAudio)
     ...
   }
   

หยุดการประมวลผลการคาดการณ์

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

หากต้องการหยุดการบันทึกและการจัดหมวดหมู่เสียง:

• ใช้เมธอด AudioClassificationHelper.stopAudioClassification() เพื่อหยุดการบันทึกและการดำเนินการโมเดล ดังที่แสดงด้านล่างในคลาส AudioFragment :

  override fun onPause() {
    super.onPause()
    if (::audioHelper.isInitialized ) {
      audioHelper.stopAudioClassification()
    }
  }
  

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

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

หากต้องการรับผลลัพธ์การทำนายจากแบบจำลอง:

1. รับผลลัพธ์ของ classify() วิธีการของออบเจ็ กต์ AudioClassifier และส่งต่อไปยังออบเจ็กต์ Listener (การอ้างอิงโค้ด):

   private fun classifyAudio() {
     ...
     val output = classifier.classify(tensorAudio)
     listener.onResult(output[0].categories, inferenceTime)
   }
   

2. ใช้ฟังก์ชัน onResult() ของผู้ฟังเพื่อจัดการเอาต์พุตโดยดำเนินการตรรกะทางธุรกิจหรือแสดงผลลัพธ์แก่ผู้ใช้:

   private val audioClassificationListener = object : AudioClassificationListener {
     override fun onResult(results: List<Category>, inferenceTime: Long) {
       requireActivity().runOnUiThread {
         adapter.categoryList = results
         adapter.notifyDataSetChanged()
         fragmentAudioBinding.bottomSheetLayout.inferenceTimeVal.text =
           String.format("%d ms", inferenceTime)
       }
     }
   

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

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

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

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