วัตถุประสงค์ของบทความนี้คือการช่วยให้ผู้อ่านเข้าใจวิธีใช้ประโยชน์จากการฝังคำและการเรียนรู้เชิงลึกเมื่อสร้างตัวแยกประเภทข้อความ
นอกจากนี้ ส่วนต่างๆ ของการสร้างแบบจำลองข้อความที่มักถูกมองข้าม เช่น การฝังคำคืออะไร เลเยอร์การฝังคืออะไร หรืออินพุตสำหรับโมเดลการเรียนรู้เชิงลึกคืออะไร จะกล่าวถึงที่นี่
ในที่สุด การแสดงแนวคิดทั้งหมดจะถูกนำไปปฏิบัติในชุดข้อมูลที่เผยแพร่จาก Twitter ว่าทวีตเกี่ยวข้องกับภัยพิบัติทางธรรมชาติหรือไม่
เทคโนโลยีหลักที่ใช้ในบทความนี้คือ Python และ Keras API
ไปป์ไลน์การจัดหมวดหมู่ข้อความที่ทำงานเต็มรูปแบบพร้อมชุดข้อมูลจาก Twitter สามารถพบได้ที่นี่: https://github.com/Eligijus112/twitter-genuine-twitters
ไฟล์ Word embeddings ที่ใช้ในบทความนี้มีอยู่ที่นี่: https://nlp.stanford.edu/projects/glove/
ไปป์ไลน์สำหรับการสร้างแบบจำลองการเรียนรู้เชิงลึกโดยใช้ข้อความที่มีป้ายกำกับมีดังนี้:
- แบ่งข้อมูลออกเป็นข้อความ (X) และป้ายกำกับ (Y)
- ประมวลผลล่วงหน้า X
- สร้างเมทริกซ์การฝังคำจาก X
- สร้างอินพุตเทนเซอร์จาก X
- ฝึกโมเดลการเรียนรู้เชิงลึกโดยใช้อินพุตและป้ายกำกับเทนเซอร์ (Y)
- คาดการณ์ข้อมูลใหม่
ในบทความนี้ ฉันจะอธิบายแต่ละขั้นตอนเหล่านี้ ส่วนแรกของบทความจะทำงานร่วมกับชุดข้อมูลตัวอย่างเล็กๆ ที่จะครอบคลุมแนวคิดทั้งหมด ส่วนที่สองของบทความจะนำแนวคิดทั้งหมดไปใช้เป็นตัวอย่างในชีวิตจริงว่าทวีตเกี่ยวข้องกับภัยพิบัติทางธรรมชาติหรือไม่
โครงสร้างหลักของโมเดลการเรียนรู้เชิงลึกที่ใช้ข้อความในการคาดเดาคือการฝังคำ
จากวิกิ:การฝังคำ เป็นชื่อรวมของชุดเทคนิค "การสร้างแบบจำลองภาษา" และ "การเรียนรู้คุณลักษณะ" ใน "การประมวลผลภาษาธรรมชาติ" (NLP) โดยที่ คำหรือวลีจากคำศัพท์ แมปกับเวกเตอร์ของจำนวนจริง ตัวอย่างเช่น
“พ่อ” = [0.1548, 0.4848, 1.864]
“แม่” = [0.8785, 0.8974, 2.794]
กล่าวโดยสรุป การฝังคำเป็นเวกเตอร์ตัวเลขที่แสดงถึงสตริง
ในทางปฏิบัติ การแสดงคำเป็นเวกเตอร์ 100, 200 หรือ 300 มิติ และคำเหล่านี้ได้รับการฝึกฝนกับข้อความที่มีขนาดใหญ่มาก
คุณลักษณะที่สำคัญอย่างหนึ่งของการฝังคำคือคำที่คล้ายกันในความหมายทางความหมายมีระยะห่างระหว่างคำเหล่านั้น (ทั้งแบบยุคลิด โคไซน์ หรืออื่นๆ) น้อยกว่าคำที่ไม่มีความสัมพันธ์ทางความหมาย ตัวอย่างเช่น คำอย่าง "แม่" และ "พ่อ" ควรใกล้เคียงกันในทางคณิตศาสตร์มากกว่าคำว่า "แม่" และ "ซอสมะเขือเทศ" หรือ "พ่อ" และ "เนย"
คุณลักษณะที่สำคัญประการที่สองของการฝังคำคือ เมื่อสร้างเมทริกซ์อินพุตสำหรับโมเดล ไม่ว่าเราจะมีคำที่ไม่ซ้ำกันกี่คำในคลังข้อความ เราก็จะมีคอลัมน์ในเมทริกซ์อินพุตเท่ากัน นี่เป็นชัยชนะครั้งใหญ่เมื่อเปรียบเทียบกับเทคนิคการเข้ารหัสแบบร้อนแรง โดยที่จำนวนคอลัมน์มักจะเท่ากับจำนวนคำที่ไม่ซ้ำกันในเอกสาร จำนวนนี้สามารถเป็นแสนหรือเป็นล้านก็ได้ การจัดการกับเมทริกซ์อินพุตที่กว้างมากนั้นเป็นความต้องการในการคำนวณอย่างมาก
ตัวอย่างเช่น,
ลองนึกภาพประโยค: คลาร์กชอบเดินเล่นในสวนสาธารณะ
มี 7 คำที่ไม่ซ้ำที่นี่ การใช้เวกเตอร์เข้ารหัสร้อนตัวเดียว เราจะแสดงแต่ละคำโดย:
Clark = [1, 0, 0, 0, 0, 0, 0] likes = [0, 1, 0, 0, 0, 0, 0] to = [0, 0, 1, 0, 0, 0, 0] walk = [0, 0, 0, 1, 0, 0, 0] in = [0, 0, 0, 0, 1, 0, 0] the = [0, 0, 0, 0, 0, 1, 0] park = [0, 0, 0, 0, 0, 0, 1]
ในขณะที่หากใช้การฝังคำแบบ 2 มิติ เราจะจัดการกับเวกเตอร์ของ:
Clark = [0.13, 0.61] likes = [0.23, 0.66] to = [0.55, 0.11] walk = [0.03, 0.01] in = [0.15, 0.69] the = [0.99, 0.00] park = [0.98, 0.12]
ทีนี้ลองจินตนาการว่ามีประโยค n ประโยค เวกเตอร์ในกรณีที่เข้ารหัสแบบร้อนแรงจะเพิ่มขึ้นแบบทวีคูณ ในขณะที่เวกเตอร์ที่ฝังอยู่ของคำจะมีขนาดเท่าเดิม ด้วยเหตุนี้เมื่อทำงานกับข้อความจำนวนมาก การฝังคำจึงถูกนำมาใช้แทนคำ ประโยค หรือทั้งเอกสาร
การฝังคำถูกสร้างขึ้นโดยใช้โครงข่ายประสาทเทียมที่มีเลเยอร์อินพุตหนึ่งเลเยอร์ เลเยอร์ที่ซ่อนอยู่หนึ่งเลเยอร์ และเลเยอร์เอาต์พุตหนึ่งเลเยอร์
หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการสร้างการฝังคำ โปรดไปที่บทความ:
เพื่อให้คอมพิวเตอร์พิจารณาว่าข้อความใด 'ดี' และข้อความใด 'ไม่ดี' เราจำเป็นต้องติดป้ายกำกับไว้ อาจมีคลาสกี่คลาสก็ได้ และคลาสเองก็อาจหมายถึงสิ่งต่างๆ ที่หลากหลายมาก ให้เราสร้างข้อความบางส่วน:
d = [
('This article is awesome', 1),
('There are just too much words here', 0),
('The math is actually wrong here', 0),
('I really enjoy learning new stuff', 1),
('I am kinda lazy so I just skim these texts', 0),
('Who cares about AI?', 0),
('I will surely be a better person after reading this!', 1),
('The author is pretty cute :)', 1)
]
เรามี 8 สิ่งอันดับ โดยพิกัดแรกคือข้อความ และพิกัดที่สองคือป้ายกำกับ ป้ายกำกับ 0 หมายถึงความรู้สึกเชิงลบ และป้ายกำกับ 1 หมายถึงความรู้สึกเชิงบวก ในการสร้างโมเดลการทำงาน เราจำเป็นต้องมีข้อมูลมากขึ้น (ในทางปฏิบัติของฉัน จุดข้อมูลที่ติดป้ายกำกับนับพันจุดขึ้นไปจะเริ่มให้ผลลัพธ์ที่ดีหากมีเพียงสองคลาสและคลาสมีความสมดุล)
ให้เราทำการประมวลผลข้อความคลาสสิกล่วงหน้า:
X_train = [x[0] for x in d] # Text Y_train = [y[1] for y in d] # Label X_train = [clean_text(x) for x in X_train]
ข้อความที่สะอาด (X_train):
'this article is awesome' 'there are just too much words here' 'the math is actually wrong here' 'i really enjoy learning new stuff' 'i am kinda lazy so i just skim these texts' 'who cares about ai' 'i will surely be a better person after reading this' 'the author is pretty cute'
ป้ายกำกับ (Y_train):
[1, 0, 0, 1, 0, 0, 1, 1]
ตอนนี้เรามีข้อความที่ประมวลผลล่วงหน้าในเมทริกซ์ X_train และเมทริกซ์คลาส Y_train แล้ว เราจำเป็นต้องสร้างอินพุตสำหรับโครงข่ายประสาทเทียม
การป้อนข้อมูลของโมเดลการเรียนรู้เชิงลึกด้วยเลเยอร์การฝังจะใช้เมทริกซ์การฝัง เมทริกซ์การฝังคือเมทริกซ์ที่มีขนาดแถวเท่ากับจำนวนคำที่ไม่ซ้ำกันในเอกสาร และมีขนาดคอลัมน์เป็นมิติเวกเตอร์ที่ฝัง ดังนั้น ในการสร้างเมทริกซ์การฝัง เราจำเป็นต้องสร้างเวกเตอร์การฝังคำ หรือใช้การฝังคำที่ได้รับการฝึกไว้ล่วงหน้า ในตัวอย่างนี้ เราจะอ่านไฟล์การฝังคำสมมติและสร้างเมทริกซ์
รูปแบบปกติในการจัดเก็บคำที่ฝังอยู่ในเอกสารข้อความ
ให้เราเรียกไฟล์ฝังข้างต้นว่า mini_embedding.txt สำหรับการใช้งานคัดลอก-วางอย่างรวดเร็ว:
beautiful 1.5804182 0.25605154 boy -0.4558624 -1.5827272 can 0.9358587 -0.68037164 children -0.51683635 1.4153042 daughter 1.1436981 0.66987246 family -0.33289963 0.9955545
ในตัวอย่างนี้ มิติข้อมูลการฝังมีค่าเท่ากับ 2 แต่ในคำว่า embeddings จากลิงก์ https://nlp.stanford.edu/projects/glove/ มิติข้อมูลคือ 300 ไม่ว่าในกรณีใด tเขา โครงสร้าง คือ คำนั้นเป็นองค์ประกอบแรก ตามด้วยค่าสัมประสิทธิ์ที่คั่นด้วยช่องว่างสีขาว พิกัดจะสิ้นสุดเมื่อมีตัวคั่นบรรทัดใหม่ที่ท้ายบรรทัด
หากต้องการอ่านเอกสาร txt ให้เราสร้างคลาส:
สมมติว่าคุณมีไฟล์ที่ฝังอยู่ในโฟลเดอร์ การฝัง
embedding = Embeddings( 'embeddings/mini_embedding.txt', vector_dimension=2 ) embedding_matrix = embedding.create_embedding_matrix()
เรายังไม่ได้สแกนเอกสารใดๆ ดังนั้นเมทริกซ์การฝังจึงส่งคืนคำทั้งหมดที่อยู่ในไฟล์ mini_embeddings.txt:
array([[ 1.58041823, 0.25605154],
[-0.4558624 , -1.58272719],
[ 0.93585873, -0.68037164],
[-0.51683635, 1.41530418],
[ 1.1436981 , 0.66987246],
[-0.33289963, 0.99555451]])
เมทริกซ์การฝังจะมีจำนวนคอลัมน์เท่ากับจำนวนมิติที่ฝังเสมอ และจำนวนแถวจะเท่ากับจำนวนคำที่ไม่ซ้ำในเอกสารหรือจำนวนแถวที่ผู้ใช้กำหนด
เว้นแต่คุณจะมี RAM จำนวนมากในเครื่องของคุณ โดยทั่วไปขอแนะนำให้สร้างเมทริกซ์การฝังโดยใช้คำที่ไม่ซ้ำกันทั้งหมดในเอกสารการฝึกอบรมที่คุณใช้สร้างเมทริกซ์การฝังให้สูงสุด ในไฟล์ฝัง GloVe มีคำนับล้านคำ ส่วนใหญ่ไม่ปรากฏแม้แต่ครั้งเดียวในเอกสารข้อความส่วนใหญ่ ดังนั้นจึงไม่แนะนำให้สร้างเมทริกซ์การฝังด้วยคำเฉพาะทั้งหมดจากไฟล์การฝังขนาดใหญ่
การฝังคำที่ฝึกไว้ล่วงหน้าในโมเดลการเรียนรู้เชิงลึกจะใส่ไว้ในเมทริกซ์และใช้ในเลเยอร์อินพุต เป็นน้ำหนัก จากเอกสาร Keras API https://keras.io/layers/embeddings/:
keras.layers.Embedding(input_dim, output_dim,...) Turns positive integers (indexes) into dense vectors of fixed size. eg. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]] This layer can only be used as the first layer in a deep learning model.
อาร์กิวเมนต์อินพุตหลักสองตัวคือ input_dim และ output_dim
input_dim เท่ากับจำนวนคำที่ไม่ซ้ำกันทั้งหมดในข้อความของเรา (หรือจำนวนคำที่ไม่ซ้ำกันซึ่งผู้ใช้กำหนด)
output_dim เท่ากับขนาดเวกเตอร์ที่ฝัง
ในการสร้างพจนานุกรมคำที่ไม่ซ้ำใคร เราจะใช้เมธอด Tokenizer() จากไลบรารี Keras
from keras.preprocessing.text import Tokenizer tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train)
เพื่อเป็นการเตือนความจำ X_train ที่ประมวลผลล่วงหน้าของเราคือ:
'this article is awesome' 'there are just too much words here' 'the math is actually wrong here' 'i really enjoy learning new stuff' 'i am kinda lazy so i just skim these texts' 'who cares about ai' 'i will surely be a better person after reading this' 'the author is pretty cute'
วิธีการ Tokenizer() สร้างพจนานุกรมภายในของคำที่ไม่ซ้ำใครและกำหนดจำนวนเต็มให้กับทุกคำ ผลลัพธ์ของ tokenizer.word_index:
{'i': 1,
'is': 2,
'this': 3,
'just': 4,
'here': 5,
'the': 6,
'article': 7,
'awesome': 8,
'there': 9,
'are': 10,
'too': 11,
'much': 12,
'words': 13,
'math': 14,
'actually': 15,
'wrong': 16,
'really': 17,
'enjoy': 18,
'learning': 19,
'new': 20,
'stuff': 21,
'am': 22,
'kinda': 23,
'lazy': 24,
'so': 25,
'skim': 26,
'these': 27,
'texts': 28,
'who': 29,
'cares': 30,
'about': 31,
'ai': 32,
'will': 33,
'surely': 34,
'be': 35,
'a': 36,
'better': 37,
'person': 38,
'after': 39,
'reading': 40,
'author': 41,
'pretty': 42,
'cute': 43}
มีคำศัพท์ที่ไม่ซ้ำกัน 43 คำในข้อความ X_train ของเรา ให้เราแปลงข้อความเป็นรายการที่จัดทำดัชนี:
tokenizer.texts_to_sequences(X_train) [[3, 7, 2, 8], [9, 10, 4, 11, 12, 13, 5], [6, 14, 2, 15, 16, 5], [1, 17, 18, 19, 20, 21], [1, 22, 23, 24, 25, 1, 4, 26, 27, 28], [29, 30, 31, 32], [1, 33, 34, 35, 36, 37, 38, 39, 40, 3], [6, 41, 2, 42, 43]]
ประโยคแรกในเมทริกซ์ X_train ของเรา "บทความนี้ยอดเยี่ยมมาก" จะถูกแปลงเป็นรายการ [3, 7, 2, 8] ดัชนีเหล่านี้แสดงถึงค่าคีย์ในพจนานุกรมที่สร้างโทเค็น:
{...
'is': 2,
'this': 3,
...
'article': 7,
'awesome': 8,
...}
เมธอด text_to_sequence() ให้รายการรายการที่แต่ละรายการมีขนาดต่างกันและไม่มีโครงสร้าง โมเดลแมชชีนเลิร์นนิงใดๆ ก็ตามจำเป็นต้องทราบจำนวนมิติคุณลักษณะ และจำนวนนั้นจะต้องเท่ากันทั้งสำหรับการฝึกและการคาดการณ์ในการสังเกตการณ์ใหม่ ในการแปลงลำดับให้เป็นเมทริกซ์ที่มีโครงสร้างอย่างดีสำหรับการฝึกการเรียนรู้เชิงลึก เราจะใช้เมธอด pad_sequances() จาก Keras:
import numpy as np from keras.preprocessing.sequence import pad_sequences # Getting the biggest sentence max_len = np.max([len(text.split()) for text in X_train]) # Creating the padded matrices X_train_NN = tokenizer.texts_to_sequences(X_train) X_train_NN = pad_sequences(string_list, maxlen=max_len)
วัตถุ X_train_NN ดูเหมือนว่า:
array([[ 0, 0, 0, 0, 0, 0, 3, 7, 2, 8],
[ 0, 0, 0, 9, 10, 4, 11, 12, 13, 5],
[ 0, 0, 0, 0, 6, 14, 2, 15, 16, 5],
[ 0, 0, 0, 0, 1, 17, 18, 19, 20, 21],
[ 1, 22, 23, 24, 25, 1, 4, 26, 27, 28],
[ 0, 0, 0, 0, 0, 0, 29, 30, 31, 32],
[ 1, 33, 34, 35, 36, 37, 38, 39, 40, 3],
[ 0, 0, 0, 0, 0, 6, 41, 2, 42, 43]])
จำนวนแถวเท่ากับจำนวนองค์ประกอบ X_train และจำนวนคอลัมน์เท่ากับประโยคที่ยาวที่สุด (ซึ่งเท่ากับ 10 คำ) โดยปกติแล้วจำนวนคอลัมน์จะถูกกำหนดโดยผู้ใช้ก่อนที่จะอ่านเอกสารด้วยซ้ำ เนื่องจากเมื่อทำงานกับข้อความที่มีป้ายกำกับในชีวิตจริง ข้อความที่ยาวที่สุดอาจยาวมากได้ (หลายพันคำ) และอาจนำไปสู่ปัญหากับหน่วยความจำคอมพิวเตอร์เมื่อฝึกโครงข่ายประสาทเทียม
หากต้องการสร้างอินพุตที่เป็นระเบียบเรียบร้อยสำหรับโครงข่ายประสาทเทียมโดยใช้ข้อความที่ประมวลผลล่วงหน้า ฉันใช้คลาส TextToTensor ที่กำหนดไว้:
เทนเซอร์คือคอนเทนเนอร์ที่สามารถจัดเก็บข้อมูลในขนาด N เวกเตอร์สามารถเก็บข้อมูลไว้ใน 1 มิติ เมทริกซ์สามารถเก็บข้อมูลไว้ใน 2 มิติ และเทนเซอร์สามารถเก็บข้อมูลไว้ใน N ได้ ข้อมูลเพิ่มเติมเกี่ยวกับเทนเซอร์:
https://www.kdnuggets.com/2018/05/wtf-tensor.html
การใช้งาน TextToTensor เต็มรูปแบบ:
# Tokenizing the text tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) # Getting the longest sentence max_len = np.max([len(text.split()) for text in X_train]) # Converting to tensor TextToTensor_instance = TextToTensor( tokenizer=tokenizer, max_len=max_len ) X_train_NN = TextToTensor_instance.string_to_tensor(X_train)
ตอนนี้เราสามารถสร้างเทนเซอร์จากข้อความได้แล้ว เราสามารถเริ่มใช้เลเยอร์ การฝัง จาก Keras API ได้
from keras.models import Sequential from keras.layers import Embedding model = Sequential() model.add(Embedding( input_dim=44, output_dim=3, input_length=max_len)) model.compile('rmsprop', 'mse') output_array = model.predict(X_train_NN)[0]
โปรดสังเกตว่าในเลเยอร์การฝัง input_dim เท่ากับ 44 แต่ข้อความของเรามีคำที่ไม่ซ้ำกันเพียง 43 คำ นี่เป็นเพราะคำจำกัดความการฝังใน Keras API:
input_dim: int › 0. ขนาดของคำศัพท์ เช่น ดัชนีจำนวนเต็มสูงสุด + 1
output_array ดูเหมือนว่า:
array([[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[ 0.04183744, -0.00413301, 0.04792741],
[-0.00870543, -0.00829206, 0.02079277],
[ 0.02819189, -0.04957005, 0.03384084],
[ 0.0394035 , -0.02159669, 0.01720046]], dtype=float32)
ลำดับอินพุตคือ (องค์ประกอบแรกของ X_train_NN):
array([0, 0, 0, 0, 0, 0, 3, 7, 2, 8])
เลเยอร์การฝังจะกำหนดจำนวนเต็มให้กับเวกเตอร์ขนาด output_dim ซึ่งในกรณีของเราเท่ากับ 3 เราไม่สามารถควบคุมการคำนวณภายในนั้นได้ และเวกเตอร์ที่กำหนดให้กับดัชนีจำนวนเต็มแต่ละตัวไม่มีคุณสมบัติที่ คำที่เกี่ยวข้องอย่างใกล้ชิดในความหมายเชิงความหมายจะมีระยะห่างระหว่างคำเหล่านั้นน้อยกว่าคำที่มีความหมายเชิงความหมายต่างกัน
เพื่อแก้ไขปัญหานี้ เราจะใช้การฝังคำที่ได้รับการฝึกอบรมล่วงหน้าจากแผนก NLP ของ Stanfords (https://nlp.stanford.edu/projects/glove/) ในการสร้างเมทริกซ์การฝังเราจะใช้วิธีการที่กำหนดไว้ก่อนหน้านี้
สมมติว่า X_train เป็นรายการข้อความที่ประมวลผลล่วงหน้าอีกครั้ง
embed_path = 'embeddings\\glove.840B.300d.txt' embed_dim = 300 # Tokenizing the text tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) # Creating the embedding matrix embedding = Embeddings(embed_path, embed_dim) embedding_matrix = embedding.create_embedding_matrix(tokenizer, len(tokenizer.word_counts))
แม้ว่าเอกสาร glove.840B.300d.txtมีคำที่ไม่ซ้ำกันหลายแสนคำ รูปร่างสุดท้ายของเมทริกซ์ที่ฝังคือ (44, 300) เนื่องจากเราต้องการบันทึกหน่วยความจำให้ได้มากที่สุด และจำนวนคำที่ไม่ซ้ำในเอกสารทั้งหมดของเราเท่ากับ 44 การบันทึกพิกัดของคำอื่นๆ ทั้งหมดจากเอกสาร txt จะเป็นการเปล่าประโยชน์เพราะเราจะไม่นำไปใช้ที่อื่น
หากต้องการใช้เมทริกซ์การฝังในโมเดลการเรียนรู้เชิงลึก เราจำเป็นต้องส่งเมทริกซ์นั้นเป็นพารามิเตอร์ น้ำหนัก ในเลเยอร์การฝัง
from keras.models import Sequential from keras.layers import Embedding# Converting to tensor TextToTensor_instance = TextToTensor( tokenizer=tokenizer, max_len=max_len ) X_train_NN = TextToTensor_instance.string_to_tensor(X_train)model = Sequential() model.add(Embedding( input_dim=44, output_dim=300, input_length=max_len, weights=[embedding_matrix])) model.compile('rmsprop', 'mse') output_array = model.predict(X_train_NN)[0]
ตอนนี้รูปร่างของ output_array คือ (10, 300) และผลลัพธ์จะมีลักษณะดังนี้:
array([[ 0.18733 , 0.40595 , -0.51174 , ..., 0.16495 , 0.18757 ,
0.53874 ],
[ 0.18733 , 0.40595 , -0.51174 , ..., 0.16495 , 0.18757 ,
0.53874 ],
[ 0.18733 , 0.40595 , -0.51174 , ..., 0.16495 , 0.18757 ,
0.53874 ],
...,
[-0.34338 , 0.1677 , -0.1448 , ..., 0.095014, -0.073342,
0.47798 ],
[-0.087595, 0.35502 , 0.063868, ..., 0.03446 , -0.15027 ,
0.40673 ],
[ 0.16718 , 0.30593 , -0.13682 , ..., -0.035268, 0.1281 ,
0.023683]], dtype=float32)
จนถึงจุดนี้เราได้กล่าวถึง:
- การฝังคำคืออะไร
- การสร้างเทนเซอร์จากข้อความ
- การสร้างเมทริกซ์การฝังคำ
- เลเยอร์ Keras Embedded คืออะไร
- วิธีใช้ประโยชน์จากเมทริกซ์การฝัง
ตอนนี้ให้เรารวบรวมทุกอย่างเข้าด้วยกันและจัดการกับปัญหาในชีวิตจริงโดยพิจารณาว่าทวีตจาก Twitter เป็นเรื่องเกี่ยวกับภัยพิบัติทางธรรมชาติหรือไม่
# Importing generic python packages
import pandas as pd
# Reading the data
train = pd.read_csv('data/train.csv')[['text', 'target']]
test = pd.read_csv('data/test.csv')
# Creating the input for the pipeline
X_train = train['text'].tolist()
Y_train = train['target'].tolist()
X_test = test['text'].tolist()
รูปร่างของข้อมูลรถไฟคือ (7613, 2)ซึ่งหมายความว่ามีทวีต7613 ที่จะใช้งานได้ ให้เราตรวจสอบการกระจายของทวีต:
train.groupby(['target'], as_index=False).count()
ดังที่เราเห็น คลาสต่างๆ อย่างน้อยก็สำหรับกรณีข้อมูลในโลกแห่งความเป็นจริงนั้นมีความสมดุล
ตัวอย่างทวีต “ดี”:
[ 'Our Deeds are the Reason of this #earthquake May ALLAH Forgive us all', 'Forest fire near La Ronge Sask. Canada', "All residents asked to 'shelter in place' are being notified by officers. No other evacuation or shelter in place orders are expected", '13,000 people receive #wildfires evacuation orders in California ', 'Just got sent this photo from Ruby #Alaska as smoke from #wildfires pours into a school' ]
ตัวอย่างทวีตที่ไม่ดี:
[ "What's up man?", 'I love fruits', 'Summer is lovely', 'My car is so fast', 'What a goooooooaaaaaal!!!!!!' ]
ให้เราประมวลผลข้อความล่วงหน้าและดูคำยอดนิยม:
# Counting the number of words
from collections import Counter
# Plotting functions
import matplotlib.pyplot as plt
X_train = [clean_text(text) for text in X_train]
Y_train = np.asarray(Y_train)
# Tokenizing the text
tokenizer = Tokenizer()
tokenizer.fit_on_texts(X_train)
# Getting the most frequent words
d1 = train.loc[train['target']==1, 'text'].tolist()
d0 = train.loc[train['target']==0, 'text'].tolist()
d1 = [clean_text(x, stop_words=stop_words) for x in d1]
d0 = [clean_text(x, stop_words=stop_words) for x in d0]
d1_text = ' '.join(d1).split()
d0_text = ' '.join(d0).split()
topd1 = Counter(d1_text)
topd0 = Counter(d0_text)
topd1 = topd1.most_common(20)
topd0 = topd0.most_common(20)
plt.bar(range(len(topd1)), [val[1] for val in topd1], align='center')
plt.xticks(range(len(topd1)), [val[0] for val in topd1])
plt.xticks(rotation=70)
plt.title('Disaster tweets')
plt.show()
plt.bar(range(len(topd0)), [val[1] for val in topd0], align='center')
plt.xticks(range(len(topd0)), [val[0] for val in topd0])
plt.xticks(rotation=70)
plt.title('Not disaster tweets')
plt.show()
คำที่ไม่เกิดภัยพิบัตินั้นกว้างกว่าคำว่าภัยพิบัติ เราอาจคาดหวังว่าการฝัง GloVe และโมเดลการเรียนรู้เชิงลึกจะสามารถจับความแตกต่างเหล่านี้ได้
การกระจายจำนวนคำในแต่ละทวีต:
จากการกระจายข้างต้น เราสามารถพูดได้ว่าการสร้างเทนเซอร์อินพุตที่มีขนาดคอลัมน์ 20 จะยกเว้นคำในทวีตเพียงเล็กน้อยเท่านั้น ในด้านมือโปร เราจะชนะเวลาคำนวณได้มาก
สถาปัตยกรรมโมเดลการเรียนรู้เชิงลึกมีดังต่อไปนี้:
ไปป์ไลน์ที่สรุปทุกอย่างที่กล่าวถึงในบทความนี้ยังถูกกำหนดให้เป็นคลาสใน python:
สามารถดูโค้ดทั้งหมดและไปป์ไลน์การทำงานทั้งหมดได้ที่นี่:
หากต้องการฝึกโมเดลให้ใช้รหัส:
results = Pipeline( X_train=X_train, Y_train=Y_train, embed_path='embeddings\\glove.840B.300d.txt', embed_dim=300, stop_words=stop_words, X_test=X_test, max_len=20, epochs=10, batch_size=256 )
ตอนนี้ให้เราสร้างข้อความสองข้อความ:
ดี = [“ไฟในวิลนีอุส! รถดับเพลิงอยู่ไหน??? #ภาวะฉุกเฉิน"]
แย่= [“ซูชิหรือพิซซ่า? ชีวิตลำบาก :(("]
TextToTensor_instance = TextToTensor( tokenizer=results.tokenizer, max_len=20 ) # Converting to tensors good_nn = TextToTensor_instance.string_to_tensor(good) bad_nn = TextToTensor_instance.string_to_tensor(bad) # Forecasting p_good = results.model.predict(good_nn)[0][0] p_bad = results.model.predict(bad_nn)[0][0]
p_bad = 0.014 และ p_good = 0.963 ความน่าจะเป็นเหล่านี้มาจากคำถามว่าทวีตเกี่ยวข้องกับภัยพิบัติหรือไม่ ดังนั้นทวีตเกี่ยวกับซูชิจึงมีคะแนนต่ำมาก และทวีตเกี่ยวกับไฟก็มีคะแนนสูง ซึ่งหมายความว่าตรรกะที่นำเสนอในบทความนี้ใช้ได้กับประโยคที่แต่งขึ้นเป็นอย่างน้อย
