การจัดหมวดหมู่ข้อความด้วย Android

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

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

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

ภาพรวมการจัดหมวดหมู่ข้อความ

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

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการสร้างโมเดลในบทช่วยสอนนี้ โปรดดูบท ช่วยสอนการจัดหมวดหมู่ข้อความด้วย TensorFlow Lite Model Maker

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

บทช่วยสอนนี้ใช้แบบจำลองที่ได้รับการฝึกโดยใช้ชุดข้อมูล SST-2 (Stanford Sentiment Treebank) SST-2 ประกอบด้วยบทวิจารณ์ภาพยนตร์ 67,349 รายการสำหรับการฝึกอบรม และบทวิจารณ์ภาพยนตร์ 872 รายการสำหรับการทดสอบ โดยแต่ละบทวิจารณ์แบ่งออกเป็นเชิงบวกหรือเชิงลบ โมเดลที่ใช้ในแอปนี้ได้รับการฝึกฝนโดยใช้เครื่องมือ TensorFlow Lite Model Maker

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

  • Average Word Vector ( NLClassifier ) - NLClassifier ของไลบรารีงานจะจัดประเภทข้อความอินพุตเป็นหมวดหมู่ต่างๆ และสามารถรองรับโมเดลการจัดหมวดหมู่ข้อความส่วนใหญ่ได้

  • MobileBERT ( BertNLClassifier ) - BertNLClassifier ของ Task Library นั้นคล้ายคลึงกับ NLClassifier แต่ได้รับการปรับแต่งสำหรับกรณีที่ต้องใช้โทเค็นของ Wordpiece และ Sentencepiece ที่ไม่อยู่ในกราฟ

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

หากต้องการตั้งค่าแอปพลิเคชันการจัดประเภทข้อความ ให้ดาวน์โหลดแอปตัวอย่างจาก GitHub และเรียกใช้โดยใช้ Android Studio

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

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

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

สร้างสำเนาโค้ดตัวอย่างในเครื่อง คุณจะใช้โค้ดนี้เพื่อสร้างโปรเจ็กต์ใน 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/text_classification/android

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

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

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

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

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

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

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

การใช้แอพพลิเคชั่น

แอพตัวอย่างการจำแนกข้อความใน Android

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

หากต้องการใช้ตัวแยกประเภทข้อความ:

  1. ป้อนตัวอย่างข้อความในกล่องข้อความ
  2. จากดรอปดาวน์ Delegate ให้เลือก CPU หรือ NNAPI
  3. ระบุโมเดลโดยเลือก AverageWordVec หรือ MobileBERT
  4. เลือก จำแนกประเภท

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

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

แอปตัวอย่างทำงานอย่างไร

แอปพลิเคชันใช้ ไลบรารีงานสำหรับแพ็คเกจภาษาธรรมชาติ (NL) เพื่อใช้แบบจำลองการจัดหมวดหมู่ข้อความ ทั้งสองโมเดล ได้แก่ Average Word Vector และ MobileBERT ได้รับการฝึกโดยใช้ TensorFlow Lite Model Maker แอปพลิเคชันทำงานบน CPU ตามค่าเริ่มต้น พร้อมตัวเลือกในการเร่งความเร็วด้วยฮาร์ดแวร์โดยใช้ตัวแทน NNAPI

ไฟล์และไดเร็กทอรีต่อไปนี้มีรหัสสำคัญสำหรับแอปพลิเคชันการจัดประเภทข้อความนี้:

  • TextClassificationHelper.kt - เตรียมใช้งานตัวแยกประเภทข้อความและจัดการการเลือกโมเดลและผู้รับมอบสิทธิ์
  • MainActivity.kt - ใช้งานแอปพลิเคชัน รวมถึงการเรียก TextClassificationHelper และ ResultsAdapter
  • ResultsAdapter.kt - จัดการและจัดรูปแบบผลลัพธ์

แก้ไขใบสมัครของคุณ

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

เปิดหรือสร้างโครงการ Android

คุณต้องมีโครงการพัฒนา Android ใน Android Studio เพื่อปฏิบัติตามคำแนะนำที่เหลือ ทำตามคำแนะนำด้านล่างเพื่อเปิดโปรเจ็กต์ที่มีอยู่หรือสร้างโปรเจ็กต์ใหม่

หากต้องการเปิดโครงการพัฒนา Android ที่มีอยู่:

  • ใน Android Studio ให้เลือก ไฟล์ > เปิด และเลือกโปรเจ็กต์ที่มีอยู่

ในการสร้างโครงการพัฒนา Android ขั้นพื้นฐาน:

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้ Android Studio โปรดดู เอกสารประกอบของ Android Studio

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

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

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

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

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

    ในแอปพลิเคชันตัวอย่าง การขึ้นต่อกันจะอยู่ใน app/build.gradle :

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

    โครงการจะต้องมีไลบรารีงานข้อความ ( tensorflow-lite-task-text )

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

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

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

ในแอป Android คุณต้องเริ่มต้นโมเดลแมชชีนเลิร์นนิง TensorFlow Lite ด้วยพารามิเตอร์ก่อนที่จะเรียกใช้การคาดการณ์ด้วยโมเดล

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

  • <project>/src/main/assets/mobilebert.tflite
  • <project>/src/main/assets/wordvec.tflite

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

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

  1. สร้างออบเจ็กต์ร่วมเพื่อกำหนดการตั้งค่าสำหรับโมเดล ในแอปพลิเคชันตัวอย่าง อ็อบเจ็กต์นี้จะอยู่ใน TextClassificationHelper.kt :

    companion object {
  const val DELEGATE_CPU = 0
  const val DELEGATE_NNAPI = 1
  const val WORD_VEC = "wordvec.tflite"
  const val MOBILEBERT = "mobilebert.tflite"
}

  2. สร้างการตั้งค่าสำหรับโมเดลโดยการสร้างออบเจ็กต์ตัวแยกประเภท และสร้างออบเจ็กต์ TensorFlow Lite โดยใช้ BertNLClassifier หรือ NLClassifier

    ในแอปพลิเคชันตัวอย่าง สิ่งนี้จะอยู่ในฟังก์ชัน initClassifier ภายใน TextClassificationHelper.kt :

    fun initClassifier() {
  ...
  if( currentModel == MOBILEBERT ) {
    ...
    bertClassifier = BertNLClassifier.createFromFileAndOptions(
      context,
      MOBILEBERT,
      options)
  } else if (currentModel == WORD_VEC) {
      ...
      nlClassifier = NLClassifier.createFromFileAndOptions(
        context,
        WORD_VEC,
        options)
  }
}

เปิดใช้งานการเร่งด้วยฮาร์ดแวร์ (ไม่จำเป็น)

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

หากต้องการเปิดใช้งานการเร่งด้วยฮาร์ดแวร์ในแอปของคุณ:

  1. สร้างตัวแปรเพื่อกำหนดผู้รับมอบสิทธิ์ที่แอปพลิเคชันจะใช้ ในแอปพลิเคชันตัวอย่าง ตัวแปรนี้อยู่ที่ช่วงต้นของ TextClassificationHelper.kt :

    var currentDelegate: Int = 0

  2. สร้างตัวเลือกผู้รับมอบสิทธิ์ ในแอปพลิเคชันตัวอย่าง ตัวเลือกผู้รับมอบสิทธิ์จะอยู่ในฟังก์ชัน initClassifier ภายใน TextClassificationHelper.kt :

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

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

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

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

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

ในการจัดเตรียมข้อมูลข้อความให้กับโมเดล:

  1. ตรวจสอบให้แน่ใจว่าฟังก์ชัน initClassifier มีโค้ดสำหรับผู้รับมอบสิทธิ์และโมเดล ตามที่อธิบายไว้ในส่วน เริ่มต้นโมเดล ML และ เปิดใช้งานการเร่งด้วยฮาร์ดแวร์

  2. ใช้บล็อก init เพื่อเรียกใช้ฟังก์ชัน initClassifier ในแอปพลิเคชันตัวอย่าง init จะอยู่ใน TextClassificationHelper.kt :

    init {
  initClassifier()
}

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

ในแอป Android ของคุณ เมื่อคุณเริ่มต้นวัตถุ BertNLClassifier หรือ NLClassifier แล้ว คุณสามารถเริ่มป้อนข้อความอินพุตสำหรับโมเดลเพื่อจัดหมวดหมู่เป็น "บวก" หรือ "ลบ"

หากต้องการเรียกใช้การคาดการณ์:

  1. สร้างฟังก์ชัน classify ซึ่งใช้ตัวแยกประเภทที่เลือก ( currentModel ) และวัดเวลาที่ใช้ในการจัดประเภทข้อความอินพุต ( inferenceTime ) ในแอปพลิเคชันตัวอย่าง ฟังก์ชัน classify จะอยู่ใน TextClassificationHelper.kt :

    fun classify(text: String) {
  executor = ScheduledThreadPoolExecutor(1)

  executor.execute {
    val results: List<Category>
    // inferenceTime is the amount of time, in milliseconds, that it takes to
    // classify the input text.
    var inferenceTime = SystemClock.uptimeMillis()

    // Use the appropriate classifier based on the selected model
    if(currentModel == MOBILEBERT) {
      results = bertClassifier.classify(text)
    } else {
      results = nlClassifier.classify(text)
    }

    inferenceTime = SystemClock.uptimeMillis() - inferenceTime

    listener.onResult(results, inferenceTime)
  }
}

  2. ส่งผ่านผลลัพธ์จาก classify ไปยังวัตถุผู้ฟัง

    fun classify(text: String) {
  ...
  listener.onResult(results, inferenceTime)
}

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

หลังจากที่คุณป้อนบรรทัดข้อความ แบบจำลองจะสร้างคะแนนการคาดการณ์ ซึ่งแสดงเป็นแบบทศนิยม ระหว่าง 0 ถึง 1 สำหรับหมวดหมู่ 'บวก' และ 'เชิงลบ'

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

  1. สร้างฟังก์ชัน onResult สำหรับออบเจ็กต์ Listener เพื่อจัดการเอาต์พุต ในแอปพลิเคชันตัวอย่าง ออบเจ็กต์ Listener จะอยู่ใน MainActivity.kt

    private val listener = object : TextClassificationHelper.TextResultsListener {
  override fun onResult(results: List<Category>, inferenceTime: Long) {
    runOnUiThread {
      activityMainBinding.bottomSheetLayout.inferenceTimeVal.text =
        String.format("%d ms", inferenceTime)

      adapter.resultsList = results.sortedByDescending {
        it.score
      }

      adapter.notifyDataSetChanged()
    }
  }
  ...
}

  2. เพิ่มฟังก์ชัน onError ให้กับออบเจ็กต์ Listener เพื่อจัดการข้อผิดพลาด:

      private val listener = object : TextClassificationHelper.TextResultsListener {
    ...
    override fun onError(error: String) {
      Toast.makeText(this@MainActivity, error, Toast.LENGTH_SHORT).show()
    }
  }

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

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