Welcome to

AI Bootcamp

Course Syllabus and Content

Week 1

Onboarding & Tooling

3 Units

  • 01
    AI Onboarding & Python Essentials
     

    • Welcome & Community

      • Course Overview
      • Community: Getting Started with Circle and Notion

    • Python & Tooling Essentials

      • Intro to Python: Why Python for AI and Why Use Python 3 (Not Python 2)
      • Install Python and Set Virtual Environments
      • Basic Python Introduction: Variables, Data Types, Loops & Functions
      • Using Jupyter Notebooks

    • Introduction to AI Tools & Ecosystem

      • Introduction to AI & Why Learn It
      • Models & Their Features: Choosing the Right AI Model for Your Needs
      • Finding and Using AI Models & Datasets: A Practical Guide with Hugging Face
      • Using Restricted vs Unrestricted Open-Source AI Models from Hugging Face
      • Hardware for AI: GPUs, TPUs, and Apple Silicon
      • Advanced AI Concepts Worth Knowing
      • Practical Tips on How to Be Productive with AI

    • Brainstorming Ideas with AI

      • Brainstorming with Prompting Tools
  • 02
    Orientation — Course Introduction
     
    • Meet the instructors and understand the support ecosystem (Circle, Notion, async help)
    • Learn the 4 learning pillars: concept clarity, muscle memory, project building, and peer community
    • Understand course philosophy: minimize math, maximize intuition, focus on real-world relevance
    • Set up accountability systems, learning tools, and productivity habits for long-term success
  • 03
    Orientation — Technical Kickoff
     

    • Jupyter & Python Setup

      • Understanding why Python is used in AI (simplicity, libraries, end-to-end stack)
      • Exploring Jupyter Notebooks: shortcuts, code + text blocks, and cloud tools like Google Colab

    • Hands-On with Arrays, Vectors, and Tensors

      • Creating and manipulating 2D and 3D NumPy arrays (reshaping, indexing, slicing)
      • Performing matrix operations: element-wise math and dot products
      • Visualizing vectors and tensors in 2D and 3D space using matplotlib

    • Mathematical Foundations in Practice

      • Exponentiation and logarithms: visual intuition and matrix operations
      • Normalization techniques and why they matter in ML workflows
      • Activation functions: sigmoid and softmax with coding from scratch

    • Statistics and Real Data Practice

      • Exploring core stats: mean, standard deviation, normal distributions
      • Working with real datasets (Titanic) using Pandas: filtering, grouping, feature engineering, visualization
      • Preprocessing tabular data for ML: encoding, scaling, train/test split

    • Bonus Topics

      • Intro to probability, distributions, classification vs regression
      • Tensor intuition and compute providers (GPU, Colab, cloud vs local)
Week 2

AI Projects and Use Cases

3 Units

  • 01
    Navigating the Landscape of LLM Projects & Modalities
     
    • Compare transformer-based LLMs vs diffusion models and their use cases
    • Understand the "lego blocks" of LLM-based systems: prompts, embeddings, generation, inference
    • Explore core LLM application types: RAG, vertical models, agents, and multimodal apps
    • Learn how LLMs are being used in different roles and industries (e.g., healthcare, finance, legal)
    • Discuss practical project scoping: what to build vs outsource, how to identify viable ideas
    • Identify limitations of LLMs: hallucinations, lack of reasoning, sensitivity to prompts
    • Highlight real-world startup examples (e.g., AutoShorts, HeadshotPro) and venture-backed tools
  • 02
    From Theory to Practice — Building Your First LLM Application
     
    • Understand how inference works in LLMs (prompt processing vs. autoregressive decoding)
    • Explore real-world AI applications: RAG, vertical models, agents, multimodal tools
    • Learn the five phases of the model lifecycle: pretraining to RLHF to evaluation
    • Compare architecture types: generic LLMs vs. ChatGPT vs. domain-specialized models
    • Work with tools like Hugging Face, Modal, and vector databases
    • Build a “Hello World” LLM inference API using OPT-125m on Modal
  • 03
    Intro to AI-Centric Evaluation
     
    • Metrics and Evaluation Design
    • Foundation for Future Metrics Work
    • Building synthetic data for AI applications
Week 3

Prompt Engineering & Embeddings

2 Units

  • 01
    Prompt Engineering — From Structure to Evaluation (Mini Project 1)
     
    • Learn foundational prompt styles: vague vs. specific, structured formatting, XML-tagging
    • Practice prompt design for controlled output: enforcing strict JSON formats with Pydantic
    • Discover failure modes and label incorrect LLM behavior (e.g., hallucinations, format issues)
    • Build early evaluators to measure LLM output quality and rule-following
    • Write your first "LLM-as-a-judge" prompts to automate pass/fail decisions
    • Iterate prompts based on analysis-feedback loops and evaluator results
    • Explore advanced prompting techniques: multi-turn, rubric-based human alignment, and A/B testing
    • Experiment with dspy for signature-based structured prompting and validation
  • 02
    Tokens, Embeddings & Modalities — Foundations of Understanding Text, Image, and Audio
     
    • Understand the journey from raw text → tokens → token IDs → embeddings
    • Compare word-based, BPE, and advanced tokenizers (LLaMA, GPT-2, T5)
    • Analyze how good/bad tokenization affects loss, inference time, and semantic meaning
    • Learn how embedding vectors represent meaning and change with context
    • Explore and manipulate Word2Vec-style word embeddings through vector math and dot product similarity
    • Apply tokenization and embedding logic to multimodal models (CLIP, ViLT, ViT-GPT2)
    • Conduct retrieval and classification tasks using image and audio embeddings (CLIP, Wav2Vec2)
    • Discuss emerging architectures like Byte Latent Transformers and their implications
Week 4

Multimodal + Retrieval-Augmented Systems

2 Units

  • 01
    Multimodal Embeddings (CLIP)
     
    • Understand how CLIP learns joint image-text representations using contrastive learning
    • Run your first CLIP similarity queries and interpret shared embedding space
    • Practice prompt engineering with images — and see how wording shifts retrieval results
    • Build retrieval systems: text-to-image and image-to-image using cosine similarity
    • Experiment with visual vector arithmetic: apply analogies to embeddings
    • Explore advanced tasks like visual question answering (VQA) and image captioning
    • Compare multimodal architectures: CLIP, ViLT, ViT-GPT2 and how they process fusion
    • Learn how modality-specific encoders (image/audio) integrate into transformer models
  • 02
    RAG & Retrieval Techniques (Mini Project 2)
     
    • Understand the full RAG pipeline: pre-retrieval, retrieval, and post-retrieval stages
    • Learn the difference between term-based and embedding-based retrieval methods (e.g., TF-IDF, BM25 vs. vector search)
    • Explore vector databases, chunking, and query optimization techniques like HyDE, reranking, and filtering
    • Use contrastive learning and cosine similarity to map queries and documents into shared vector spaces
    • Practice retrieval evaluation using recall@k, precision@k, and MRR
    • Generate synthetic data using LLMs (Instructor, Pydantic) for local eval scenarios
    • Implement baseline vector search pipelines using LanceDB and OpenAI embeddings (3-small, 3-large)
    • Apply rerankers and statistically validate results with bootstrapping and t-tests to build intuition around eval reliability
Week 5

Classical Language Models

2 Units

  • 01
    N-Gram Language Models (Mini Project 3)
     
    • Understand what n-grams are and how they model language with simple probabilities
    • Implement bigram and trigram extraction using sliding windows over character sequences
    • Construct frequency dictionaries and normalize into probability matrices
    • Sample random text using bigram and trigram models to generate synthetic sequences
    • Evaluate model quality using entropy, character diversity, and negative log likelihood (NLL)
    • One-hot encode inputs and build PyTorch models for bigram and trigram neural networks
    • Train models with cross-entropy loss and monitor training dynamics
    • Compare classical vs. neural models in terms of coherence, prediction accuracy, and generalization
  • 02
    Triplet Loss Embedding Finetuning for Search & Ranking (Mini Project 4)
     
    • Triplet-Based Embedding Adaptation
    • User-to-Music & E-commerce Use Cases
Week 6

Attention & Finetuning

2 Units

  • 01
    Building Self-Attention Layers
     
    • Understand the motivation for attention: limitations of fixed-window n-gram models
    • Explore how word meaning changes with context using static vs contextual embeddings (e.g., "bank" problem)
    • Learn the mechanics of self-attention: Query, Key, Value, dot products, and weighted sums
    • Manually compute attention scores and visualize how softmax creates probabilistic context focus
    • Implement self-attention layers in PyTorch using toy examples and evaluate outputs
    • Visualize attention heatmaps using real LLMs to interpret which words the model attends to
    • Compare loss curves of self-attention models vs trigram models and observe learning dynamics - Understand how embeddings evolve through transformer layers and extract them using GPT-2
    • Build both single-head and multi-head transformer models; compare their predictions and training performance
    • Implement a Mixture-of-Experts (MoE) attention model and observe gating behavior on different inputs
    • Evaluate self-attention vs MoE vs n-gram models on fluency, generalization, and loss curves
    • Run meta-evaluation across all models to compare generation quality and training stability
  • 02
    Instructional Finetuning with LoRA (Mini Project 5)
     
    • Understand the difference between fine-tuning and instruction fine-tuning (IFT)
    • Learn when to apply fine-tuning vs IFT vs RAG based on domain, style, or output needs
    • Explore lightweight tuning methods like LoRA, BitFit, and prompt tuning
    • Build instruction-tuned systems for outputs like JSON, tone, formatting, or domain tasks
    • Apply fine-tuning to real case studies: HTML generation, resume scoring, financial tasks
    • Use Hugging Face PEFT tools to train and evaluate LoRA-tuned models
    • Understand tokenizer compatibility, loss choices, and runtime hardware considerations
    • Compare instruction-following performance of base vs IFT models with real examples
Week 7

Architectures & Multimodal Systems

2 Units

  • 01
    Feedforward Networks & Loss-Centric Training
     
    • Understand the role of linear + nonlinear layers in neural networks
    • Explore how MLPs refine outputs after self-attention in transformers
    • Learn the structure of FFNs (e.g., two-layer projection + activation like ReLU/SwiGLU)
    • Implement your own FFN in PyTorch with real training/evaluation
    • Compare activation functions: ReLU, GELU, SwiGLU
    • Understand how dropout prevents co-adaptation and improves generalization
    • Learn the role of LayerNorm, positional encoding, and skip connections
    • Build intuition for how transformers encode depth, context, and structure into layers
  • 02
    Multimodal Finetuning (Mini Project 6)
     
    • Understand what CLIP is and how contrastive learning aligns image/text modalities
    • Fine-tune CLIP for classification (e.g., pizza types) or regression (e.g., solar prediction)
    • Add heads on top of CLIP embeddings for specific downstream tasks
    • Compare zero-shot performance vs fine-tuned model accuracy
    • Apply domain-specific LoRA tuning to vision/text encoders
    • Explore regression/classification heads, cosine similarity scoring, and decision layers
    • Learn how diffusion models extend CLIP-like embeddings for text-to-image and video generation
    • Understand how video generation differs via temporal modeling, spatiotemporal coherence
Week 8

Assembling & Training Transformers

2 Units

  • 01
    Full Transformer Architecture (From Scratch)
     
    • Connect all core transformer components: embeddings, attention, feedforward, normalization
    • Implement skip connections and positional encodings manually
    • Use sanity checks and test loss to debug your model assembly
    • Observe transformer behavior on structured prompts and simple sequences
    • Compare transformer predictions vs earlier trigram or FFN models to appreciate context depth
  • 02
    Advanced RAG & Retrieval Methods
     
    • Analyze case studies on production-grade RAG systems and tools like Relari and Evidently
    • Understand common RAG bottlenecks and solutions: chunking, reranking, retriever+generator coordination
    • Compare embedding models (small vs large) and reranking strategies
    • Evaluate real-world RAG outputs using recall, MRR, and qualitative techniques
    • Learn how RAG design changes based on use case (enterprise Q&A, citation engines, document summaries)
Week 9

Specialized Finetuning Projects

2 Units

  • 01
    CLIP Fine-Tuning for Insurance
     
    • Fine-tune CLIP to classify car damage using real-world image categories
    • Use Google Custom Search API to generate labeled datasets from scratch
    • Apply PEFT techniques like LoRA to vision models and optimize hyperparameters with Optuna
    • Evaluate accuracy using cosine similarity over natural language prompts (e.g. “a car with large damage”)
    • Deploy the model in a real-world insurance agent workflow using LLaMA for reasoning over predictions
  • 02
    Math Reasoning & Tool-Augmented Finetuning
     
    • Use SymPy to introduce symbolic reasoning to LLMs for math-focused applications
    • Fine-tune with Chain-of-Thought (CoT) data that blends natural language with executable Python
    • Learn two-stage finetuning: CoT → CoT+Tool integration
    • Evaluate reasoning accuracy using symbolic checks, semantic validation, and regression metrics
    • Train quantized models with LoRA and save for deployment with minimal resource overhead
Week 10

Advanced RLHF & Engineering Architectures

2 Units

  • 01
    Preference-Based Finetuning — DPO, PPO, RLHF & GRPO
     
    • Learn why base LLMs are misaligned and how preference data corrects this
    • Understand the difference between DPO, PPO, RLHF, and GRPO
    • Generate math-focused DPO datasets using numeric correctness as preference signal
    • Apply ensemble voting to simulate “majority correctness” and eliminate hallucinations
    • Evaluate model learning using preference alignment instead of reward models
    • Compare training pipelines: DPO vs RLHF vs PPO — cost, control, complexity
  • 02
    Building AI Code Agents — Case Studies from Copilot, Cursor, Windsurf
     
    • Reverse engineer modern code agents like Copilot, Cursor, Windsurf, and Augment Code
    • Compare transformer context windows vs RAG + AST-powered systems
    • Learn how indexing, retrieval, caching, and incremental compilation create agentic coding experiences
    • Explore architecture of knowledge graphs, graph-based embeddings, and execution-aware completions
    • Design your own multi-agent AI IDE stack: chunking, AST parsing, RAG + LLM collaboration
Week 11

Agents & Multimodal Code Systems

2 Units

  • 01
    Agent Design Patterns
     
    • Understand agent design patterns: Tool use, Planning, Reflection, Collaboration
    • Learn evaluation challenges in agent systems: output variability, partial correctness
    • Study architecture patterns: single-agent vs constellation/multi-agent
    • Explore memory models, tool integration, and production constraints
    • Compare agent toolkits: AutoGen, LangGraph, CrewAI, and practical use cases
  • 02
    Text-to-SQL and Text-to-Music Architectures
     
    • Implement text-to-SQL using structured prompts and fine-tuned models
    • Train and evaluate SQL generation accuracy using execution-based metrics
    • Explore text-to-music pipelines: prompt → MIDI → audio generation
    • Compare contrastive vs generative learning in multimodal alignment
    • Study evaluation tradeoffs for logic-heavy vs creative outputs
Week 12

Deep Internals & Production Pipelines

2 Units

  • 01
    Positional Encoding + DeepSeek Internals
     
    • Understand why self-attention requires positional encoding
    • Compare encoding types: sinusoidal, RoPE, learned, binary, integer
    • Study skip connections and layer norms: stability and convergence
    • Learn from DeepSeek-V3 architecture: MLA (KV compression), MoE (expert gating), MTP (parallel decoding), FP8 training
    • Explore when and why to use advanced transformer optimizations
  • 02
    LLM Production Chain (Inference, Deployment, CI/CD)
     
    • Map the end-to-end LLM production chain: data, serving, latency, monitoring
    • Explore multi-tenant LLM APIs, vector databases, caching, rate limiting
    • Understand tradeoffs between hosting vs using APIs, and inference tuning
    • Plan a scalable serving stack (e.g., LLM + vector DB + API + orchestrator)
    • Learn about LLMOps roles, workflows, and production-level tooling
Week 13

Enterprise LLMs, Hallucinations & Career Growth

4 Units

  • 01
    RAG Hallucination Control & Enterprise Search
     
    • Explore use of RAG in enterprise settings with citation engines
    • Compare hallucination reduction strategies: constrained decoding, retrieval, DPO
    • Evaluate model trustworthiness for sensitive applications
    • Learn from production examples in legal, compliance, and finance contexts
  • 02
    Career Prep — Roles, Interviews, and AI Career Paths
     
    • Break down roles: AI Engineer, Model Engineer, Researcher, PM, Architect
    • Prepare for FAANG/LLM interviews with DSA, behavioral prep, and project portfolio
    • Use ChatGPT and other tools for mock interviews and story crafting
    • Learn how to build a standout AI resume, repo, and demo strategy
    • Explore internal AI projects, indie hacker startup paths, and transition guides
  • 03
    Staying Current with AI (Research, News, and Tools)
     
    • Track foundational trends: RAG, Agents, Fine-tuning, RLHF, Infra
    • Understand tradeoffs of long context windows vs retrieval pipelines
    • Compare agent frameworks (CrewAI vs LangGraph vs Relevance AI)
    • Learn from real 2025 GenAI use cases: productivity + emotion-first design
    • Stay current via curated newsletters, YouTube breakdowns, and community tools
  • 04
    Bonus Content
     
    • 2 courses - Fundamentals of transformers with Alvin Wan and Responsive LLM Applications with Server-Sent Events
    • Prompt engineering templates
    • AI newsletters, channels, X, reddit channels
    • Break down of LLama components
    • Open source models with their capabilities
    • Data sources
    • AI specific cloud services
    • Open source frameworks
    • Project ideas from other indie hackers
    • Bonus: FANG Machine learning interview cheatsheet
    • Free API Keys for building AI Applications
    • How people will are using GenAI in 2025
    • How to stay ahead of AI Trends?
    • N8N and Free High-Roi AI Automation Templates worth $50,000