AI: From Basics to GenAI
A complete, standalone beginner course — from math intuition through transformers, GenAI, RAG, agentic AI, and production scaling with portfolio-ready projects.
What you'll learn
- Foundations to GenAI
- Hands-on projects
- Self-paced modules
Your progress
0 / 82 lessons reached
Lessons in this path
Work top to bottom within each module, or jump in from the table of contents on each lesson page.
Module 1. Module 1 — Math & intuition
Start here if you are new to AI. Each lesson explains why the idea matters, walks through numeric examples, and connects to the hands-on project — not bullet-point summaries.
- Lesson 135 min
Welcome — start here
Key AI vocabulary (model, training, inference, loss, and more), how to read lessons effectively, what Module 1 covers, and what to install before the project.
- Lesson 275 min
Vectors, matrices, and image data
How photos become grids and lists of numbers — with worked patch examples, flattening walkthroughs, and common shape mistakes explained.
- Lesson 370 min
Dot products — measuring similarity
Multiply-and-add similarity, template matching intuition, brightness bias, cosine similarity, and how classifiers score inputs.
- Lesson 465 min
Probability — when measurements lie a little
Signal and noise, averages and spread, grain in photos, histograms, and why training averages error over many samples.
- Lesson 575 min
Derivatives & gradient descent — how learning works
Slope as uphill/downhill on an error graph, a full numeric walkthrough, the training loop, and tuning learning rate.
- Lesson 655 min
Module 1 quiz & review
25 interactive multiple-choice questions with instant feedback, explanations, and lesson links for topics you miss.
- Lesson 7120 min
Project: predict shading on an image patch
Build gradient descent in NumPy, plot error vs epoch, visualize residuals, and compare with a closed-form solver.
Module 2. Module 2 — Core machine learning
Supervised learning, regression vs classification, honest evaluation with train/val/test splits, precision and recall — ending with a spam classifier served through Node.js and MongoDB.
- Lesson 825 min
Welcome to Module 2
How Module 2 builds on Module 1, what you will learn, what to install before the spam project, and the lesson order.
- Lesson 960 min
Supervised vs unsupervised learning
Labels vs no labels, real-world examples of each, semi-supervised preview, and how to classify a new problem.
- Lesson 1065 min
Regression vs classification
Numeric outputs vs categories, logistic regression naming, multi-class vs binary, and connecting to the Module 1 project.
- Lesson 1170 min
Overfitting & underfitting
Generalization, diagnosing train vs test gaps, bias–variance intuition, and practical fixes like more data and early stopping.
- Lesson 1265 min
Train, validation & test splits
Three-way splits, why validation exists, stratified sampling, and avoiding data leakage before modeling.
- Lesson 1395 min
Metrics — confusion matrix, precision, recall & F1
Build and read confusion matrices, derive precision/recall/specificity/F1, tune thresholds, sklearn classification_report, and ROC/PR preview for imbalanced spam.
- Lesson 1455 min
Module 2 quiz & review
25 interactive multiple-choice questions covering splits, metrics, overfitting, and supervised learning with lesson review links.
- Lesson 15180 min
Project: spam classifier with API & MongoDB
Train logistic regression in Python, report confusion matrix metrics, expose a Node.js classify endpoint, and log predictions to MongoDB.
Module 3. Module 3 — Neural networks basics
Perceptrons, activations, forward and backward passes, loss functions for classification — ending with an MNIST digit classifier and a draw-and-predict UI.
- Lesson 1625 min
Welcome to Module 3
How Module 3 builds on Modules 1–2, what deep learning means at a high level, and what to install before the MNIST project.
- Lesson 1770 min
The perceptron — one neuron
Weighted sum, bias, step vs sigmoid decisions, linear separability, and why XOR needs hidden layers.
- Lesson 1870 min
Activation functions — ReLU & sigmoid
Why non-linearity matters, comparing ReLU and sigmoid, output activations for classification, and vanishing gradients.
- Lesson 1965 min
Forward propagation
Layer-by-layer computation, matrix view of fully connected layers, and tracing a digit through a small network.
- Lesson 2080 min
Backpropagation — how networks learn
Chain rule intuition, backward gradient flow, what each weight learns, and connection to Module 1 gradient descent.
- Lesson 2165 min
Loss functions for neural networks
Cross-entropy with softmax, why MSE is weak for classification, multi-class MNIST loss, and reading training curves.
- Lesson 2255 min
Module 3 quiz & review
25 interactive questions on activations, forward/backward passes, vanishing gradients, and classification loss.
- Lesson 23240 min
Project: MNIST digit classifier + draw UI
Train a network in PyTorch on MNIST, optional NumPy backprop sketch, Next.js canvas UI, and API route for live predictions.
Module 4. Module 4 — Deep learning architectures
CNNs for images, RNNs and LSTM/GRU for sequences, word embeddings for language — ending with a sentiment analysis system and trend dashboard on real review data.
- Lesson 2425 min
Welcome to Module 4
How Module 4 extends Module 3, architecture overview, and what to install before the sentiment project.
- Lesson 2575 min
CNNs — convolution for images
Filters, feature maps, pooling, parameter sharing, and why conv beats flattening for spatial data.
- Lesson 2670 min
RNNs — sequences and hidden state
Unrolling over time, backprop through time intuition, and why vanilla RNNs forget long context.
- Lesson 2775 min
LSTM & GRU — long-term memory
Gating intuition, cell state, forget/input/output gates, and when GRU is enough.
- Lesson 2870 min
Word embeddings — language as vectors
From one-hot to dense vectors, similarity in embedding space, pre-trained vs trained-from-scratch, and GenAI relevance.
- Lesson 2955 min
Module 4 quiz & review
25 interactive questions on CNNs, RNNs, LSTM/GRU, and embeddings with lesson review links.
- Lesson 30240 min
Project: sentiment analysis + dashboard
Train an LSTM on product reviews (own or pre-trained embeddings), expose a Next.js API, and chart sentiment trends over time.
Module 5. Module 5 — Image segmentation
Dense prediction for vision — segmentation types, encoder–decoder math, U-Net, FCN/DeepLab/SegFormer landscape, Mask R-CNN, IoU/Dice training, and a from-scratch pet-mask project.
- Lesson 3135 min
Welcome to Module 5
Why dense prediction matters, full lesson path (U-Net plus other models), study pacing, and how this module connects to CNNs.
- Lesson 3285 min
What is image segmentation?
Task ladder, 4×4 worked example, semantic vs instance vs panoptic, portrait-mode walkthrough, and annotation cost.
- Lesson 3380 min
Encoder–decoder & dense prediction
Spatial size trace through encoder/decoder, receptive field, upsampling choices, mask alignment rules, and bottleneck motivation.
- Lesson 3485 min
U-Net architecture
Skip connections, double conv blocks, shape table for a 256×256 forward pass, concat vs add, and pointer to other model families.
- Lesson 3590 min
Beyond U-Net — FCN, DeepLab, SegFormer
FCN dense prediction, atrous conv and ASPP, pyramid pooling, transformer decoders, and when to pick each family.
- Lesson 3685 min
Instance segmentation & Mask R-CNN
Per-instance masks, two-stage detectors, RoIAlign, mask head, and panoptic segmentation overview.
- Lesson 3780 min
Segmentation losses & metrics
Per-pixel CE wiring, IoU/Dice worked examples, class imbalance traps, pet trimap classes, and what to log each epoch.
- Lesson 3860 min
Module 5 quiz & review
25 interactive questions on segmentation types, U-Net, DeepLab, Mask R-CNN, and IoU/Dice with lesson review links.
- Lesson 39420 min
Project: U-Net pet segmentation
Build U-Net in PyTorch on Oxford-IIIT Pet masks, track mIoU, save overlay visualizations, optional DeepLab compare, and upload demo.
Module 6. Module 6 — Transformers (core of GenAI)
Attention, self-attention, encoder vs decoder, tokenization, and vectorization — concept-first, ending with a mini transformer trained on blog text for next-word prediction.
- Lesson 4025 min
Welcome to Module 6
Why transformers matter, how Module 6 connects to Modules 4–5, and what to install before the text-generation project.
- Lesson 4185 min
Attention mechanism — Query, Key, Value
Why RNNs bottleneck long-range links, the library analogy for Q/K/V, scaled dot-product steps, softmax weights, and cross- vs self-attention preview.
- Lesson 4275 min
Self-attention & multi-head attention
Tokens attending to tokens, contextual vectors, multiple heads, and causal masking for generation.
- Lesson 4375 min
Transformer architecture
Encoder blocks, feed-forward sublayers, residuals, layer norm, positional encoding — without heavy matrix calculus.
- Lesson 4470 min
Encoder vs decoder — BERT, GPT, translation
Bidirectional encoders, autoregressive decoders, cross-attention in seq2seq, and which stack powers which apps.
- Lesson 4565 min
Tokenization & context window
Tokens vs words, BPE subwords, vocabulary, padding, truncation, and context length limits in production.
- Lesson 4670 min
Vectorization — text to vectors
Token embeddings, positional encodings, sentence embeddings for retrieval, and how vectorization connects tokenization to attention.
- Lesson 4775 min
Module 6 quiz & review
40 interactive questions on attention, transformers, tokenization, vectorization, and interview topics (KV cache, O(n²), BERT vs GPT).
- Lesson 48240 min
Project: mini transformer on blog text
Train a small causal transformer on KinetiqVision blog MDX, predict next tokens, and generate sample sentences from a prompt.
Module 7. Module 7 — GenAI & LLMs
LLM lifecycle, fine-tuning and quantization, RAG engineering, AI-automated workflows, and trust — ending with a hands-on RAG chatbot with citations and safety patterns.
- Lesson 4925 min
Welcome to Module 7
Enter modern GenAI: how LLM apps work, what you will build, and prerequisites from Module 6.
- Lesson 5070 min
LLM basics — GPT-style models
Pretraining, next-token prediction, inference vs training, API chat roles, and what models can and cannot do alone.
- Lesson 5180 min
LLM training lifecycle
End-to-end path from data processing and pre-training through post-training (SFT, RLHF) to inference and deployment.
- Lesson 5275 min
Prompt engineering
System/user/assistant messages, clarity and constraints, few-shot examples, chain-of-thought when to use it, and output formats.
- Lesson 5360 min
Temperature, top-k & top-p
Controlling randomness at decode time, greedy vs sampled generation, and picking settings for chat vs creative tasks.
- Lesson 5480 min
Fine-tuning & quantization for work
LoRA and full fine-tuning for business requirements, INT8/GPTQ quantization for fast inference, and when each approach fits.
- Lesson 5575 min
Building AI-automated workflows
Use coding agents effectively — Claude Code, skills, subagents, and cowork patterns for generating code, docs, and repeatable workflows.
- Lesson 5665 min
Fine-tuning vs RAG — when to use which
Compare updating weights vs retrieving documents, hybrid patterns, and citation-friendly architectures.
- Lesson 5785 min
RAG engineering — chunking, indexing & reranking
Chunking strategies, data ingestion pipelines, vector databases, hybrid search, reranking, and production retrieval quality.
- Lesson 5865 min
Hallucinations, trust & AI safety
Why models invent facts, grounding strategies, refusal patterns, safety guardrails, and human-in-the-loop review.
- Lesson 5975 min
Module 7 quiz & review
40 interactive questions on LLM lifecycle, LoRA, RAG engineering, hybrid search, reranking, evals, and interview trade-offs.
- Lesson 60300 min
Project: RAG chatbot with citations
Index blog MDX and PDFs in FAISS, Next.js chat UI, grounded answers with source links, safety checks, and eval on held-out questions.
Module 8. Module 8 — Agentic AI
Tools, ReAct, MCP, context engineering, multi-agent orchestration, evals, and agentic system design — ending with a multi-agent travel planner using real APIs.
- Lesson 6125 min
Welcome to Module 8
What agentic AI means, interview focus areas, prerequisites from Module 7, and the travel planner project overview.
- Lesson 6290 min
What is an AI agent?
Agents vs chatbots vs workflows vs plain LLMs, the observe–think–act loop with a worked travel example, when to use agents, and failure modes.
- Lesson 6395 min
Tools & function calling
Full tool lifecycle, JSON schemas, validation and auth, error formatting, parallel vs sequential calls, and a minimal Python agent loop.
- Lesson 6490 min
Planning vs execution — ReAct
ReAct traces, planner and executor prompts, retry and replan logic, UI reasoning traces, and workflow vs agentic replan.
- Lesson 6585 min
Agent memory — short & long term
Session vs persisted memory, scratchpads, summarization, vector recall, memory vs RAG, and privacy rules.
- Lesson 6690 min
MCP & context engineering
Model Context Protocol servers and clients, context stack layers, token budgeting, handoffs, and security.
- Lesson 6795 min
Multi-agent systems & orchestration
LangChain building blocks, LangGraph state machines, handoffs, shared state, observability per node, and when multi-agent wins.
- Lesson 6890 min
Evals for AI apps
SME gold sets, LLM-as-judge rubrics, trajectory evals with mocked tools, CI gates, and frameworks.
- Lesson 6990 min
Agentic system design
Production architecture, deployment and scaling, structured traces, guardrails, degradation, and on-call runbooks.
- Lesson 7075 min
Module 8 quiz & review
40 interactive questions on agents, tools, MCP, evals, DAG vs agent, guardrails, and production design patterns.
- Lesson 71300 min
Project: multi-agent travel planner
Planner + executor agents, weather/maps APIs, MongoDB or file memory for preferences, retries, and a Next.js UI with reasoning trace.
Module 9. Module 9 — Multimodal & image models
How vision and language models are trained together — CLIP, native multimodality, and diffusion-based image generation.
- Lesson 7225 min
Welcome to Module 9
Why multimodal models matter, how they connect to your LLM and CV foundations, and what this module covers.
- Lesson 7380 min
CLIP & native multimodal models
Contrastive image–text training, zero-shot classification, vision encoders in GPT-4o-style models, and video understanding basics.
- Lesson 7485 min
Diffusion models & image generation
Noise schedules, U-Net denoisers, Stable Diffusion pipeline, ControlNet, and practical limits of generative image APIs.
Module 10. Module 10 — Production & scaling
Model serving, Redis caching, rate limits, token cost control, monitoring and error handling — capstone project ships a production-ready GenAI app combining RAG, agents, and observability.
- Lesson 7525 min
Welcome to Module 10
Why production skills matter, interview focus on cost and latency, prerequisites from Module 8, and the capstone project overview.
- Lesson 7670 min
Model serving & deployment
Hosted APIs vs self-hosting, Next.js API routes, streaming, timeouts, and deployment patterns for GenAI workloads.
- Lesson 7765 min
Caching for LLM apps
Redis cache-aside, embedding and completion caches, cache keys, TTLs, and invalidation when indexes change.
- Lesson 7860 min
Rate limiting & guardrails
Token buckets, per-user limits, 429 responses, abuse prevention, and protecting upstream provider quotas.
- Lesson 7970 min
Cost optimization & token budgets
Input vs output pricing, context trimming, model routing, prompt caching, and setting per-request budgets.
- Lesson 8075 min
Monitoring, logging & errors
Structured logs, metrics, traces, graceful degradation, retries with backoff, and user-visible failure messages.
- Lesson 8155 min
Module 10 quiz & review
25 interactive questions on serving, caching, rate limits, cost, latency, monitoring, and production trade-offs.
- Lesson 82360 min
Project: production-ready GenAI app
Combine Module 7 RAG + Module 8 agents in one Next.js app with Redis cache, rate limits, structured logging, and a simple metrics dashboard.