ฝึกโมเดลการตรวจจับสแปมความคิดเห็นด้วย TensorFlow Lite Model Maker

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

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

โค้ดที่คุณตรวจสอบจะแสดงที่นี่ แต่ขอแนะนำให้คุณทำตามโค้ดใน Colaboratory

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

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

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

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

  • สิทธิ์เข้าถึง 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. ดาวน์โหลดข้อมูล

จากนั้นคุณจะดาวน์โหลดข้อมูลจากเซิร์ฟเวอร์ Colab ไปยังอุปกรณ์ และตั้งค่าตัวแปร 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

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

c42755151d511ce.png

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

7d0ee06a5246b58d.png

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

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

f063ff6e1d2add67.png

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

  1. เรียกใช้เซลล์นี้เพื่อระบุไดเรกทอรีและส่งออกโมเดล
model.export(export_dire='/mm_spam_savedmodel', export_format=[ExportFormat.LABEL, ExportFormat.VOCAB, ExportFormat.SAVED_MODEL])
  1. บีบอัดโฟลเดอร์ /mm_spam_savedmodel ทั้งหมดและดาวน์โหลดไฟล์ mm_spam_savedmodel.zip ที่สร้างขึ้น ซึ่งคุณจะต้องใช้ใน Codelab ถัดไป
# Rename the SavedModel subfolder to a version number
!mv /mm_spam_savedmodel/saved_model /mm_spam_savedmodel/123
!zip -r mm_spam_savedmodel.zip /mm_spam_savedmodel/

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

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

ดูข้อมูลเพิ่มเติม