AI พร้อม Python - แพ็คเกจ NLTK

ในบทนี้เราจะเรียนรู้วิธีการเริ่มต้นใช้งาน Natural Language Toolkit Package

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

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

ในการสร้างแอปพลิเคชันดังกล่าวเราจะใช้แพ็คเกจ Python ที่เรียกว่า NLTK (Natural Language Toolkit Package)

การนำเข้า NLTK

เราจำเป็นต้องติดตั้ง NLTK ก่อนใช้งาน สามารถติดตั้งได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -

pip install nltk

ในการสร้างแพ็คเกจ conda สำหรับ NLTK ให้ใช้คำสั่งต่อไปนี้ -

conda install -c anaconda nltk

หลังจากติดตั้งแพ็คเกจ NLTK แล้วเราจำเป็นต้องนำเข้าผ่านพรอมต์คำสั่ง python เราสามารถนำเข้าได้โดยเขียนคำสั่งต่อไปนี้ในพรอมต์คำสั่ง Python -

>>> import nltk

กำลังดาวน์โหลดข้อมูลของ NLTK

หลังจากนำเข้า NLTK แล้วเราจำเป็นต้องดาวน์โหลดข้อมูลที่ต้องการ สามารถทำได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ในพรอมต์คำสั่ง Python -

>>> nltk.download()

การติดตั้งแพ็คเกจที่จำเป็นอื่น ๆ

สำหรับการสร้างแอปพลิเคชันการประมวลผลภาษาธรรมชาติโดยใช้ NLTK เราจำเป็นต้องติดตั้งแพ็คเกจที่จำเป็น แพ็คเกจมีดังนี้ -

เกนซิม

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

pip install gensim

รูปแบบ

จะใช้ในการทำ gensimแพคเกจทำงานอย่างถูกต้อง เราสามารถติดตั้งได้โดยดำเนินการคำสั่งต่อไปนี้

pip install pattern

แนวคิดของ Tokenization, Stemming และ Lemmatization

ในส่วนนี้เราจะทำความเข้าใจว่าอะไรคือโทเค็นการกำหนดต้นกำเนิดและการให้คำนาม

Tokenization

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

Input - มะม่วงกล้วยสับปะรดและแอปเปิ้ลล้วนเป็นผลไม้

Output -

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

ในโมดูล Python NLTK เรามีแพ็คเกจต่างๆที่เกี่ยวข้องกับโทเค็นซึ่งเราสามารถใช้เพื่อแบ่งข้อความออกเป็นโทเค็นตามความต้องการของเรา บางส่วนของแพ็คเกจมีดังนี้ -

sent_tokenize แพ็คเกจ

ตามชื่อที่แนะนำแพ็คเกจนี้จะแบ่งข้อความที่ป้อนออกเป็นประโยค เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -

from nltk.tokenize import sent_tokenize

word_tokenize แพ็คเกจ

แพ็คเกจนี้แบ่งข้อความที่ป้อนเป็นคำ เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -

from nltk.tokenize import word_tokenize

แพ็คเกจ WordPunctTokenizer

แพ็กเกจนี้แบ่งข้อความที่ป้อนเป็นคำและเครื่องหมายวรรคตอน เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -

from nltk.tokenize import WordPuncttokenizer

Stemming

ในขณะที่ทำงานกับคำเราพบรูปแบบต่างๆมากมายเนื่องจากเหตุผลทางไวยากรณ์ แนวคิดของรูปแบบในที่นี้หมายความว่าเราต้องจัดการกับรูปแบบต่างๆของคำเดียวกันเช่นdemocracy, democratic, และ democratization. จำเป็นมากที่เครื่องจักรจะต้องเข้าใจว่าคำต่างๆเหล่านี้มีรูปแบบฐานเดียวกัน ด้วยวิธีนี้การแยกรูปแบบฐานของคำในขณะที่เราวิเคราะห์ข้อความจะมีประโยชน์

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

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

แพ็คเกจ PorterStemmer

แพคเกจ Python นี้ใช้อัลกอริทึมของ Porter เพื่อแยกรูปแบบพื้นฐาน เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -

from nltk.stem.porter import PorterStemmer

ตัวอย่างเช่นถ้าเราจะให้คำ ‘writing’ ในฐานะที่เป็นข้อมูลในการทำให้เกิดสิ่งนี้เราจะได้คำนั้น ‘write’ หลังจากหยุดชะงัก

แพ็คเกจ LancasterStemmer

แพคเกจ Python นี้จะใช้อัลกอริทึมของ Lancaster เพื่อแยกรูปแบบพื้นฐาน เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -

from nltk.stem.lancaster import LancasterStemmer

แพ็คเกจ SnowballStemmer

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

from nltk.stem.snowball import SnowballStemmer

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

Lemmatization

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

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

ในโมดูล Python NLTK เรามีแพ็คเกจต่อไปนี้ที่เกี่ยวข้องกับกระบวนการสร้างคำศัพท์ซึ่งเราสามารถใช้เพื่อรับรูปแบบพื้นฐานของคำ -

แพ็คเกจ WordNetLemmatizer

แพคเกจ Python นี้จะดึงรูปแบบพื้นฐานของคำขึ้นอยู่กับว่าใช้เป็นคำนามหรือเป็นคำกริยา เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -

from nltk.stem import WordNetLemmatizer

Chunking: แบ่งข้อมูลออกเป็นชิ้น ๆ

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

ในส่วนต่อไปนี้เราจะเรียนรู้เกี่ยวกับประเภทต่างๆของ Chunking

ประเภทของก้อน

การทำก้อนมีสองประเภท ประเภทมีดังนี้ -

เป็นก้อนขึ้น

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

ลดจำนวนลง

ในกระบวนการของการแยกชิ้นส่วนวัตถุสิ่งของ ฯลฯ จะเคลื่อนไปสู่ความเฉพาะเจาะจงมากขึ้นและภาษาได้รับการเจาะมากขึ้น โครงสร้างที่ลึกกว่าจะถูกตรวจสอบเป็นชิ้น ๆ ในขั้นตอนนี้เราจะซูมเข้าตัวอย่างเช่นถ้าเราสรุปคำถาม "บอกเฉพาะเกี่ยวกับรถ"? เราจะได้รับข้อมูลชิ้นเล็ก ๆ เกี่ยวกับรถ

Example

ในตัวอย่างนี้เราจะทำ Noun-Phrase chunking ซึ่งเป็นหมวดหมู่ของ chunking ซึ่งจะค้นหาวลีคำนามในประโยคโดยใช้โมดูล NLTK ใน Python -

Follow these steps in python for implementing noun phrase chunking −

Step 1- ในขั้นตอนนี้เราต้องกำหนดไวยากรณ์สำหรับการแยกชิ้นส่วน มันจะประกอบด้วยกฎที่เราต้องปฏิบัติตาม

Step 2- ในขั้นตอนนี้เราต้องสร้างตัวแยกวิเคราะห์แบบก้อน มันจะแยกวิเคราะห์ไวยากรณ์และให้ผลลัพธ์

Step 3 - ในขั้นตอนสุดท้ายนี้ผลลัพธ์จะถูกสร้างในรูปแบบต้นไม้

ให้เรานำเข้าแพ็คเกจ NLTK ที่จำเป็นดังต่อไปนี้ -

import nltk

ตอนนี้เราต้องกำหนดประโยค ในที่นี้ DT หมายถึงดีเทอร์มิแนนต์ VBP หมายถึงคำกริยา JJ หมายถึงคำคุณศัพท์ IN หมายถึงคำบุพบทและ NN หมายถึงคำนาม

sentence=[("a","DT"),("clever","JJ"),("fox","NN"),("was","VBP"),
          ("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]

ตอนนี้เราต้องให้ไวยากรณ์ ในที่นี้เราจะให้ไวยากรณ์ในรูปแบบของนิพจน์ทั่วไป

grammar = "NP:{<DT>?<JJ>*<NN>}"

เราจำเป็นต้องกำหนด parser ซึ่งจะแยกวิเคราะห์ไวยากรณ์

parser_chunking = nltk.RegexpParser(grammar)

parser จะแยกวิเคราะห์ประโยคดังนี้ -

parser_chunking.parse(sentence)

ต่อไปเราต้องได้รับผลลัพธ์ ผลลัพธ์ถูกสร้างขึ้นในตัวแปรอย่างง่ายที่เรียกว่าoutput_chunk.

Output_chunk = parser_chunking.parse(sentence)

เมื่อดำเนินการตามรหัสต่อไปนี้เราสามารถวาดผลลัพธ์ของเราในรูปแบบของต้นไม้

output.draw()

Bag of Word (BoW) รุ่น

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

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

มันทำงานอย่างไร

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

แนวคิดของเมทริกซ์ระยะเอกสาร

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

Example

สมมติว่าเรามีสองประโยคต่อไปนี้ -

Sentence 1 - เรากำลังใช้โมเดล Bag of Words
Sentence 2 - แบบจำลอง Bag of Words ใช้สำหรับการแยกคุณสมบัติ

ตอนนี้เมื่อพิจารณาสองประโยคนี้เรามี 13 คำที่แตกต่างกันดังต่อไปนี้ -

we
are
using
the
bag
of
words
model
is
used
for
extracting
features

ตอนนี้เราต้องสร้างฮิสโตแกรมสำหรับแต่ละประโยคโดยใช้จำนวนคำในแต่ละประโยค -

Sentence 1 - [1,1,1,1,1,1,1,1,0,0,0,0,0,0]
Sentence 2 - [0,0,0,1,1,1,1,1,1,1,1,1,1]

ด้วยวิธีนี้เรามีเวกเตอร์คุณลักษณะที่แยกออกมาแล้ว เวกเตอร์คุณลักษณะแต่ละตัวมีขนาด 13 มิติเนื่องจากเรามีคำที่แตกต่างกัน 13 คำ

แนวคิดของสถิติ

แนวคิดของสถิติเรียกว่า TermFrequency-Inverse Document Frequency (tf-idf) ทุกคำมีความสำคัญในเอกสาร สถิติช่วยให้เราเข้าใจความสำคัญของทุกคำ

ระยะความถี่ (tf)

เป็นการวัดความถี่ที่คำแต่ละคำปรากฏในเอกสาร สามารถหาได้โดยการหารจำนวนคำแต่ละคำด้วยจำนวนคำทั้งหมดในเอกสารที่กำหนด

ความถี่เอกสารผกผัน (idf)

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

การสร้างแบบจำลองถุงคำใน NLTK

ในส่วนนี้เราจะกำหนดชุดของสตริงโดยใช้ CountVectorizer เพื่อสร้างเวกเตอร์จากประโยคเหล่านี้

ให้เรานำเข้าแพ็คเกจที่จำเป็น -

from sklearn.feature_extraction.text import CountVectorizer

ตอนนี้กำหนดชุดของประโยค

Sentences = ['We are using the Bag of Word model', 'Bag of Word model is
           used for extracting the features.']

vectorizer_count = CountVectorizer()

features_text = vectorizer.fit_transform(Sentences).todense()

print(vectorizer.vocabulary_)

โปรแกรมด้านบนจะสร้างผลลัพธ์ตามที่แสดงด้านล่าง แสดงว่าเรามี 13 คำที่แตกต่างกันในสองประโยคข้างต้น -

{'we': 11, 'are': 0, 'using': 10, 'the': 8, 'bag': 1, 'of': 7,
 'word': 12, 'model': 6, 'is': 5, 'used': 9, 'for': 4, 'extracting': 2, 'features': 3}

นี่คือเวกเตอร์คุณลักษณะ (ข้อความเป็นรูปแบบตัวเลข) ซึ่งสามารถใช้สำหรับการเรียนรู้ของเครื่อง

แก้ไขปัญหา

ในส่วนนี้เราจะแก้ปัญหาที่เกี่ยวข้องเล็กน้อย

การทำนายหมวดหมู่

ในชุดเอกสารไม่เพียง แต่คำ แต่หมวดหมู่ของคำก็มีความสำคัญเช่นกัน ข้อความในหมวดหมู่ใดที่มีคำใดคำหนึ่งตกอยู่ ตัวอย่างเช่นเราต้องการคาดคะเนว่าประโยคใดเป็นของอีเมลหมวดหมู่ข่าวสารกีฬาคอมพิวเตอร์ ฯลฯ ในตัวอย่างต่อไปนี้เราจะใช้ tf-idf เพื่อกำหนดเวกเตอร์คุณลักษณะเพื่อค้นหาหมวดหมู่ของเอกสาร เราจะใช้ข้อมูลจากชุดข้อมูล 20 กลุ่มข่าวของ sklearn

เราจำเป็นต้องนำเข้าแพ็คเกจที่จำเป็น -

from sklearn.datasets import fetch_20newsgroups
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer

กำหนดแผนที่หมวดหมู่ เราใช้ห้าหมวดหมู่ที่แตกต่างกันชื่อศาสนารถยนต์กีฬาอิเล็กทรอนิกส์และอวกาศ

category_map = {'talk.religion.misc':'Religion','rec.autos''Autos',
   'rec.sport.hockey':'Hockey','sci.electronics':'Electronics', 'sci.space': 'Space'}

สร้างชุดฝึก -

training_data = fetch_20newsgroups(subset = 'train',
   categories = category_map.keys(), shuffle = True, random_state = 5)

สร้างเวกเตอร์การนับและแยกคำที่นับ -

vectorizer_count = CountVectorizer()
train_tc = vectorizer_count.fit_transform(training_data.data)
print("\nDimensions of training data:", train_tc.shape)

หม้อแปลง tf-idf ถูกสร้างขึ้นดังนี้ -

tfidf = TfidfTransformer()
train_tfidf = tfidf.fit_transform(train_tc)

ตอนนี้กำหนดข้อมูลการทดสอบ -

input_data = [
   'Discovery was a space shuttle',
   'Hindu, Christian, Sikh all are religions',
   'We must have to drive safely',
   'Puck is a disk made of rubber',
   'Television, Microwave, Refrigrated all uses electricity'
]

ข้อมูลข้างต้นจะช่วยให้เราฝึกตัวจำแนก Multinomial Naive Bayes -

classifier = MultinomialNB().fit(train_tfidf, training_data.target)

แปลงข้อมูลอินพุตโดยใช้ตัวนับเวกเตอร์ -

input_tc = vectorizer_count.transform(input_data)

ตอนนี้เราจะแปลงข้อมูลเวกเตอร์โดยใช้หม้อแปลง tfidf -

input_tfidf = tfidf.transform(input_tc)

เราจะทำนายประเภทผลลัพธ์ -

predictions = classifier.predict(input_tfidf)

ผลลัพธ์ถูกสร้างขึ้นดังนี้ -

for sent, category in zip(input_data, predictions):
   print('\nInput Data:', sent, '\n Category:', \
      category_map[training_data.target_names[category]])

ตัวทำนายหมวดหมู่จะสร้างผลลัพธ์ต่อไปนี้ -

Dimensions of training data: (2755, 39297)

Input Data: Discovery was a space shuttle
Category: Space

Input Data: Hindu, Christian, Sikh all are religions
Category: Religion

Input Data: We must have to drive safely
Category: Autos

Input Data: Puck is a disk made of rubber
Category: Hockey

Input Data: Television, Microwave, Refrigrated all uses electricity
Category: Electronics

ตัวค้นหาเพศ

ในคำชี้แจงปัญหานี้ลักษณนามจะได้รับการฝึกฝนเพื่อค้นหาเพศ (ชายหรือหญิง) โดยการระบุชื่อ เราจำเป็นต้องใช้ฮิวริสติกเพื่อสร้างเวกเตอร์คุณลักษณะและฝึกลักษณนาม เราจะใช้ข้อมูลที่มีป้ายกำกับจากแพ็คเกจ scikit-learn ต่อไปนี้เป็นรหัส Python เพื่อสร้างตัวค้นหาเพศ -

ให้เรานำเข้าแพ็คเกจที่จำเป็น -

import random

from nltk import NaiveBayesClassifier
from nltk.classify import accuracy as nltk_accuracy
from nltk.corpus import names

ตอนนี้เราต้องแยกตัวอักษร N สุดท้ายออกจากคำที่ป้อน ตัวอักษรเหล่านี้จะทำหน้าที่เป็นคุณสมบัติ -

def extract_features(word, N = 2):
   last_n_letters = word[-N:]
   return {'feature': last_n_letters.lower()}
	
if __name__=='__main__':

สร้างข้อมูลการฝึกอบรมโดยใช้ชื่อที่มีป้ายกำกับ (ชายและหญิง) ที่มีอยู่ใน NLTK -

male_list = [(name, 'male') for name in names.words('male.txt')]
female_list = [(name, 'female') for name in names.words('female.txt')]
data = (male_list + female_list)

random.seed(5)
random.shuffle(data)

ตอนนี้ข้อมูลการทดสอบจะถูกสร้างขึ้นดังนี้ -

namesInput = ['Rajesh', 'Gaurav', 'Swati', 'Shubha']

กำหนดจำนวนตัวอย่างที่ใช้ในการฝึกและทดสอบด้วยรหัสต่อไปนี้

train_sample = int(0.8 * len(data))

ตอนนี้เราต้องวนซ้ำตามความยาวที่แตกต่างกันเพื่อให้สามารถเปรียบเทียบความแม่นยำได้ -

for i in range(1, 6):
   print('\nNumber of end letters:', i)
   features = [(extract_features(n, i), gender) for (n, gender) in data]
   train_data, test_data = features[:train_sample],
features[train_sample:]
   classifier = NaiveBayesClassifier.train(train_data)

ความถูกต้องของลักษณนามสามารถคำนวณได้ดังนี้ -

accuracy_classifier = round(100 * nltk_accuracy(classifier, test_data), 2)
   print('Accuracy = ' + str(accuracy_classifier) + '%')

ตอนนี้เราสามารถทำนายผลลัพธ์ -

for name in namesInput:
   print(name, '==>', classifier.classify(extract_features(name, i)))

โปรแกรมข้างต้นจะสร้างผลลัพธ์ต่อไปนี้ -

Number of end letters: 1
Accuracy = 74.7%
Rajesh -> female
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 2
Accuracy = 78.79%
Rajesh -> male
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 3
Accuracy = 77.22%
Rajesh -> male
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 4
Accuracy = 69.98%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 5
Accuracy = 64.63%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female

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

การสร้างแบบจำลองหัวข้อ: การระบุรูปแบบในข้อมูลข้อความ

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

เราสามารถใช้เทคนิคการสร้างแบบจำลองหัวข้อในสถานการณ์ต่อไปนี้ -

การจัดประเภทข้อความ

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

ระบบผู้แนะนำ

ด้วยความช่วยเหลือของการสร้างแบบจำลองหัวข้อเราสามารถสร้างระบบผู้แนะนำโดยใช้มาตรการความคล้ายคลึงกัน

อัลกอริทึมสำหรับการสร้างแบบจำลองหัวข้อ

การสร้างแบบจำลองหัวข้อสามารถทำได้โดยใช้อัลกอริทึม อัลกอริทึมมีดังนี้ -

การจัดสรร Dirichlet แฝง (LDA)

อัลกอริทึมนี้เป็นที่นิยมมากที่สุดสำหรับการสร้างแบบจำลองหัวข้อ ใช้โมเดลกราฟิกที่น่าจะเป็นในการใช้การสร้างแบบจำลองหัวข้อ เราจำเป็นต้องนำเข้าแพ็คเกจ gensim ใน Python เพื่อใช้ LDA sl algorithm

การวิเคราะห์ความหมายแฝง (LDA) หรือการจัดทำดัชนีความหมายแฝง (LSI)

อัลกอริทึมนี้ขึ้นอยู่กับพีชคณิตเชิงเส้น โดยทั่วไปจะใช้แนวคิดของ SVD (Singular Value Decomposition) บนเมทริกซ์คำศัพท์ของเอกสาร

การแยกตัวประกอบเมทริกซ์ที่ไม่ใช่เชิงลบ (NMF)

นอกจากนี้ยังขึ้นอยู่กับพีชคณิตเชิงเส้น

อัลกอริทึมที่กล่าวถึงข้างต้นทั้งหมดสำหรับการสร้างแบบจำลองหัวข้อจะมีไฟล์ number of topics เป็นพารามิเตอร์ Document-Word Matrix เป็นอินพุตและ WTM (Word Topic Matrix) & TDM (Topic Document Matrix) เป็นเอาต์พุต