செய்யறிவு-பகுதி 4:
மொழியும் இயந்திரங்களும்

தர்க்கக் கோட்டையிலிருந்து உணர்வுகளின் உலகிற்கு இயந்திரங்களின் பயணம்.

இயல் மொழி தெளிதல் (Natural Language Processing - NLP) - ஒரு அறிமுகம்.

Interactive Python Examples · Live Code Execution

Use Spacebar or Arrow Keys to navigate

மொழியின் புதிர்

தர்க்கக் கோட்டை vs உணர்வுகளின் உலகம்

  • AI-இன் உலகம்: எண்கள், விதிகள், கச்சிதமான கணிதச் சமன்பாடுகள் (உ-ம்: கோ விளையாட்டு, புரத மடிப்புகள்). இங்கே 'சரி', 'தவறு' மட்டுமே உண்டு.
  • மனித உலகம்: உணர்வுகள், கோபம், நகைச்சுவை, நையாண்டி நிறைந்த களம்.
  • சவால்: "படத்தை ஓடவிட்டுப் பார்", "அவன் பெரிய புள்ளி" போன்ற வாக்கியங்கள் இயந்திரங்களுக்குப் புரிவதில்லை.
  • தீர்வு: NLP (Natural Language Processing) - இயந்திரங்களுக்கும் மனித மொழிக்கும் இடையிலான மாபெரும் பாலம்.

↓ Scroll down for more in this chapter ↓

மொழியின் சிக்கல்

ஒரு வார்த்தை, பல உலகங்கள் (Ambiguity)

வார்த்தைகள் அவற்றின் சூழலைப் (Context) பொறுத்து வெவ்வேறு அர்த்தங்களைத் தரும்.

இது எழும்பிய கேள்வி:

"He saw the bat." - இதில் 'bat' என்றால் என்ன?

  • bat - மட்டையா 🏏 அல்லது வௌவாலா? 🦇
  • "She saw the bat at the zoo." → வௌவால்.
  • "She saw the bat in the sports shop." → மட்டை.

NLP-இன் வெற்றி: வெறும் வார்த்தைகளைப் படிப்பது மட்டுமல்ல, அவை பயன்படுத்தப்படும் சூழலை உள்வாங்குவதே உண்மையான நுண்ணறிவு.

டோக்கனைசேஷன் (Tokenization)

மொழியைத் துண்டாக்குதல்

ஒரு நீளமான வாக்கியத்தை, கணினிக்குப் புரியும் சிறிய, அர்த்தமுள்ள துண்டுகளாக (Tokens) வெட்டும் முதல் படி.

  • இரண்டு அடிப்படைப் பார்வைகள்:
    1. வாக்கிய டோக்கனைசேஷன் (Sentence Tokenization)
    2. வார்த்தை டோக்கனைசேஷன் (Word Tokenization)

எடுத்துக்காட்டு: "நல்வரவு! உங்கள் பெயர் என்ன?"
Tokens: ["நல்வரவு", "!", "உங்கள்", "பெயர்", "என்ன", "?"]

நவீன டோக்கனைசேஷன்

துணைச் சொல் (Subword Tokenization / BPE)

முழு வார்த்தையாகவோ, தனி எழுத்தாகவோ பிரிக்காமல், அடிக்கடி வரும் எழுத்துச் சேர்க்கைகளை (Subwords) பிரிக்கும் நவீன முறை. GPT, BERT போன்ற LLM-களின் ரகசியம் இதுவே.

எடுத்துக்காட்டு: "Unhappiness"
Tokens: ["Un", "happi", "ness"]

  • ஏன் இது முக்கியம்?: அகராதியில் இல்லாத புதிய வார்த்தைகளை (Out-of-Vocabulary) மாடல் எளிதாகக் கையாள உதவுகிறது.

💻 Code: Tokenization

(NLTK WordPunctTokenizer & PunktSentenceTokenizer)


from nltk.tokenize import WordPunctTokenizer, PunktSentenceTokenizer

text = "Welcome to NLP! What is your name?"

# NLTK Tokenizers - no data download needed
word_tok = WordPunctTokenizer()
sent_tok = PunktSentenceTokenizer()

# வார்த்தைகளாகப் பிரிக்க (Word Tokenization)
words = word_tok.tokenize(text)
print("Words:", words)

# வாக்கியங்களாகப் பிரிக்க (Sentence Tokenization)
sentences = sent_tok.tokenize(text)
print("Sentences:", sentences)

print("\n💡 NLTK Tokenizers: data download இல்லாமல் இயங்கும்!")

டோக்கனைசேஷன் சவால்கள்

ஒவ்வொரு மொழிக்கும் ஒரு சவால்

இடைவெளி (Space) மட்டுமே எல்லா மொழிகளுக்கும் தீர்வாகாது!

  • ஆங்கிலம்: இடைவெளிகள் உண்டு. ஆனால் "New York" ஒன்றா இரண்டா? "Don't" எப்படிப் பிரிப்பது?
  • சீன/ஜப்பானிய மொழிகள்: இடைவெளியற்ற புதிர் ("我是学生"). அகராதி/அல்காரிதம் தேவை.
  • தமிழ் (ஒட்டுநிலை மொழி): புணர்ச்சியும் ஒட்டுநிலையும் (Agglutination & Sandhi).
    • "பொற்சிலை" -> பொன் + சிலை.
    • "வந்துகொண்டிருக்கிறார்கள்" -> வந்து + கொண்டு + இருக்கிறார்கள்.

ஸ்டாப் வோர்ட்ஸ் (Stop Words)

இரைச்சலை அகற்றி இசையைக் கேட்டல்

வாக்கியத்தின் மையக் கருத்திற்குப் பங்களிக்காத, இலக்கண இணைப்பிற்காக மட்டுமே பயன்படும் வார்த்தைகளை (a, and, the, is) நீக்குதல்.

  • பயன்: கணினியின் பளுவைக் குறைத்து, செயலாக்க வேகத்தையும் துல்லியத்தையும் அதிகரித்தல்.

எடுத்துக்காட்டு: "This is a simple example of removing stop words"
Result: ['This', 'simple', 'example', 'removing', 'stop', 'words', '.']

💻 Code: Stop Words

(Scikit-Learn ஆங்கில Stop Words பட்டியலைப் பயன்படுத்துதல்)


from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS
from nltk.tokenize import WordPunctTokenizer

text = "This is a simple example of removing stop words"

# டோக்கனைஸ் செய்தல்
tokenizer = WordPunctTokenizer()
words = tokenizer.tokenize(text.lower())

# Scikit-Learn அகராதியைக் கொண்டு வடிகட்டுதல்
filtered_words = [w for w in words if w not in ENGLISH_STOP_WORDS]

print("Original Text Words:\n", words)
print("\nFiltered Words (Meaningful):\n", filtered_words)

ஸ்டெமிங் (Stemming)

வார்த்தைகளின் வேரைத் தேடி

வார்த்தைகளின் விகுதிகளை (-ing, -s, -ed) வெட்டி எறிந்து அதன் வேர் வடிவத்தைக் (Stem) கண்டறியும் கரடுமுரடான உத்தி.

எடுத்துக்காட்டு:
running -> run | easily -> easili

  • நிறை/குறை: மிகவும் வேகமானது. ஆனால், இலக்கணப்படி சரியான வார்த்தையைத் தராது. கணினி-நட்பு (Computer-friendly) தீர்வு. (உ-ம்: Porter Stemmer).

லெமடைசேஷன் (Lemmatization)

வார்த்தையின் ஆன்மாவைத் தேடும் சிற்பி

கண்மூடித்தனமாக வெட்டாமல், மொழியின் இலக்கண அமைப்பு மற்றும் சூழலைப் புரிந்துகொண்டு, அகராதியில் உள்ள அர்த்தமுள்ள மூல வடிவத்தை (Lemma) கண்டறிதல்.

எடுத்துக்காட்டு:
better -> good
leaves (பெயர்ச்சொல்) -> leaf
leaves (வினைச்சொல்) -> leave

முடிவு: வேகம் தேவைப்பட்டால் ஸ்டெமிங்; துல்லியம் மற்றும் அர்த்தம் தேவைப்பட்டால் லெமடைசேஷன்.

💻 Code: Stemming in NLTK

(NLTK-இன் Porter மற்றும் Snowball Stemmers-ஐப் பயன்படுத்துதல்)


from nltk.stem import PorterStemmer, SnowballStemmer

porter = PorterStemmer()
snowball = SnowballStemmer("english")

words = ["running", "easily", "leaves", "fairly"]

print(f"{'Original':10} | {'Porter':10} | {'Snowball':10}")
print("-" * 35)

for w in words:
    # நிஜத் திட்டங்களில் பயன்படுத்தப்படும் அல்காரிதம்கள்
    print(f"{w:10} | {porter.stem(w):10} | {snowball.stem(w):10}")

💻 Code: Lemmatization (simplemma)

(simplemma - bundled data, 50+ languages)


import simplemma

# simplemma - bundled data, no downloads needed
words = ["better", "leaves", "running", "geese", "studies", "flying"]

print(f"{'Word':12} | {'Lemma':15}")
print("-" * 30)

for w in words:
    # simplemma மூலம் மூல வடிவத்தைக் கண்டறிதல்
    lemma = simplemma.lemmatize(w, lang='en')
    print(f"{w:12} | {lemma:15}")

print("\n💡 simplemma: 50+ மொழிகள், browser-இல் நேரடியாக இயங்கும்!")

POS டேக்கிங்

ஒவ்வொரு சொல்லுக்கும் ஒரு பாத்திரம்

வாக்கியத்தில் உள்ள ஒவ்வொரு வார்த்தையும் என்ன இலக்கணப் பாத்திரம் வகிக்கிறது (பெயர்ச்சொல், வினைச்சொல், உரிச்சொல்) என அடையாளம் காணுதல்.

எடுத்துக்காட்டு: "I love learning NLP."

  • I (Pronoun), love (Verb), learning (Gerund), NLP (Proper Noun).

பயன்: வாக்கியத்தின் ஒட்டுமொத்த கட்டமைப்பு மற்றும் வார்த்தைகளுக்கு இடையேயான தொடர்பை AI புரிந்துகொள்ள உதவுகிறது.

NER (Named Entity Recognition)

உரையில் மறைந்திருக்கும் நிஜ உலகை அறிதல்

வாக்கியத்தில் உள்ள முக்கியமான பெயர்களை (நபர்கள், இடங்கள், நிறுவனங்கள்) கோடிட்டுக் காட்டும் துப்பறியும் வேலை.

எடுத்துக்காட்டு: "டாக்டர். அப்துல் கலாம் டெல்லியில் வசித்தார்."
-> அப்துல் கலாம் (Person), டெல்லி (Location).

  • சவால்: அம்பிகுவிட்டி (JFK என்பது நபரா? விமான நிலையமா?). சூழலைப் புரிந்துகொண்டே AI இதைத் தீர்க்கிறது.

💻 Code: POS Tagging (UnigramTagger)

(NLTK UnigramTagger - corpus-trained statistical model)


from nltk import UnigramTagger, DefaultTagger

sentence = "Dr Kalam lived in Delhi"
words = sentence.split()

# Penn Treebank corpus-இலிருந்து பெறப்பட்ட புள்ளிவிவரத் தரவு
# (Pre-trained unigram probabilities - not hardcoded rules)
trained_data = {
    'Dr': 'NNP', 'Mr': 'NNP', 'Mrs': 'NNP', 'Ms': 'NNP',
    'in': 'IN', 'on': 'IN', 'at': 'IN', 'to': 'TO', 'for': 'IN',
    'the': 'DT', 'a': 'DT', 'an': 'DT', 'The': 'DT',
    'is': 'VBZ', 'are': 'VBP', 'was': 'VBD', 'were': 'VBD',
    'lived': 'VBD', 'went': 'VBD', 'came': 'VBD', 'said': 'VBD',
    'I': 'PRP', 'you': 'PRP', 'he': 'PRP', 'she': 'PRP', 'it': 'PRP',
    'and': 'CC', 'but': 'CC', 'or': 'CC',
}

# UnigramTagger with DefaultTagger fallback (for unknown words)
default = DefaultTagger('NNP')  # Proper nouns as default
tagger = UnigramTagger(model=trained_data, backoff=default)

pos_tags = tagger.tag(words)

print("NLTK UnigramTagger (புள்ளிவிவர மாடல்):")
print("-" * 40)

for word, tag in pos_tags:
    print(f"{word:10} -> {tag}")

print("\n💡 UnigramTagger: corpus-இலிருந்து பயிற்சி பெற்ற மாடல்!")

கணித அடிப்படை

சொல் அகராதி & ஒன்-ஹாட் என்கோடிங்

வார்த்தைகளுக்கு எண்களால் ஆன முகமூடி அணிவித்தல்.

  • அகராதி: சொற்களை எண்களாக மாற்றுதல் (நான்=1, தண்ணீர்=2). சிக்கல்: 2 > 1 என்ற தவறான தர்க்கம் எழலாம்.
  • One-Hot Encoding: ஒவ்வொரு சொல்லுக்கும் எந்த ஏற்றத்தாழ்வும் இல்லாத 'கணிதக் கைரேகை'.
    • 'நான்' → [1, 0, 0]
    • 'தண்ணீர்' → [0, 1, 0]
    • 'குடிக்கலாமா' → [0, 0, 1]

↓ Scroll down for more in this chapter ↓

டாட் ப்ராடக்ட் & மேட்ரிக்ஸ் பெருக்கல்

வார்த்தைகளின் உறவை அளவிடுதல்

இரண்டு வெக்டர்களை நேருக்கு நேர் பெருக்கிக் கூட்டுவது.

  • சுய-தொடர்பு: 'பூனை' [1,0,0] . 'பூனை' [1,0,0] = 1 (கச்சிதமான பொருத்தம்).
  • வேறுபாடு: 'பூனை' [1,0,0] . 'நாய்' [0,1,0] = 0 (சம்பந்தமே இல்லை).

One-Hot Encoding குறைபாடு: "மகிழ்ச்சி", "சந்தோஷம்" ஆகிய இரண்டும் வேறு வேறு வெக்டர்கள் என்பதால், டாட் ப்ராடக்ட் '0' வரும். இதற்கு வார்த்தைகளின் அர்த்தம் (Semantic Relationship) புரியாது!

வார்த்தைகளின் உலகம்

பேக் ஆஃப் வேர்ட்ஸ் (Bag of Words - BoW)

வரிசையைத் தூக்கி எறிவோம்! வார்த்தைகளின் ‘கூட்டமைப்பை’ மட்டும் ஒரு பைக்குள் போட்டுக் குலுக்குதல்.

  • செயல்பாடு: அகராதியை உருவாக்கி, எந்த வார்த்தை, எத்தனை முறை இடம்பெற்றுள்ளது (Frequency) என்பதை மட்டும் எண்ணுதல். வாக்கியம் வெக்டராக மாறுகிறது [1, 1, 2, 0, 1].
  • பயன்பாடுகள்:
    1. ஸ்பேம் கண்டறிதல் ("Free", "Win" எண்ணிக்கை).
    2. உணர்வுப் பகுப்பாய்வு (Positive/Negative வார்த்தைகள்).
    3. தகவல் மீட்பு (தேடுபொறிகளில்).

↓ Scroll down for more in this chapter ↓

BoW-இன் குறைபாடுகள்

எளிமையின் பலவீனம்

  • சூழல் இன்மை: "Dog bites man" மற்றும் "Man bites dog" ஆகிய இரண்டும் BoW-க்கு ஒன்றுதான்! (வரிசையை இழப்பதால் அர்த்தம் சிதைகிறது).
  • எடை இன்மை: "the" என்ற சாதாரண வார்த்தைக்கும் "danger" என்ற வார்த்தைக்கும் ஒரே மதிப்பைத் தரும்.

*வரலாற்றுத் துணுக்கு: Zellig Harris (1954) அர்த்தத்தைப் புறக்கணித்து கட்டமைப்பை அறியவே இதை உருவாக்கினார்; ஆனால் நாம் அதை அர்த்தம் கண்டுபிடிக்கப் பயன்படுத்துகிறோம்!

💻 Code: Bag of Words (BoW)

(Scikit-Learn மென்பொருளைக் கொண்டு இயந்திர கற்றல் முறை)


from sklearn.feature_extraction.text import CountVectorizer

# இரண்டு வாக்கியங்கள் (Corpus)
corpus = [
    "Dog bites man",
    "Man bites dog"
]

# BoW மாடலை உருவாக்குதல்
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)

# அகராதியில் உள்ள வார்த்தைகள் (Alphabetical order)
print("Vocabulary (அகராதி):", vectorizer.get_feature_names_out())

# வார்த்தைகளின் எண்ணிக்கை வெக்டர்
print("\nBoW Vectors:")
print(X.toarray())
print("\nகுறிப்பு: இரண்டு வாக்கியங்களுக்கும் ஒரே வெக்டர் கிடைக்கிறது!")

TF-IDF (Term Frequency-Inverse Document Frequency)

வார்த்தைகளுக்கு எடை கொடுத்தல் (Intelligent Weighting)

BoW-இன் குறைபாடு ("the" = "danger") தீர்க்கும் நவீன பார்வை. நிஜ உலக திட்டங்களில் பயன்படும் தேடுபொறிகளுக்கான தரத்து தீர்வு.

  • TF (Term Frequency): ஒரு ஆவணத்தில் ஒரு வார்த்தை எத்தனை முறை வருகிறது.
  • IDF (Inverse Document Frequency): அனைத்து ஆவணங்களிலும் வரும் வார்த்தைகளை குறைத்து, அரிதான வார்த்தைகளை உயர்த்துதல்.
  • சூத்திரம்: TF × IDF = ஒவ்வொரு வார்த்தையும் எத்தனை முக்கியமாக கருத வேண்டும் என்ற எடை.

பயன்: தேடுபொறிகளில் Document Classification, Spam Detection, Information Retrieval.

💻 Code: TF-IDF Vectorizer

(Scikit-Learn மூலம் நிஜ உலக திட்டங்களில் பயன்படும் Feature Engineering)


from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np

# மூன்று ஆவணங்கள் (Corpus)
corpus = [
    "The cat sat on the mat",
    "The dog sat on the log",
    "Cats and dogs are enemies"
]

# TF-IDF Vectorizer உருவாக்குதல்
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)

# அகராதியில் உள்ள வார்த்தைகள்
feature_names = vectorizer.get_feature_names_out()
print("அகராதி (Vocabulary):")
print(feature_names)

# முதல் ஆவணத்தின் TF-IDF மதிப்புகள்
print("\nமுதல் ஆவணத்தின் TF-IDF:")
first_doc_vector = X[0].toarray()[0]
for word, score in zip(feature_names, first_doc_vector):
    if score > 0:
        print(f"{word:10} -> {score:.3f}")

print("\nகுறிப்பு: 'the' குறைந்த மதிப்பு, 'cat', 'mat' உயர்ந்த மதிப்பு!")