How to choose an Model?

 

LLM Pre-training

Definition of Pre-training

Pre-training is the process of training a model on vast, diverse, and largely unlabeled data to learn general representations and patterns of a domain — such as language, vision, audio, or sensor data — before it is specialized for specific tasks.

It is a self-supervised learning stage where the model develops an internal “world model” by predicting or reconstructing parts of its input (e.g., the next token, masked pixel, next audio frame, or next action).
The goal is not to perform a narrow task, but to build a foundation of understanding that later fine-tuning, prompting, or reinforcement can adapt to many downstream objectives.

---

🧠 Core Idea

Pre-training = learning how the world looks, sounds, or reads —
before learning how to do something with that knowledge.

General Formulation

Aspect	Description
Input	Large, diverse, unlabeled data (text, images, audio, code, trajectories, etc.)
Objective	Predict missing or future parts of data (self-supervised task)
Outcome	Dense, structured representations (embeddings) capturing meaning and relationships
Purpose	Build transferable understanding to accelerate later adaptation

Why It Matters

Pre-training converts raw data → reusable intelligence.
Once the base model is pretrained, it can be:

• Fine-tuned for specialized tasks,

• Aligned for human intent (via RLHF),

• Connected to live knowledge (via RAG).

It’s the difference between:

teaching a brain how to think and perceive,
versus teaching it what to think or do.

When You Should Pre-train

You should pre-train from scratch only when:

• You need a new base model (new architecture, tokenizer, or modality);

• Existing models don’t cover your language or data type (e.g., low-resource languages, medical imaging, genomic data);

• You want full control over knowledge, bias, and compliance;

• You’re performing foundational research into architectures or training dynamics.

Otherwise — reuse and fine-tune an existing pre-trained foundation. 

 

What is the need for LLM Finetuning?

 Reason number 1

You might not want the above result, rather something like below would help you

Reason number 2 for LLM fine tuning

Reason number for LLM Fine Tuning

Another reason to fine tune

LLM Fine-tuning

Next Layer: Fine-Tuning

Where RAG retrieves knowledge dynamically, fine-tuning actually modifies the model’s brain — it teaches the LLM new patterns or behaviors by updating its internal weights.

---

⚙️ How Fine-Tuning Works

1. Start with a pretrained model (e.g., GPT-3.5, Llama-3, Mistral).

2. Prepare training data — examples of how you want the model to behave:

   • Inputs → desired outputs

   • e.g., “User story → corresponding UAT test case”

3. Train the model on these examples (using supervised learning or reinforcement learning).

4. The model’s weights are adjusted, internalizing the new style, tone, or domain language.

After fine-tuning, the model natively performs the desired task without needing the examples fed each time.

---

⚖️ RAG vs Fine-Tuning: Clear Comparison

Aspect	RAG (Retrieval-Augmented Generation)	Fine-Tuning
Mechanism	Adds external info at runtime	Alters model weights via training
When Used	When data changes often or is large	When you need consistent behavior or reasoning style
Data Type	Documents, databases, APIs	Labeled prompt–response pairs
Cost	Low (no retraining)	High (GPU time, expertise, re-training)
Freshness	Instantly updatable	Requires re-training to update
Control	You control retrieved sources	You control reasoning patterns
Example Use	Ask questions about new policies	Teach model to write test cases in your company’s format
Analogy	Reading from a manual before answering	Rewriting the brain to remember the manual forever

---

🧩 Combining Both: RAG + Fine-Tuning = Domain-Native AI

The real power comes when both are used together:

Layer	Role
Fine-Tuning	Teaches the model how to think — e.g., how to structure a UAT test case, how to handle defects, your tone/style.
RAG	Gives it the latest knowledge — e.g., current epics, Jira stories, or Salesforce objects from your live data.

So the LLM becomes:

A fine-tuned specialist with a live retrieval memory.

---

🧬 Example: In Your AGL Salesforce / UAT Context

Step	Example
Fine-tuning	You fine-tune the LLM on 1,000 existing UAT test cases and business rules. Now it understands your structure and tone.
RAG layer	You connect it to Jira and Confluence via embeddings, so when you ask, “Generate UAT test cases for Drop-3 Call Centre Epics,” it retrieves the latest epics and acceptance criteria.
Result	You get context-aware, properly formatted, accurate UAT cases consistent with AGL’s standards.

That’s enterprise-grade augmentation — the model both knows how to think like your testers and knows what’s new from your systems.

---

🧠 Summary Table

Capability	Base LLM	+ RAG	+ Fine-Tuning	+ Both
General reasoning	✅	✅	✅	✅
Access to private or new data	❌	✅	⚠ (only if baked in)	✅
Domain vocabulary & formats	⚠	⚠	✅	✅
Updatable knowledge	❌	✅	❌	✅
Low hallucination	⚠	✅	✅	✅✅
Cost to build	–	Low	Medium–High	Medium

---

🚀 The Strategic Rule of Thumb

If your problem is...	Then use...
“Model doesn’t know the latest information.”	✅ RAG
“Model doesn’t behave or write like us.”	✅ Fine-Tuning
“Model doesn’t know and doesn’t behave correctly.”	✅ Both

---

That’s the progressive architecture:

• RAG extends knowledge.

• Fine-tuning embeds behavior.

• Together, they form the foundation for enterprise-grade AI systems.

LLMs and RAG (Retrieval-Augmented Generation)

 

🧩 What Is RAG (Retrieval-Augmented Generation)?

Retrieval-Augmented Generation (RAG) is an AI architecture pattern where a Large Language Model (LLM) doesn’t rely only on its internal “frozen” training data.

Instead, it retrieves relevant, up-to-date, or domain-specific information from an external knowledge source (like your documents, databases, or APIs) just before it generates an answer.

So the model’s reasoning process becomes:

Question → Retrieve relevant documents → Feed them into the LLM → Generate answer using both

You can think of it as giving the LLM a “just-in-time memory extension.”

---

⚙️ How It Works — Step by Step

1. User query comes in.

2. Retriever searches a knowledge base (PDFs, wikis, databases, Jira tickets, etc.) for the most relevant chunks.

3. Top-k relevant passages are embedded and appended to the model’s prompt.

4. LLM generates the final response, grounded in those retrieved facts.

Typical components:

Component	Description
LLM	The reasoning and text-generation engine (e.g., GPT-5, Claude, Gemini).
Retriever	Finds relevant text snippets via embeddings (vector similarity search).
Vector Database	Stores text chunks as numerical embeddings (e.g., Pinecone, Chroma, FAISS).
Orchestrator Layer	Handles query parsing, retrieval, prompt assembly, and response formatting.

---

🎯 The Core Benefit: Grounded Intelligence

RAG bridges the gap between static models and dynamic knowledge.

Problem Without RAG	How RAG Solves It
LLM knowledge cutoff (e.g., 2023)	Retrieves real-time or updated data
Hallucinations / made-up facts	Grounds responses in retrieved, traceable context
Domain specificity (finance, legal, energy, healthcare, etc.)	Pulls your proprietary content as context
Data privacy and compliance	Keeps data in your environment (no fine-tuning needed)
High cost of fine-tuning models	Lets you “teach” via retrieval instead of retraining

---

💡 Real-World Examples

Use Case	What RAG Does
Enterprise knowledge assistant	Searches company Confluence, Jira, Salesforce, and answers from those docs
Customer support bot	Retrieves FAQs and policy docs to answer accurately
Research assistant	Pulls academic papers from a library before summarizing
Testing & QA (your domain)	Retrieves test cases, acceptance criteria, or epic notes to generate UAT scenarios
Legal advisor	Retrieves specific clauses or past judgments to draft responses

---

📈 Key Benefits Summarized

Benefit	Description
Accuracy	Reduces hallucination by grounding outputs in retrieved data
Freshness	Keeps responses current without retraining
Cost-effective	No need for fine-tuning or re-training large models
Traceability	You can show sources and citations (useful for audits, compliance)
Scalability	Works across thousands or millions of documents
Data Control	Keeps your proprietary knowledge within your secure environment

---

🧠 Why It’s Still Relevant (Even in 2025)

Modern LLMs (GPT-5, Gemini 2, Claude 3.5, etc.) can read attached documents —
but they still can’t:

• Search across large knowledge bases automatically,

• Maintain persistent memory across sessions,

• Retrieve structured metadata or enforce data lineage.

RAG remains the backbone of enterprise AI because it allows controlled, explainable, and auditable intelligence.

---

🔍 In One Line

RAG = Reasoning + Retrieval.
It gives LLMs a dynamic external memory, making them accurate, current, and domain-aware.