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

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

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

โค้ดที่คุณจะตรวจสอบมีอยู่ที่นี่ แต่เราขอแนะนำให้คุณทำตามโค้ดใน Google Colab

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

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

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

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

สิ่งที่คุณต้องมี

• สิทธิ์เข้าถึง Google Colab

2. ติดตั้ง TensorFlow Lite Model Maker

เปิด Colab เซลล์แรกใน Notebook จะติดตั้ง TensorFlow Lite Model Maker ให้คุณ

!pip install -q tflite-model-maker

เมื่อดำเนินการเสร็จแล้ว ให้ไปที่เซลล์ถัดไป

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

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

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)

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

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

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

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

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

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

รหัสมีดังนี้

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

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

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

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

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

เมื่อถึง Epoch ที่ 50 โมเดลจะรายงานความแม่นยำในระดับที่สูงขึ้นมาก ในกรณีนี้แสดง 99%

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

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

เมื่อฝึกโมเดลเสร็จแล้ว คุณจะส่งออกโมเดลได้

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

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

model.export(export_dir='/mm_spam')

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

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

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

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

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

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

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

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