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

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

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

Stemming คืออะไร?

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

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

He was riding.
He was taking the ride.

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

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

โปรแกรมสำหรับการทำความเข้าใจ 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)

Output:

wait
wait
wait
wait

Code คำอธิบาย:

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

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

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

Code คำอธิบาย:

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

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

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

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

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

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

Code เพื่อแยกความแตกต่างระหว่าง Lemmatization และ Stemming

อารมณ์ Code:

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

เล็มมาไลเซชั่น Code:

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

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

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

ใช้กรณีของ Lemmatizer

โปรแกรม Lemmatizer ช่วยลดความกำกวมของข้อความ คำต่างๆ เช่น bicycle หรือ bicycles จะถูกแปลงเป็นคำหลัก bicycle โดยจะแปลงคำทุกคำที่มีความหมายเหมือนกันแต่มีรูปแบบการเขียนต่างกันให้เป็นรูปคำหลัก ลดความหนาแน่นของคำ และช่วยลดความกำกวมของข้อความping เตรียมคุณลักษณะที่แม่นยำสำหรับการฝึกฝนเครื่องจักร ยิ่งข้อมูลสะอาดมากเท่าไหร่ โมเดลการเรียนรู้ของเครื่องจักรก็จะยิ่งแม่นยำมากขึ้นเท่านั้น นอกจากนี้ 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)

Output:

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

Code คำอธิบาย:

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

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

คำถามที่พบบ่อย