การฝังคำและโมเดล Word2Vec พร้อมตัวอย่าง

การฝัง Word คืออะไร?

การฝังคำ เป็นประเภทการแสดงคำที่ช่วยให้อัลกอริทึมการเรียนรู้ของเครื่องสามารถเข้าใจคำที่มีความหมายคล้ายกัน เป็นการสร้างแบบจำลองภาษาและเทคนิคการเรียนรู้คุณลักษณะเพื่อจับคู่คำเป็นเวกเตอร์ของจำนวนจริงโดยใช้เครือข่ายประสาท โมเดลความน่าจะเป็น หรือการลดมิติบนเมทริกซ์การเกิดขึ้นพร้อมกันของคำ โมเดลการฝังคำบางประเภท ได้แก่ Word2vec (Google), Glove (Stanford) และเร็วที่สุด (Facebook)

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

การฝัง Word ใช้ที่ไหน?

การฝังคำช่วยในการสร้างคุณลักษณะ การจัดกลุ่มเอกสาร การจำแนกข้อความ และงานการประมวลผลภาษาธรรมชาติ มาทำรายการและหารือเกี่ยวกับแอปพลิเคชันเหล่านี้กัน

• คำนวณคำที่คล้ายกัน: การฝังคำใช้เพื่อแนะนำคำที่คล้ายกับคำที่อยู่ภายใต้แบบจำลองการทำนาย นอกจากนั้นยังแนะนำคำที่แตกต่างกัน รวมถึงคำที่พบบ่อยที่สุดอีกด้วย
• สร้างกลุ่มคำที่เกี่ยวข้อง: ใช้สำหรับการจัดกลุ่มความหมายซึ่งจะจัดกลุ่มสิ่งที่มีลักษณะคล้ายคลึงกันไว้ด้วยกันและต่างกันออกไป
• คุณสมบัติสำหรับการจำแนกข้อความ: ข้อความถูกแมปเป็นอาร์เรย์ของเวกเตอร์ซึ่งป้อนให้กับโมเดลเพื่อการฝึกและการทำนาย โมเดลตัวแยกประเภทตามข้อความไม่สามารถฝึกบนสตริงได้ ดังนั้นสิ่งนี้จะแปลงข้อความเป็นรูปแบบที่ฝึกด้วยเครื่องได้ เพิ่มเติมคุณสมบัติของการสร้างความช่วยเหลือเชิงความหมายในการจำแนกตามข้อความ
• การจัดกลุ่มเอกสาร: เป็นอีกแอปพลิเคชั่นหนึ่งที่ Word Embedding Word2vec ถูกใช้กันอย่างแพร่หลาย
• การประมวลผลภาษาธรรมชาติ: มีแอปพลิเคชันจำนวนมากที่การฝังคำมีประโยชน์และเอาชนะขั้นตอนการแยกคุณลักษณะ เช่น ส่วนของแท็กคำพูด การวิเคราะห์ความรู้สึก และการวิเคราะห์วากยสัมพันธ์ ตอนนี้เรามีความรู้เกี่ยวกับการฝังคำแล้ว แสงบางส่วนยังถูกฉายไปยังโมเดลต่างๆ เพื่อใช้งานการฝังคำ บทช่วยสอนการฝังคำทั้งหมดนี้มุ่งเน้นไปที่หนึ่งในโมเดล (Word2vec)

Word2vec คืออะไร?

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

ก่อนที่จะไปเพิ่มเติมในบทช่วยสอน Word2vec นี้ โปรดดูความแตกต่างระหว่างโครงข่ายประสาทเทียมแบบตื้นและแบบลึกดังที่แสดงในแผนภาพตัวอย่างการฝัง Word ด้านล่าง:

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

Word2vec เป็นเครือข่ายสองชั้นซึ่งมีอินพุตและเอาต์พุตที่ซ่อนอยู่หนึ่งเลเยอร์

Word2vec ได้รับการพัฒนาโดยกลุ่มนักวิจัยที่นำโดย Tomas Mikolov จาก Google Word2vec ดีกว่าและมีประสิทธิภาพมากกว่าโมเดลการวิเคราะห์ความหมายแฝง

ทำไมต้อง Word2vec?

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

Word2vec สร้างบริบททางภาษาของคำขึ้นมาใหม่ ก่อนจะไปไกลกว่านี้ เรามาทำความเข้าใจก่อนว่าบริบททางภาษาคืออะไร? ในสถานการณ์ชีวิตทั่วไป เมื่อเราพูดหรือเขียนเพื่อสื่อสาร คนอื่นจะพยายามเข้าใจว่าอะไรคือวัตถุประสงค์ของประโยค ตัวอย่างเช่น “อุณหภูมิของอินเดียคืออะไร” ในที่นี้บริบทคือผู้ใช้ต้องการทราบ “อุณหภูมิของอินเดีย” ซึ่งเป็นบริบท กล่าวโดยสรุป วัตถุประสงค์หลักของประโยคคือบริบท คำหรือประโยคที่อยู่รอบภาษาพูดหรือภาษาเขียน (การเปิดเผย) ช่วยในการกำหนดความหมายของบริบท Word2vec เรียนรู้การแสดงเวกเตอร์ของคำผ่านบริบท

Word2vec ทำอะไรได้บ้าง?

ก่อนที่จะฝังคำ

สิ่งสำคัญคือต้องรู้ว่าใช้แนวทางใดก่อนการฝังคำและข้อเสียของมันคืออะไร จากนั้นเราจะย้ายไปยังหัวข้อว่าการฝังคำเอาชนะการด้อยค่าโดยใช้วิธี Word2vec ได้อย่างไร สุดท้ายนี้ เราจะย้ายวิธีการทำงานของ Word2vec เนื่องจากสิ่งสำคัญคือต้องเข้าใจว่า WordXNUMXvec ทำงานอย่างไร

แนวทางการวิเคราะห์ความหมายแฝง

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

ตัวอย่าง Word2vec

from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer()
data_corpus = ["guru99 is the best site for online tutorials. I love to visit guru99."]
vocabulary = vectorizer.fit(data_corpus)
X = vectorizer.transform(data_corpus)

print(X.toarray())
print(vectorizer.get_feature_names_out())

Output:

[[1 2 1 1 1 1 1 1 1 1]]

[u'best', u'guru99', u'is', u'love', u'online', u'sitefor', u'the', u'to', u'tutorials', u'visit']

คำอธิบายรหัส

1. CountVectorizer เป็นโมดูลที่ใช้จัดเก็บคำศัพท์โดยพิจารณาจากการปรับคำศัพท์ให้เหมาะสม สิ่งนี้นำเข้าจาก sklearn
2. สร้างวัตถุโดยใช้คลาส CountVectorizer
3. เขียนข้อมูลในรายการที่จะติดตั้งใน CountVectorizer
4. ข้อมูลมีความพอดีในวัตถุที่สร้างจากคลาส CountVectorizer
5. ใช้วิธีถุงคำเพื่อนับคำในข้อมูลโดยใช้คำศัพท์ หากไม่มีคำหรือโทเค็นในคำศัพท์ ตำแหน่งดัชนีดังกล่าวจะถูกตั้งค่าเป็นศูนย์
6. ตัวแปรในบรรทัดที่ 5 ซึ่ง x จะถูกแปลงเป็นอาร์เรย์ (วิธีการที่มีให้สำหรับ x) นี่จะเป็นการนับแต่ละโทเค็นในประโยคหรือรายการที่ระบุไว้ในบรรทัดที่ 3
7. นี่จะแสดงคุณสมบัติที่เป็นส่วนหนึ่งของคำศัพท์เมื่อติดตั้งโดยใช้ข้อมูลในบรรทัดที่ 4

ในแนวทางความหมายแฝง แถวแสดงถึงคำที่ไม่ซ้ำกัน ในขณะที่คอลัมน์แสดงถึงจำนวนครั้งที่คำนั้นปรากฏในเอกสาร เป็นการแทนคำในรูปแบบของเมทริกซ์เอกสาร Term-Frequency Inverse Document Frequency (TFIDF) ใช้ในการนับความถี่ของคำในเอกสาร ซึ่งเป็นความถี่ของคำศัพท์ในเอกสาร/ความถี่ของคำศัพท์ในคลังข้อมูลทั้งหมด

ข้อบกพร่องของวิธี Bag of Words

• มันละเลยลำดับของคำ เช่น this is bad = bad is this
• โดยไม่สนใจบริบทของคำ สมมติว่าถ้าฉันเขียนประโยค “เขารักหนังสือ การศึกษาพบได้ในหนังสือดีที่สุด” มันจะสร้างเวกเตอร์สองตัวขึ้นมา ตัวหนึ่งสำหรับ “เขารักหนังสือ” และอีกตัวสำหรับ “การศึกษาพบได้ในหนังสือมากที่สุด” มันจะปฏิบัติต่อทั้งสองมุมฉากซึ่งทำให้เป็นอิสระ แต่ในความเป็นจริงแล้วพวกมันมีความสัมพันธ์ซึ่งกันและกัน

เพื่อเอาชนะข้อจำกัดเหล่านี้ การฝังคำจึงได้รับการพัฒนา และ Word2vec เป็นแนวทางในการนำไปปฏิบัติดังกล่าว

Word2vec ทำงานอย่างไร?

Word2vec เรียนรู้คำศัพท์โดยการทำนายบริบทโดยรอบ ตัวอย่างเช่น ให้เราใช้คำว่า “เขา” รัก ฟุตบอล."

เราต้องการคำนวณ Word2vec สำหรับคำว่า: ความรัก

สมมติ

loves =  Vin. P(Vout / Vin) is calculated	
where,	
Vin is the input word. 	
P is the probability of likelihood.	
Vout is the output word. 	

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

คุณสมบัติสุ่มทั้งหมดของคำ รัก ถูกคำนวณ คุณสมบัติเหล่านี้มีการเปลี่ยนแปลงหรืออัปเดตเกี่ยวกับเพื่อนบ้านหรือคำบริบทด้วยความช่วยเหลือของ การขยายพันธุ์กลับ วิธี

วิธีการเรียนรู้อีกวิธีหนึ่งคือ ถ้าบริบทของคำสองคำคล้ายกันหรือคำสองคำมีลักษณะคล้ายกัน คำนั้นก็จะมีความสัมพันธ์กัน

เวิร์ด2เวค Archiเทคเจอร์

Word2vec มีสองสถาปัตยกรรมที่ใช้:

1. ถุงคำต่อเนื่อง (CBOW)
2. ข้ามกรัม

ก่อนจะไปต่อในบทช่วยสอน Word2vec นี้ เรามาพูดถึงกันก่อนว่าทำไมสถาปัตยกรรมหรือโมเดลเหล่านี้จึงมีความสำคัญจากมุมมองของการแสดงคำ การเรียนรู้การแสดงคำนั้นโดยพื้นฐานแล้วไม่มีการดูแล แต่จำเป็นต้องมีเป้าหมาย/ป้ายกำกับเพื่อฝึกโมเดล Skip-gram และ CBOW จะแปลงการแสดงที่ไม่มีการดูแลเป็นรูปแบบที่มีการดูแลเพื่อฝึกโมเดล

ใน CBOW คำปัจจุบันจะถูกทำนายโดยใช้หน้าต่างของหน้าต่างบริบทโดยรอบ ตัวอย่างเช่น หาก w_I-1,w_I-2,w_{i + 1},w_{i + 2}ได้รับคำหรือบริบท โมเดลนี้จะจัดให้มี w_i

Skip-Gram ดำเนินการตรงกันข้ามกับ CBOW ซึ่งหมายความว่าทำนายลำดับหรือบริบทที่กำหนดจากคำนั้น คุณสามารถย้อนกลับตัวอย่างเพื่อทำความเข้าใจได้ ถ้าว_i จะได้รับ ซึ่งจะทำนายบริบทหรือw_I-1,w_I-2,w_{i + 1},w_ฉัน+2.

Word2vec มีตัวเลือกให้เลือกใช้ CBOW (Continuous Bag of words) และ skim-gram พารามิเตอร์ดังกล่าวจะแสดงระหว่างการฝึกโมเดล ผู้ใช้สามารถเลือกใช้การสุ่มแบบลบหรือเลเยอร์ซอฟต์แมกซ์แบบลำดับชั้นได้

ถุงคำพูดอย่างต่อเนื่อง

ให้เราวาดไดอะแกรมตัวอย่าง Word2vec ง่ายๆ เพื่อทำความเข้าใจโครงสร้างคำที่ต่อเนื่องกัน

ให้เราคำนวณสมการทางคณิตศาสตร์ สมมติว่า V คือขนาดคำศัพท์ และ N คือขนาดเลเยอร์ที่ซ่อนอยู่ อินพุตถูกกำหนดเป็น { x_I-1, x_ไอ-2, x_ฉัน+1, x_{i + 2}}. เราจะได้เมทริกซ์น้ำหนักจากการคูณ V * N เมทริกซ์อื่นจะได้จากการคูณเวกเตอร์อินพุตกับเมทริกซ์น้ำหนัก ซึ่งเราสามารถเข้าใจได้จากสมการต่อไปนี้

ชั่วโมง=ซี^tW

ที่ไหนซี^t- W คือเวกเตอร์อินพุตและเมทริกซ์น้ำหนักตามลำดับ

หากต้องการคำนวณการจับคู่ระหว่างบริบทกับคำถัดไป โปรดดูสมการด้านล่าง

u=การคาดการณ์การเป็นตัวแทน*h

โดยที่แบบจำลองได้รับการคาดการณ์ไว้?h ในสมการข้างต้น

โมเดล Skip-Gram

วิธีข้ามแกรมใช้เพื่อทำนายประโยคที่ได้รับคำที่ป้อนเข้าไป เพื่อให้เข้าใจได้ดีขึ้น ให้เราวาดไดอะแกรมตามที่แสดงในตัวอย่าง Word2vec ด้านล่าง

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

เลือกรุ่นไหนดี?

CBOW เร็วกว่าข้ามกรัมหลายเท่าและให้ความถี่ที่ดีกว่าสำหรับคำที่ใช้บ่อย ในขณะที่ข้ามกรัมต้องการข้อมูลการฝึกอบรมเพียงเล็กน้อยและแสดงถึงคำหรือวลีที่หายาก

ความสัมพันธ์ระหว่าง Word2vec และ NLTK

เอ็นแอลทีเค คือชุดเครื่องมือภาษาธรรมชาติ ใช้สำหรับการประมวลผลข้อความเบื้องต้น สามารถดำเนินการต่างๆ ได้ เช่น การแท็กส่วนประกอบของคำพูด การทำให้เป็นเล็มมา การแยกคำ การลบคำที่หยุด การลบคำที่หายากหรือคำที่ใช้น้อยที่สุด ช่วยในการทำความสะอาดข้อความ ตลอดจนช่วยในการเตรียมคุณลักษณะจากคำที่มีผล ในอีกทางหนึ่ง Word2vec ใช้สำหรับการจับคู่ความหมาย (รายการที่เกี่ยวข้องอย่างใกล้ชิด) และการจับคู่ทางวากยสัมพันธ์ (ลำดับ) การใช้ Word2vec คุณสามารถค้นหาคำที่คล้ายกัน คำที่ไม่เหมือนกัน การลดมิติ และอื่นๆ อีกมากมาย คุณสมบัติที่สำคัญอีกประการหนึ่งของ Word2vec คือการแปลงการแสดงข้อความที่มีมิติสูงกว่าเป็นเวกเตอร์ที่มีมิติต่ำกว่า

จะใช้ NLTK และ Word2vec ได้ที่ไหน

หากต้องทำงานตามวัตถุประสงค์ทั่วไปบางอย่างให้สำเร็จตามที่กล่าวไว้ข้างต้น เช่น โทเค็น การแท็ก POS และการแยกวิเคราะห์ ต้องใช้ NLTK ในขณะที่ทำนายคำตามบริบท การสร้างแบบจำลองหัวข้อ หรือความคล้ายคลึงกันของเอกสาร ต้องใช้ Word2vec

ความสัมพันธ์ของ NLTK และ Word2vec ด้วยความช่วยเหลือของโค้ด

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

nltk(nltk.download('all'))

โปรดดูภาพหน้าจอสำหรับรหัส

import nltk
import gensim
from nltk.corpus import abc

model= gensim.models.Word2Vec(abc.sents())
X= list(model.wv.vocab)
data=model.most_similar('science')
print(data)

Output:

[('law', 0.9415997266769409), ('practice', 0.9276568293571472), ('discussion', 0.9259148836135864), ('agriculture', 0.9257254004478455), ('media', 0.9232194423675537), ('policy', 0.922248125076294), ('general', 0.9166069030761719), ('undertaking', 0.916458249092102), ('tight', 0.9129181504249573), ('board', 0.9107444286346436)]

คำอธิบายของรหัส

1. ไลบรารี nltk ถูกนำเข้า ซึ่งคุณสามารถดาวน์โหลดคลังข้อมูล abc ซึ่งเราจะใช้ในขั้นตอนถัดไป
2. เกนซิมนำเข้ามา หากไม่ได้ติดตั้ง Gensim Word2vec โปรดติดตั้งโดยใช้คำสั่ง ” pip3 install gensim” โปรดดูภาพหน้าจอด้านล่าง

3. นำเข้าคลังข้อมูล abc ซึ่งได้รับการดาวน์โหลดโดยใช้ nltk.download('abc')
4. ส่งไฟล์ไปยังโมเดล Word2vec ซึ่งนำเข้าโดยใช้ Gensim เป็นประโยค
5. คำศัพท์จะถูกจัดเก็บไว้ในรูปแบบของตัวแปร
6. แบบจำลองได้รับการทดสอบโดยใช้คำตัวอย่างวิทยาศาสตร์ เนื่องจากไฟล์เหล่านี้เกี่ยวข้องกับวิทยาศาสตร์
7. แบบจำลองนี้ทำนายคำว่า "วิทยาศาสตร์" ที่คล้ายกัน

ตัวกระตุ้นและ Word2Vec

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

ที่นี่ x1,x2,..x4 คือโหนดของโครงข่ายประสาทเทียม

w1, w2, w3 คือน้ำหนักของโหนด

- คือผลรวมของน้ำหนักและค่าโหนดทั้งหมดซึ่งทำหน้าที่เป็นฟังก์ชันการเปิดใช้งาน

ทำไมต้องเปิดใช้งานฟังก์ชั่น?

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

วิธีคำนวณเลเยอร์การเปิดใช้งานในการฝังคำ (Word2vec)

เลเยอร์ซอฟต์แมกซ์ (ฟังก์ชันเลขชี้กำลังแบบปกติ) คือฟังก์ชันเลเยอร์เอาต์พุตที่เปิดใช้งานหรือเปิดใช้งานแต่ละโหนด อีกวิธีหนึ่งที่ใช้คือซอฟต์แมกซ์แบบลำดับชั้น โดยที่ความซับซ้อนจะคำนวณโดย O(log)₂V) โดยที่ซอฟต์แมกซ์คือ O(V) โดยที่ V คือขนาดคำศัพท์ ความแตกต่างระหว่างทั้งสองนี้คือการลดความซับซ้อนในเลเยอร์ซอฟต์แมกซ์แบบลำดับชั้น หากต้องการทำความเข้าใจฟังก์ชันการทำงาน (ซอฟต์แมกซ์แบบลำดับชั้น) โปรดดูตัวอย่างการฝัง Word ด้านล่าง:

สมมติว่าเราต้องการคำนวณความน่าจะเป็นที่จะสังเกตคำนั้น ความรัก ได้รับบริบทบางอย่าง การไหลจากรากไปยังโหนดใบจะเป็นการย้ายครั้งแรกไปยังโหนด 2 จากนั้นไปยังโหนด 5 ดังนั้นหากเรามีขนาดคำศัพท์เท่ากับ 8 ก็จำเป็นต้องใช้การคำนวณเพียงสามครั้งเท่านั้น จึงสามารถย่อยสลายการคำนวณความน่าจะเป็นของคำเดียว (ความรัก).

มีตัวเลือกอื่นใดอีกนอกจาก Hierarchical Softmax บ้าง?

หากพูดในความหมายทั่วไปสำหรับตัวเลือกการฝังคำที่มีอยู่ ได้แก่ Softmax ที่แตกต่าง, CNN-Softmax, การสุ่มตัวอย่างความสำคัญ, การสุ่มตัวอย่างความสำคัญแบบปรับตัว, การประมาณค่าความเปรียบต่างของสัญญาณรบกวน, การสุ่มตัวอย่างเชิงลบ, การทำให้เป็นมาตรฐานด้วยตนเอง และการทำให้เป็นมาตรฐานไม่บ่อยนัก

เมื่อพูดถึง Word2vec โดยเฉพาะ เรามีตัวอย่างเชิงลบให้เลือก

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

ข้อสรุปอะไรที่สามารถสรุปได้?

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

บทช่วยสอนนี้เป็นเรื่องเกี่ยวกับ Word2vec ดังนั้นเราจะยึดตามหัวข้อปัจจุบัน

วิธีการใช้งาน Word2vec โดยใช้ Gensim

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

ด้านล่างนี้เป็นวิธีการทีละขั้นตอนในการใช้งาน Word2vec โดยใช้ Gensim:

ขั้นตอนที่ 1) การรวบรวมข้อมูล

ขั้นตอนแรกในการใช้โมเดลการเรียนรู้ของเครื่องหรือการประมวลผลภาษาธรรมชาติคือการรวบรวมข้อมูล

โปรดสังเกตข้อมูลเพื่อสร้างแชทบอทอัจฉริยะดังที่แสดงในตัวอย่าง Gensim Word2vec ด้านล่าง

[{"tag": "welcome",
"patterns": ["Hi", "How are you", "Is any one to talk?", "Hello", "hi are you available"],
"responses": ["Hello, thanks for contacting us", "Good to see you here"," Hi there, how may I assist you?"]

        },
{"tag": "goodbye",
"patterns": ["Bye", "See you later", "Goodbye", "I will come back soon"],
"responses": ["See you later, thanks for visiting", "have a great day ahead", "Wish you Come back again soon."]
        },

{"tag": "thankful",
"patterns": ["Thanks for helping me", "Thank your guidance", "That's helpful and kind from you"],
"responses": ["Happy to help!", "Any time!", "My pleasure", "It is my duty to help you"]
        },
        {"tag": "hoursopening",
"patterns": ["What hours are you open?", "Tell your opening time?", "When are you open?", "Just your timing please"],
"responses": ["We're open every day 8am-7pm", "Our office hours are 8am-7pm every day", "We open office at 8 am and close at 7 pm"]
        },

{"tag": "payments",
"patterns": ["Can I pay using credit card?", " Can I pay using Mastercard?", " Can I pay using cash only?" ],
"responses": ["We accept VISA, Mastercard and credit card", "We accept credit card, debit cards and cash. Please don’t worry"]
        }
   ]

นี่คือสิ่งที่เราเข้าใจจากข้อมูล

• ข้อมูลนี้มีแท็ก รูปแบบ และการตอบกลับสามสิ่ง แท็กคือเจตนา (หัวข้อการสนทนาคืออะไร)
• ข้อมูลอยู่ในรูปแบบ JSON
• รูปแบบคือคำถามที่ผู้ใช้จะถามบอท
• Response คือคำตอบที่ Chatbot จะให้กับคำถามหรือรูปแบบที่เกี่ยวข้อง

ขั้นตอนที่ 2) การประมวลผลข้อมูลล่วงหน้า

การประมวลผลข้อมูลดิบเป็นสิ่งสำคัญมาก หากข้อมูลที่ล้างแล้วถูกป้อนเข้าเครื่อง โมเดลจะตอบสนองได้แม่นยำยิ่งขึ้น และจะเรียนรู้ข้อมูลได้อย่างมีประสิทธิภาพมากขึ้น

ขั้นตอนนี้เกี่ยวข้องกับการลบคำหยุด การกั้น คำที่ไม่จำเป็น ฯลฯ ก่อนที่จะดำเนินการต่อ สิ่งสำคัญคือต้องโหลดข้อมูลและแปลงเป็นกรอบข้อมูล โปรดดูรหัสด้านล่างสำหรับสิ่งดังกล่าว

import json
json_file =’intents.json'
with open('intents.json','r') as f:
    data = json.load(f)

คำอธิบายของรหัส:

1. เนื่องจากข้อมูลอยู่ในรูปแบบ json ดังนั้น json จึงถูกนำเข้า
2. ไฟล์ถูกเก็บไว้ในตัวแปร
3. ไฟล์ถูกเปิดและโหลดในตัวแปรข้อมูล

ขณะนี้ข้อมูลถูกนำเข้าแล้ว และถึงเวลาแปลงข้อมูลเป็นกรอบข้อมูล โปรดดูโค้ดด้านล่างเพื่อดูขั้นตอนต่อไป

import pandas as pd
df = pd.DataFrame(data)
df['patterns'] = df['patterns'].apply(', '.join) 

คำอธิบายของรหัส:

1. ข้อมูลจะถูกแปลงเป็นกรอบข้อมูลโดยใช้แพนด้าที่นำเข้าไว้ด้านบน

2. จะแปลงรายการในรูปแบบคอลัมน์เป็นสตริง

from nltk.corpus import stopwords
from textblob import Word
stop = stopwords.words('english')
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x.lower() for x in x.split()))
df['patterns't']= df['patterns''].apply(lambda x: ' '.join(x for x in x.split() if x not in string.punctuation)
df['patterns']= df['patterns'].str.replace('[^\w\s]','')
df['patterns']= df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if  not x.isdigit()))
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x for x in x.split() if not x in stop))
df['patterns'] = df['patterns'].apply(lambda x: " ".join([Word(word).lemmatize() for word in x.split()]))

คำอธิบายรหัส:

1. คำหยุดภาษาอังกฤษจะถูกนำเข้าโดยใช้โมดูลคำหยุดจากชุดเครื่องมือ nltk

2. คำทั้งหมดในข้อความจะถูกแปลงเป็นตัวพิมพ์เล็กเพื่อใช้สำหรับเงื่อนไขและฟังก์ชันแลมบ์ดา ฟังก์ชันแลมบ์ดา เป็นฟังก์ชันที่ไม่ระบุชื่อ

3. แถวทั้งหมดของข้อความในกรอบข้อมูลได้รับการตรวจสอบเครื่องหมายวรรคตอนของสตริง และตัวกรองเหล่านี้จะถูกกรอง

4. อักขระต่างๆ เช่น ตัวเลขหรือจุด จะถูกลบออกโดยใช้นิพจน์ทั่วไป

5. Digits จะถูกลบออกจากข้อความ

6. คำหยุดจะถูกลบออกในขั้นตอนนี้

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

Output:

, patterns, responses, tag
0,hi one talk hello hi available,"['Hello, thanks for contacting us', 'Good to see you here', ' Hi there, how may I assist you?']",welcome
1,bye see later goodbye come back soon,"['See you later, thanks for visiting', 'have a great day ahead', 'Wish you Come back again soon.']",goodbye
2,thanks helping thank guidance thats helpful kind,"['Happy to help!', 'Any time!', 'My pleasure', 'It is my duty to help you']",thankful
3,hour open tell opening time open timing please,"[""We're open every day 8am-7pm"", 'Our office hours are 8am-7pm every day', 'We open office at 8 am and close at 7 pm']",hoursopening
4,pay using credit card pay using mastercard pay using cash,"['We accept VISA, Mastercard and credit card', 'We accept credit card, debit cards and cash. Please don’t worry']",payments

ขั้นตอนที่ 3) การสร้างโครงข่ายประสาทเทียมโดยใช้ Word2vec

ตอนนี้ได้เวลาสร้างโมเดลโดยใช้โมดูล Gensim Word2vec แล้ว เราต้องนำเข้า Word2vec จาก Gensim ให้เราทำเช่นนี้ จากนั้นเราจะสร้าง และในขั้นตอนสุดท้าย เราจะตรวจสอบแบบจำลองด้วยข้อมูลแบบเรียลไทม์

from gensim.models import Word2Vec

ในบทช่วยสอน Gensim Word2vec นี้ เราสามารถสร้างโมเดลโดยใช้ Word2Vec ได้สำเร็จ โปรดดูโค้ดบรรทัดถัดไปเพื่อเรียนรู้วิธีการสร้างแบบจำลองโดยใช้ Word2Vec ข้อความถูกกำหนดให้กับโมเดลในรูปแบบของรายการ ดังนั้นเราจะแปลงข้อความจากกรอบข้อมูลเป็นรายการโดยใช้โค้ดด้านล่าง

Bigger_list=[]
for i in df['patterns']
     li = list(i.split(""))
     Bigger_list.append(li)	
Model= Word2Vec(Bigger_list,min_count=1,size=300,workers=4)

คำอธิบายของรหัส:

1. สร้าง big_list โดยที่รายการภายในจะถูกต่อท้าย นี่คือรูปแบบที่ป้อนให้กับโมเดล Word2Vec

2. มีการใช้การวนซ้ำ และแต่ละรายการในคอลัมน์รูปแบบของกรอบข้อมูลจะถูกวนซ้ำ

3. แต่ละองค์ประกอบของรูปแบบคอลัมน์จะถูกแยกและจัดเก็บไว้ในรายการภายใน li

4. รายการภายในจะถูกต่อท้ายด้วยรายการภายนอก

5. รายการนี้มีไว้สำหรับรุ่น Word2Vec ให้เราเข้าใจพารามิเตอร์บางตัวที่ให้ไว้ที่นี่

ขั้นต่ำ_จำนวน: มันจะไม่สนใจคำทั้งหมดที่มีความถี่รวมต่ำกว่านี้

ขนาด: มันบอกมิติของคำว่าเวกเตอร์

แรงงาน: สิ่งเหล่านี้คือหัวข้อในการฝึกโมเดล

นอกจากนี้ยังมีตัวเลือกอื่นๆ ให้เลือก และตัวเลือกที่สำคัญบางส่วนจะอธิบายไว้ด้านล่าง

หน้าต่าง: ระยะห่างสูงสุดระหว่างคำปัจจุบันและคำที่คาดเดาภายในประโยค

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

ชั่วโมง: หากเป็น 1 แสดงว่าเราใช้ซอฟต์แมกซ์แบบลำดับชั้นในการฝึกอบรม และหากเป็น 0 แสดงว่าเราใช้การสุ่มเชิงลบ

อัลฟา: อัตราการเรียนรู้เริ่มต้น

ให้เราแสดงโค้ดสุดท้ายด้านล่าง:

#list of libraries used by the code
import string
from gensim.models import Word2Vec
import logging
from nltk.corpus import stopwords
from textblob import Word
import json
import pandas as pd
#data in json format
json_file = 'intents.json'
with open('intents.json','r') as f:
    data = json.load(f)
#displaying the list of stopwords
stop = stopwords.words('english')
#dataframe
df = pd.DataFrame(data)

df['patterns'] = df['patterns'].apply(', '.join)
# print(df['patterns'])
#print(df['patterns'])
#cleaning the data using the NLP approach
print(df)
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x.lower() for x in x.split()))
df['patterns']= df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if x not in string.punctuation))
df['patterns']= df['patterns'].str.replace('[^\w\s]','')
df['patterns']= df['patterns'].apply(lambda x: ' '.join(x for x in x.split() if  not x.isdigit()))
df['patterns'] = df['patterns'].apply(lambda x:' '.join(x for x in x.split() if not x in stop))
df['patterns'] = df['patterns'].apply(lambda x: " ".join([Word(word).lemmatize() for word in x.split()]))
#taking the outer list
bigger_list=[]
for i in df['patterns']:
    li = list(i.split(" "))
    bigger_list.append(li)
#structure of data to be taken by the model.word2vec
print("Data format for the overall list:",bigger_list)
#custom data is fed to machine for further processing
model = Word2Vec(bigger_list, min_count=1,size=300,workers=4)
#print(model)

ขั้นตอนที่ 4) การบันทึกโมเดล

โมเดลสามารถบันทึกได้ในรูปแบบถังและรูปแบบโมเดล Bin เป็นรูปแบบไบนารี โปรดดูบรรทัดด้านล่างเพื่อบันทึกโมเดล

model.save("word2vec.model")
model.save("model.bin")

คำอธิบายของรหัสข้างต้น

1. โมเดลจะถูกบันทึกในรูปแบบของไฟล์ .model

2. โมเดลจะถูกบันทึกในรูปแบบไฟล์ .bin

เราจะใช้แบบจำลองนี้เพื่อทำการทดสอบแบบเรียลไทม์ เช่น คำที่คล้ายกัน คำที่แตกต่างกัน และคำที่พบบ่อยที่สุด

ขั้นตอนที่ 5) กำลังโหลดโมเดลและดำเนินการทดสอบแบบเรียลไทม์

โหลดโมเดลโดยใช้โค้ดด้านล่าง:

model = Word2Vec.load('model.bin')

หากคุณต้องการพิมพ์คำศัพท์ก็ทำได้โดยใช้คำสั่งด้านล่าง:

vocab = list(model.wv.vocab)

โปรดดูผลลัพธ์:

['see', 'thank', 'back', 'thanks', 'soon', 'open', 'mastercard', 'card', 'time', 'pay', 'talk', 'cash', 'one', 'please', 'goodbye', 'thats', 'helpful', 'hour', 'credit', 'hi', 'later', 'guidance', 'opening', 'timing', 'hello', 'helping', 'bye', 'tell', 'come', 'using', 'kind', 'available']

ขั้นตอนที่ 6) การตรวจสอบคำที่คล้ายกันมากที่สุด

ให้เรานำสิ่งต่าง ๆ ไปใช้จริง:

similar_words = model.most_similar('thanks')	
print(similar_words)	

โปรดดูผลลัพธ์:

[('kind', 0.16104359924793243), ('using', 0.1352398842573166), ('come', 0.11500970274209976), ('later', 0.09989878535270691), ('helping', 0.04855936020612717), ('credit', 0.04659383371472359), ('pay', 0.0329081267118454), ('thank', 0.02484947443008423), ('hour', 0.0202352125197649), ('opening', 0.018177658319473267)]

ขั้นตอนที่ 7) ไม่ตรงกับคำจากคำที่ให้มา

dissimlar_words = model.doesnt_match('See you later, thanks for visiting'.split())
print(dissimlar_words)

เราได้จัดหาคำ 'เจอกันใหม่ ขอบคุณที่แวะมาเยี่ยมชม' นี้จะ พิมพ์คำที่แตกต่างกันมากที่สุดจากคำเหล่านี้ ให้เรารันโค้ดนี้แล้วค้นหาผลลัพธ์

ผลลัพธ์หลังจากการรันโค้ดข้างต้น:

Thanks

ขั้นตอนที่ 8) ค้นหาความคล้ายคลึงกันระหว่างคำสองคำ

สิ่งนี้จะบอกผลลัพธ์ความน่าจะเป็นของความคล้ายคลึงกันระหว่างคำสองคำ โปรดดูโค้ดด้านล่างวิธีการดำเนินการส่วนนี้

similarity_two_words = model.similarity('please','see')
print("Please provide the similarity between these two words:")
print(similarity_two_words)

ผลลัพธ์ของโค้ดข้างต้นเป็นดังนี้

0.13706

คุณสามารถค้นหาคำที่คล้ายกันเพิ่มเติมได้โดยการรันโค้ดด้านล่าง

similar = model.similar_by_word('kind')
print(similar)

ผลลัพธ์ของโค้ดด้านบน:

[('credit', 0.11764447391033173), ('cash', 0.11440904438495636), ('one', 0.11151769757270813), ('hour', 0.0944807156920433), ('using', 0.0705675333738327), ('thats', 0.05206916481256485), ('later', 0.04502468928694725), ('bye', 0.03960943967103958), ('back', 0.03837274760007858), ('thank', 0.0380823090672493)] 

สรุป

• การฝังคำเป็นรูปแบบหนึ่งของการแสดงคำที่ช่วยให้อัลกอริทึมการเรียนรู้ของเครื่องสามารถเข้าใจคำที่มีความหมายคล้ายกันได้
• การฝังคำใช้เพื่อคำนวณคำที่คล้ายกัน สร้างกลุ่มคำที่เกี่ยวข้อง ฟีเจอร์สำหรับการจำแนกข้อความ การจัดกลุ่มเอกสาร การประมวลผลภาษาธรรมชาติ
• Word2vec อธิบาย: Word2vec เป็นแบบจำลองโครงข่ายประสาทเทียมสองชั้นแบบตื้นเพื่อสร้างการฝังคำเพื่อการแสดงคำที่ดีขึ้น
• Word2vec แทนคำในการแทนปริภูมิเวกเตอร์ คำต่างๆ จะถูกนำเสนอในรูปแบบของเวกเตอร์ และการจัดวางในลักษณะที่ทำให้คำที่มีความหมายคล้ายกันปรากฏพร้อมกัน และคำที่แตกต่างกันจะอยู่ห่างไกลจากกัน
• อัลกอริทึม Word2vec ใช้สถาปัตยกรรม 2 แบบ คือ Continuous Bag of words (CBOW) และ skip gram
• CBOW เร็วกว่าข้ามกรัมหลายเท่าและให้ความถี่ที่ดีกว่าสำหรับคำที่ใช้บ่อย ในขณะที่ข้ามกรัมต้องการข้อมูลการฝึกอบรมเพียงเล็กน้อยและแสดงถึงคำหรือวลีที่หายาก
• สามารถใช้ NLTK และ Word2vec ร่วมกันเพื่อสร้างแอปพลิเคชันที่มีประสิทธิภาพ
• ฟังก์ชันการเปิดใช้งานของเซลล์ประสาทจะกำหนดเอาต์พุตของเซลล์ประสาทนั้นโดยได้รับชุดอินพุต ใน Word2vec Softmax Layer (ฟังก์ชันเอ็กซ์โปเนนเชียลที่ทำให้เป็นมาตรฐาน) คือฟังก์ชันเลเยอร์เอาต์พุตที่เปิดใช้งานหรือเริ่มทำงานแต่ละโหนด Word2vec ยังมีการสุ่มตัวอย่างเชิงลบด้วย
• Gensim เป็นชุดเครื่องมือสร้างโมเดลหัวข้อที่ใช้ใน Python