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

1. ข้อควรทราบก่อนที่จะเริ่มต้น

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

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

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

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

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

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

  • เข้าถึง Colab

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

  • เปิด 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 ซึ่งเป็นข้อกําหนดในการใช้เครื่องมือสร้างโมเดลหรือไม่

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)

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

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

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

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

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

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

โค้ดของแอปมีดังนี้

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

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

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

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

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

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