AI How LLMs Learn

In the last lesson, you learned AI Tokens and Tokenization. Now let us see how an LLM learns, but only at a simple idea level.

Here is the simple learning flow:

🤔 Why Learn the Training Process?

You do not need to train a large model yourself to build AI apps.

Still, you should know the basic story.

• The model sees many examples, like text, code, documents, or question-answer pairs.
• It notices things that appear again and again, like common word order, code shapes, and question-answer formats.
• Later, users send new prompts that the model has not seen in that exact form.
• The model uses those learned examples to write an answer for the new prompt.

But you should understand the broad process because it explains:

• Why models can answer many general questions: They saw many kinds of text during training.
• Why they can still be outdated: Training data stops at some point, so newer facts may be missing.
• Why they may produce biased or wrong output: Training data can contain mistakes, imbalance, or harmful patterns.
• Why chat models feel different: Instruction tuning teaches the model to answer tasks, not just continue text.

📚 Training Data

An LLM learns from huge collections of text and other data.

Data means examples the model learns from.

Training data can include many kinds of examples:

The model does not store the data like a normal database. During training, it adjusts internal parameters so it can predict patterns from that data.

So do not imagine the model opening a folder and copying one exact page. It is using learned patterns.

🔎 What the Model Notices from Data

The model notices repeated things at many levels. For example, it sees that questions often need answers, headings often introduce sections, and code functions often have inputs and outputs.

But remember the important point:

• Seeing the same kind of text many times is not the same as checking whether a fact is true.
• A model may generate something that sounds right because it matches a pattern.
• That is why grounding and evaluation matter later.

🌍 Why Models Feel Different

🏋️ Pre-training

Pre-training is the first large learning phase.

The model sees text and learns to predict missing or next tokens.

Training text
 |
Token prediction task
 |
Parameter updates
 |
Base model

After pre-training, the model may know how sentences are usually written, how code is usually shaped, and how many common facts are usually explained.

But it may not yet behave like a helpful assistant.

📝 Instruction Tuning

Instruction tuning teaches the model to follow tasks.

Examples of instructions:

• “Summarize this paragraph.” The model should not continue the paragraph. It should shorten it into main points.
• “Answer this question.” The model should focus on the question and reply directly.
• “Write code for this function.” The model should produce code, not a theory paragraph.
• “Return JSON in this shape.” The model should follow the exact output format requested by the app.

So the model moves from “continue this text” toward “helpfully respond to this instruction”.

Why instruction tuning changes the user experience

A raw pre-trained model may simply continue text.

An instruction-tuned model is more likely to:

• Answer directly: If you ask “what is a token?”, it explains tokens instead of continuing your sentence.
• Follow format: If you ask for three bullets, it tries to return three bullets.
• Refuse unsafe instructions: It can avoid requests that are harmful or not allowed.
• Ask for clarification: If your request is unclear, it may ask a follow-up question.
• Behave like an assistant: It tries to be useful in a conversation, not just predict random continuation.

This is why most product APIs use instruction-following or chat-tuned models.

🙋 Human Feedback and Alignment

Human feedback is used to improve behavior.

People or preference systems compare outputs and guide the model toward better responses.

This can help the model:

• Follow instructions more clearly: The model learns which answers users prefer for a task.
• Avoid harmful responses: The training process pushes it away from unsafe outputs.
• Refuse unsafe tasks: It can learn to say no when a request should not be completed.
• Prefer clearer answers: If answer A is confusing and answer B explains step by step, people can mark answer B as better.

⚠️ Why Models Still Make Mistakes

Even after training and alignment, mistakes happen.

• It predicts likely text, not guaranteed truth: A likely sentence can still contain a wrong fact.
• Training data may be incomplete or outdated: The model may not know newer information.
• The prompt may be unclear: If the question is vague, the answer can go in the wrong direction.
• Private context may be missing: The model does not know your company’s documents unless the app provides them.
• The task may need a tool: Current weather, prices, inventory, or account details need live lookup.

⚖️ Training vs Fine-Tuning vs RAG

These three are different, okay?

• Training from zero creates a base model. This is expensive and rare for normal teams.
• Fine-tuning adjusts a model for a specific behavior or domain.
• RAG does not train the model. It retrieves information and adds it to the current prompt.

For many business apps, RAG is the first choice because documents change often.

This is why later lessons talk about hallucinations, RAG, tools, and evaluation.

🧩 What You’ve Learned

• ✅ LLMs are trained on many examples before users ask questions.
• ✅ Instruction tuning teaches a model to respond like an assistant, not just continue text.

🚀 What’s Next?

When we write “My laptop is not charging”, the model must understand that the problem is about the laptop. Attention helps it focus on the right words, and a transformer is the structure that uses attention to process the text. Next, let us understand transformers and attention.