สร้างโมเดลแมชชีนเลิร์นนิงสำหรับสแปมความคิดเห็น

1. ก่อนเริ่มต้น

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

โค้ดที่คุณจะตรวจสอบได้ระบุไว้ที่นี่ แต่ขอแนะนําอย่างยิ่งให้ติดตามด้วยโค้ดใน Google Colab

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

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

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

• วิธีติดตั้ง TensorFlow Lite Model Maker โดยใช้ Google Colab
• วิธีดาวน์โหลดข้อมูลจากเซิร์ฟเวอร์ระบบคลาวด์ลงในอุปกรณ์ของคุณ
• วิธีใช้ตัวโหลดข้อมูล
• วิธีสร้างโมเดล

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

• เข้าถึง Google Colab

2. ติดตั้งเครื่องสร้างโมเดล TensorFlow Lite

เปิด Colab เซลล์แรกในสมุดบันทึกจะติดตั้ง TensorFLow Lite Model Maker ให้คุณ

!pip install -q tflite-model-maker

เมื่อเสร็จเรียบร้อยแล้ว ให้ไปยังเซลล์ถัดไป

3. นำเข้าโค้ด

เซลล์ถัดไปมีการนำเข้าที่โค้ดในสมุดบันทึกจะต้องใช้ ดังนี้

import numpy as np
import os
from tflite_model_maker import configs
from tflite_model_maker import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import text_classifier
from tflite_model_maker.text_classifier import DataLoader

import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')

การดำเนินการนี้จะตรวจสอบว่าคุณได้เรียกใช้ TensorFlow 2.x หรือไม่ ซึ่งเป็นข้อกำหนดในการใช้ Model Maker

4. ดาวน์โหลดข้อมูล

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

data_file = tf.keras.utils.get_file(fname='comment-spam.csv', 
  origin='https://storage.googleapis.com/laurencemoroney-blog.appspot.com/lmblog_comments.csv', 
  extract=False)

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

5. การฝังสิ่งที่เรียนรู้ไว้ล่วงหน้า

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

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

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

เครื่องสร้างโมเดลมีการฝังสิ่งที่เรียนรู้ไว้ล่วงหน้ามากมายที่คุณสามารถใช้ได้ แต่วิธีเริ่มต้นที่ง่ายที่สุดและรวดเร็วที่สุดคือ average_word_vec

ต่อไปนี้เป็นรหัส:

spec = model_spec.get('average_word_vec')
spec.num_words = 2000
spec.seq_len = 20
spec.wordvec_dim = 7

พารามิเตอร์ num_words

นอกจากนี้ คุณยังต้องระบุจำนวนคำที่ต้องการให้โมเดลใช้ด้วย

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

จำนวนที่น้อยอาจหมายถึงโมเดลที่เล็กกว่าและเร็วกว่า แต่ก็อาจมีความแม่นยำน้อยลงเนื่องจากจดจำคำได้น้อยกว่า ตัวเลขที่มากกว่าจะมีโมเดลที่ใหญ่กว่าและช้ากว่า การหาจุดที่ลงตัวคือกุญแจสำคัญ

พารามิเตอร์ wordvec_dim

พารามิเตอร์ wordved_dim คือจำนวนมิติข้อมูลที่คุณต้องการใช้กับเวกเตอร์ของแต่ละคำ หลักการทั่วไปที่พิจารณาจากการวิจัยคือรากที่ 4 ของจำนวนคำ ตัวอย่างเช่น หากคุณใช้ 2,000 คำ จุดเริ่มต้นที่ดีคือ 7 หากเปลี่ยนจำนวนคำที่ใช้ คุณจะเปลี่ยนตัวเลขนี้ได้

พารามิเตอร์ seq_len

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

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

6. ใช้ตัวโหลดข้อมูล

คุณดาวน์โหลดไฟล์ CSV ไว้ก่อนหน้านี้ ตอนนี้ได้เวลาใช้ตัวโหลดข้อมูลเพื่อเปลี่ยนข้อมูลนี้เป็นข้อมูลการฝึกที่โมเดลสามารถจดจำได้:

data = DataLoader.from_csv(
    filename=data_file,
    text_column='commenttext',
    label_column='spam',
    model_spec=spec,
    delimiter=',',
    shuffle=True,
    is_training=True)

train_data, test_data = data.split(0.9)

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

คุณจะเห็นว่าข้อบ่งชี้สำหรับคอลัมน์แรกคือ commenttext และรายการแรกในแต่ละบรรทัดจะเป็นข้อความของความคิดเห็น ในทำนองเดียวกัน ข้อบ่งชี้สำหรับคอลัมน์ที่ 2 คือ spam และคุณจะเห็นว่ารายการที่ 2 ในแต่ละบรรทัดคือ True หรือ False, เพื่อระบุว่าข้อความนั้นเป็นสแปมความคิดเห็นหรือไม่ พร็อพเพอร์ตี้อื่นๆ จะตั้งค่า model_spec ที่คุณสร้างขึ้นก่อนหน้านี้พร้อมกับอักขระตัวคั่น ซึ่งในกรณีนี้จะเป็นเครื่องหมายจุลภาคเนื่องจากไฟล์มีการคั่นด้วยเครื่องหมายจุลภาค คุณจะใช้ข้อมูลนี้เพื่อฝึกโมเดล จึงมีการตั้งค่า is_Training เป็น True

คุณจะต้องเก็บข้อมูลบางส่วนไว้ทดสอบโมเดล แบ่งข้อมูล โดยแบ่งเป็น 90% เป็นการฝึก และอีก 10% เป็นการทดสอบ/ประเมิน เนื่องจากเราดำเนินการเช่นนี้ เราจึงต้องการทำให้แน่ใจว่ามีการเลือกข้อมูลการทดสอบแบบสุ่ม และไม่ใช่ข้อมูล "ต่ำสุด" 10% ของชุดข้อมูล คุณจึงใช้ shuffle=True เมื่อโหลดข้อมูลเพื่อสุ่ม

7. สร้างโมเดล

เซลล์ถัดไปคือการสร้างโมเดล และเป็นโค้ดบรรทัดเดียว

# Build the model
model = text_classifier.create(train_data, model_spec=spec, epochs=50, 
                               validation_data=test_data)

วิธีนี้จะสร้างโมเดลตัวแยกประเภทข้อความด้วย Model Maker และคุณระบุข้อมูลการฝึกที่ต้องการใช้ (ตามที่ตั้งค่าในขั้นตอนที่ 4) ข้อมูลจำเพาะของโมเดล (ตามที่ตั้งค่าในขั้นตอนที่ 4) และจำนวน Epoch ในกรณีดังนี้ 50

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

จากนั้นจะวัดผลลัพธ์ของกระบวนการนี้และเรียกใช้โค้ดการเพิ่มประสิทธิภาพเพื่อปรับแต่งการคาดการณ์ แล้วลองอีกครั้ง นี่คือ Epoch ดังนั้น เมื่อระบุ epochs=50 จะผ่าน "loop" นี้ 50 ครั้ง

เมื่อถึง Epoch ที่ 50 โมเดลจะรายงานระดับความแม่นยําที่สูงขึ้นมาก ในกรณีนี้ ผลลัพธ์จะแสดงเป็น 99%!

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

8. ส่งออกโมเดล

เมื่อการฝึกเสร็จสมบูรณ์ คุณจะส่งออกโมเดลได้

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

เพียงส่งออกโมเดลโดยระบุไดเรกทอรีดังนี้

model.export(export_dir='/mm_spam')

คุณจะเห็นไฟล์ model.tflite ภายในไดเรกทอรีนั้น ดาวน์โหลด คุณจะต้องใช้ใน Codelab ครั้งถัดไป ซึ่งเป็นที่ที่คุณเพิ่มไปยังแอป Android

ข้อควรพิจารณาเกี่ยวกับ iOS

โมเดล .tflite ที่คุณเพิ่งส่งออกทำงานได้ดีสำหรับ Android เนื่องจากมีข้อมูลเมตาเกี่ยวกับโมเดลฝังอยู่ในโมเดลและ Android Studio สามารถอ่านข้อมูลเมตานั้นได้

ข้อมูลเมตานี้มีความสำคัญมากเนื่องจากมีพจนานุกรมของโทเค็นที่แสดงถึงคำต่างๆ ในขณะที่โมเดลจดจำได้ จำได้ไหมว่าก่อนหน้านี้เมื่อคุณเรียนรู้ว่าคำกลายเป็นโทเค็น แล้วโทเค็นเหล่านี้จะได้รับเวกเตอร์สำหรับความรู้สึกไหม แอปบนอุปกรณ์เคลื่อนที่ของคุณจำเป็นต้องทราบโทเค็นเหล่านี้ เช่น หากคำว่า "สุนัข" ถูกแปลงให้เป็นโทเค็น 42 และผู้ใช้พิมพ์คำว่า "สุนัข" เป็นประโยค แอปของคุณจะต้องแปลงคำว่า "สุนัข" เป็น 42 เพื่อให้โมเดลเข้าใจ ในฐานะนักพัฒนาแอป Android คุณจะได้ "ไลบรารีงาน TensorFlow Lite" ซึ่งทำให้การใช้งานง่ายขึ้น แต่บน iOS คุณจะต้องประมวลคำศัพท์ที่คุณจำเป็นต้องใช้ เครื่องสร้างโมเดลสามารถส่งออกรายการนี้ให้คุณโดยการระบุพารามิเตอร์ export_format ดังนั้นหากต้องการรับป้ายกำกับและคำศัพท์สำหรับโมเดลของคุณ คุณสามารถใช้เงื่อนไขนี้:

model.export(export_dir='/mm_spam/', 
             export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])

9. ขอแสดงความยินดี

Codelab นี้นำคุณเข้าสู่โค้ด Python สำหรับการสร้างและส่งออกโมเดล คุณจะมีไฟล์ .tflite ที่ส่วนท้าย

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