AI/ML Foundations for Absolute Beginners (AgenticAI + MLOps)

What is Machine Learning?

"Machine Learning is the field of study that gives computers the ability to learn without being explicitly programmed." — Arthur Samuel, 1959

Traditional Programming:

• Explicit rules: IF this, THEN that

• Human writes all the logic

• Static behavior once deployed

Machine Learning:

• Learn patterns from data

• Generate rules automatically

• Adapt behavior as data changes

The Cooking Analogy

Traditional Programming:

• Following a precise recipe with exact measurements

• Same ingredients always produce the same dish

• Changes require rewriting the recipe

Machine Learning:

• Learning cooking principles by studying many dishes

• Understanding flavor combinations and techniques

• Creating new dishes based on learned patterns

Traditional Programming vs Machine Learning

Traditional Programming:

IF income > 100000 AND credit_score > 700 AND debt_ratio < 0.3 THEN loan_approved = TRUE ELSE loan_approved = FALSE

Machine Learning:

model.train(historical_loan_data) loan_approved = model.predict(new_application)

When to Use Machine Learning

Good candidates for ML:

• Complex patterns (facial recognition)

• Dynamic environments (stock market)

• Personalization (recommendations)

• Natural language understanding

Not ideal for ML:

• Simple logic (calculating taxes)

• Situations requiring 100% accuracy

• Limited data availability

• When explainability is critical

The Evolution of Programming

1950s-1960s: Write explicit instructions for every action

1970s-1990s: Create abstractions (functions, objects, APIs)

2000s-Present: Let machines learn patterns from data

Future: Autonomous systems that continuously learn and adapt

ML Paradigms: Three Learning Approaches

Think of ML paradigms as different teaching methods:

• Supervised Learning: Learning with examples and answers

• Unsupervised Learning: Learning through observation

• Reinforcement Learning: Learning through experience

Supervised Learning: Learning with a Teacher

How it works:

• Provide input-output pairs (labeled data)

• Model learns the mapping function

• Use model to predict outputs for new inputs

The Driving Instructor Analogy:

• Instructor provides examples of good driving

• Points out mistakes and correct actions

• Eventually, you drive independently using learned skills

Supervised Learning: Classification vs Regression

Classification:

• Predicting categories or classes

• Output is discrete (spam/not spam)

• Like sorting mail into different bins

Examples: Email filtering, disease diagnosis, sentiment analysis

Regression:

• Predicting continuous values

• Output is a number (price, temperature)

• Like estimating how many jellybeans are in a jar

Examples: House price prediction, temperature forecasting, sales projections

Supervised Learning: Real World Example

Credit Card Fraud Detection:

1. Training Data:

   • Thousands of transactions labeled as "fraudulent" or "legitimate"

   • Features: amount, location, time, merchant type, etc.

2. Learning Process:

   • Model learns patterns associated with fraud

   • Example: unusual locations, atypical purchase amounts

3. Deployment:

   • Real-time scoring of new transactions

   • Alert or block suspicious activities

Unsupervised Learning: Finding Hidden Patterns

How it works:

• Only input data provided (no labels)

• Model discovers structure in data

• Useful for finding unknown patterns

The Librarian Analogy:

• Books arrive with no categories

• Librarian organizes based on similarities

• Creates a system without prior categorization

Unsupervised Learning: Main Types

Clustering:

• Grouping similar items together

• Example: Customer segmentation for targeted marketing

• Like organizing clothes by type in your closet

Dimensionality Reduction:

• Simplifying data while preserving meaning

• Example: Compressing images or identifying key features

• Like creating a summary of a long document

Unsupervised Learning: Real World Example

Customer Segmentation:

1. Data Collection:

   • Customer information: purchases, browsing behavior, demographics

2. Analysis:

   • Algorithm identifies natural groupings

   • No predefined categories

3. Results:

   • "Budget-conscious young professionals"

   • "Luxury-oriented empty nesters"

   • "Tech-savvy early adopters"

4. Application:

   • Personalized marketing campaigns

   • Product recommendations

   • Inventory planning

Reinforcement Learning: Learning by Doing

How it works:

• Agent interacts with environment

• Receives rewards or penalties

• Learns to maximize rewards over time

The Pet Training Analogy:

• Dog performs actions (sit, stay)

• Owner gives treats for good behavior

• Dog learns which behaviors earn rewards

Reinforcement Learning Components

• Agent: The decision-maker (ML model)

• Environment: The world the agent operates in

• State: Current situation

• Action: What the agent can do

• Reward: Feedback signal

• Policy: Strategy for choosing actions

Reinforcement Learning: Real World Example

Autonomous Vehicles:

1. Agent: Self-driving car system

2. Environment: Roads, traffic, weather

3. States: Position, speed, surrounding vehicles

4. Actions: Accelerate, brake, turn

5. Rewards:

   • Positive: Safe driving, reaching destination efficiently

   • Negative: Collisions, traffic violations, passenger discomfort

6. Learning: Millions of simulated and real driving scenarios

Comparing ML Paradigms

Paradigm Data Goal Real-World Example Supervised Labeled Predict outputs Spam filter Unsupervised Unlabeled Find structure Customer segments Reinforcement Feedback Optimize strategy Game playing

Hybrid approaches often combine these paradigms for complex problems.

Choosing the Right Approach

Supervised Learning when:

• You have labeled examples

• You know what you want to predict

• You need specific outputs

Unsupervised Learning when:

• You lack labels

• You want to discover patterns

• You need to group or compress data

Reinforcement Learning when:

• There's sequential decision making

• You can define clear rewards

• The environment can be simulated

The ML Journey: From Data to Decisions

1. Problem Definition: What are you trying to solve?

2. Data Collection: Gathering relevant information

3. Data Preprocessing: Cleaning, formatting, feature engineering

4. Model Selection: Choosing the right algorithm

5. Training & Evaluation: Learning from data and testing

6. Deployment: Putting the model into production

7. Monitoring & Updating: Ensuring continued performance

Summary: Machine Learning Basics

Key Takeaways:

• ML enables computers to learn from data without explicit programming

• Supervised learning uses labeled examples to predict outcomes

• Unsupervised learning finds patterns in unlabeled data

• Reinforcement learning optimizes behavior through feedback

• Choosing the right approach depends on your data and goals

Coming Next: Key ML Terminology

Building Blocks of Machine Learning

Understanding key terminology is essential for:

• Communicating with ML practitioners

• Setting up effective MLOps workflows

• Diagnosing issues in ML systems

• Making informed design decisions

Let's explore the fundamental concepts...

Features & Labels: The Raw Materials

Features (X):

• Input variables used for prediction

• The "ingredients" of your model

• Represented as columns in your dataset

Labels (Y):

• Output values you're trying to predict

• The "answers" your model learns from

• The target variable in supervised learning

Features & Labels: The Detective Analogy

Features are like clues:

• Individual pieces of information

• Some more relevant than others

• Collectively help solve the mystery

Labels are like case solutions:

• The answer you're trying to predict

• Known for past cases (training data)

• Unknown for new cases (test data)

Features in the Real World

E-commerce Example:

• Raw Features: user_id, product_id, timestamp

• Derived Features: time_since_last_visit, items_in_cart

• Engineered Features: user_purchase_frequency, price_sensitivity_score

The quality of your features often matters more than the sophistication of your algorithm!

Feature Engineering: The Secret Sauce

Raw Features vs. Engineered Features:

Raw: Date = "2023-03-15" ↓ Engineered: - Day_of_week = "Wednesday" - Month = "March" - Is_holiday = False - Shopping_season = "Spring"

Why it matters:

• Transforms raw data into meaningful signals

• Incorporates domain knowledge

• Often the difference between average and exceptional models

Dataset Splitting: The Learning Journey

Training Set (60-80%):

• Textbooks and classroom exercises

• Where the model learns patterns

• Can make and learn from mistakes

Validation Set (10-20%):

• Practice tests

• Fine-tune model parameters

• Prevent memorization (overfitting)

Test Set (10-20%):

• Final exam

• Evaluate real-world performance

• Never seen during training

The School Analogy for Dataset Splitting

Training Set:

• Learning material during the semester

• Homework assignments with solutions

• Practice problems with feedback

Validation Set:

• Mid-term exams

• Adjust study strategy based on performance

• Identify weak areas before the final

Test Set:

• Final exam

• True measure of knowledge

• No answers provided during testing

The Golden Rule of ML

Never peek at your test data!

Data Leakage occurs when test information influences training.

Like:

• Seeing exam questions before the test

• Studying the answer key instead of learning concepts

• Teaching to the test instead of teaching the subject

Consequences: Overestimated model performance that fails in production

Training vs. Inference: Two ML Phases

Training Phase:

• Learning patterns from historical data

• Computationally intensive

• Updates model parameters

• Runs on specialized hardware (often GPUs)

• Happens periodically (daily/weekly/monthly)

Inference Phase:

• Applying learned patterns to new data

• Computationally efficient

• Fixed model parameters

• Can run on various hardware (CPU/mobile/edge)

• Happens continuously (often in real-time)

Training vs. Inference: The Cooking Class Analogy

Training: The cooking class where the chef learns:

• Experimenting with recipes and techniques

• Making adjustments based on taste tests

• Learning from failures and successes

• Taking hours or days to perfect a dish

Inference: The restaurant service:

• Using established recipes

• Preparing dishes consistently

• Serving customers quickly

• Taking minutes to deliver the final product

Overfitting vs. Underfitting: The Goldilocks Problem

Underfitting:

• Model is too simple

• Misses important patterns

• Poor performance on all data

Just Right:

• Captures true patterns

• Generalizes well to new data

• Balances simplicity and accuracy

Overfitting:

• Model is too complex

• Memorizes training data

• Poor performance on new data

Overfitting vs. Underfitting: The Memorization Analogy

Underfitting:

• A student who didn't study enough

• Only understands basic concepts

• Can't solve advanced problems

Just Right:

• A student who learned the principles

• Can apply knowledge to new situations

• Understands underlying concepts

Overfitting:

• A student who memorized example problems

• Can solve identical problems perfectly

• Gets confused by slight variations

Detecting Fitting Problems

Signs of Underfitting:

• Poor performance on training data

• Simple model for complex data

• High bias in predictions

Signs of Overfitting:

• Perfect on training data, poor on validation

• Complex model for limited data

• Predictions too sensitive to small changes

Monitoring: Plot learning curves to detect issues early

Hyperparameters: The Control Knobs

Parameters vs. Hyperparameters:

Parameters:

• Learned from data during training

• Weights and biases in neural networks

• Automatically optimized

Hyperparameters:

• Set before training begins

• Control the learning process

• Manually configured or tuned

Common Hyperparameters

Learning Rate:

• How quickly the model adapts to new information

• Too high: unstable learning

• Too low: slow convergence

Regularization Strength:

• Controls model complexity

• Helps prevent overfitting

Model-Specific Hyperparameters:

• Trees: depth, number of trees, split criteria

• Neural Networks: number of layers, neurons per layer

• SVM: kernel type, margin parameters

Hyperparameter Tuning: The Restaurant Analogy

Imagine opening a restaurant:

Parameters: Things that change with each meal

• Ingredients used for each dish

• Cooking time for each order

• Seasoning based on customer preferences

Hyperparameters: Restaurant setup decisions

• Kitchen layout design

• Types of cooking equipment

• Menu selection and pricing strategy

Tuning: Finding the optimal restaurant configuration through experimentation

Hyperparameter Tuning Methods

Grid Search:

• Try all combinations of predefined values

• Comprehensive but computationally expensive

• Like trying every possible restaurant layout systematically

Random Search:

• Sample random combinations

• Often more efficient than grid search

• Like trying random restaurant configurations

Advanced Methods:

• Bayesian Optimization

• Genetic Algorithms

• Neural Architecture Search

Bias-Variance Tradeoff: The Core ML Dilemma

Bias:

• Simplifying assumptions

• Causes underfitting

• Model consistently wrong

Variance:

• Sensitivity to training data fluctuations

• Causes overfitting

• Model inconsistently wrong

Goal: Find the sweet spot that minimizes total error

Bias-Variance: The Archery Analogy

High Bias, Low Variance:

• Arrows consistently hit the same spot, but far from bullseye

• Systematically wrong in the same way

Low Bias, High Variance:

• Arrows scattered all over the target

• Sometimes hit bullseye, sometimes completely miss

Low Bias, Low Variance (Ideal):

• Arrows consistently hit near the bullseye

• Both accurate and precise

Model Evaluation: Measuring Success

Classification Metrics:

• Accuracy: Overall correctness percentage

• Precision: When model predicts yes, how often it's correct

• Recall: What percentage of actual positives were identified

• F1-Score: Harmonic mean of precision and recall

Regression Metrics:

• Mean Absolute Error (MAE): Average absolute difference

• Root Mean Squared Error (RMSE): Root of average squared differences

• R² Score: Proportion of variance explained by model

Learning Curves: Visualizing Model Performance

What they show:

• Performance on training and validation data

• Changes as model learns from more data

• Early signs of overfitting/underfitting

How to read them:

• Large gap between curves: overfitting

• Both curves plateau high: underfitting

• Converging at high performance: good fit

The ML Workflow in Practice

1. Data Collection & Preparation

   • Gather relevant data

   • Clean and preprocess

   • Engineer features

2. Model Development

   • Split into train/validation/test sets

   • Select algorithms

   • Train initial models

3. Model Optimization

   • Tune hyperparameters

   • Address overfitting/underfitting

   • Ensemble or stack models

4. Deployment & Monitoring

   • Implement in production

   • Monitor performance

   • Retrain as needed

MLOps Perspective on Key Terminology

Term MLOps Considerations Features Version control, transformation pipelines Dataset Splitting Reproducible splits, stratification Training Orchestration, resource management Hyperparameters Systematic tuning, configuration tracking Evaluation Metrics logging, visualization Model Versions Registry, lineage tracking

Summary: Key ML Terminology

Key Takeaways:

• Features and labels form the foundation of ML models

• Proper dataset splitting prevents overestimation of performance

• Training and inference have different requirements

• Balancing underfitting and overfitting is critical

• Hyperparameter tuning optimizes model behavior

• Evaluation metrics should match business objectives

Coming Next: Traditional ML Models

Traditional ML Models

A Beginner's Guide

MLOps, LLMOps & Agentic AI Bootcamp

School of DevOps

Once Upon a Time in ML Land...

Imagine a kingdom with different types of helpers:

• Linear Regression: The straight-line drawer

• Decision Trees: The question asker

• Random Forests: The village council

• Neural Networks: The brain mimicker

Each helper has special talents for solving different problems!

Linear Regression: Drawing the Line

Real-Life Story: Sarah wants to predict house prices in her neighborhood.

She notices:

• Bigger houses cost more (usually)

• Older houses cost less (usually)

• More bathrooms mean higher prices (usually)

Linear regression draws the "best-fit line" through all these relationships!

Linear Regression: How It Works

The House Price Example:

House Price = $100,000 (starting point) + $100 × Square Feet + $15,000 × Number of Bedrooms - $2,000 × House Age (years)

For a 2,000 sq ft, 3-bedroom, 10-year-old house: Price ≈ $100,000 + $200,000 + $45,000 - $20,000 = $325,000

When to Use Linear Regression

Perfect for:

• Predicting numbers (prices, temperatures, sales)

• Understanding which factors matter most

• Simple, explainable predictions

Not great for:

• Complex patterns or relationships

• Yes/no questions

Real-world uses:

• Predicting sales based on advertising spend

• Estimating how temperature affects ice cream sales

• Forecasting crop yields based on rainfall

Logistic Regression: Yes or No Questions

Real-Life Story: A doctor named Luis needs to predict if patients have a certain disease.

He looks at:

• Age

• Blood pressure

• Family history

• Certain symptoms

Logistic regression helps him calculate the probability of disease!

Logistic Regression: The S-Curve

Unlike a straight line, logistic regression creates an S-shaped curve:

• Output is always between 0 and 1 (a probability)

• Below 0.5: Probably "No"

• Above 0.5: Probably "Yes"

Email Example:

• 0.95 = 95% chance this is spam

• 0.03 = 3% chance this is spam (probably not spam)

When to Use Logistic Regression

Perfect for:

• Yes/No predictions

• Spam or not spam

• Approved or denied

• Fraud or legitimate

Real-world uses:

• Credit card approval

• Email spam filtering

• Disease diagnosis

• Customer churn prediction (will they quit your service?)

Decision Trees: Playing 20 Questions

Real-Life Story: Carlos works at a bank approving loans. He creates a simple flowchart:

Is income > $50,000? ├── Yes → Is debt-to-income < 30%? │ ├── Yes → APPROVE │ └── No → Check credit score └── No → Is credit score excellent? ├── Yes → APPROVE └── No → DENY

This is exactly how a decision tree works!

Decision Trees: Simple But Powerful

Why people love decision trees:

• Easy to understand (even for non-technical people)

• Can show the tree to others

• Works with all types of data

• Makes decisions similar to humans

Like following a recipe: If this, then do that. Otherwise, do something else.

When to Use Decision Trees

Perfect for:

• When you need to explain your model

• Mixed types of data

• When rules are important

Real-world uses:

• Customer segmentation

• Diagnosis systems

• Risk assessment

• Determining eligibility

Downside: They can become too specific to training data (overfitting)

Random Forests: Asking the Crowd

Real-Life Story: Instead of asking one doctor about your symptoms, imagine asking 100 doctors and taking a vote on their diagnosis.

That's a random forest!

How it works:

1. Create many decision trees (the "forest")

2. Each tree sees slightly different data

3. Get predictions from all trees

4. Take the majority vote (or average)

Random Forests: Wisdom of the Trees

Why it works:

• Individual trees might make mistakes

• But they tend to make different mistakes

• The majority is usually right

• Less likely to overfit than a single tree

Like a democracy of trees!

When to Use Random Forests

Perfect for:

• When you need high accuracy

• When a single decision tree overfits

• When you have a reasonable amount of data

• When you want feature importance rankings

Real-world uses:

• Credit risk assessment

• Predicting disease outcomes

• Recommendation systems

• Fraud detection

Support Vector Machines: Finding Boundaries

Real-Life Story: Maria needs to separate ripe vs. unripe fruits on a conveyor belt.

SVM finds the best dividing line by maximizing the "gap" between the groups.

Like: Finding the fairest way to split a room between two roommates, leaving maximum buffer space between their areas.

When to Use Support Vector Machines

Perfect for:

• Clear separation between categories

• Working with limited data

• High-dimensional data

• When you need a clear boundary

Real-world uses:

• Image classification

• Text categorization

• Handwriting recognition

• Detecting manufacturing defects

Neural Networks: Brain-Inspired Learning

Real-Life Story: Alex wants to recognize handwritten digits (0-9) automatically.

Simple rules don't work because everyone writes differently!

A neural network can learn the patterns by seeing thousands of examples, similar to how you learned to recognize digits as a child.

Neural Networks: Simplified

The Restaurant Analogy:

• Input Layer: Taking customer orders

• Hidden Layer: Kitchen staff processing orders

• Output Layer: Final dishes delivered to customers

Data flows through the network, being transformed at each step!

When to Use Neural Networks

Perfect for:

• Complex patterns (images, speech, text)

• When other models struggle

• When you have lots of data

• When accuracy matters more than explainability

Real-world uses:

• Image recognition

• Voice assistants

• Translation

• Recommendation systems

Choosing the Right Model: The Vehicle Analogy

Bicycle (Linear/Logistic Regression):

• Simple, easy to understand

• Gets you there on flat, smooth roads

• Limited capability but practical

Car (Decision Trees/Random Forests):

• More versatile

• Handles more conditions

• Good balance of power and practicality

Airplane (Neural Networks):

• Powerful, handles complex journeys

• Requires more resources

• Best for difficult terrain

Model Evaluation: Did It Work?

The Dating Analogy:

Accuracy: How often did you pick a good match?

• 90% accuracy = 9 out of 10 dates were good matches

Precision: When you thought there was a match, how often were you right?

• High precision = When you say "we'll click," you're usually right

Recall: How many good matches did you find out of all possible matches?

• High recall = You find most of the people you'd be compatible with

Regression Metrics Made Simple

Predicting House Prices:

Mean Absolute Error (MAE):

• On average, how many dollars are you off by?

• MAE = $15,000 means predictions are off by $15,000 on average

R² (R-Squared):

• How much better are you than just guessing the average price?

• R² = 0: No better than guessing the average

• R² = 1: Perfect predictions

• R² = 0.7: 70% better than guessing the average

Summary: ML Models Simplified

Remember:

• Linear Regression: Drawing the best straight line through data

• Logistic Regression: Yes/no probability predictions

• Decision Trees: Flowchart of yes/no questions

• Random Forests: Committee of decision trees voting

• Neural Networks: Brain-inspired pattern recognition

The right model depends on your specific problem

Large Language Models (LLMs)

A Complete Beginner's Guide

MLOps, LLMOps & Agentic AI Bootcamp

School of DevOps

What Are Large Language Models?

LLMs are AI systems that:

• Read and write text like humans

• Complete your sentences

• Answer your questions

• Write stories, emails, and code

• Translate languages

• Summarize long documents

Popular examples: ChatGPT, Google Gemini, Claude, Llama

The Library Analogy

Imagine an LLM as a massive library:

Traditional ML Models:

• A small bookshop with specific books

• Good at one topic (like only sports books)

Large Language Models:

• A giant library containing millions of books

• Has "read" almost everything on the internet

• Can talk about nearly any topic

• Combines knowledge in new ways

A Day with LLMs: Real-Life Uses

Meet Priya, a marketing manager in Bengaluru:

Morning: Asks an LLM to summarize 5 market research reports

Noon: Uses it to draft email responses to clients

Afternoon: Creates social media post ideas for a new campaign

Evening: Translates content to Hindi and Tamil

"It's like having a versatile assistant who can handle almost any text-based task!"

How Do LLMs Work? The Prediction Game

LLMs play a sophisticated "guess the next word" game:

Example:

• Input: "The capital of India is..."

• LLM predicts: "New Delhi"

Through billions of such predictions, LLMs learn:

• Grammar and language rules

• Facts about the world

• How to reason and respond

• Cultural references

What Are "Tokens"?

Tokens are the bite-sized pieces of text an LLM processes:

• Parts of words or whole words

• Punctuation marks

• Special characters

Example: "I love eating samosas" might become: ["I", "love", "eat", "ing", "samo", "sas"]

Think of tokens as:

• The individual pieces LLMs read and write

• Like letters in a Scrabble game

The Token Limit: Short-Term Memory

Context Window = How much text an LLM can "see" at once

The Conversation Analogy:

• Like a person who can only remember the last few minutes of conversation

• Earlier parts get forgotten when new information comes in

• Newer models remember more (larger context windows)

ChatGPT: Can remember about 8,000 words Claude, GPT-4: Can remember 50,000+ words

What Are "Parameters"?

Parameters are the "knowledge knobs" in an LLM:

• Adjustable values that store what the model has learned

• More parameters = more storage for language patterns

• Modern LLMs have billions of parameters

The Brain Cell Analogy:

• Like connections between brain cells

• Each connection stores a tiny piece of knowledge

• Billions of connections create a thinking system

The Memory Palace Analogy for Parameters

Imagine parameters as rooms in a memory palace:

• Small model (1 million parameters): A house with 1,000 rooms for storing knowledge

• Medium model (7 billion parameters): A city with 7 million buildings

• Large model (175 billion parameters): A country with 175 million buildings

Each "room" stores a tiny piece of language knowledge

Why "Large" Matters in LLMs

1. Data: Trained on trillions of words from:

• Books, articles, websites

• Code repositories

• Wikipedia, news, forums

2. Parameters: Billions of adjustable values

• GPT-3: 175 billion parameters

• Like having 175 billion "memory cells"

3. Computing: Thousands of specialized chips

• Training can cost millions of dollars

• Like building a supercomputer just for language

The History of LLMs: A Short Story

Chapter 1 (Before 2017): Simple models that predicted words, often making mistakes

Chapter 2 (2017): The "Transformer" invention changes everything

Chapter 3 (2018-2020): Models grow larger, showing surprising abilities

Chapter 4 (2022-2023): ChatGPT makes LLMs mainstream

Chapter 5 (2023-Present): Models become multi-talented (text, images, code)

The Transformer: What Makes Modern LLMs Possible

Before Transformers:

• Models processed text one word at a time

• Like reading a book with a tiny flashlight, seeing one word at a time

With Transformers:

• Models look at all words at once and understand relationships between them

• Like reading a book with the full page visible, seeing how words connect

This was the breakthrough that enabled modern LLMs!

The Transformer Architecture: A School Classroom

Imagine a classroom:

Self-Attention: Students listening to each other discuss a topic, focusing on important points

Multi-Head Attention: Different study groups focusing on different aspects (grammar, content, context)

Feed-Forward Networks: Students individually processing what they heard

Result: Better understanding of the whole text

Attention: The Magic of "Looking at Relationships"

The Party Conversation Analogy:

When you hear "bank" in a conversation, you need context to understand the meaning:

"I deposited money at the bank" → Financial institution "I went fishing by the river bank" → Edge of a river

Self-Attention allows the model to:

• Look at all words together

• Understand how they relate to each other

• Focus on relevant words for context

• Disambiguate meanings based on context

The Attention Mechanism: Simple Example

Sentence: "The man who wore a mask couldn't be recognized"

Without Attention: Model might connect "mask" and "recognized" but miss their relationship

With Attention:

• When processing "recognized"

• Pays strong attention to "mask" and "couldn't"

• Understands the mask prevented recognition

Like connecting the dots between related words, even if they're far apart

Pre-training: The General Education Phase

The School Analogy:

Pre-training = General Education (K-12)

• Learning broadly about many subjects

• Building a foundation of knowledge

• No specific career goal yet

• Takes many years (or enormous computing power for LLMs)

The Process:

• Model reads trillions of words from the internet

• Predicts missing or next words

• Adjusts its parameters to improve predictions

• Eventually learns language patterns and knowledge

Fine-tuning: The Specialized Training Phase

The School Analogy (continued):

Fine-tuning = Specialized Education (College/Professional Training)

• Focused on specific skills

• Builds on general knowledge

• Prepares for specific career

• Takes less time than general education

Example:

• Start with pre-trained model that understands language

• Show it examples of customer service conversations

• It learns the specific style and knowledge for customer support

• Result: A specialized customer service AI

Pre-training vs. Fine-tuning: A Restaurant Story

Meet Rahul, who wants to become a chef:

Pre-training (General Cooking Knowledge):

• Spends years learning all cuisines

• Masters basic techniques

• Understands ingredients

• Learns food science

• Very expensive and time-consuming

Fine-tuning (Specialization):

• Takes additional training in South Indian cuisine

• Much shorter training period

• Uses existing cooking knowledge

• Less expensive

• Results in a specialized South Indian chef

Foundation Models vs. Task-specific Models

Foundation Models:

• General-purpose, like a skilled worker with basic training

• Can do many tasks reasonably well

• Examples: GPT-4, Llama, Claude

Task-Specific Models:

• Specialized, like a professional in a specific field

• Excel at one particular task

• Examples: Code-generation models, medical assistants

Like the difference between:

• A general handyman who can fix many things

• A specialized electrician who's expert in one area

Talking to LLMs: Introduction to Prompts

A "prompt" is simply what you say to an LLM to get a response

The Tour Guide Analogy:

• LLM is like a tour guide in a new city

• Without specific directions, they might show you random sights

• Clear directions get you exactly where you want to go

Example:

• Vague: "Tell me about India"

• Specific: "Write a 2-paragraph summary of India's space program achievements"

Prompt Engineering: The Art of Clear Instructions

Bad Prompt: "Write something about climate"

Good Prompt: "Write a 300-word explanation of climate change impacts in Mumbai for a 10th-grade student. Include 3 specific examples and potential solutions."

What Makes It Better:

• Clear length (300 words)

• Specific topic (climate change in Mumbai)

• Defined audience (10th-grade)

• Exact requirements (3 examples, solutions)

Prompt Engineering: Using Examples

Teaching by Example:

Showing examples helps LLMs understand exactly what you want:

Convert these statements to Hindi: English: Hello, how are you? Hindi: नमस्ते, आप कैसे हैं? English: Where is the railway station? Hindi:

Like training a new employee by showing them examples of good work

The Role You Assign: Setting the Stage

You can tell an LLM to assume a specific role:

You are an experienced math teacher explaining concepts to 8-year-old children. Explain multiplication in simple terms.

Other useful roles:

• "You are a cybersecurity expert..."

• "You are a chef specializing in North Indian cuisine..."

• "You are a helpful coding assistant..."

This helps frame how the LLM responds

Controlling LLM Output: Temperature

"Temperature" controls how creative or predictable the LLM is:

Low Temperature (0.1-0.3):

• More predictable, focused responses

• Good for factual answers, code, specific instructions

• Like following a recipe exactly

High Temperature (0.7-1.0):

• More creative, varied, surprising responses

• Good for brainstorming, creative writing

• Like experimenting in the kitchen

Temperature: A Story of Two Chefs

Chef Anil (Low Temperature = 0.2):

• Always follows recipes precisely

• Consistent results every time

• Excellent for standard dishes

• Not very creative or experimental

Chef Prisha (High Temperature = 0.8):

• Uses recipes as inspiration

• Results vary and surprise

• Creates unique combinations

• Sometimes makes unusual choices

Both are valuable for different situations!

What Are "Top-p" and "Top-k"?

These control which words the LLM considers when generating text

The Restaurant Menu Analogy:

Top-k = limiting choices to k most likely options

• Like only considering the 10 most popular dishes on a menu

Top-p (nucleus sampling) = considering options until reaching a probability threshold

• Like considering dishes that make up 80% of all orders

Both help control randomness and quality of generated text

LLM Limitations: Hallucinations

"Hallucinations" = confidently stating incorrect information

The Overconfident Student Analogy:

• A student who makes up answers rather than saying "I don't know"

• Sounds convincing but may be completely wrong

Example: Question: "Who was the first female astronaut from India?"

Hallucinated Answer: "Ritu Karidhal was the first female astronaut from India, completing her space mission in 1997."

Reality: Kalpana Chawla was the first Indian-born woman in space (2003). Ritu Karidhal is a rocket scientist, not an astronaut.

Why Do Hallucinations Happen?

LLMs are trained to:

1. Continue text in plausible ways

2. Sound confident and fluent

3. Provide complete-looking answers

But they don't actually:

• Truly understand facts

• Know when they don't know

• Check their knowledge

It's like a student who prioritizes having an answer over having the correct answer

LLM Limitations: Knowledge Cutoff

LLMs only know information up to their training cutoff date

The Frozen Library Analogy:

• Like a library that stopped receiving new books after a specific date

• Very knowledgeable about things before that date

• Completely unaware of events after that date

Example: "ChatGPT's knowledge cutoff is January 2022, so it doesn't know about events that happened after that date unless recently updated."

LLM Limitations: Context Window

Context window = how much text an LLM can consider at once

The Short-Term Memory Analogy:

• Like a person who can only remember the last few minutes of conversation

• Can only "see" a limited amount of text at once

• If content exceeds this limit, early information is forgotten

Analogy: Trying to read a book through a small window that only shows a few pages at a time

More Limitations of LLMs

Reasoning Limitations:

• Struggle with complex logic puzzles

• May make simple math errors

• Can miss contradictions in their own text

Bias Issues:

• Reflect biases in their training data

• May generate stereotyped content

• Can treat topics unevenly

Lack of True Understanding:

• Don't truly "understand" meaning

• Pattern matching rather than comprehension

• No genuine knowledge or beliefs

Solving the Knowledge Problem: RAG

Retrieval-Augmented Generation (RAG):

• Combines LLMs with information retrieval

• Searches databases or documents for relevant information

• Includes this information in the prompt

• Results in more factual, up-to-date answers

The Assistant with a Reference Library:

• LLM alone = Smart person making educated guesses

• LLM with RAG = Smart person with access to reference library

RAG: How It Works in Simple Terms

1. User asks a question: "What were the key announcements in the 2024 Indian budget?"

2. System searches a database of reliable sources (finds recent articles about the 2024 budget)

3. System includes this information in the prompt: "Based on the following information: [budget details]... Answer the question about the 2024 Indian budget"

4. LLM generates response using this reliable information

Result: More accurate, up-to-date answers!

LLMs in Production: Size Matters

The challenge: LLMs are HUGE

GPT-3 (175B parameters):

• ~350GB model size

• Expensive to run

• Requires specialized hardware

Solutions:

• Cloud APIs (use someone else's infrastructure)

• Model compression (make models smaller)

• Specialized hardware (optimize for AI)

Running LLMs: Your Options

1. Using Cloud APIs:

• OpenAI, Google, Anthropic, etc.

• Pay per use (per token)

• No technical hassle

• Limited control

2. Running Your Own:

• Open-source models (Llama, Mistral)

• Full control

• Higher technical complexity

• Significant hardware needs

• Privacy advantages

Making LLMs Smaller and Faster

Quantization:

• Reducing numerical precision

• Like compressing a high-res photo to medium quality

• 2-4x smaller with minimal quality loss

Distillation:

• Creating smaller "student" models

• Like teaching a summary of knowledge to a new model

• Faster but slightly less capable

Pruning:

• Removing less important connections

• Like editing down a long essay to key points

LLMOps: Running LLMs in Production

Unique Challenges:

• Managing prompts like code (versioning)

• Monitoring for harmful outputs

• Detecting hallucinations

• Keeping costs under control

• Handling high traffic efficiently

The Factory Analogy:

• Traditional MLOps = Regular factory

• LLMOps = Factory with special requirements for fragile, expensive materials

Real World Example: LLM-Powered Customer Service

Deepika implements an LLM system for her e-commerce company:

The System:

• Uses fine-tuned LLM for customer service

• Connects to product database (RAG approach)

• Has guardrails for sensitive topics

• Falls back to human agents when uncertain

Benefits:

• 24/7 support coverage

• Handles 70% of queries automatically

• Reduces wait times

• Frees human agents for complex cases

Getting Started with LLMs: First Steps

1. Start with cloud APIs:

• OpenAI, Claude, etc.

• Low technical barrier

2. Experiment with prompts:

• Learn prompt engineering basics

• Try different instructions and formats

3. For developers:

• Try open-source models like Llama

• Explore model hosting options

• Learn about fine-tuning and RAG

Summary: Large Language Models (LLMs)

Key Takeaways:

• LLMs are AI systems that understand and generate human-like text

• They work by predicting tokens (pieces of text) based on patterns

• Transformer architecture with attention revolutionized language models

• Parameters are the "knowledge storage units" in LLMs

• Pre-training teaches general language, fine-tuning adds specialization

• Prompts are how we instruct LLMs

• Limitations include hallucinations, knowledge cutoff, and context windows

• RAG enhances LLMs with external knowledge sources

Agentic AI Basics

Understanding AI That Takes Action

MLOps, LLMOps & Agentic AI Bootcamp

School of DevOps

What is Agentic AI?

Agentic AI systems:

• Can take actions on their own to complete tasks

• Make decisions based on their goals

• Use tools and interact with the world

• Remember past actions and learn from them

• Work independently with minimal human supervision

Think of them as: AI assistants that don't just answer questions but can actually do things for you!

The Personal Assistant Analogy

Traditional AI (like simple chatbots):

• Like an advisor who can only give information

• "The best restaurant nearby is Spice Garden."

LLMs (like ChatGPT):

• Like an advisor who can have conversations and create content

• "Here's a detailed restaurant recommendation and directions."

Agentic AI:

• Like a personal assistant who can actually make the reservation for you

• "I've booked a table at Spice Garden for 7:30 PM and added it to your calendar."

The Four Key Components of Agentic AI

1. Goals: What the agent is trying to achieve

2. Tools: Capabilities the agent can use

3. Memory: Information the agent can store and recall

4. Planning: How the agent decides what to do next

The Road Trip Analogy:

• Goals: Your destination

• Tools: Your car, GPS, and credit card

• Memory: Remembering routes and past experiences

• Planning: Mapping the journey and making adjustments

Real-Life Example: Meet AIRA

AIRA (AI Research Assistant):

Deepak, a researcher in Mumbai, uses AIRA to help with his work:

1. Deepak asks AIRA to research recent advances in renewable energy

2. AIRA searches the web, finds relevant papers, and summarizes them

3. AIRA creates a bibliography in the proper format

4. AIRA monitors for new publications on this topic

5. When new research appears, AIRA notifies Deepak

All of this happens with minimal oversight from Deepak!

How Agentic AI Differs from Regular AI

Traditional ML Models:

• Make specific predictions

• Run once when called

• No memory between uses

• Limited to one task

LLMs (like plain ChatGPT):

• Generate text responses

• Limited to conversation

• Can't take real-world actions

Agentic AI:

• Makes decisions and takes actions

• Persistent with ongoing tasks

• Remembers past interactions

• Uses multiple tools to achieve goals

Goals: The Driving Force

Goals give agents purpose and direction.

Types of Goals:

• Task-based: Complete a specific task (book a flight)

• Optimization: Maximize or minimize something (find the cheapest flight)

• Maintenance: Keep something in a desired state (monitor price changes)

• Learning: Gather information (research travel destinations)

Like humans, agents need clear goals to be effective!

The Importance of Clear Goals

Unclear Goal: "Find me something about travel"

Clear Goal: "Find me the 3 cheapest flights from Delhi to Bangkok departing next weekend, compare their amenities, and book the one with the best balance of price and comfort."

The GPS Analogy:

• Without a specific address, GPS can't give you directions

• Similarly, agents need specific goals to work effectively

• The clearer the goal, the better the result

Tools: How Agents Interact with the World

Tools are the abilities that allow agents to take actions.

Common Tools:

• Web browsers and search engines

• APIs (weather, maps, flight booking)

• Data analysis tools

• Calendar and email access

• Document creation and editing

• Code execution environments

Just as humans use tools to extend their capabilities, agents use tools to accomplish tasks.

Real-World Tool Examples

Weather API: Get current weather or forecast

get_weather(location="Mumbai", forecast_days=5)

Search Tool: Find information online

web_search(query="best restaurants in Bengaluru")

Calendar Tool: Schedule appointments

calendar_add_event(title="Team Meeting", date="2025-03-10", time="14:00")

Each tool has specific inputs and outputs the agent must understand.

Memory: Remembering What Matters

Without memory, agents would start from scratch every time.

Types of Memory:

• Short-term: Current conversation or task information

• Long-term: Knowledge from past interactions

• Episodic: Specific events or actions taken

• Procedural: How to perform certain tasks

The Human Memory Analogy: Just as you remember your friends' preferences when buying gifts, agents remember your preferences and past interactions.

Memory in Action: A Story

Meet Priya and her AI Shopping Assistant:

First Interaction: Priya: "I'm looking for gifts for my mother." Agent: "What does your mother like?" Priya: "She loves gardening and the color purple." Agent: [Stores this information in memory]

One Month Later: Priya: "I need a birthday present for my mother." Agent: "Based on our previous conversation, would you like to see purple gardening tools or botanical gifts?"

This continuity makes agents feel more helpful and personalized.

Planning: The Decision-Making Process

Planning is how agents decide which actions to take to achieve their goals.

The Chess Player Analogy:

• Consider possible moves (actions)

• Evaluate outcomes of each move

• Choose the best path forward

• Adjust strategy as the game evolves

Types of Planning:

• Sequential: Step-by-step approach

• Hierarchical: Breaking goals into sub-goals

• Reactive: Responding to changing conditions

• Probabilistic: Dealing with uncertainty

Planning Methods in Agentic AI

Common Approaches:

1. Chain-of-Thought: The agent thinks through steps logically

To book a flight, I first need to search available options, then compare prices, then check baggage policies...

1. Tree of Thoughts: The agent considers multiple possible paths

If I search by price, I might find cheaper options. If I search by duration, I might find more convenient options. Let me try both approaches and compare...

1. ReAct (Reasoning + Acting): The agent alternates between reasoning and taking actions

The Agent Loop: How Agents Work

The fundamental process of agentic AI:

1. Observe: Gather information about the current state

2. Think: Process information and decide what to do

3. Act: Take action using available tools

4. Learn: Update knowledge based on results

5. Repeat: Continue this loop until the goal is achieved

This loop allows agents to work through complex tasks step by step.

The Agent Loop: Real Example

Goal: Book a restaurant for dinner tonight

1. Observe: User wants restaurant for 4 people, Indian cuisine, in Bengaluru 2. Think: Need to find restaurants, check availability, make reservation 3. Act: Search for "top-rated Indian restaurants in Bengaluru" 4. Observe: Found 5 matching restaurants 5. Think: Need to check availability for each 6. Act: Check reservation system for each restaurant 7. Observe: 3 restaurants have availability at 8:00 PM 8. Think: Should present options to user 9. Act: Present the 3 options with ratings and menus ...and so on until the reservation is completed

Agentic AI Architecture: The Building Blocks

Main Components:

• LLM Brain: Core reasoning capability (often GPT-4 or similar)

• Tool Library: Collection of available actions

• Memory System: Storage for past interactions and knowledge

• Planning Module: Decision-making process

• Execution Engine: Carries out the planned actions

• Safety Guardrails: Ensures responsible behavior

LLM as the Brain of Agents

The Central Role of LLMs:

• LLMs provide the reasoning capability

• They understand natural language instructions

• They can generate thoughts and action plans

• They interpret results of actions

• They communicate with users

Think of an LLM as the "brain" that powers the agent's thinking, while tools are the "hands" that allow it to act.

Types of Agentic AI Systems

Based on autonomy level:

• Semi-autonomous: Require confirmation for actions

  • "I found these flights. Should I book the 9:00 AM departure?"

• Fully autonomous: Complete tasks independently

  • "I've booked your flight based on your preferences. Confirmation sent to your email."

Based on task scope:

• Specialists: Excel at specific domains (travel booking, coding)

• Generalists: Handle a wide range of tasks with less depth

Popular Agentic AI Examples

AutoGPT:

• One of the first popular autonomous agents

• Can run multiple steps without intervention

• Uses GPT models for reasoning

BabyAGI:

• Simple, task-focused agent framework

• Breaks down goals into manageable tasks

• Demonstrates basic autonomous behavior

Microsoft Copilot:

• Commercial agentic AI for productivity

• Helps with writing, coding, and data analysis

• Integrates with Microsoft tools and services

The Emergence of Multi-Agent Systems

Multi-agent systems have multiple AI agents working together:

• Different agents with specialized roles

• Agents communicate and collaborate

• Can solve more complex problems

• Inspired by human team collaboration

The Restaurant Kitchen Analogy:

• Head chef (coordinator)

• Line cooks (specialists)

• Waitstaff (interface with customers)

• Dishwashers (maintenance)

Together they accomplish what would be difficult for a single agent.

Real-World Multi-Agent Example: Software Development

Development Team of AI Agents:

• Product Manager Agent: Defines requirements and priorities

• Architect Agent: Creates high-level design

• Developer Agents: Write specific code modules

• Testing Agent: Finds bugs and issues

• Documentation Agent: Creates user guides

Each specialized agent handles part of the process while communicating with others.

Agentic AI in Business: Real Applications

Customer Service:

• Agents that handle the entire customer journey

• Can look up information, make changes to accounts, process refunds

Research & Analysis:

• Agents that gather information from multiple sources

• Analyze data and create comprehensive reports

Administrative Support:

• Scheduling meetings based on availability

• Managing email and organizing information

• Preparing documents and presentations

Software Development:

• Writing, testing, and debugging code

• Creating documentation

• Deploying applications

Agentic AI: Challenges and Limitations

Current Challenges:

1. Tool Brittleness:

   • Tools break or change over time

   • APIs may have unexpected behaviors

2. Planning Limitations:

   • Difficulty with complex, long-term planning

   • Sometimes gets stuck in loops

3. Safety Concerns:

   • Potential for harmful actions if not properly constrained

   • Security risks with powerful tools

4. Alignment Problems:

   • Ensuring agent goals match human intentions

   • Avoiding unwanted side effects

The Future of Agentic AI

Coming developments:

• More capable reasoning: Better planning and problem-solving

• Extended memory: Richer, more useful long-term memory

• Better tool use: More reliable and diverse tool integration

• Improved collaboration: Both human-AI and AI-AI teamwork

• Specialized domains: Industry-specific agents with deep expertise

The long-term vision: AI systems that can handle increasingly complex real-world tasks with minimal human supervision.

Building Your First Agent: Starting Simple

Begin with a focused agent:

1. Choose a specific domain

   • E.g., "Research assistant" or "Data analyzer"

2. Define clear tools

   • Search tools, data processing, scheduling

3. Start with supervision

   • Confirm actions before execution

4. Add more abilities gradually

   • Expand tools and autonomy as you gain confidence

Remember: Even simple agents can provide significant value!

Agentic AI and MLOps: The Connection

Unique MLOps challenges for Agentic AI:

• Tool management: Versioning and maintaining tool connections

• Monitoring agent behavior: Tracking actions and decisions

• Agent testing: Evaluating complex, multi-step behaviors

• Safety guardrails: Implementing and updating constraints

• Multi-agent orchestration: Managing teams of agents

MLOps for agents is more complex than for traditional ML or even LLMs!

Case Study: Agentic AI in Healthcare

Dr. Mehta at a hospital in Delhi uses an agentic healthcare assistant:

Capabilities:

• Monitors patient vital signs from hospital systems

• Alerts doctors to concerning changes

• Retrieves relevant patient history

• Suggests possible diagnoses based on symptoms

• Orders routine tests based on protocols

• Schedules follow-up appointments

Result: Dr. Mehta can focus on complex cases while the agent handles routine monitoring and administrative tasks.

Ethical Considerations in Agentic AI

Key questions to consider:

• Transparency: Do users know they're interacting with an agent?

• Control: Can people easily override agent actions?

• Privacy: How is data handled during agent operations?

• Bias: Are agent recommendations fair across different groups?

• Accountability: Who is responsible if an agent makes mistakes?

Responsibility: Creating agents requires thinking through these ethical implications carefully.

Getting Started with Agentic AI: Tools & Frameworks

Popular frameworks:

• LangChain: Tools for building agent workflows

• AutoGPT: Open-source autonomous agent framework

• CrewAI: For building multi-agent systems

• Microsoft Semantic Kernel: Framework for AI agents

Cloud Platforms:

• OpenAI's Assistants API

• Google's Agents for Vertex AI

• Anthropic's Claude with tools

These provide the building blocks for creating your own agents.

Summary: Agentic AI Basics

Key takeaways:

• Agentic AI systems can take actions to complete tasks autonomously

• Four key components: Goals, Tools, Memory, and Planning

• Agent Loop: Observe, Think, Act, Learn, Repeat

• LLMs provide the reasoning "brain" of agents

• Tools connect agents to external systems and capabilities

• Memory allows for continuity across interactions

• Multi-agent systems combine specialized agents for complex tasks

• MLOps for agents requires special considerations

Thank You!

Questions?

Next Module: Core MLOps, LLMOps & AgenticOps Principles

School of DevOps