RAG என்றால் என்ன?

RAG (Retrieval-Augmented Generation) ஒரு LLM உங்கள் சொந்த ஆவணங்களைப் பயன்படுத்தி கேள்விகளுக்கு பதிலளிக்க அனுமதிக்கிறது. ஒரு கேள்விக்கான சில தொடர்புடைய துண்டுகளை அது மீட்டெடுக்கிறது, பின்னர் அந்த சூழலை மட்டுமே பயன்படுத்தி மாடலை பதிலளிக்க வைக்கிறது – மறுபயிற்சி தேவையில்லை.

RAG முழுவதுமாக உள்ளூரில் இயங்க முடியுமா?

ஆம். உள்ளூர் LLM மற்றும் ஒரு சிறிய எம்பெடிங் மாடலுடன் (இரண்டும் Ollama வழியாக), முழு load-embed-retrieve-generate பைப்லைன் ஆஃப்லைனிலும் தனிப்பட்ட முறையிலும் இயங்கும்.

RAG ஆரம்பத்திலிருந்து: உங்கள் சொந்த ஆவணங்களைப் பற்றி கேள்விகள் கேளுங்கள்

ஒரு LLM எதில் பயிற்றுவிக்கப்பட்டதோ அதை அறியும் – ஆனால் உங்கள் குறிப்புகள், உங்கள் PDFகள், உங்கள் குறியீடு அல்லது உங்கள் நிறுவனத்தின் ஆவணங்களை அல்ல. RAG (Retrieval-Augmented Generation) ஒரு மாடல் உங்கள் ஆவணங்களைப் பயன்படுத்தி, மறுபயிற்சி இல்லாமல் கேள்விகளுக்கு பதிலளிக்க அனுமதிப்பதன் மூலம் அதை சரிசெய்கிறது. "உங்கள் PDF உடன் அரட்டை" செயலிகள் எப்படி செயல்படுகின்றன என்பதே, அதை உங்கள் சொந்த கணினியில் உள்ளூர் LLM உடன் முழுவதுமாக உருவாக்கலாம்.

இந்த வழிகாட்டி RAG இன் நான்கு இயங்கும் பகுதிகளை விளக்கி, ஒரு செயல்படும், உள்ளூர்-முதன்மையான எடுத்துக்காட்டை நடத்திச் செல்கிறது.

RAG இன் நான்கு பகுதிகள்

Load – உங்கள் ஆவணங்களை (PDF, markdown, text) உரை துண்டுகளாகப் படியுங்கள்.
Embed – ஒவ்வொரு துண்டையும் ஒரு வெக்டராக (அதன் பொருளைப் பிடிக்கும் எண்களின் பட்டியல்) ஒரு எம்பெடிங் மாடலுடன் மாற்றுங்கள்.
Retrieve – ஒரு கேள்வி வரும்போது, அதையும் எம்பெட் செய்து, அதன் வெக்டர்களுக்கு மிக அருகில் இருக்கும் துண்டுகளைக் கண்டறியுங்கள்.
Generate – LLM க்கு மீட்டெடுக்கப்பட்ட துண்டுகளையும் கேள்வியையும் கொடுத்து, அந்த சூழலை மட்டுமே பயன்படுத்தி பதிலளிக்க விடுங்கள்.

முழு தந்திரமும் அதுவே. LLM உங்கள் முழு ஆவணத் தொகுப்பையும் ஒருபோதும் பார்ப்பதில்லை – அடித்தளமான சூழலாகப் பயன்படுத்தும் சில தொடர்புடைய துண்டுகளை மட்டுமே. அதனால்தான் பதில்கள் துல்லியமாக இருக்கின்றன, அதனால்தான் எதையும் மறுபயிற்சி செய்ய வேண்டியதில்லை.

படி 1: Load மற்றும் chunk

உங்கள் ஆவணங்களை சில நூறு எழுத்துக்கள் கொண்ட துண்டுகளாகப் பிரிக்கவும், அவற்றுக்கு இடையே சிறிது ஒன்றுடன் ஒன்று வைக்கவும். ஏன் ஒன்றுடன் ஒன்று? ஒரு துண்டு எல்லையைக் கடக்கும் சூழல் இழக்கப்படாததற்காக. Python இல் ஒரு எளிய அணுகுமுறை:

import re
text = open("notes.md").read()
chunks = [text[i:i+500] for i in range(0, len(text), 400)]  # 500 chars, 100 overlap

LlamaIndex மற்றும் LangChain போன்ற கருவிகள் புத்திசாலித்தனமான chunking ஐ ஆன்-தி-பாக்ஸ் கையாளுகின்றன, ஆனால் கருத்து ஒன்றுதான்.

படி 2: Embed

ஒரு எம்பெடிங் மாடல் உரையை ஒரு வெக்டராக மாற்றுகிறது – ஒரு நிலையான அளவு எண்களின் பட்டியல் – ஒத்த பொருள் அருகருகே விழும் வகையில். ஒரு சிறிய எம்பெடிங் மாடல் எந்த CPU இல் வேகமாக இயங்குகிறது, எனவே இது மலிவானது. Ollama இல் பல உள்ளன, எ.கா. nomic-embed-text:

ollama pull nomic-embed-text

ஒவ்வொரு துண்டையும் எம்பெட் செய்து வெக்டர்களைச் சேமிக்கவும் (தனிப்பட்ட பயன்பாட்டிற்கு ஒரு எளிய JSON அல்லது SQLite கோப்பு போதுமானது; Chroma அல்லது Qdrant போன்ற வெக்டர் தரவுத்தளங்கள் பெரிய அளவிற்கானவை).

படி 3: Retrieve

யாராவது ஒரு கேள்வி கேட்கும்போது, அதை அதே மாடலுடன் எம்பெட் செய்யவும், பின்னர் வெக்டர்கள் மிகவும் ஒத்திருக்கும் துண்டுகளைக் கண்டறியவும். "ஒற்றுமை" பொதுவாக கோசைன் ஒற்றுமை – வெக்டர்களுக்கு இடையேயான சிறிய கோணம் அதிக தொடர்புடைய பொருளைக் குறிக்கிறது. முதல் 3–5 துண்டுகளைத் தேர்ந்தெடுக்கவும்:

import numpy as np
# assume emb(q) is the question vector, emb(chunks) is a matrix
scores = emb(chunks) @ emb(q) / (norms * norm_q)   # cosine sim
top = np.argsort(scores)[::-1][:5]                  # top 5 chunk indices

கேள்வியும் ஒரு துண்டும் ஒத்த சொற்கள் அல்லது கருத்துகளைக் கொண்டிருந்தால், அவை உயர்ந்த தரவரிசையில் வரும் – LLM எல்லாவற்றையும் பார்க்காமல் RAG சரியான பகுதிகளைக் கண்டறிவது அப்படித்தான்.

படி 4: Generate

இறுதியாக, LLM க்கு மீட்டெடுக்கப்பட்ட துண்டுகளை சூழலாகக் கொண்டு prompt செய்யவும். மாயாஜாலம் அறிவுறுத்தலில்தான்: இந்த சூழலை மட்டும் பயன்படுத்தி பதிலளிக்கவும்.

system: You are a helpful assistant. Answer the question using ONLY the
context below. If the answer isn't there, say you don't know.

Context:
--- chunk 3 ---
--- chunk 7 ---
--- chunk 11 ---

Question: What did the notes say about X?

உள்ளூர் மாடலுடன் (எ.கா. Ollama வழியாக ஒரு 7B), இது முழுவதுமாக ஆஃப்லைனில் இயங்குகிறது. உள்ளூர் AI வழிகாட்டி மாடலை எப்படி இயக்குவது என்பதைக் காட்டுகிறது; prompt வழிகாட்டி "சூழலை மட்டும் பயன்படுத்து" என்ற அறிவுறுத்தல் ஏன் அவ்வளவு முக்கியம் என்பதை விளக்குகிறது.

ஒரு எளிய குறுக்குவழி: Ollama + Open WebUI

நீங்கள் குறியீட்டை எழுத விரும்பவில்லை என்றால், Open WebUI இல் RAG உள்ளமைக்கப்பட்டுள்ளது: ஒரு ஆவணத்தை பதிவேற்றுங்கள், அது உங்கள் உள்ளூர் Ollama மாடல்களுக்கு எதிராக தானாகவே chunk, embed, retrieve செய்யும். RAG ஐ முயற்சிக்க இதுவே வேகமான வழி – மேலே உள்ள "ஆரம்பத்திலிருந்து" பதிப்பு அது உள்ளுக்குள் எப்படி செயல்படுகிறது என்பதுதான்.

RAG எப்போது செயல்படுகிறது (எப்போது செயல்படாது)

மிகச் சிறந்தது: உங்கள் ஆவணங்களில் உண்மைகளைக் கண்டறிதல், பதில்களை அடித்தளமாக்குதல், மேற்கோள்கள் ("இது பகுதி 3 இலிருந்து"), தனிப்பட்ட தரவு.
நல்லது: பல ஆவணங்களில் சுருக்கம் (retrieve செய்து பிறகு summarize).
அவ்வளவு சிறப்பாக இல்லை: முழு தொகுப்பின் மீது கணிதம் அல்லது பல-படி சிந்தனை (அது ஏஜென்ட்கள் + கருவிகள், வேறு விலங்கு), அல்லது பதில் பல துண்டிக்கப்பட்ட துண்டுகளின் சூழல் தேவைப்படும்போது.

துண்டு அளவு மற்றும் மீட்டெடுப்பு எண்ணிக்கை மிக முக்கியமான இரண்டு குமிழ்கள். மிகக் குறைவான அல்லது மிகச் சிறிய துண்டுகள் → காணாமல் போன சூழல். மிக அதிகம் → LLM திசைதிருப்பப்படுகிறது அல்லது பதில் நீளமாகிறது. ~500-எழுத்து துண்டுகள் மற்றும் top-5 மீட்டெடுப்புடன் தொடங்கி, பிறகு சரிசெய்யவும்.

இறுதி விளைவு

RAG என்பது load, embed, retrieve, generate – முழுவதுமாக உள்ளூரில் இயக்கக்கூடிய நான்கு படிகள். இது ஒரு பொது LLM ஐ உங்கள் ஆவணங்களை உண்மையாக அறியும் ஒன்றாக மாற்றுகிறது, அடித்தளமான, மேற்கோளிடக்கூடிய பதில்களுடன், மறுபயிற்சி இல்லாமல். நீங்கள் ஒரு லைப்ரரியைப் பயன்படுத்தினாலும் மேலே உள்ள மூல படிகளைப் பயன்படுத்தினாலும், கருத்து ஒன்றே, மேலும் ஒரு உள்ளூர் மாடலின் மேல் நீங்கள் உருவாக்கக்கூடிய மிகவும் பயனுள்ள விஷயங்களில் இதுவும் ஒன்று.