การกั้นคำและการย่อคำใน Python NLTK พร้อมตัวอย่าง

Stemming และ Lemmatization คืออะไร Python เอ็นแอลทีเค?

ต้นกำเนิดและเล็มมาไรเซชัน in Python NLTK คือเทคนิคการทำให้ข้อความเป็นมาตรฐานสำหรับการประมวลผลภาษาธรรมชาติ เทคนิคเหล่านี้ใช้กันอย่างแพร่หลายสำหรับการประมวลผลข้อความเบื้องต้น ความแตกต่างระหว่างการสร้างคำจากรากศัพท์และการสร้างคำจากเล็มมาทคือ การสร้างคำจากรากศัพท์จะเร็วกว่าเนื่องจากตัดคำโดยไม่ทราบบริบท ในขณะที่การสร้างคำจากเล็มมาทจะช้ากว่าเนื่องจากทราบบริบทของคำก่อนการประมวลผล

Stemming คืออะไร?

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

กล่าวอีกนัยหนึ่ง มีคำหนึ่งคำ แต่คำเดียวกันมีหลายรูปแบบ ตัวอย่างเช่น รากศัพท์คือ "กิน" และรูปแบบต่างๆ คือ "กิน กิน กิน และชอบ" ในทำนองเดียวกัน ด้วยความช่วยเหลือของ Stemming in Pythonเราสามารถหารากศัพท์ของรูปแบบต่างๆ ได้

ตัวอย่างเช่น

He was riding.	
He was taking the ride.

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

ลองใช้สิ่งนี้กับ a Python program.NLTK มีอัลกอริทึมชื่อ "PorterStemmer" อัลกอริทึมนี้ยอมรับรายการคำโทเค็นและแยกเป็นคำราก

โปรแกรมทำความเข้าใจ Stemming

from nltk.stem import PorterStemmer
e_words= ["wait", "waiting", "waited", "waits"]
ps =PorterStemmer()
for w in e_words:
    rootWord=ps.stem(w)
    print(rootWord)

เอาท์พุต:

wait	
wait	
wait	
wait 

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

• มีโมดูลต้นกำเนิดใน NLTk ซึ่งนำเข้า หากคุณนำเข้าโมดูลทั้งหมด โปรแกรมจะหนักขึ้นเนื่องจากมีโค้ดหลายพันบรรทัด ดังนั้นจากโมดูลต้นกำเนิดทั้งหมด เรานำเข้าเฉพาะ "PorterStemmer" เท่านั้น
• เราได้เตรียมรายการจำลองของข้อมูลรูปแบบต่างๆ ที่เป็นคำเดียวกัน
• อ็อบเจ็กต์ถูกสร้างขึ้นซึ่งเป็นของคลาส nltk.stem.porter.PorterStemmer

• นอกจากนี้เรายังส่งต่อไปยัง PorterStemmer ทีละรายการโดยใช้ลูป "for" ในที่สุด เราก็ได้ผลลัพธ์รูตคำของแต่ละคำที่กล่าวถึงในรายการ

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

ตอนนี้เราผ่านประโยคที่สมบูรณ์แล้วตรวจสอบพฤติกรรมของประโยคนั้นเป็นผลลัพธ์

โปรแกรม:

from nltk.stem import PorterStemmer
from nltk.tokenize import sent_tokenize, word_tokenize
sentence="Hello Guru99, You have to build a very good site and I love visiting your site."
words = word_tokenize(sentence)
ps = PorterStemmer()
for w in words:
	rootWord=ps.stem(w)
	print(rootWord)

Output:

hello	
guru99	
,	
you	
have	
build	
a	
veri	
good	
site	
and	
I	
love	
visit	
your	
site	 

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

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

สรุป:

Stemming เป็นโมดูลการประมวลผลข้อมูลล่วงหน้า ภาษาอังกฤษมีคำเดียวหลายรูปแบบ รูปแบบเหล่านี้สร้างความคลุมเครือในการฝึกฝนและการทำนายของแมชชีนเลิร์นนิง ในการสร้างโมเดลที่ประสบความสำเร็จ จำเป็นอย่างยิ่งที่จะต้องกรองคำดังกล่าวและแปลงเป็นข้อมูลลำดับเดียวกันโดยใช้การแยกคำ นอกจากนี้ นี่เป็นเทคนิคที่สำคัญในการรับข้อมูลแถวจากชุดประโยคและการลบข้อมูลที่ซ้ำซ้อนหรือที่เรียกว่าการทำให้เป็นมาตรฐาน

เล็มเมตไลเซชันคืออะไร?

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

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

ทำไม Lemmatization ถึงดีกว่า Stemming?

อัลกอริทึมการกั้นคำทำงานโดยการตัดส่วนต่อท้ายออกจากคำ ในความหมายที่กว้างขึ้นให้ตัดคำขึ้นต้นหรือจุดสิ้นสุดของคำ

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

รหัสเพื่อแยกแยะระหว่าง Lemmatization และ Stemming

รหัสการกั้น:

import nltk
from nltk.stem.porter import PorterStemmer
porter_stemmer  = PorterStemmer()
text = "studies studying cries cry"
tokenization = nltk.word_tokenize(text)
for w in tokenization:
print("Stemming for {} is {}".format(w,porter_stemmer.stem(w)))  

Output::

Stemming for studies is studi
Stemming for studying is studi
Stemming for cries is cri
Stemming for cry is cri

รหัสการย่อ:

import nltk
	from nltk.stem import 	WordNetLemmatizer
	wordnet_lemmatizer = WordNetLemmatizer()
	text = "studies studying cries cry"
	tokenization = nltk.word_tokenize(text)
	 for w in tokenization:
		print("Lemma for {} is {}".format(w, wordnet_lemmatizer.lemmatize(w)))  

Output:

Lemma for studies is study
Lemma for studying is studying
Lemma for cries is cry
Lemma for cry is cry

การอภิปรายเกี่ยวกับผลผลิต

หากคุณมองหาการจำกัดการศึกษาและการเรียน ผลลัพธ์จะเหมือนกัน (studi) แต่ตัวแทรก NLTK ให้บทแทรกที่แตกต่างกันสำหรับทั้งโทเค็น study for educational และ educational for educational ดังนั้นเมื่อเราจำเป็นต้องตั้งค่าคุณลักษณะให้กับการฝึกเครื่องจักร จะดีมากหากเลือกใช้การย่อคำ

ใช้กรณีของ Lemmatizer

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

ตัวอย่างเรียลไทม์ที่แสดงการใช้งาน Wordnet Lemmatization และ POS Tagging ใน Python

from nltk.corpus import wordnet as wn
	from nltk.stem.wordnet import WordNetLemmatizer
	from nltk import word_tokenize, pos_tag
	from collections import defaultdict
	tag_map = defaultdict(lambda : wn.NOUN)
	tag_map['J'] = wn.ADJ
	tag_map['V'] = wn.VERB
	tag_map['R'] = wn.ADV

	text = "guru99 is a totally new kind of learning experience."
	tokens = word_tokenize(text)
	lemma_function = WordNetLemmatizer()
	for token, tag in pos_tag(tokens):
		lemma = lemma_function.lemmatize(token, tag_map[tag[0]])
		print(token, "=>", lemma)

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

• ประการแรก นำเข้า wordnet ของโปรแกรมอ่านคลังข้อมูล
• WordNetLemmatizer นำเข้าจาก wordnet
• โทเค็นของ Word และแท็กคำพูดบางส่วนถูกนำเข้าจาก nltk
• พจนานุกรมเริ่มต้นถูกนำเข้าจากคอลเลกชัน
• พจนานุกรมถูกสร้างขึ้นโดยที่ pos_tag (ตัวอักษรตัวแรก) คือค่าคีย์ที่ค่าจะถูกแมปกับค่าจากพจนานุกรม Wordnet เราได้เลือกตัวอักษรตัวแรกเพียงตัวเดียวเท่านั้น เนื่องจากเราจะใช้ตัวอักษรตัวแรกนี้ในลูปในภายหลัง
• ข้อความถูกเขียนและเป็นโทเค็น
• วัตถุ lemma_function ถูกสร้างขึ้นซึ่งจะใช้ภายในลูป
• วนซ้ำถูกรันและย่อย่อจะใช้สองอาร์กิวเมนต์ อันหนึ่งคือโทเค็นและอีกอันคือการแมปของ pos_tag ด้วยค่า wordnet

เอาท์พุต:

guru99 => guru99				
is => be				
totally => totally				
new => new				
kind => kind				
of => of				
learning => learn				
experience => experience				
. => .				 

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