RAG & Knowledge Cutoff

அடிப்படை மொழிமாதிரிகளிலிருந்து அறிவு-திரட்டிய AI-க்கு: உண்மைகளை மறக்காமல் கற்றுக்கொடுப்பது எப்படி?

Solving AI Hallucination · Vector Databases · Factual Truth

1. கோட்பாடு: அடிப்படை Language Model

அடிப்படை Language Model (LLM) என்பது அடிப்படையில் ஒரு "அடுத்த வார்த்தையை யூகிக்கும் இயந்திரம்" (Next-Word Predictor) மட்டுமே. இது மொழியின் இலக்கணம் மற்றும் வார்த்தைகளுக்கு இடையிலான உறவுகளைப் புரிந்துகொள்ள பிரம்மாண்டமான தரவுகளில் பயிற்றுவிக்கப்படுகிறது.

இதற்கு எப்படிப் பேச வேண்டும் என்பது தெரியும், ஆனால் இதனிடம் உண்மைகளைக் கொண்ட தரவுத்தளம் (Database) ஏதும் இல்லை. இது உண்மைகளையும் இலக்கணத்தையும் ஒன்றாகவே கருதி, தனது Neural Weights-ஐ மட்டுமே நம்பி செயல்படுகிறது.

இது வார்த்தைகளை எண்களாக (Vocabulary Indices) மாற்றுகிறது.
வார்த்தைகளின் முக்கியத்துவத்தை அறிய Self-Attention முறையைப் பயன்படுத்துகிறது.

2. மாயத்தோற்ற ஆபத்து (Hallucination)

சிக்கல்

இந்த அடிப்படை மாடலிடம் ஒரு குறிப்பிட்ட உண்மையைக் கேட்டால் (உதாரணமாக, "திருக்குறள் 1250 என்ன?"), அது எந்த தரவுத்தளத்திலும் தேடாது. மாறாக், அதிக நிகழ்தகவு (Statistical Probability) உள்ள வார்த்தைகளை அடுக்கி ஒரு பதிலை உருவாக்கும்.

இதுவே மாயத்தோற்றம் (Hallucination) எனப்படுகிறது. இது அதுவாகவே ஒரு போலி குறளை உருவாக்கி, அதுதான் உண்மை என்று 100% நம்பிக்கையுடன் சொல்லும். இது யூகங்களை உருவாக்கும் இயந்திரமே தவிர, உண்மைகளை அல்ல.

# 1. கணிப்பு (உண்மையை யூகித்தல்)
with torch.no_grad():
    predictions = model(tensor_input)
    
    # அதிக நிகழ்தகவு உள்ள வார்த்தையை மட்டும் 
    # கண்மூடித்தனமாகத் தேர்ந்தெடுக்கிறது
    pred_idx = predictions.argmax().item()
    predicted_word = idx2word[pred_idx]
                

3. RAG தொழில்நுட்பம்

மாயத்தோற்றத்தைத் தவிர்க்க, மொழி உருவாக்கும் திறனையும், தரவு சேமிப்பையும் நாம் பிரிக்க வேண்டும். AI-யை மனப்பாடம் செய்ய வற்புறுத்துவதை விட்டுவிட்டு, அதற்கு "Open Book Exam" கொடுக்கிறோம்.

தேடு (Retrieve)

உண்மையான தரவுகளை Vector Database-இல் சேமிக்கிறோம். பயனர் கேள்வி கேட்கும்போது, கணிதவியல் மூலம் சரியான உண்மையைத் தேடுகிறோம்.

சேர் (Augment)

கண்டுபிடிக்கப்பட்ட உண்மையான தரவை AI-இன் Prompt-இல் அப்படியே சேர்க்கிறோம்.

உருவாக்கு (Generate)

AI தன் தவறான நினைவாற்றலை நம்பாமல், நாம் கொடுத்த உண்மையான தரவை மட்டும் வைத்துச் சிந்தித்து பதில் அளிக்கிறது.

4. RAG செயல்படுத்தம்: தேடுதல்

யூகிக்க வேண்டாம், தேடுங்கள். பயனரின் கேள்வியை கணித வெக்டாராக மாற்றி, சரியான குறளை நமது தரவுத்தளத்தில் தேடுகிறோம்.

# Step 1: பயனரின் கேள்வியை Vector-ஆக மாற்றுதல்
res = client.models.embed_content(
    model="text-embedding-004", 
    contents=user_input
)
query_embedding = res.embeddings[0].values

# Step 2: Cosine Similarity மூலம் தரவுத்தளத்தில் தேடுதல்
similarities = [
    cosine_similarity(query_embedding, emb) 
    for emb in corpus_embeddings
]

# Step 3: உண்மையான குறளைத் தேர்ந்தெடுத்தல்
best_idx = np.argmax(similarities)
best_kural = df.iloc[best_idx]
                

5. RAG செயல்படுத்தம்: சேர்த்தல் & உருவாக்குதல்

AI-யைக் கட்டுப்படுத்துகிறோம். உண்மையான குறளை Prompt-இல் செலுத்தி, அதை மட்டுமே வைத்துப் பதிலளிக்க உத்தரவிடுகிறோம்.

# Step 4: AUGMENT - Prompt-இல் செலுத்துதல்
kural_text = f"குறள்: {best_kural['Line1']}\n{best_kural['Line2']}"

prompt = f"""
பயனரின் பிரச்சனை: {user_input}
கண்டுபிடிக்கப்பட்ட குறள்: {kural_text}
"""

# Step 5: GENERATE - AI பதிலை அளிக்கிறது
response = client.models.generate_content(
    model="gemini", 
    contents=prompt
)
                

6. உதாரணம்: முன் vs பின்

அடிப்படை LLM

கேள்வி: "திருக்குறள் 433 என்ன?"

"தன்னம்பிக்கை இல்லார்க்கு வாழ்க்கை இல்லை
அதனால் துணிந்து முயல்வது நல்லது"

மாயத்தோற்றம்! இது திருக்குறளில் இல்லை!

RAG அமைப்பு

கேள்வி: "திருக்குறள் 433 என்ன?"

"அஞ்சுவது அஞ்சாமை பேதைமை அஞ்சுவது
அஞ்சல் அறிவார் தொழில்"

100% துல்லியம்! தரவுத்தளத்திலிருந்து தேடப்பட்டது

7. RAG-இன் நன்மைகள்

மாயத்தோற்றம் இல்லை: AI நாம் கொடுத்த தரவுகளுக்குள் மட்டுமே சுருக்கப்பட்டுள்ளது. அதனால் போலி குறள்களை உருவாக்க முடியாது.
எளிதான மேம்பாடு: AI-க்கு புதிய விஷயங்களைக் கற்பிக்க, Neural Network-ஐ மீண்டும் பயிற்றுவிக்கத் தேவையில்லை.
நம்பகத்தன்மை: AI எந்தத் தரவை வைத்து பதில் சொன்னது என்பதை நம்மால் தெளிவாக அறிய முடியும்.
செலவு குறைப்பு: Vector Database-ஐ மட்டும் மேம்படுத்துவது மிகவும் மலிவானது.

அடிப்படை LLM: இலக்கணம் | உண்மைகள்
RAG அமைப்பு: இலக்கணம் | உண்மைகள்