Updated: 8th July, 2026

Phase 0: Prepare (Optional)

Before embarking on the intensive AI learning journey, it's crucial to establish a solid foundation. This preparatory phase is designed to equip you with the essential knowledge and skills needed to tackle the main syllabus effectively. If you already possess these foundational skills, feel free to proceed directly to Phase 1.

Day 0.01: Advanced basic mathematics

• Linear algebra: matrices, vectors, dot/cross products, determinants, matrix norms, eigenvalues and eigenvectors, systems of linear equations.

• Calculus: Limits, single-variable derivatives, partial derivatives, gradients, integrals, Taylor series expansion.

• Discrete mathematics: Set theory, formal logic, combinations and permutations.

• Mini project: Implement matrix multiplication, dot product, and a basic gradient approximation function using pure Python (no libraries).

Day 0.02: Probability, statistics and information theory

• Basic concepts of probability, conditional probability, Bayes' theorem, Markov chains basics.

• Common probability distributions: Normal, binomial, poisson, exponential, uniform (PDF and PMF).

• Descriptive and inferential statistics, hypothesis testing (t-tests, p-values), correlation vs. causation, A/B testing fundamentals.

• Mini project: Simulate probability distributions using Python, visualize the central limit theorem, and code a basic Naive Bayes probability calculator.

Day 0.03: Advanced Python programming & internals

• Syntax, variables, data types, type hinting, memory management (garbage collection, reference counting).

• Control structures: if-else, loops, list/dict comprehensions.

• Functions, modules, decorators, generators, iterators, context managers (with statement).

• Concurrency basics: Multithreading, multiprocessing, Asyncio (async/await) concepts.

• Mini project: Write a program to solve quadratic equations and implement a custom context manager and a generator for reading large files efficiently.

Day 0.04: Data structures, algorithms and complexity

• Core structures: Lists, tuples, dictionaries, sets, stacks, queues, hash tables.

• Advanced structures: Trees (Binary, AVL, Trie), graphs (directed, undirected).

• Searching and sorting algorithms: quicksort, mergesort, binary search, DFS, BFS.

• Algorithm complexity: Big O, big theta, big omega notation, space-time tradeoff, dynamic programming concepts.

• Mini project: Implement the quicksort algorithm and build a basic breadth-first search (BFS) to traverse a graph.

Day 0.05: Object-oriented programming & design patterns

• Classes and objects, __dunder__ methods, metaclasses.

• Inheritance, polymorphism, multiple inheritance (MRO).

• Encapsulation, abstraction, composition over inheritance.

• SOLID principles, basic design patterns (singleton, factory, observer).

• Mini project: Build a student management system implementing SOLID principles, utilizing class inheritance and a factory pattern for object creation.

Day 0.06: High-performance data processing

• NumPy arrays, broadcasting rules, vectorization, memory layout (C-order vs F-order).

• DataFrames and series in pandas, multi-indexing, memory optimization for large datasets.

• Reading/writing data, handling missing data, complex GroupBy mechanics, window functions.

• Mini project: Analyze a messy CSV file, apply vectorized NumPy operations for speed, and handle out-of-memory errors using data chunking.

Day 0.07: Data visualization & communication

• Matplotlib and Seaborn, figure and axes manipulation.

• Basic types of charts (histograms, scatter plots, box plots, heatmaps).

• Customizing and formatting charts, visual perception principles (avoiding misleading graphs).

• Interactive visualization tools (Plotly or Dash basics).

• Mini project: Create an interactive exploratory data analysis (EDA) dashboard from a dataset highlighting correlations and outliers.

Day 0.08: Databases, SQL and document stores

• Relational model, ACID properties, transaction isolation levels, indexing (B-trees).

• Advanced SQL queries: Joins, subqueries, CTEs (Common Table Expressions), window functions.

• Connecting Python to databases (ORM vs raw connections).

• Document database fundamentals, schema design patterns for NoSQL, BSON format, aggregation framework (e.g., in MongoDB), BASE properties.

• Mini project: Build a data pipeline that ingests data, runs complex SQL window functions, and syncs the results into a document database using aggregation pipelines.

Day 0.09: Web programming, APIs & networking

• HTML, CSS, DOM manipulation, basic JavaScript.

• Network protocols: HTTP/HTTPS, TCP/IP basics, RESTful APIs vs. gRPC, WebSockets.

• Simple web framework (e.g., Flask or FastAPI), request routing, middleware.

• API Security: Authentication (JWT), authorization, CORS, rate limiting.

• Mini project: Create a secure RESTful API using FastAPI to serve data analysis results, protected by a simple token-based authentication mechanism.

Day 0.10: Version control, platform ops & Linux basics

• Basics of Git and GitHub, branching strategies (GitFlow, trunk-based development), merge conflicts.

• Linux command line fundamentals (Bash scripting, grep, awk, sed, file permissions, SSH).

• Software development process, Agile fundamentals, CI/CD pipeline concepts.

• Containerization basics, creating robust Dockerfile environments for consistent execution.

• Mini project: Create a repository, implement a Git branching strategy, write a shell script to automate environment setup, and containerize the Day 0.09 API.

Phase 1: Foundations

Day 1: Introduction to AI and hardware logic

• Introduction to AI, AI methodologies, AI terminologies. Basic electronic elements, digital gates (OR, AND, NOT).

• Advanced Injection: Explore how basic logic gates (XOR, NAND) combine to form half/full Adders and ALUs (Arithmetic Logic Units). Understand hardware-level number representation (integer vs. floating point - IEEE 754) and the critical role of FP16 and BF16 formats in optimizing memory footprints for AI model serving.

• Mini Project 1: Create a simple logic gate simulator in Python (using Tkinter for GUI).

• Advanced: Extend the simulator to model a 1-bit Half Adder circuit entirely from foundational logic gates.

• Mini Project 2: Design a basic AI chatbot that responds to simple greetings.

• Advanced: Design the chatbot using a deterministic finite state machine (FSM) architecture rather than simple nested if-else statements, ensuring robust state transition management.

Day 2: Logic design and C++ memory basics

• Boolean algebra, simplification of Boolean expressions. Basic syntax, data types, operators in C++.

• Advanced Injection: Master bitwise operations (AND, OR, XOR, SHIFT) and understand their core role in model quantization (e.g., INT8/FP8 representations for low-latency inference). Investigate the actual memory footprint of C++ data types (sizeof) at the OS level.

• Mini Project 1: Implement Boolean algebra simplification in Python.

• Advanced: Utilize bitwise operators in Python to simulate and programmatically verify the truth tables of complex Boolean expressions.

• Mini Project 2: Write a C++ program to perform basic arithmetic operations.

• Advanced: Build a benchmarking module to measure execution time differences between integer arithmetic and floating-point arithmetic across millions of loop iterations.

Day 3: C++ Control Structures & CPU Mechanics

• Conditional statements (if, if-else), loop statements (while, for).

• Advanced Injection: Dive into CPU branch prediction mechanics and understand why conditional if statements can stall the computation pipeline. Learn about loop unrolling and the fundamentals of SIMD (Single Instruction, Multiple Data) processing, which is the bedrock of parallel matrix computations.

• Mini Project 1: Create a C++ program that uses loops to print the Fibonacci sequence.

• Advanced: Optimize the loop to strictly eliminate unnecessary memory reallocations during each iteration.

• Mini Project 2: Write a C++ program that checks if a number is positive, negative, or zero.

• Advanced: Rewrite the logic using branchless programming techniques (bitwise masking) to eliminate the if statement entirely, ensuring constant execution time.

Day 4: C++ functions and call stack

• Functions (declaration, definition, prototypes), recursion.

• Advanced Injection: Analyze the Call Stack architecture in memory (understanding the root cause of Stack Overflows). Evaluate the memory cost and performance differences between pass-by-value, pass-by-peference, and pass-by-pointer. Explore inline functions and tail recursion optimization.

• Mini Project 1: Write a C++ function to calculate the factorial of a number.

• Advanced: Implement both a standard iterative version and a tail-recursive version, then compile the C++ code with optimization flags (e.g., -O2 or -O3) to observe the compiler's behavior.

• Mini Project 2: Create a C++ program that uses recursion to calculate the nth Fibonacci number.

• Advanced: Upgrade the recursive function using Memoization (Dynamic Programming) to drastically reduce time complexity from O(2^n) to O(n).

Day 5: C++ arrays, strings & cache locality

• Syllabus Content: Arrays declaration, initialization, accessing elements, strings.

• Advanced Injection: Understand arrays as contiguous memory blocks. Deep dive into CPU cache locality (L1/L2 cache hit/miss ratios). Learn why traversing multi-dimensional arrays in Row-major order is exponentially faster than column-major order in C++ (a mandatory concept for writing custom matrix multiplication kernels in CUDA).

• Mini Project 1: Write a C++ program to reverse a string.

• Advanced: Perform the string reversal completely in-place (O(1) space complexity) utilizing the Two Pointers technique.

• Mini Project 2: Create a C++ program that finds the largest element in an array.

• Advanced: Allocate a massive 2D array and benchmark the execution speed of finding the maximum value when traversing row-by-row versus column-by-column to witness CPU cache mechanics firsthand.

Day 6: C++ pointers and memory management

• Pointers, pointer arithmetic, pointer and arrays.

• Advanced Injection: Contrast heap vs. stack memory allocation. Identify memory leaks and dangling pointers. Introduction to C++ smart pointers (std::unique_ptr, std::shared_ptr) for strict resource management. Understand memory alignment and padding.

• Mini Project 1: Write a C++ program to swap two numbers using pointers.

• Advanced: Refactor the raw pointer implementation to utilize std::unique_ptr, ensuring absolute memory safety.

• Mini Project 2: Create a C++ program that dynamically allocates memory for an array.

• Advanced: Instead of dynamically allocating an array of pointers (a nested 2D array), implement a 2D structure using a Flat 1D Array and mathematical indexing (e.g., index = row * width + col). This is the standard memory layout for Tensors in PyTorch and NumPy.

Day 7: C++ structures, files & I/O optimization

• Structures, unions, files (opening, reading, writing, closing).

• Advanced Injection: Investigate memory packing and padding inside structs (how the order of variable declaration dictates the struct's final size). Compare binary file vs. text file operations. Introduce memory-mapped files (mmap)-the crucial OS-level technique used to load massive LLM weights (like .safetensors or .bin) directly into memory at lightning speed.

• Mini Project 1: Create a C++ program to store and retrieve data from a file using structures.

• Advanced: Read and write the data strictly in pure binary format, explicitly managing and verifying the exact byte size of the struct on disk.

• Mini Project 2: Write a C++ program that reads data from a file, processes it, and writes the output to another file.

• Advanced: Implement chunk-based reading (buffered I/O) to process a hypothetical log file or dataset that vastly exceeds the machine's available RAM.

Day 8: Basic circuit theory & GPU power delivery

• Ohm's law, resistors in series and parallel, voltage and current division.

• Advanced Injection: Relate Ohm’s law and resistance to power delivery networks (PDN) in modern AI accelerators. Understand thermal design power (TDP) and why delivering 700W+ to an NVIDIA H100 chip requires extreme current management and voltage step-down techniques to prevent melting the silicon.

• Mini Project 1: Simulate a series and parallel resistor circuit in Python.

• Advanced: Simulate a grid of processing elements (representing a GPU's CUDA cores) and calculate the voltage drop (IR drop) across the silicon chip from the power source to the center cores.

• Mini Project 2: Calculate the equivalent resistance of a complex resistor network.

• Advanced: Model the network as an adjacency matrix and use NumPy to solve the equivalent resistance, bridging circuit theory with Graph Theory.

Day 9: Circuit theory - Kirchhoff’s laws & matrix solvers

• Kirchhoff's current law (KCL) and Kirchhoff's voltage law (KVL), nodal analysis and mesh analysis.

• Advanced Injection: Formulate KVL and KCL as massive systems of linear equations. Understand how SPICE simulators work under the hood. Relate network topologies to multi-GPU communication bottlenecks (e.g., NVLink, PCIe topologies).

• Mini Project 1: Solve a circuit using Kirchhoff's laws in Python.

• Advanced: Instead of hardcoding the math, build a Python parser that takes a netlist (text description of a circuit) and dynamically generates the KVL/KCL matrices.

• Mini Project 2: Implement nodal analysis to determine node voltages in a circuit.

• Advanced: Optimize the nodal solver using NumPy's highly optimized np.linalg.solve to process thousands of nodes simultaneously, demonstrating vectorized matrix inversion.

Day 10: Network theorems & high-speed I/O

• Thevenin’s theorem, Norton’s theorem, superposition theorem.

• Advanced Injection: Apply Thevenin equivalents to model input/output (I/O) pins. Understand signal integrity and impedance matching-the physical constraints that dictate why high bandwidth memory (HBM) must be stacked right next to the GPU die rather than connected via long motherboard traces.

• Mini Project 1: Analyze a circuit using Thevenin's theorem.

• Advanced: Model an HBM interface connection using Thevenin equivalents to calculate the maximum theoretical data transfer rate before the signal degrades.

• Mini Project 2: Verify the superposition theorem for a linear circuit.

• Advanced: Programmatically prove the theorem across a dataset of 100 random circuit states, laying the groundwork for understanding linear transformations in Neural Networks.

Day 11: Capacitors, inductors & transient GPU loads

• Introduction to the capacitor (C) & the inductor (L), impedance and frequency dependency.

• Advanced Injection: Parasitic capacitance in microchips (which causes latency/delay in AI calculations). The critical role of decoupling capacitors in smoothing out massive transient voltage droops when an AI model suddenly transitions a GPU from idle to 100% matrix-multiplication load.

• Mini Project 1: Simulate the charging and discharging of a capacitor in Python.

• Advanced: Simulate a decoupling network mitigating voltage droop during a step load (simulating an AI inference burst).

• Mini Project 2: Calculate the impedance of an inductor at a given frequency.

• Advanced: Plot an impedance vs. frequency graph using Matplotlib to visualize resonance in high-speed chip environments.

Day 12: Filters, signals & analog AI computing

• RL and RC filter circuits (low pass, high pass), transfer function.

• Advanced Injection: Time-domain vs. Ffrequency-domain representations. Introduction to the laplace transform. Connect the concept of analog filtering to 2D image filtering (Convolutions) used in convolutional neural networks (CNNs).

• Mini Project 1: Design a low-pass RC filter in Python.

• Advanced: Implement a fast fourier transform (FFT) alongside the filter to analyze its frequency response directly (a foundational math concept for optimizing convolutions).

• Mini Project 2: Simulate the frequency response of a high-pass RL filter.

• Advanced: Apply your simulated digital high-pass filter to a real image matrix to extract edge features, explicitly bridging electrical engineering with computer vision.

Day 13: Diodes & in-memory computing (neuromorphic)

• Diodes and its applications.

• Advanced Injection: Non-linear electronic components as the physical equivalent of neural network activation functions (e.g., using a diode as an analog ReLU). Introduction to memristors and crossbar arrays - the cutting edge of compute-in-memory AI hardware that eliminates the Von Neumann bottleneck.

• Mini Project 1: Simulate a half-wave rectifier circuit.

• Advanced: Code a simulation of a diode acting as a physical ReLU activation function processing a stream of data.

• Mini Project 2: Design a simple diode clipping circuit.

• Advanced: Simulate a nemristor crossbar array performing analog matrix-vector multiplication purely using Ohm's law and Kirchhoff's laws (this is how next-gen analog AI chips work!).

Day 14: Waves & fourier foundations

• Plane and spherical waves, longitudinal and transverse waves, wave equation.

• Advanced injection: Connect the mathematics of waves to the continuous fourier transform. Understand how 2D wave mechanics theoretically parallel 2D spatial convolutions used in Deep Learning.

• Mini Project 1: Simulate a transverse wave in Python.

• Advanced: Create an animation of a wave using matplotlib.animation to visualize propagation over time.

• Mini Project 2: Numerically solve the wave equation for a vibrating string.

• Advanced: Use NumPy vectorization to solve the partial differential equations (PDEs) at high speed, introducing you to physics-informed neural networks (PINNs) logic.

Day 15: Wave optics & optical neural networks

• Huygen's Principle and Young double slit experiment, interference, diffraction.

• Advanced Injection: Silicon photonics and optical computing. Understand how light interference can passively calculate Fourier transforms at the speed of light, with zero energy cost, leading to the development of optical neural networks (ONNs).

• Mini Project 1: Simulate Young’s double-slit experiment in Python.

• Advanced: Model the resulting interference pattern as an intensity matrix (tensor).

• Mini Project 2: Model the diffraction pattern of a single slit.

• Advanced: Simulate a basic optical neural network layer (using Mach-Zehnder Interferometers) where matrix multiplication is performed via phase shifting of light beams.

Day 16: Polarization & tensor data encoding

• Polarized and unpolarized light, Malus's law, Brewster's law, types of polarization.

• Advanced Injection: Data encoding in photonic AI chips. How tensor manipulation concepts can be mapped to polarization states to process multiple data streams concurrently.

• Mini Project 1: Simulate the effect of a polarizer on light intensity.

• Advanced: Simulate a system where polarization states represent quantized weights (e.g., -1, 0, 1) in a ternary neural network.

• Mini Project 2: Model Brewster's angle and its effect on polarization.

Day 17: LASER, Ooptical fibre & distributed AI clusters

• Introduction to LASER and optical fibre.

• Advanced Injection: Optical interconnects in multi-node AI clusters (e.g., scaling out training across 10,000 GPUs). Understand wavelength division multiplexing (WDM) as a physical necessity for the massive bandwidth required by data parallelism and tensor parallelism.

• Mini Project 1: Research and present on the applications of lasers in a specific field.

• Advanced: Write a technical architectural brief on how optical transceivers function inside AI data centers to connect GPU racks.

• Mini Project 2: Simulate the basic principles of optical fiber communication.

• Advanced: Simulate a high-throughput fiber-optic link computing latency and bandwidth, calculating the exact communication overhead (in milliseconds) for syncing gradients during distributed LLM training.

Day 18: Wave-particle duality & probabilistic computing

• Syllabus Content: The necessity of quantum mechanical picture, Wave-particle duality, de-Broglie waves.

• Advanced Injection: Probabilistic computing. Connect quantum uncertainty and probability distributions to stochastic gradient descent (SGD) and generative latent spaces (like in VAEs and diffusion models).

• Mini Project 1: Write a report on the historical experiments that demonstrated wave-particle duality.

• Mini Project 2: Simulate the behavior of a particle in a box.

• Advanced: Program a Monte Carlo simulation representing particle probability distributions - a foundational technique for modern generative AI and Bayesian neural networks.

Day 19: Quantum mechanics to quantum machine learning (QML)

• Postulates of quantum mechanics, wave function, superposition principle, one dimensional Schrodinger equation.

• Advanced Injection: Quantum machine learning and tensor networks. How the exponential state space of quantum mechanics maps to high-dimensional tensor operations.

• Mini Project 1: Solve the Schrodinger equation for a simple potential well.

• Advanced: Cast the Hamiltonian as a matrix and find its eigenvalues using computational linear algebra.

• Mini Project 2: Simulate the superposition principle with a qubit.

• Advanced: Extend the qubit simulation to model a basic parameterized quantum circuit (a quantum neural network) using a framework like PennyLane or Qiskit.

Day 20: Logic design - inside the Google TPU

• Combinational circuits, design procedure, adders, subtractors, multiplexer/demultiplexer, decoder/encoder.

• Advanced Injection: Designing the ALU (Arithmetic Logic Unit) and hardware floating-point multipliers. Deep dive into systolic arrays - the specific hardware architecture that powers Google's tensor processing units (TPUs) and NVIDIA's tensor cores.

• Mini Project 1: Simulate a 4-bit adder/subtractor circuit.

• Advanced: Design a multiplier circuit entirely from logic gates and simulate a basic multiply-accumulate (MAC) unit - the beating heart of all AI accelerators.

• Mini Project 2: Design a multiplexer and demultiplexer using logic gates.

Day 21: Logic design - dataflow & pipelining

• Latches, flip-flops, counters, shift registers.

• Advanced Injection: Memory hierarchies (SRAM cell design). How shift registers function in dataflow architectures to pipeline massive AI operations without stalling the processor.

• Mini Project 1: Simulate a D flip-flop and its truth table.

• Mini Project 2: Design a 4-bit synchronous counter.

• Advanced: Design a 2x2 systolic array grid using shift registers and MAC units to perform matrix multiplication via pure logic simulation, illustrating how data flows through an AI chip.

Day 22: Automata & AI compilers (XLA/Triton)

• Introduction, sets, relation, and functions, mathematical logics, formal languages, language classification.

• Advanced Injection: Compiler theory fundamentals. How high-level AI models (PyTorch/TensorFlow graphs) are mathematically represented as directed acyclic graphs (DAGs) and compiled into hardware instructions via compilers like OpenAI Triton or XLA (Accelerated Linear Algebra).

• Mini Project 1: Write a program to implement set operations (union, intersection, difference) in Python.

• Mini Project 2: Design a simple finite state machine for a traffic light.

• Advanced: Upgrade the FSM to model an AI Agent's decision tree navigating a grid world, directly bridging Automata theory with reinforcement learning environment design.

Day 23: Finite Automata & LLM tokenization

• Finite Automata: Finite state machine (FSM), DFA, NFA, epsilon-NFA, Equivalence Between NFA to DFA.

• Advanced Injection: Regular expressions under the hood. How string matching and DFAs absolutely underpin the byte-pair encoding (BPE) or WordPiece tokenizers used in every modern large language model (GPT-4, Llama 3).

• Mini Project 1: Convert a given NFA to a DFA.

• Mini Project 2: Write a program to simulate a DFA in Python.

• Advanced: Implement a basic tokenizer for an LLM using a DFA approach to efficiently segment text into sub-word units based on a predefined vocabulary tree.

Day 24: Regular expressions & LLM tokenizer engines

• Regular language, regular expression, regular expression to finite automata, finite automata to regular expression.

• Advanced Injection: Regular expression engine internals (NFA vs. DFA execution, backtracking, and ReDoS attacks). Understand how deterministic finite automata (DFA) form the absolute core of highly optimized LLM tokenizers (like BPE, WordPiece, and OpenAI's tiktoken) to chunk raw text into machine-readable IDs at gigabytes per second.

• Mini Project 1: Write a regular expression to validate a specific input format (e.g., phone number, date) in Python.

• Advanced: Benchmark your regex against a massive text file to measure processing speed, identifying patterns that cause catastrophic backtracking.

• Mini Project 2: Convert a regular expression to a finite automaton.

• Advanced: Write a script to visualize the state transitions of a basic byte-pair encoding (BPE) tokenizer as it merges characters into sub-words.

Day 25: Context-free grammars & structured AI output

• Context free grammar, context free language (CFG), regular grammar.

• Advanced Injection: Abstract syntax trees (ASTs). Learn how CFGs are used in modern AI to constrain large language models (using libraries like Guidance or Outlines) so they are mathematically forced to output valid JSON structures or correct programming code without hallucinating syntax errors.

• Mini Project 1: Write a context-free grammar for a simple programming language construct (e.g., arithmetic expressions).

• Mini Project 2: Parse a simple string using a given CFG.

• Advanced: Traverse the generated parse tree (AST) to evaluate the mathematical expression, simulating how a code-interpreter AI agent mathematically processes user queries.

Day 26: Pushdown automata & sequence modeling limits

• Push down automata, normalization of grammar, CNF, GNF.

• Advanced Injection: Memory stacks in parsing logic. Compare the strict memory stack of a PDA to the soft memory of recurrent neural networks (RNNs) and Transformers. Understand why standard neural networks historically struggle with tasks requiring exact hierarchical memory (like perfectly matching nested parentheses).

• Mini Project 1: Design a pushdown automaton for a given context-free grammar.

• Advanced: Design a PDA for a bracket-matching task, and write a theoretical analysis on how a Transformer's Attention mechanism attempts to solve this same problem contextually rather than strictly.

• Mini Project 2: Convert a CFG to Chomsky Normal Form.

Day 27: Turing machines & external AI memory

• Turing machine (TM): Definition and design, church-turing thesis, state transition diagram for turing machine.

• Advanced Injection: Universal approximation theorem vs. the church-turing thesis. Introduction to advanced AI architectures like Neural Turing Machines (NTMs) and differentiable neural computers (DNCs) - neural networks augmented with external, differentiable read/write memory banks.

• Mini Project 1: Design a Turing machine to recognize a specific language.

• Mini Project 2: Simulate the operation of a Turing machine.

• Advanced: Add a module to your simulation that tracks how many memory "tape" read/write operations occur, drawing parallels to GPU memory read/write bottlenecks (memory bandwidth limit).

Day 28: Computational complexity & the hardness of AI training

• Computational complexity: The concept of a reduction, P, NP, and NP-completeness.

• Advanced Injection: Why optimizing a neural network to a global minimum is mathematically NP-hard. Understand why we rely on heuristics and approximations (like stochastic gradient descent). Analyze the space/time computational complexity of the transformer attention mechanism O(N^2).

• Mini Project 1: Research and present on a specific NP-complete problem.

• Advanced: Research and write a brief technical paper on why finding the optimal weights for a simple 3-node neural network is considered NP-hard.

• Mini Project 2: Explain the concept of polynomial time reduction with examples.

Day 29: Python CPython internals & system Basics

• Why is Python preferred in AI? applications of Python, versions of Python, setting up Python environment, variables, data types, operators.

• Advanced Injection: CPython internals. Understand that Python is just the glue layer, while C/C++/CUDA does the heavy lifting. Deep dive into the global interpreter lock (GIL) and why pure Python struggles with multi-core CPU parallelism. Inspect how Python objects (PyObject) are structured in memory with reference counting.

• Mini Project 1: Write a Python program to calculate the area of a circle.

• Advanced: Use the sys.getsizeof() and dis (disassembler) modules to inspect the exact memory footprint and bytecode instructions of your variables, proving that a Python int is much heavier than a C++ int.

• Mini Project 2: Create a Python program that takes user input and performs basic operations.

Day 30: Python control structures & vectorization mastery

• Conditional statements: If, if-else, nested if-else. Looping: for, while, nested loops. Control statements: break, continue, and pass.

• Advanced Injection: The massive overhead of Python for loops. Introduction to vectorization (using C-extensions) as the absolute mandatory alternative to Python control structures in AI computing.

• Mini Project 1: Write a Python program to check if a number is prime.

• Mini Project 2: Create a Python program that uses loops to iterate through a list and perform operations.

• Advanced: Benchmark your pure Python loop against a NumPy vectorized array operation performing the exact same math, aiming to witness a 100x+ execution speedup.

Day 31: Python lists vs. contiguous memory arrays

• Lists and nested list: Introduction, accessing list, operations, working with lists, library function and methods with lists.

• Advanced Injection: Python lists (arrays of memory pointers scattered across RAM) vs. C-arrays (contiguous memory blocks). Why List[List[float]] is catastrophic for machine learning performance. Introduction to the Python buffer protocol and memoryview.

• Mini Project 1: Write a Python program to find the maximum and minimum elements in a list.

• Mini Project 2: Create a Python program that manipulates nested lists.

• Advanced: Create a nested list matrix and a flattened 1D array matrix. Profile the CPU cache miss differences when traversing them, proving why tensors must be stored in flat, contiguous memory.

Day 32: Python strings, sets, and data encodings

• Strings: accessing items of a string, operations, working, library functions, and methods with strings.

• Sets: operations, working, functions with sets.

• Advanced Injection: Unicode and UTF-8 encoding at the byte level (essential for LLM data preprocessing). How sets and dictionaries utilize hash tables under the hood for O(1) lookups, and how hash collisions are resolved.

• Mini Project 1: Write a Python program to check if a string is a palindrome.

• Advanced: Encode the text string down to its raw byte-array representation, simulating the exact data format that is fed into a neural network tokenizer.

• Mini Project 2: Create a Python program that performs set operations.

Day 33: Python dictionaries, tuples & state management

• Dictionaries: accessing values in dictionaries, working with dictionaries, library functions.

• Tuple: accessing tuples, operations, library functions, and methods with tuples.

• Advanced Injection: Tuples as immutable, hashable dimension definitions (e.g., standardizing tensor.shape). Dictionaries as the core memory architecture of Python itself (__dict__) and their use in AI frameworks (e.g., PyTorch's state_dict for saving multi-gigabyte model weights).

• Mini Project 1: Write a Python program to count the frequency of words in a given text.

• Mini Project 2: Create a Python program that uses tuples to store and manipulate data.

• Advanced: Structure your word frequency data into a simulated PyTorch state_dict and serialize it, mimicking how AI model parameters are packaged.

Day 34: Python functions, closures & JIT compilation

• Functions: Defining a function, calling a function, types of functions, function arguments, anonymous functions, global and local variables.

• Advanced Injection: Functions as first-class citizens, closures, and the function call overhead stack in CPython. Introduction to Just-In-Time (JIT) compilation concepts (like Numba or JAX's @jit decorator) to compile Python functions directly into LLVM machine code at runtime.

• Mini Project 1: Write a Python function to calculate the area of a triangle.

• Advanced: Use the numba library to @jit compile your math function, benchmarking its execution speed against the pure Python interpreter version.

• Mini Project 2: Create a Python program that uses lambda functions.

Day 35: High-throughput file handling & serialization

• File handling, exception handling, modules, namespaces.

• Advanced Injection: Identifying I/O bottlenecks in AI training (the GPU starvation problem). Moving from slow text files (CSV/JSON) to highly optimized binary serialization formats for big data and AI weights (pickle, HDF5, parquet, .safetensors).

• Mini Project 1: Write a Python program to read data from a file and count the number of lines.

• Advanced: Read a massive dataset iteratively (using a memory-efficient generator), then convert and save it into a binary .parquet or .safetensors format for zero-copy memory mapping.

• Mini Project 2: Create a Python program that handles exceptions when reading from or writing to files.

Day 36: Python OOP & deep learning computational graphs

• Object oriented programming, classes & objects, encapsulation, data abstraction, inheritance, polymorphism.

• Advanced Injection: How OOP is the architectural foundation of Deep Learning frameworks (e.g., torch.nn.Module). Using inheritance to build modular neural network layers. Utilizing __call__ dunder methods (functors) to make objects behave dynamically like functions.

• Mini Project 1: Design a simple class and create objects in Python.

• Mini Project 2: Implement inheritance in Python.

• Advanced: Design a BaseLayer class with forward/backward pass definitions, and inherit from it to create a LinearLayer class equipped with initialized random weight matrices, perfectly simulating the OOP architecture of PyTorch.

Day 37: Python packages & C-level backends

• Modules & packages: Importing module, math module, random module, creating modules.

• Introduction to NumPy.

• Advanced Injection: What makes NumPy fast? Dive into the underlying C/Fortran libraries: BLAS (Basic Linear Algebra Subprograms) and LAPACK. Understand how Python packages are often just wrappers around highly optimized, compiled C/C++ binaries. Learn how to write your own simple C-extension for Python to bypass the Global Interpreter Lock (GIL).

• Mini Project 1: Create a Python module and import it into another program.

• Advanced: Create a Python module using Cython or pybind11 to compile a custom math function in C++, importing it into Python to achieve native C speeds.

• Mini Project 2: Use the NumPy library to perform matrix operations.

• Advanced: Benchmark a 1000x1000 matrix multiplication using pure Python nested loops vs. np.dot(), and monitor your CPU threads to witness NumPy utilizing multi-core BLAS under the hood.

Day 38: High-performance data processing & tokenization

• Operations on NumPy, reading and writing data of different file formats (e.g., CSV) using pandas, operations on pandas, and data preprocessing using libraries such as NLTK.

• Advanced Injection: The limitations of Pandas (single-threaded, high memory overhead) and the shift towards Apache Arrow (in-memory columnar format) and Polars (Rust-based, multi-threaded dataframe library). For NLP: Understand the evolution from legacy NLTK stemming to modern, sub-word tokenizers built in Rust (like HuggingFace tokenizers) used for LLMs.

• Mini Project 1: Read data from a CSV file using Pandas and perform basic data analysis (e.g., calculating mean, median).

• Advanced: Load a multi-gigabyte dataset. Compare the memory usage and load times between reading a raw CSV with Pandas vs. reading a zero-copy .parquet file using Polars.

• Mini Project 2: Preprocess text data using NLTK (e.g., tokenization, stemming).

• Advanced: Implement a script that compares NLTK word tokenization against a pre-trained BPE (byte-pair encoding) tokenizer from the transformers library, analyzing the difference in vocabulary size and memory efficiency.

Day 39: Data visualization & high-dimensional profiling

• Analyze the data using Matplotlib and Plotly.

• Advanced Injection: Visualizing high-dimensional AI spaces. Move beyond basic charts to visualizing AI latent spaces (using PCA, t-SNE, or UMAP to compress 1024-dimensional embeddings down to 2D/3D). Introduction to visualizing AI hardware profiling (e.g., plotting GPU memory bandwidth utilization over time).

• Mini Project 1: Create a bar chart and a scatter plot using Matplotlib.

• Advanced: Extract the weight matrix from a simple neural network layer and plot its distribution as a Matplotlib heatmap to visually inspect for vanishing or exploding gradients.

• Mini Project 2: Generate interactive plots using Plotly.

• Advanced: Use Plotly 3D to visualize a simulated loss landscape of a neural network, helping you geometrically understand how Ggradient descent finds the minimum loss.

Day 40: Linear algebra - matrices & hardware tiling

• Systems of linear equations, matrices, Gaussian elimination, echelon form, column space, null space, the rank of a matrix.

• Advanced Injection: Tiled matrix multiplication. Understand why naive matrix multiplication is cache-inefficient and how hardware (like GPUs) uses block-wise (tiled) operations to maximize L1/L2 cache hits. Understand why direct solvers (like Gaussian elimination) are practically never used in deep learning due to their O(N^3) complexity, favoring iterative solvers (SGD/Adam) instead.

• Mini Project 1: Write a program to solve a system of linear equations using Gaussian elimination in Python.

• Advanced: Implement a block matrix/tiled matrix multiplication algorithm from scratch, demonstrating how dividing matrices into smaller chunks improves CPU cache locality.

• Mini Project 2: Calculate the rank and null space of a given matrix using NumPy.

Day 41: Linear algebra - vector spaces & AI latent spaces

• Vector spaces, subspaces, spanning set, linear independence, basis, and dimension.

• Advanced Injection: Embeddings and latent spaces. Deep learning is fundamentally the science of learning geometric transformations of vector spaces. Understand how an LLM maps words into a 4096-dimensional vector space where semantic meaning is represented by linear independence and spatial distance.

• Mini Project 1: Determine if a set of vectors is linearly independent using NumPy.

• Advanced: Generate a set of word embeddings (using a lightweight model like Word2Vec) and mathematically prove their linear independence or dependence to find semantic correlations.

• Mini Project 2: Find a basis for a given vector space.

Day 42: Linear transformations & LoRA (low-rank adaptation)

• Linear transformations, rank-nullity theorem, matrix of a linear transformation, change of basis and similarity.

• Advanced Injection: A neural network's linear or dense layer is simply a mathematical linear transformation (y = Wx + b). Deep dive into the rank of a matrix and how it is the mathematical foundation for LoRA (low-rank sdaptation) - the technique used to fine-tune massive LLMs on a single GPU by freezing the main matrix and only training two low-rank decomposition matrices.

• Mini Project 1: Find the matrix representation of a linear transformation.

• Advanced: Simulate a LoRA layer from scratch: Take a large 1000x1000 weight matrix W, and approximate its transformation using two smaller matrices A (1000x8) and B (8x1000), calculating the massive reduction in trainable parameters.

• Mini Project 2: Analyze the rank and nullity of a linear transformation.

Day 43: Eigenvalues, eigenvectors & training stability

• Eigenvalues and eigenvectors, algebraic and geometric multiplicity, diagonalization by similarity.

• Advanced Injection: The Hessian matrix and optimization. The eigenvalues of the Hessian matrix (the matrix of second-order derivatives of the loss function) dictate whether a neural network will converge or diverge during training. If the maximum eigenvalue is too large, the learning rate will cause the model to explode.

• Mini Project 1: Calculate the eigenvalues and eigenvectors of a given matrix using NumPy.

• Advanced: Perform principal component analysis (PCA) strictly from scratch by calculating the covariance matrix of a dataset and extracting its top eigenvectors, demonstrating dimensionality reduction.

• Mini Project 2: Diagonalize a matrix if possible.

Day 44: Inner-product spaces & the attention mechanism

• Inner-product spaces, Gram-Schmidt process, orthonormal basis; orthogonal, hermitian and symmetric matrices.

• Advanced Injection: Dot-product attention and vector databases. The inner product (dot product) is the exact mathematical operation used to calculate cosine similarity. This is the heart of vector databases (Milvus, Qdrant) used in RAG systems, and the absolute core of the Transformer's attention mechanism (multiplying the query matrix by the key matrix). Furthermore, learn how orthogonal weight initialization prevents vanishing gradients in deep networks.

• Mini Project 1: Apply the Gram-Schmidt process to orthogonalize a set of vectors.

• Advanced: Implement orthogonal weight initialization for a neural network layer using the Gram-Schmidt process to ensure the weight matrix preserves the norm of the input vectors.

• Mini Project 2: Determine if a matrix is orthogonal, hermitian, or symmetric.

• Advanced: Write a script to calculate the dot-product similarity (inner product) between a Query vector and a massive matrix of Key vectors, explicitly coding the first step of the LLM self-attention mechanism.

Day 45: Calculus - convergence, limits & continuous AI models

• Convergence of sequences and series of real numbers; limits and continuity.

• Advanced Injection: Lipschitz continuity and gradient descent convergence. Understand the mathematical proof of why and when Gradient Descent converges to a minimum. Explore the concept of taking limits to infinity in the context of continuous-depth neural networks (neural ODEs) and the reverse-time continuous processes of diffusion models.

• Mini Project 1: Write a program to determine the convergence of a sequence.

• Advanced: Simulate the convergence of a basic gradient descent algorithm on a convex function, explicitly tracking and graphing how the sequence of steps approaches the true mathematical limit (the global minimum).

• Mini Project 2: Calculate the limit of a function at a given point.

Day 46: Calculus - differentiation & backpropagation internals

• Derivative of a function, differentiation rules, L'Hôpital's rule, chain rule, implicit differentiation.

• Advanced Injection: The chain rule is backpropagation. Deep dive into computational graphs. Understand how deep learning frameworks (like PyTorch and TensorFlow) use automatic differentiation (Autograd) engines to track gradients backward through complex networks using the chain rule (dz/dx = dz/dy * dy/dx).

• Mini Project 1: Implement a numerical differentiation method in Python.

• Advanced: Build a primitive Autograd engine from scratch in pure Python. Define a custom Value object that stores its data and its gradient, and implement a backward() function to compute gradients automatically for simple math equations.

• Mini Project 2: Calculate the derivative of a function using symbolic differentiation.

Day 47: Calculus - loss landscapes & gradient optimization

• Local maxima and local minima, intermediate value theorem, rolle's theorem and mean value theorem, functions and their geometric properties; convexity, concavity, and curve sketching.

• Advanced Injection: Convex vs. non-convex optimization. Why deep neural network loss functions are highly non-convex (filled with saddle points and local minima). Understand the vanishing and exploding gradient problems geometrically, and how architectural fixes like residual connections (ResNet) smooth out the loss landscape.

• Mini Project 1: Find the local maxima and minima of a given function.

• Advanced: Implement vanilla gradient descent to find the global minimum of a custom loss function. Then, introduce momentum into your algorithm to help it escape a simulated local minimum.

• Mini Project 2: Sketch the curve of a function based on its derivatives.

Day 48: Calculus - integration & continuous AI models

• Improper integrals; application to length, area, volume, and surface area of revolution.

• Advanced Injection: Integration in probability density functions (PDFs). Introduction to continuous-time models like diffusion models (used in image generation), where the process of adding and removing noise is modeled mathematically as stochastic differential equations (SDEs) and solved via integration.

• Mini Project 1: Implement a numerical integration method (e.g., trapezoidal rule) in Python.

• Mini Project 2: Calculate the volume of a solid of revolution.

• Advanced: Use numerical integration to calculate the total expected value (area under the curve) of a continuous probability distribution representing an AI model's prediction confidence.

Day 49: Probability theory & LLM next-token prediction

• Basic probability rules and axioms, combinatorics and counting techniques, conditional probability, independence.

• Advanced Injection: Bayes' theorem as the core of generative AI. Understand the Markov assumption. How Large Language Models (LLMs) fundamentally calculate conditional probability: P(Next_Word | Previous_Words).

• Mini Project 1: Write a program to calculate probabilities of events.

• Advanced: Build a basic N-gram language model from scratch. Calculate the conditional probabilities of word sequences using raw frequency counts from a text corpus.

• Mini Project 2: Simulate a simple probability experiment (e.g., coin toss, dice roll) in Python.

Day 50: Probability distributions & latent spaces

• Syllabus Content: Random variables, and probability distributions (discrete), random variables and probability distributions (continuous), expected value variance, moments, joint probability, joint conditional probability correlation, covariance, transformations of random variables.

• Advanced Injection: Covariance matrices in high dimensions. Understand how multiple random variables interact. This is the mathematical foundation for understanding latent variables in variational autoencoders (VAEs) and the Mahalanobis distance for anomaly detection in data pipelines.

• Mini Project 1: Generate random numbers from different probability distributions.

• Advanced: Calculate and visualize a covariance matrix for a multi-dimensional dataset, identifying which features are highly correlated (and thus redundant, which helps in feature engineering).

• Mini Project 2: Calculate the expected value and variance of a random variable.

Day 51: Discrete probability & softmax classification

• Discrete distributions: probability mass function (PMF): bernoulli, binomial, poisson, geometric.

• Advanced Injection: The softmax function and temperature scaling. How deep learning models turn raw output scores (logits) into a valid discrete probability distribution for multi-class classification tasks (like an LLM picking the single best next token out of a 100,000-word vocabulary).

• Mini Project 1: Simulate a Bernoulli trial and calculate probabilities.

• Advanced: Implement the Softmax function from scratch using NumPy. Address the numerical stability issue (preventing NaN errors when calculating exponentials of very large logits).

• Mini Project 2: Generate and visualize a Poisson distribution.

Day 52: Continuous probability & Gaussian noise

• Syllabus Content: Continuous distribution: Probability density function (PDF), cumulative distribution function (CDF), uniform distribution, exponential distribution, normal distribution, standard normal distributions. Z Scores, Z tables.

• Advanced Injection: Gaussian noise and the reparameterization trick. Why the standard normal distribution (mean=0, variance=1) is the holy grail target for generative latent spaces. How VAEs use the reparameterization trick to allow backpropagation through random Gaussian sampling.

• Mini Project 1: Generate a normal distribution and calculate probabilities using Z-tables.

• Advanced: Write a script to take an image matrix, add progressive Gaussian noise to it over 100 steps, and analyze the distribution of pixel values at each step (simulating the forward process of a diffusion model).

• Mini Project 2: Simulate an exponential distribution.

Day 53: Statistical Inference & maximum likelihood

• Sampling distribution, Point estimation: methods of estimation (e.g., method of moments, maximum likelihood estimation), central limit theorem, confidence interval estimation.

• Advanced Injection: Maximum likelihood estimation (MLE) vs. Maximum A posteriori (MAP). Understand the absolute core of machine learning: Training a model is mathematically equivalent to performing MLE to find the parameter weights that maximize the likelihood of the training data.

• Mini Project 1: Estimate the mean and variance of a population from a sample.

• Advanced: Prove mathematically and via Python code that minimizing the mean squared error (MSE) loss function is strictly equivalent to performing maximum likelihood estimation assuming the errors follow a Gaussian distribution.

• Mini Project 2: Calculate a confidence interval for a population parameter.

Day 54: Hypothesis testing & A/B testing in MLOps

• Hypothesis testing: concepts and methods, null and alternative hypotheses; alternative hypothesis - two way test, t-tests (one-sample, two-sample).

• Advanced Injection: A/B testing AI models in production. How to statistically prove that your newly fine-tuned model (e.g., a LoRA updated weights file) is actually performing better than the baseline model in the real world, rather than just relying on lucky test-set metrics.

• Mini Project 1: Perform a t-test to compare the means of two samples.

• Advanced: Simulate production traffic data comparing the latency and accuracy of model A vs. model B. Perform a rigorous hypothesis test (calculating p-values) to decide whether to roll out Model B to 100% of your users.

• Mini Project 2: Conduct a hypothesis test to determine if a sample mean is significantly different from a population mean.

Day 55: Linear regression as a neural primitive

• Chi-square distribution, F-distribution comparison test, Z-distribution, simple linear regression, multiple linear regression.

• Advanced Injection: Linear regression is a 0-hidden-layer network. Understand linear regression not just as a statistical tool, but as a single-layer perceptron with a linear activation function. Understand how L1 (Lasso) and L2 (Ridge) regularization terms translate directly into weight decay in neural network optimizers to prevent overfitting.

• Mini Project 1: Perform a chi-square test for independence.

• Mini Project 2: Implement a simple linear regression model.

• Advanced: Implement linear regression twice: once using exact matrix inversion (the normal equation) and once using iterative gradient descent. Compare the execution speed and numerical stability of both approaches on a dataset with 1 million rows.

Day 56: ANOVA & logistic regression internals

• Analysis of variance (ANOVA), non-parametric methods, logistic regression.

• Advanced Injection: The sigmoid function and binary cross-entropy (BCE). How logistic regression acts as the fundamental building block for binary classification in neural networks. Unpacking the math behind the BCE loss function and why it forces the model to output probabilities between 0 and 1.

• Mini Project 1: Perform an ANOVA test to compare means across multiple groups.

• Mini Project 2: Implement a logistic regression model.

• Advanced: Build a logistic regression model from scratch using pure NumPy. Manually calculate the gradients of the binary cross-entropy loss with respect to the weights, and update the weights iteratively.

Day 57: Advanced statistical concepts & theoretical bounds

• Markov inequality, Chebyshev inequality, WLLN, descriptive statistics, visualization of central tendency and variability.

• Advanced Injection: Theoretical bounds of machine learning. Understand the weak law of large numbers (WLLN) as the mathematical proof of why accumulating more training data stabilizes stochastic gradient descent. Revisit information theory to solidify how variance and uncertainty directly correlate with cross-entropy loss.

• Mini Project 1: Calculate descriptive statistics for a dataset in Python.

• Mini Project 2: Visualize data using histograms and box plots.

• Advanced: Simulate a data stream of 1 million samples. Write a script to visually prove Chebyshev's inequality by calculating the exact percentage of data points falling within k standard deviations of the mean as the sample size grows.

Phase 2: Core machine learning

Day 58: Introduction to machine learning & matrix formulation

• Overview of machine learning, definitions, types, and applications. supervised vs. unsupervised learning.

• Advanced Injection: Formulating ML algorithms as massive matrix operations. Understand the hardware shift: why CPUs are terrible at training ML models compared to the massively parallel architecture of GPUs.

• Mini Project 1: Implement a simple machine learning algorithm (e.g., linear regression) in Python using scikit-learn.

• Advanced: Implement the exact same linear regression algorithm using pure NumPy array operations (solving the normal equation via matrix inversion). Benchmark its execution time against the scikit-learn version on a dataset with 1 million rows.

• Mini Project 2: Research and present on a specific application of machine learning.

Day 59: Machine learning pipeline & data loaders

• Machine learning pipeline: data preprocessing, feature engineering, model training, and evaluation. Evaluation metrics for classification and regression tasks., bias-variance tradeoff and overfitting.

• Advanced Injection: High-performance data pipelines. Why standard Python for loops cause GPU starvation (the GPU sitting idle waiting for data). Understand the mathematical proof of the bias-variance decomposition and how it dictates model capacity.

• Mini Project 1: Preprocess a dataset for machine learning.

• Advanced: Build a custom multi-processed data generator in Python using the multiprocessing library that yields preprocessed data batches, simulating the architecture of PyTorch's highly optimized DataLoader.

• Mini Project 2: Evaluate the performance of a machine learning model using appropriate metrics.

Day 60: Supervised learning - linear models & softmax

• Linear regression, polynomial regression, logistic regression, multi-class classification problem.

• Advanced Injection: Multi-class logistic regression via the softmax function and cross-entropy loss. Vectorizing the gradient computation for multi-class problems to eliminate loops entirely.

• Mini Project 1: Implement a polynomial regression model in Python using scikit-learn.

• Mini Project 2: Build a logistic regression model for a binary classification problem.

• Advanced: Implement a fully vectorized multi-class logistic regression (softmax regression) from scratch using NumPy. Manually code the one-hot encoding, the forward pass, and the gradient update step.

Day 61: Supervised learning - SVM & optimization

• Syllabus Content: Support vector machine for classification and regression.

• Advanced Injection: The kernel trick as projecting data into infinite-dimensional hilbert spaces. Understand the underlying optimization math: solving the primal versus dual formulation using quadratic programming (QP).

• Mini Project 1: Implement a support vector machine for classification.

• Advanced: Implement a linear SVM completely from scratch using hinge loss and sub-gradient descent. Skip the scikit-learn wrapper so you can physically code the math that maximizes the margin between classes.

• Mini Project 2: Use SVM for a regression task.

Day 62: Supervised learning - decision trees & GPU branching

• Syllabus Content: Decision trees and ensemble-based learning: bagging and boosting.

• Advanced Injection: Why decision trees are historically hostile to GPU acceleration (GPUs hate conditional branching logic). Deep dive into the internals of modern high-performance libraries like XGBoost and LightGBM (gradient-based one-side sampling, histogram-based splits).

• Mini Project 1: Build a decision tree classifier in Python using scikit-learn.

• Advanced: Write a pure Python script to calculate Information gain and gini impurity from scratch. Use these metrics to recursively split a toy dataset, forming the backbone of your very own custom decision tree class.

• Mini Project 2: Implement a bagging or boosting algorithm.

Day 63: Supervised learning - KNN to vector databases

• Syllabus Content: k-nearest neighbors.

• Advanced Injection: The curse of dimensionality. Why exact KNN algorithms completely fail in high dimensions (like 4096-D LLM embeddings) and massive datasets. Introduction to approximate nearest neighbors (ANN), KD-Trees, and hierarchical navigable small world (HNSW) graphs - the exact architectures powering modern vector databases (like Pinecone, Milvus, Qdrant).

• Mini Project 1: Implement a k-nearest neighbors classifier.

• Advanced: Implement a brute-force KNN using advanced NumPy broadcasting for massive L2 distance calculations. Then, install and benchmark it against Facebook's highly optimized FAISS (Facebook AI Similarity Search) library.

• Mini Project 2: Use KNN for a regression problem.

Day 64: Introduction to neural networks (MLP from scratch)

• Neural networks: theory, architectures, and activation functions. Deep learning fundamentals: feedforward neural networks.

• Advanced Injection: Forward and backward passes purely in matrix form. Cache memory management: understanding how the forward pass must save layer activations (tensors) in memory because they are mathematically required to calculate gradients during the backward pass (the root cause of GPU VRAM limits).

• Mini Project 1: Build a simple feedforward neural network in Python using TensorFlow or PyTorch.

• Advanced (Crucial): DO NOT use TensorFlow or PyTorch yet. Build a 3-layer multilayer perceptron (MLP) purely in NumPy. Manually code the forward pass, the ReLU activation, the cross-entropy loss, and the complete backpropagation chain using the chain rule.

• Mini Project 2: Experiment with different activation functions in a neural network.

Day 65: Unsupervised learning - clustering & memory limits

• Clustering algorithms: K-means, hierarchical clustering, DBSCAN.

• Advanced Injection: Vectorizing K-Means distance calculations to run on hardware accelerators. Handling out-of-memory clustering using mini-batch K-means for datasets that exceed available RAM.

• Mini Project 1: Implement a K-means clustering algorithm in Python.

• Advanced: Write the K-Means algorithm completely from scratch. Profile the execution time to find the bottleneck, then optimize the centroid-distance calculation step using np.einsum (Einstein summation convention) or advanced broadcasting techniques.

• Mini Project 2: Apply hierarchical clustering to a dataset.

Day 66: Unsupervised learning - dimensionality reduction & embeddings

• Dimensionality reduction techniques: principal component analysis (PCA), t-distributed stochastic neighbor embedding (t-SNE).

• Advanced Injection: The math of PCA: Singular value decomposition (SVD) vs. Eigen-decomposition of the covariance matrix. Understand dimensionality reduction not just for visualization, but as a compression technique for storing massive dense embedding vectors in enterprise RAG systems.

• Mini Project 1: Perform dimensionality reduction using PCA in Python.

• Advanced: Implement PCA from scratch using NumPy's np.linalg.svd function. Calculate the explained variance ratio, compress an image dataset, and reconstruct the images from the principal components to visually measure the data loss.

• Mini Project 2: Visualize high-dimensional data using t-SNE.

Day 67: Deep learning framework internals (PyTorch/TF)

• Learn about TensorFlow and PyTorch.

• Advanced Injection: Under the hood of PyTorch. Understand the difference between dynamic computation graphs (eager execution) and static graphs. Deep dive into PyTorch tensors: Learn how tensors are merely C++ pointers (using the ATen library) managing strides, offsets, and contiguous memory blocks. Introduction to torch.compile (PyTorch 2.0+) and how it uses OpenAI Triton to fuse GPU kernels and minimize memory reads.

• Mini Project 1: Implement a simple neural network using TensorFlow.

• Mini Project 2: Build a neural network using PyTorch.

• Advanced: Write a script that manipulates the stride and storage_offset of a PyTorch tensor directly, demonstrating how you can transpose a massive matrix in O(1) time without moving a single byte of underlying memory.

Day 68: CNN architectures & GPU convolutions

• Convolutional neural networks (CNNs): convolution, striding, padding, pooling, AlexNet architecture, image classification (ImageNet challenge), well-known CNN architectures: VGG16, VGG19.

• Advanced Injection: The im2col algorithm. GPUs cannot easily parallelize sliding windows. Learn how deep learning frameworks use the image to column (im2col) transformation to unroll 2D image patches into a flat 2D matrix, turning a complex convolution into a massive, highly optimized matrix multiplication (GEMM) that GPU tensor cores can process instantly.

• Mini Project 1: Build a CNN to classify images.

• Advanced: Implement a 2D convolution operation from scratch using pure NumPy and the im2col technique, proving that convolutions are just matrix multiplications.

• Mini Project 2: Implement a pre-trained CNN architecture (e.g., VGG16) for image classification.

Day 69: Advanced CNNs & memory-efficient bottlenecks

• Advanced CNN concepts: residual block, ResNet50, 1x1 convolution, XceptionNet, EfficientNet, transfer learning.

• Advanced Injection: Depthwise separable convolutions & VRAM constraints. Understand the exact mathematical reduction in FLOPs (floating point operations) when using 1x1 convolutions as bottleneck layers to compress channel dimensions before expensive 3x3 convolutions. Analyze how ResNet's skip connections fundamentally reshape the loss landscape from a chaotic mountain range into a smooth, convex bowl.

• Mini Project 1: Implement a ResNet50 model.

• Advanced: Build a custom residual block in PyTorch. Hook into the gradients during the backward pass to visually plot and prove that skip-connections prevent thevanishing gradient problem in deep layers.

• Mini Project 2: Apply transfer learning to an image classification task.

Day 70: Object detection & custom loss functions

• Object detection: Problem setup and cost function, well-known datasets, evaluation measures: average precision, mean average precision (mAP), detection techniques: two-stage detector, single-stage detector, RCNN, Fast RCNN, Faster RCNN, SSD, YOLO1-4, RetinaNet, EfficientDet.

• Advanced Injection: Non-maximum suppression (NMS) & bounding box math. How anchor boxes work. Deep dive into the focal loss function (introduced in RetinaNet) to mathematically solve the extreme foreground-background class imbalance.

• Mini Project 1: Implement an object detection model (e.g., YOLO) in Python using a library like OpenCV.

• Advanced: Write the non-maximum suppression (NMS) algorithm and intersection over union (IoU) calculation strictly from scratch in Python to process raw bounding box predictions into clean final outputs.

• Mini Project 2: Evaluate the performance of an object detection model.

Day 71: Image segmentation & up-sampling artifacts

• Image segmentation: Problem setup and cost function, various datasets, semantic segmentation, instance segmentation, RNN, transformer networks, evaluation measures: IoU/Jaccard Index, Dice Score, Mean Pixel Accuracy, SegNet, UNet, Mask R-CNN.

• Advanced Injection: Transposed convolutions vs. bilinear upsampling. Understand the mathematical cause of checkerboard artifacts in generative images and segmentations, and how modern architectures solve this. How the UNet architecture's symmetric skip-connections became the exact backbone used in modern diffusion models (like Stable Diffusion).

• Mini Project 1: Implement a semantic segmentation model (e.g., UNet) in Python.

• Advanced: Implement the dice loss function from scratch in PyTorch. Train a mini-UNet and compare the segmentation boundaries when optimizing for dice loss vs. standard cross-entropy loss.

• Mini Project 2: Evaluate the performance of an image segmentation model.

Day 72: Generative models (VAEs, GANs & wasserstein distance)

• Generative learning: Variational auto-encoders (VAEs), generative adversarial neural networks (GANs), generative learning applications, image generation, font generation, video generation, anime face/celebrity face generation.

• Advanced Injection: Mode collapse and the wasserstein GAN (WGAN). Why standard GANs fail to train (vanishing gradients in the discriminator). Learn the math behind the earth mover's distance (wasserstein metric) and gradient penalty, which mathematically forced GANs to become stable.

• Mini Project 1: Implement a variational autoencoder (VAE) in Python.

• Advanced: Explicitly code the reparameterization trick and the KL-divergence loss penalty. Extract samples from the latent space and generate a 2D interpolation grid to prove the model learned a continuous geometric representation of the data.

• Mini Project 2: Build a generative adversarial network (GAN) for image generation.

Day 73: Deep reinforcement learning & RLHF foundations

• Deep reinforcement learning: Markov decision process (MDP), deep Q learning, exploration vs. exploitation, value iteration vs. policy iteration; reinforcement learning applications: robotics, gaming, ad targeting, recommendation systems, decision making.

• Advanced Injection: Proximal policy optimization (PPO). Go beyond DQN to understand policy gradient methods. PPO is the exact reinforcement learning algorithm used in RLHF (reinforcement learning from human feedback) to align base LLMs (like GPT-3) into helpful chat assistants (like ChatGPT). Understand experience replay buffers and target networks.

• Mini Project 1: Implement a deep Q-network (DQN) for a simple game environment.

• Advanced: Implement an experience replay buffer class that efficiently stores and samples massive state-action-reward transitions without causing CPU RAM memory leaks.

• Mini Project 2: Simulate a reinforcement learning scenario.

Day 74: Model optimization & edge deployment

• Model optimization for deployment: pruning, quantization and binarization, transferred or compact convolutional filters, knowledge distillation.

• Advanced Injection: Hardware-aware quantization. post-training quantization (PTQ) vs. quantization-aware training (QAT). The deep mechanics of transforming FP32 weights into INT8 or FP8, calculating scale factors and zero-points. Introduction to exporting PyTorch models to ONNX (Open Neural Network Exchange) and compiling them with NVIDIA TensorRT for maximum GPU inference speed.

• Mini Project 1: Apply pruning to a trained neural network.

• Advanced: Take a trained PyTorch CNN and perform unstructured L1-norm pruning to remove 50% of the weights. Measure the theoretical size reduction versus the actual inference speedup (proving that unstructured pruning often requires specialized sparse-tensor hardware to see real speedups).

• Mini Project 2: Implement knowledge distillation to compress a model.

• Advanced: Export a trained PyTorch model to the ONNX format, explicitly defining dynamic batch size axes, preparing it for deployment in an optimized C++ or Rust backend.

Day 75: AI ethics & mathematical fairness

• Overview of ethical theories and principles, ethical considerations in AI development, understanding bias in AI algorithms.

• Advanced Injection: The mathematics of fairness. Understand the mathematical impossibility of satisfying all fairness metrics simultaneously (e.g., demographic parity vs. equalized odds). Introduction to constitutional AI and how helpful, honest, harmless (HHH) alignments are mathematically mapped into reward models during RLHF training.

• Mini Project 1: Research and present on a specific ethical issue in AI (e.g., bias in facial recognition).

• Advanced: Build a script from scratch that calculates demographic parity and equal opportunity metrics on a classification model's output, proving computationally how optimizing for overall accuracy often destroys subgroup fairness.

• Mini Project 2: Design an AI system with ethical considerations in mind.

• Advanced: Implement a custom loss function penalty that actively penalizes the model during the backward pass if its predictions diverge between two demographic groups.

Day 76: AI safety, reliability & adversarial robustness

• Ensuring the safety of AI systems, reliability engineering for AI, formal verification methods for AI.

• Advanced Injection: Adversarial machine learning. Understand how a single pixel change can completely break a CNN. Deep dive into the fast gradient sign method (FGSM) and out-of-distribution (OOD) detection. Learn how to calibrate neural networks (expected calibration error) so that when a model outputs 90% confident, it is actually mathematically correct 90% of the time.

• Mini Project 1: Design a safety mechanism for an autonomous vehicle.

• Advanced: Write an FGSM adversarial attack from scratch. Calculate the gradient of the loss with respect to the input image (instead of the weights) to generate adversarial noise that tricks a pre-trained image classifier.

• Mini Project 2: Develop a system to monitor the reliability of a machine learning model.

• Advanced: Implement an expected calibration error (ECE) monitoring script to evaluate if an LLM's raw softmax probabilities can be safely trusted in a production medical or financial environment.

Day 77: AI, robotics & GPU-accelerated simulation

• Integrating AI with robotics, perception and control in robotics, task planning and execution.

• Advanced Injection: Sim2Real (Simulation to Reality) transfer. Why physical robots are too slow for RL training. Understand GPU-accelerated physics simulators (like NVIDIA Isaac Gym) where thousands of robotic environments run simultaneously on a single GPU using parallel tensor operations. Inverse Kinematics via Jacobian matrix pseudo-inversion.

• Mini Project 1: Implement a basic robot control algorithm.

• Advanced: Implement an inverse kinematics (IK) solver using raw NumPy matrix operations to calculate the exact joint angles required for a robotic arm to reach a target 3D coordinate.

• Mini Project 2: Simulate a robot navigating a simple environment.

Day 78: Advanced computer vision & 3D rendering math

• Advanced computer vision tasks, 3D vision, and scene understanding, applications of AI in computer vision.

• Advanced Injection: Neural radiance fields (NeRFs) and 3D Gaussian splatting. Move beyond 2D pixels into volume rendering. Understand the math of ray marching, where a neural network learns to map a 5D coordinate (x, y, z spatial location + viewing angle) directly into color and density.

• Mini Project 1: Develop a 3D reconstruction from 2D images.

• Advanced: Write a foundational Ray Marching algorithm in pure Python/NumPy that calculates the accumulated density and color along a ray intersecting a simulated 3D object.

• Mini Project 2: Implement a scene understanding algorithm.

Day 79: Advanced NLP & High-throughput generation

• Advanced NLP techniques, Natural language generation, and dialogue systems, applications of AI in NLP.

• Advanced Injection: The Internals of autoregressive generation. Why generating text one token at a time is memory-bound (memory-bandwidth limited). Deep dive into key-value caching (kv-cache), PagedAttention (the core of vLLM), and speculative decoding (using a tiny model to draft tokens and a large model to verify them in parallel).

• Mini Project 1: Build a natural language generation system.

• Advanced: Implement a custom kv-cache memory manager class from scratch. Write an autoregressive generation loop that explicitly saves and reuses key/value matrices to prevent redundant calculations, benchmarking the speedup.

• Mini Project 2: Develop a simple dialogue system.

Day 80: Future of work & multi-agent orchestration

• Impact of AI on employment, automation and the workforce, preparing for the future of work.

• Advanced Injection: "AI as the Workforce". Architecting multi-agent systems. Understand the system design of agentic workflows (e.g., LangGraph, AutoGen) where AI models operate in cyclic graphs, maintaining state, passing memory context, and triggering external API tools (function calling/tool use) with strict JSON schema validation.

• Mini Project 1: Research and present on the impact of AI on a specific industry.

• Mini Project 2: Design a training program to help workers adapt to AI-driven changes.

• Advanced: Design the backend architecture for a multi-agent orchestrator. Define the state-graph, memory buffers, and the exact payload schemas required for a coder agent and a reviewer agent to pass data back and forth asynchronously.

Day 81: AI creativity & latent control algorithms

• Generative AI for art, music, and writing, AI as a tool for creative expression, Ethical considerations in AI creativity.

• Advanced Injection: The math of latent control. How do we steer creativity? Deep dive into classifier-free guidance (CFG) math in diffusion models (mixing conditioned and unconditioned latent vectors). Understand the mathematical sampling algorithms (DDIM, Euler, ancestral sampling) and LLM sampling strategies (top-k, top-p nucleus sampling, temperature scaling).

• Mini Project 1: Use AI to generate art or music.

• Advanced: Code the exact nucleus sampling (top-p) and temperature scaling algorithm from scratch using NumPy to manipulate an array of raw logits into a controlled, creative probability distribution.

• Mini Project 2: Analyze the ethical implications of AI-generated content.

Day 82: Social good, privacy & federated learning

• Applications of AI in healthcare, education, and environmental sustainability, AI for addressing social challenges, Ethical considerations in AI for social good.

• Advanced Injection: differential privacy and federated learning. How to train AI on highly sensitive medical/financial data without centralizing it. Learn the FedAvg (Federated Averaging) algorithm and how adding specifically calibrated Laplace or Gaussian noise to gradients guarantees mathematical bounds on privacy.

• Mini Project 1: Design an AI system to address a specific social problem.

• Advanced: Simulate a Federated Learning loop. Create a global server model and three local client models. Train the clients on local data fragments, extract their weight deltas, add simulated privacy noise, and manually average them back into the global model.

• Mini Project 2: Evaluate the ethical considerations of an AI for social good project.

Day 83: AI research trends & next-gen architectures

• Current trends in AI research, emerging topics and challenges, future directions for AI.

• Advanced Injection: Moving beyond the Transformer. Understand the O(N^2) context window bottleneck of Transformers and the rise of State Space Models (SSMs like Mamba/Jamba) that compress context into a fixed hidden state. Explore "Test-Time Compute" (like OpenAI's o1 architecture) where models use Reinforcement Learning to "think" via internal chains of thought before answering.

• Mini Project 1: Research and present on a cutting-edge AI research topic.

• Mini Project 2: Identify potential future applications of AI.

• Advanced: Implement a primitive continuous-time State Space Model (SSM) selective scan mechanism in NumPy, proving how it updates its internal state step-by-step rather than recalculating attention over the entire sequence.

Day 84: Reinforcement learning I - MDP & Bellman internals

• Markov Decision Process (MDP), Bellman Equation, Value Iteration, Policy Iteration.

• Advanced Injection: The Recursive Nature of Value. Understand the Bellman Optimality Equation as a fixed-point iteration problem. Deep dive into the transition matrix and how the "Discount Factor" (Gamma) mathematically ensures convergence in infinite-horizon tasks. Understand why Value Iteration is essentially a dynamic programming problem that can be parallelized as large-scale matrix-vector multiplications.

• Mini Project 1: Implement a simple MDP solver.

• Advanced: Define a 5x5 grid-world as a transition probability tensor and a reward matrix. Use NumPy to calculate the state-transition dynamics.

• Mini Project 2: Use Value Iteration to solve a basic problem.

• Advanced: Implement Value Iteration from scratch using NumPy. Track the "Delta" (residual) between iterations to visually plot the convergence rate towards the optimal value function.

Day 85: Reinforcement learning II - deep Q-learning architecture

• Syllabus Content: Q-learning, SARSA, deep reinforcement learning.

• Advanced Injection: From tabular to neural. Understand the moving target problem in deep Q-learning (DQN). Deep dive into the system design of experience replay buffers (to break data correlation) and target networks (to stabilize the Bellman update). Learn how double DQN mathematically fixes the overestimation bias of standard Q-learning.

• Mini Project 1: Implement Q-learning for a simple game.

• Advanced: Build a Q-table for the frozen lake environment. Implement an Epsilon-Greedy strategy and analyze how the exploration-exploitation tradeoff affects the learning curve.

• Mini Project 2: Explore deep reinforcement learning with a framework like PyTorch or TensorFlow.

• Advanced: Build a DQN architecture. Explicitly implement the target network synchronization step (e.g., updating weights every 1000 steps) and monitor the loss stability.

Day 86: Recommender systems - matrix factorization & scale

• Collaborative filtering, content-based recommendation, matrix factorization.

• Advanced injection: Latent factor models. Connect matrix factorization to singular value decomposition (SVD). Understand the two-tower architecture (user tower and item tower) used in high-performance production systems (like YouTube or TikTok). Learn how approximate nearest neighbor (ANN) search is used at the retrieval stage of a recommender to find candidates in milliseconds.

• Mini project 1: Build a basic collaborative filtering system.

• Advanced: Use the MovieLens dataset. Implement a user-item similarity matrix and address the cold start problem through fallback logic.

• Mini project 2: Implement a content-based recommender.

• Advanced: Implement matrix factorization using stochastic gradient descent (SGD) from scratch. Decompose a sparse rating matrix into user and item latent feature matrices and reconstruct the ratings to calculate the RMSE (root mean square error).

Day 87: Information retrieval - sparse vs. dense retrieval

• Vector space model, TF-IDF, search engine basics.

• Advanced injection: From keyword to context. Compare sparse retrieval (TF-IDF, BM25) with modern dense retrieval (bi-encoders). Understand how search engines optimize the inverted index for speed. Bridge this to RAG (retrieval-augmented generation) by understanding how reciprocal rank fusion combines keyword search with vector search for better accuracy.

• Mini project 1: Implement a simple search engine.

• Mini project 2: Calculate TF-IDF for a set of documents.

• Advanced: Build a mini-search engine that indexes 1000 documents. Implement the TF-IDF calculation using NumPy and use cosine similarity to rank results. Benchmark the search latency.

Day 88: Knowledge representation - graphs & semantic RAG

• Semantic networks, frame systems, logic-based representation.

• Advanced injection: Knowledge graphs (KG). Understand how semantic networks evolved into modern knowledge graphs. Learn the concept of GraphRAG — augmenting LLMs with structured knowledge from a graph database (like Neo4j) to prevent hallucinations in complex, multi-hop reasoning tasks.

• Mini project 1: Create a semantic network for a specific domain.

• Mini project 2: Implement a simple knowledge-based system.

• Advanced: Represent a set of facts (e.g., A is a B, B has property C) as an adjacency list. Write a recursive Python function to perform inference (e.g., Does A have property C?).

Day 89: Logic programming - symbolic AI roots

• Introduction to Prolog, logic programming paradigms, applications of logic programming.

• Advanced injection: Declarative vs. imperative. Understand why logic programming is excellent for constraint satisfaction problems. Compare symbolic AI (Prolog) with connectionist AI (neural networks). Learn how modern neuro-symbolic AI attempts to combine the reasoning logic of Prolog with the pattern recognition of deep learning.

• Mini project 1: Write a Prolog program to solve a logic puzzle.

• Mini project 2: Implement a simple expert system in Prolog.

• Advanced: Design a set of rules and facts in Prolog to solve a classic puzzle like the Zebra puzzle or a simple medical diagnosis tree.

Day 90: Fuzzy logic - handling uncertainty in signals

• Fuzzy sets, fuzzy operations, fuzzy inference systems.

• Advanced injection: Degrees of truth. Understand the fuzzification and defuzzification process. Relate fuzzy logic to softmax probabilities in neural networks — how soft logic allows for differentiable decision-making. Learn where fuzzy logic is still critical: control systems (like autonomous braking or climate control) where binary (on/off) logic is too jarring.

• Mini project 1: Implement fuzzy logic control for a system.

• Mini project 2: Design a fuzzy inference system.

• Advanced: Design a fuzzy temperature controller in Python. Define triangular membership functions (cold, warm, hot) and write the logic to determine the fan speed based on the degree of membership in each set.

Day 91: Evolutionary computing - global optimization

• Genetic algorithms, evolutionary strategies, applications of evolutionary computing.

• Advanced injection: Optimization without gradients. Understand why genetic algorithms (GA) are used for black box optimization where the gradient is unknown or non-differentiable. Learn about neuroevolution — using GAs to evolve the weights or the entire architecture (NAS - neural architecture search) of a neural network.

• Mini project 1: Implement a genetic algorithm to solve an optimization problem.

• Advanced: Solve the traveling salesperson problem (TSP) for 20 cities using a genetic algorithm. Implement crossover, mutation, and tournament selection.

• Mini project 2: Explore evolutionary strategies.

• Advanced: Plot the fitness of the population over 500 generations to visualize how the global optimum is approached.

Day 92: Swarm intelligence - decentralized optimization

• Ant colony optimization, particle swarm optimization, applications of swarm intelligence.

• Advanced injection: Emergent behavior. Understand particle swarm optimization (PSO) as a population-based search where each particle maintains a velocity based on its own best-known position and the global best position. Compare the convergence speed and local minima avoidance of PSO versus standard stochastic gradient descent (SGD).

• Mini project 1: Implement ant colony optimization for a routing problem.

• Mini project 2: Use particle swarm optimization to solve a function optimization.

• Advanced: Implement PSO to find the global minimum of the Rastrigin function (a highly non-convex function with many local minima). Visualize the particles swarming towards the global minimum over time.

Day 93: Robotics - kinematics & 3D tensor math

• Forward and inverse kinematics, Denavit-Hartenberg convention.

• Advanced injection: The mathematics of SE(3) space. Understand how to represent 3D rotations and translations efficiently using transformation matrices and quaternions (to avoid gimbal lock). Deep dive into the Jacobian matrix for inverse kinematics (IK), and understand why matrix singularities cause robotic arms to violently lock up or spin out of control.

• Mini project 1: Simulate the forward kinematics of a robotic arm.

• Advanced: Build a 3-DOF (degree of freedom) arm simulator using pure NumPy matrix multiplications to compute the exact end-effector position in 3D space.

• Mini project 2: Implement inverse kinematics for a simple robot.

• Advanced: Implement an iterative IK solver using the Jacobian pseudo-inverse method. Monitor the condition number of the matrix to detect and gracefully handle mathematical singularities.

Day 94: Robotics - dynamics & differential equations

• Lagrangian mechanics, equations of motion for robots, control of robot manipulators.

• Advanced injection: The mass-inertia matrix and Coriolis tensors. Frame classical physics as a high-performance computing problem. Understand how solving the Lagrangian requires computing massive systems of ordinary differential equations (ODEs) in real-time, and how neural networks (like physics-informed neural networks - PINNs) are being used to approximate these equations orders of magnitude faster.

• Mini project 1: Simulate the dynamics of a robot.

• Advanced: Write a simulation for a double pendulum (a classic chaotic system). Use numerical integration (e.g., Runge-Kutta) to update the state tensors over time.

• Mini project 2: Implement a control algorithm for a robot joint.

• Advanced: Implement a computed torque control algorithm that uses the exact inverse dynamics matrix to cancel out gravity and momentum, allowing the robotic joint to behave as if it is weightless.

Day 95: Robotics - perception & edge sensor fusion

• Robot sensors, computer vision for robots, sensor fusion.

• Advanced injection: The Kalman filter internals. Deep dive into the extended Kalman filter (EKF) and unscented Kalman filter (UKF). Understand the covariance matrix math used to fuse noisy IMU (inertial measurement unit) data operating at 500Hz with high-latency camera data operating at 30Hz without blowing up memory buffers.

• Mini project 1: Implement a simple object recognition system for a robot.

• Advanced: Process 3D LiDAR point clouds. Implement a voxelization algorithm in NumPy to convert sparse, unstructured 3D points into a dense 3D tensor that a neural network can actually process.

• Mini project 2: Use sensor fusion to combine data from multiple sensors.

• Advanced: Write a 1D Kalman filter from scratch to track a moving object, explicitly calculating the Kalman gain to optimally weigh the prediction against the noisy sensor measurement.

Day 96: Robotics - planning & configuration spaces

• Path planning, motion planning, task planning.

• Advanced injection: C-space (configuration space) and GPU acceleration. Understand why planning algorithms like A* fail in continuous high-dimensional robotic joints. Deep dive into RRT* (rapidly-exploring random trees) and how cost-map generation can be reframed as a 2D matrix convolution problem for massive GPU parallelization.

• Mini project 1: Implement A* search for robot path planning.

• Advanced: Implement A* on a massive 1000x1000 grid. Profile the algorithm and optimize the priority queue (heap) operations to ensure the path is found in under 50 milliseconds.

• Mini project 2: Develop a motion plan for a robot to perform a task.

• Advanced: Implement a basic RRT algorithm to navigate a 2DOF robotic arm through a field of obstacles, mapping the physical obstacles into the arm's angular configuration space.

Day 97: Robotics - control & convex optimization

• Feedback control, PID control, advanced control techniques.

• Advanced injection: Model predictive control (MPC) and LQR (linear quadratic regulator). Move beyond basic PID loops. Frame robot control as a rolling horizon optimization problem. Understand how modern autonomous vehicles use gradient descent in real-time to solve MPC cost functions, keeping the car perfectly centered on the highway.

• Mini project 1: Implement a PID controller for a robot.

• Advanced: Write a PID loop to balance a simulated inverted pendulum. Intentionally introduce integral windup and write the anti-windup logic to fix it.

• Mini project 2: Simulate a robot control system.

• Advanced: Implement a basic LQR controller. Solve the algebraic Riccati equation to find the optimal gain matrix, proving that optimal control is fundamentally a linear algebra problem.

Day 98: Robotics - SLAM & sparse matrix solvers

• Industrial robotics, service robotics, mobile robotics.

• Advanced injection: SLAM (simultaneous localization and mapping) internals. Deep dive into factor graphs and bundle adjustment. Understand how autonomous mobile robots map a factory floor by solving massive, sparse systems of equations (using libraries like Ceres Solver or g2o) to minimize reprojection errors across thousands of camera frames.

• Mini project 1: Research and present on an application of robotics in a specific industry.

• Advanced: Write an architectural breakdown of how an autonomous warehouse robot (like an Amazon Kiva) synchronizes its local SLAM map with the global fleet server.

• Mini project 2: Design a robotic system for a service application.

• Advanced: Implement a basic pose graph optimization script. Take a noisy circular trajectory of a robot and mathematically close the loop to snap the trajectory back into a perfect circle.

Day 99: VR - render pipelines & spatial computing

• VR hardware and software, VR development, VR applications.

• Advanced injection: Motion-to-photon latency and neural rendering. Understand the extreme hardware constraints of VR (requiring 90+ FPS per eye). Deep dive into foveated rendering — using eye-tracking to render the periphery at low resolution. Explore how AI (like DLSS and neural upsampling) is replacing traditional graphics pipelines to save GPU power on edge headsets.

• Mini project 1: Design a VR experience for a specific purpose (e.g., education, entertainment).

• Advanced: Write a script that calculates the exact field of view (FOV) projection matrix required to map a 3D world onto a 2D display plane for stereoscopic vision.

• Mini project 2: Explore different VR development platforms and tools.

Day 100: AR - visual-inertial odometry (VIO) & edge AI

• AR technology, AR development, AR applications.

• Advanced injection: High-frequency VIO on mobile silicon. Understand how AR glasses map the real world without draining the battery in 5 minutes. Learn the system architecture of deploying highly quantized (INT8/INT4) object detection models directly onto smartphone NPUs (neural processing units) to anchor digital objects to reality at 60 FPS.

• Mini project 1: Develop a simple AR application.

• Advanced: Implement a homography matrix calculation. Take an image of a real-world marker, extract its corners, and compute the matrix transformation needed to overlay a digital image perfectly onto that perspective.

• Mini project 2: Research AR applications in a specific industry (e.g., retail, manufacturing).

Day 101: AI in game engine internals & compute shaders

• AI for game characters, game AI techniques, AI for game design.

• Advanced injection: Real-time edge inference. Modern game engines (Unreal/Unity) demand AI execution within a 16-millisecond frame window. Understand how to bypass the CPU and run neural network inferences directly on the GPU using compute shaders (HLSL/GLSL) to execute tensor math concurrently with graphics rendering.

• Mini project 1: Implement AI for a game character.

• Advanced: Implement a reinforcement learning policy network in PyTorch, export it to ONNX, and write an optimized C++ inference loop targeting sub-millisecond execution time to control an NPC.

• Mini project 2: Design a game level using AI.

• Advanced: Build a wave function collapse (WFC) algorithm from scratch using NumPy to procedurally generate a 3D voxel game level, tracking the constraint-solving performance.

Day 102: AI in digital art & VRAM optimization

• Generative art, AI for music composition, AI for creative writing.

• Advanced injection: Internals of high-resolution diffusion and audio models. Generating 4K art or raw audio waveforms (44,100 samples per second) causes catastrophic VRAM bottlenecks. Deep dive into FlashAttention, gradient checkpointing, and tiled VAE decoding to manipulate massive latent spaces without causing out-of-memory (OOM) GPU crashes.

• Mini project 1: Use AI to generate digital art.

• Advanced: Modify the inference script of a diffusion model (like Stable Diffusion) to implement tiled decoding, allowing you to render an image larger than your GPU's physical VRAM limit by processing it in chunks.

• Mini project 2: Create a musical composition using AI.

• Advanced: Implement a 1D causal convolutional layer (used in WaveNet/AudioLM) from scratch, analyzing the memory bandwidth required to generate sequential audio tokens.

Day 103: AI in digital marketing & terabyte-scale embeddings

• AI for advertising, AI for social media marketing, AI for content creation.

• Advanced injection: Deep learning recommendation models (DLRM). Digital advertising relies on CTR (click-through rate) prediction using categorical features (user ID, ad ID) that create terabyte-scale embedding tables. Understand model parallelism: how to shard massive embedding tables across multiple GPUs using high-speed NVLink interconnects.

• Mini project 1: Design an AI-powered advertising campaign.

• Advanced: Build a DLRM architecture in PyTorch. Manually shard a simulated 50GB embedding table across two devices (e.g., CPU RAM and GPU VRAM) and write the forward pass to synchronize them.

• Mini project 2: Use AI to analyze social media trends.

• Advanced: Implement a streaming data pipeline (simulating Kafka) that ingests social media data and updates a text embedding index in real-time without locking the read-threads.

Day 104: AI in e-commerce & high-concurrency chatbots

• Recommender systems, chatbots for customer service, AI for fraud detection.

• Advanced injection: LLM serving at scale (vLLM & continuous batching). E-commerce chatbots face massive concurrent user traffic. Understand why static batching fails for LLMs. Deep dive into continuous batching and PagedAttention (managing KV-cache like an operating system manages virtual memory pages) to increase GPU throughput by 10x.

• Mini project 1: Implement a recommender system for an online store.

• Advanced: Build a hierarchical navigable small world (HNSW) graph index from scratch to perform approximate nearest neighbor (ANN) search for millions of products in under 5 milliseconds.

• Mini project 2: Build a chatbot for customer service.

• Advanced: Deploy an LLM using the vLLM engine. Use a load-testing tool (like Apache JMeter or Locust) to bombard your chatbot with 1000 concurrent requests, analyzing the GPU KV-cache allocation logs.

Day 105: AI in finance & ultra-low latency hardware

• Algorithmic trading, fraud detection, risk management.

• Advanced injection: High-frequency trading (HFT) and FPGA/ASIC deployment. In finance, microseconds cost millions. Understand how Python/PyTorch are completely stripped away, and models are compiled directly into RTL (register-transfer level) hardware code to run on FPGAs for nanosecond execution. Introduction to temporal fusion transformers (TFT) for time-series forecasting.

• Mini project 1: Develop a simple algorithmic trading strategy.

• Advanced: Export a PyTorch LSTM model to C++ using ONNX Runtime. Profile the C++ execution to ensure the forward pass completes in under 100 microseconds.

• Mini project 2: Implement an AI model for fraud detection.

• Advanced: Implement a graph neural network (GNN) for fraud detection. Optimize the sparse matrix-matrix multiplication (SpMM) operations to handle highly imbalanced financial transaction graphs.

Day 106: AI in healthcare & 3D/geometric deep learning

• Medical imaging analysis, drug discovery, personalized medicine.

• Advanced injection: 3D tensor processing and equivariant networks. Medical imaging (MRI/CT scans) uses massive 3D volumetric tensors (e.g., 512x512x512). Drug discovery relies on 3D molecular structures, requiring equivariant graph neural networks (like AlphaFold) that understand physical rotation and translation mathematically.

• Mini project 1: Analyze medical images using AI.

• Advanced: Implement a 3D convolutional layer. Write a custom memory-chunking algorithm to process an out-of-core MRI dataset that is too large to fit into RAM.

• Mini project 2: Design an AI system for drug discovery.

• Advanced: Build a basic SE(3)-equivariant neural network layer that ensures the predicted properties of a molecule remain mathematically identical regardless of how the molecule's coordinates are rotated in 3D space.

Day 107: AI in education & semantic caching systems

• Personalized learning, intelligent tutoring systems, AI for assessment.

• Advanced injection: Deep knowledge tracing & RAG infrastructure. Model student knowledge states iteratively. For automated tutoring systems, LLM inference is too expensive. Understand semantic caching (e.g., GPTCache): using vector databases to intercept user queries, calculating cosine similarity to previous questions, and returning cached answers to bypass the GPU entirely.

• Mini project 1: Develop a personalized learning platform.

• Advanced: Implement an RNN-based deep knowledge tracing model that dynamically predicts a student's probability of answering the next question correctly based on their historical time-series tensor.

• Mini project 2: Design an AI system for automated assessment.

• Advanced: Build a semantic caching layer in Python. Map incoming questions to embeddings, and if a question has a 0.95+ cosine similarity to a known question, instantly return the cached evaluation without calling the LLM.

Day 108: AI for environment & physics-informed neural networks

• AI for climate modeling, AI for renewable energy, AI for conservation.

• Advanced injection: PINNs (physics-informed neural networks) and earth-scale data. Climate models require solving complex fluid dynamics. Learn how PINNs embed exact physical laws (like the Navier-Stokes equations) directly into the neural network's loss function, forcing the AI to obey the laws of physics during training.

• Mini project 1: Use AI to model climate data.

• Advanced: Implement a physics-informed neural network to solve a basic partial differential equation (PDE) representing heat transfer across a metal plate, minimizing the PDE residual in the loss function.

• Mini project 2: Design an AI system for renewable energy optimization.

• Advanced: Build a distributed data loader using PySpark or Ray to process petabytes of simulated geospatial satellite imagery across multiple CPU nodes.

Day 109: AI in agriculture & TinyML on microcontrollers

• Precision farming, crop monitoring, automated irrigation.

• Advanced injection: Edge AI and extreme hardware constraints. Agricultural drones and IoT sensors lack internet access and GPUs. Deep dive into TinyML: pruning models and applying extreme INT8/INT4 quantization to deploy computer vision models directly onto microcontrollers (like ESP32 or Raspberry Pi Pico) drawing less than 1 watt of power.

• Mini project 1: Develop an AI system for crop monitoring.

• Advanced: Take a standard ResNet model, apply INT8 post-training static quantization (PTQ) calibrating the activation ranges, and mathematically verify the drop in memory footprint.

• Mini project 2: Design an automated irrigation system.

• Advanced: Write an inference script using TensorFlow Lite for microcontrollers (in C++) to execute a lightweight neural network directly on simulated bare-metal edge hardware.

Day 110: AI ethics, law & cryptographic provenance

• Ethical frameworks for AI, AI governance, legal and regulatory issues.

• Advanced injection: Algorithmic auditing & data watermarking. Shift from legal theory to mathematical enforcement. Understand cryptographic data provenance (proving mathematically what data was used to train a model to avoid copyright lawsuits). Deep dive into LLM watermarking techniques (modifying the logits during generation to embed an invisible statistical signature).

• Mini project 1: Analyze the ethical implications of an AI application.

• Advanced: Implement a mathematical text watermarking algorithm (e.g., Kirchenbauer et al.) from scratch. Write the generation loop that slightly biases the probability of certain green-listed tokens, and write the detector script to prove the text was AI-generated.

• Mini project 2: Research and present on legal issues related to AI.

• Advanced: Build a script using SHA-256 hashing to create a Merkle tree of a training dataset, ensuring cryptographic proof of data integrity for compliance audits.

Day 111: AI safety, security & weight poisoning

• Robust AI, adversarial attacks, AI safety engineering.

• Advanced injection: Red-teaming, prompt injection math, and backdoors. Deep dive into the mechanics of adversarial attacks specifically targeting the embedding layer of transformers. Understand model weight poisoning (sleeper agents) — how bad actors can upload fine-tuned models to HuggingFace that act normally until a specific trigger word mathematically activates a malicious sub-network.

• Mini project 1: Develop a robust AI model.

• Advanced: Implement an activation clipping defense layer in a PyTorch model designed to detect and suppress abnormal, high-magnitude tensor activations caused by malicious weight poisoning.

• Mini project 2: Implement an adversarial attack on a model.

• Advanced: Execute a white-box adversarial attack (like projected gradient descent - PGD) to maliciously alter a text prompt's embedding vectors, forcing the LLM to bypass its safety alignment.

Day 112: AI society & decentralized infrastructure

• Impact of AI on society, social implications of AI, AI and the future.

• Advanced injection: Decentralized AI compute & peer-to-peer networks. How society scales AI without relying on corporate cloud monopolies. Understand the system architecture of distributed inference networks (like Petals or Bittensor), where a massive 70-billion parameter LLM is split across hundreds of consumer GPUs over the internet via distributed RPC (remote procedure call).

• Mini project 1: Research and present on the social impact of AI.

• Advanced: Set up a distributed inference node using a framework like Petals. Connect to a global swarm to run inference on a massive LLM, analyzing the network latency and RPC overhead.

• Mini project 2: Discuss the future of AI and its societal implications.

Day 113: Advanced topics - causality & probabilistic graphs

• Causal inference, Bayesian networks, probabilistic graphical models.

• Advanced injection: Correlational vs. causal AI. Deep learning merely finds correlations. Understand Pearl's do-calculus and how to mathematically model interventions (the do operator) and counterfactuals. Deep dive into Markov chain Monte Carlo (MCMC) and Gibbs sampling algorithms used to estimate intractable probability distributions in complex graphical models.

• Mini project 1: Implement a Bayesian network for a problem.

• Advanced: Build a Markov chain Monte Carlo (MCMC) sampler from scratch in pure Python to approximate the posterior distribution of a complex Bayesian network where exact inference is mathematically impossible.

• Mini project 2: Apply causal inference techniques.

• Advanced: Implement propensity score matching on a dataset to isolate the true causal effect of a variable, proving mathematically that correlation does not equal causation.

Day 114: Distributed AI & decentralized training topologies

• Multi-agent systems, distributed problem solving, swarm intelligence.

• Advanced injection: Parameter servers vs. ring-AllReduce. Understand the system architectures of distributed deep learning. Learn how multiple GPUs synchronize gradients over a network. Deep dive into the ring-AllReduce algorithm (used by NVIDIA NCCL) which optimally shares gradients across nodes without creating a single network bottleneck.

• Mini project 1: Simulate a multi-agent system.

• Advanced: Simulate a distributed training cluster in Python. Implement a basic parameter server architecture using Python's multiprocessing and sockets to pass weight gradients back and forth asynchronously.

• Mini project 2: Implement a distributed problem-solving algorithm.

Day 115: AI hardware internals & the roofline model

• AI accelerators, neuromorphic computing, quantum computing for AI.

• Advanced injection: The roofline model. How to mathematically calculate if your AI model is compute-bound (limited by tensor cores) or memory-bound (limited by HBM bandwidth). Deep dive into spiking neural networks (SNNs) for neuromorphic chips, where neurons communicate via asynchronous binary spikes to achieve micro-watt power consumption.

• Mini project 1: Research and present on AI hardware trends.

• Advanced: Calculate the exact arithmetic intensity (FLOPs per byte of memory read) of a standard transformer layer, and plot it on a roofline model graph for an NVIDIA A100 GPU to identify the absolute hardware limit.

• Mini project 2: Explore the basics of neuromorphic computing.

• Advanced: Write a simulation of a leaky integrate-and-fire (LIF) neuron from scratch, the fundamental building block of neuromorphic AI chips.

Day 116: AI, big data & sharded dataloaders

• Big data processing, distributed computing, AI for big data analytics.

• Advanced injection: Petabyte-scale AI training. Standard file storage completely breaks down at scale. Understand the WebDataset format (tar archives of images and JSON) used to train models like Stable Diffusion. Deep dive into distributed computing frameworks like Apache Ray and how they orchestrate thousands of CPU workers to feed data to GPU clusters without stalling.

• Mini project 1: Process a large dataset using distributed computing.

• Advanced: Write a MapReduce job from scratch in Python to parse a massive text corpus, count token frequencies, and build an LLM vocabulary index.

• Mini project 2: Apply AI techniques to analyze big data.

Day 117: Advanced robotics - real-time middleware (ROS2)

• Human-robot interaction, cognitive robotics, field robotics.

• Advanced injection: Deterministic execution & DDS. AI in the lab is forgiving; AI in field robotics is not. Understand real-time operating systems (RTOS) and the data distribution service (DDS) middleware used in ROS2 (Robot Operating System 2). Learn how to guarantee that an AI perception node will process a camera frame and issue a steering command in exactly 16 milliseconds, every single time.

• Mini project 1: Design a human-robot interaction system.

• Mini project 2: Develop a cognitive model for a robot.

• Advanced: Architect a publish/subscribe node system using Python. Implement a strict timing timeout: if the simulated AI vision node takes longer than 20ms to process a frame, the control node must automatically trigger a safe-fallback braking maneuver.

Day 118: Advanced architectures - GNNs & FlashAttention

• Graph neural networks, attention mechanisms, transformer networks.

• Advanced injection: Message passing and IO-awareness. Deep dive into graph convolutional networks (GCNs): understand how multiplying an adjacency matrix by a feature matrix mathematically aggregates neighbor information. For transformers: understand FlashAttention — how fusing the attention matrices in SRAM avoids expensive read/writes to global GPU memory, shifting the transformer from memory-bound back to compute-bound.

• Mini project 1: Implement a graph neural network.

• Advanced: Code the message passing algorithm of a GNN from scratch using NumPy to classify nodes in a citation network graph.

• Mini project 2: Build a transformer network for a sequence task.

• Advanced: Build a transformer encoder from scratch in NumPy. Explicitly code the scaled dot-product attention math, complete with the softmax scaling factor to prevent gradient vanishing.

Day 119: Healthcare AI - 3D tensors & data privacy

• AI for medical diagnosis, drug discovery, and healthcare management.

• Advanced injection: 4D medical tensors and HIPAA compliance. Medical scans (CT/MRI) are not 2D images; they are massive 3D volumes (height, width, depth, channels). Understand the extreme VRAM constraints of 3D convolutions (Conv3D). Learn the architecture of federated learning systems deployed across multiple hospitals to train a shared model without ever moving sensitive patient data over the internet.

• Mini project 1: Develop an AI model for medical image diagnosis.

• Advanced: Write a memory-efficient sliding-window inference script to process a massive simulated 3D CT scan using a 3D-CNN without triggering a GPU out-of-memory error.

• Mini project 2: Design an AI system for healthcare management.

Day 120: Finance AI - order books & kernel optimization

• Algorithmic trading, risk management, and financial forecasting.

• Advanced injection: Level 2 data and GPU custom kernels. In quantitative trading, data arrives as a continuous stream of order book updates (bids and asks) at microsecond intervals. Understand how to represent limit order books as sparse tensors. Learn why standard PyTorch is too slow, and how hedge funds write custom CUDA C++ kernels to process moving averages and momentum signals on the GPU instantly.

• Mini project 1: Build a deep learning model for stock price prediction.

• Advanced: Represent a simulated limit order book as a time-series tensor and build a 1D-convolutional model to predict the next-tick price movement based on order imbalances.

• Mini project 2: Implement an AI system for risk assessment in finance.

Day 121: CV applications - temporal modeling in video

• Object detection, image segmentation, and video analysis.

• Advanced injection: Optical flow and 4D tensors. Video processing adds the dimension of time (batch, time, channels, height, width). Deep dive into the math of optical flow (tracking pixel movement between frames) and the architecture of spatial-temporal attention models (like TimeSformer or VideoMAE), analyzing the exponential explosion of attention complexity when time is introduced.

• Mini project 1: Develop a deep learning model for object detection.

• Mini project 2: Implement an image segmentation algorithm.

• Advanced: Implement a basic optical flow calculation algorithm from scratch using NumPy to mathematically track the velocity vectors of moving edges between two consecutive video frames.

Day 122: NLP applications - decoding algorithms & RoPE

• Natural language generation, dialogue systems, and text summarization.

• Advanced injection: Advanced decoding and position embeddings. How does an LLM actually speak? Deep dive into the math of beam search decoding vs. greedy decoding. Understand rotary position embeddings (RoPE) — the exact mathematical technique used in Llama-3 to inject positional information directly into the attention matrix via complex number rotations, allowing models to extrapolate to infinite context lengths.

• Mini project 1: Build a deep learning model for text generation.

• Advanced: Implement the beam search decoding algorithm from scratch. Track multiple candidate sequences and calculate their cumulative log-probabilities to find the mathematically optimal generated sentence.

• Mini project 2: Develop a dialogue system using deep learning.

Day 123: Quantum computing I - qubits & tensor states

• Quantum algorithms, quantum information theory, quantum error correction.

• Advanced injection: Quantum state vectors and tensors. Understand how a qubit's state is a complex-valued vector in a Hilbert space. Deep dive into the curse of dimensionality in classical computing versus the exponential state space of quantum entanglement. Learn how quantum machine learning (QML) uses variational quantum circuits (VQC) as an alternative to classical neural network layers.

• Mini project 1: Implement a simple quantum algorithm.

• Advanced: Use a framework like PennyLane or Qiskit to build a variational quantum circuit (VQC). Implement the parameter shift rule — the quantum equivalent of backpropagation — to calculate gradients on a simulated quantum processor.

• Mini project 2: Study quantum error correction techniques.

• Advanced: Simulate bit-flip and phase-flip noise on a quantum state. Implement a 3-qubit error correction code and mathematically verify how it preserves the logical state despite physical noise.

Day 124: Quantum computing II - quantum kernels & QML

• Quantum computing applications, quantum hardware, future of quantum computing.

• Advanced injection: Quantum kernel estimation. Understand how quantum computers can map data into a feature space so high-dimensional that it is classically unreachable. Deep dive into the hardware architecture: superconducting qubits (transmon) versus ion traps, and why cryogenic cooling and coherence time are the HPC bottlenecks of quantum systems.

• Mini project 1: Research and present on applications of quantum computing in AI.

• Advanced: Write a technical comparison between a classical support vector machine (SVM) and a quantum kernel machine, focusing on computational complexity and the quantum advantage threshold.

• Mini project 2: Explore the basics of quantum hardware.

• Advanced: Use a cloud-based quantum simulator to benchmark the execution time of a quantum circuit as you increase the number of qubits, identifying the point where classical simulation fails (quantum supremacy boundary).

Day 125: Advanced robotics - swarm intelligence & soft simulation

• Swarm robotics, evolutionary robotics, soft robotics.

• Advanced injection: Decentralized consensus & finite element method (FEM). In swarm robotics, understand the communication overhead: how thousands of agents synchronize state tensors over lossy low-power networks. For soft robotics, dive into the mechanics of soft materials simulation using FEM (finite element method) on GPUs to calculate deformation tensors in real-time.

• Mini project 1: Simulate a swarm robotic system.

• Advanced: Build a boids simulation using NumPy vectorization. Optimize the neighbor-search using spatial hashing to allow 10,000+ agents to interact at 60 FPS.

• Mini project 2: Design a soft robotic arm.

• Advanced: Simulate a 1D soft actuator using a mass-spring-damper model. Implement a PID controller that accounts for the non-linear elasticity of the material.

Day 126: AI ethics - formal verification & privacy math

• AI and human rights, AI and social justice, responsible AI development.

• Advanced injection: Formal verification and differential privacy. Shift from debate to math. Understand how to use formal methods (SMT solvers) to mathematically prove that a neural network will never output a value outside of a safe range. Deep dive into the epsilon-delta definition of differential privacy and its impact on model gradient utility.

• Mini project 1: Analyze the ethical implications of AI in a legal context.

• Advanced: Implement a fairness constraint directly into a PyTorch loss function. Train a model on a biased dataset and use the constraint to mathematically force the model to have equal false-positive rates across groups.

• Mini project 2: Develop a set of ethical guidelines for AI development.

• Advanced: Create a model card that includes a quantitative bias audit and a robustness score against adversarial noise (using the FGSM attack from day 111).

Day 127: AI & cognitive science - neuromorphic architectures

• Cognitive modeling, computational neuroscience, AI and the mind.

• Advanced injection: Spiking neural networks (SNN) and STDP. Compare the energy-efficient spiking mechanism of the human brain to the power-hungry continuous activation of standard GPUs. Deep dive into spike-timing-dependent plasticity (STDP) — a biologically plausible unsupervised learning rule — and its implementation on neuromorphic hardware (like Intel Loihi).

• Mini project 1: Develop a cognitive model for a simple task.

• Advanced: Implement a simple spiking neuron model (leaky integrate-and-fire) in NumPy. Simulate a network of these neurons performing a basic pattern recognition task.

• Mini project 2: Explore the relationship between AI and neuroscience.

• Advanced: Build a neuro-symbolic hybrid model that uses a neural network for perception (vision) and a symbolic logic engine (from day 89) for reasoning, simulating the dual process theory of the human mind.

Day 128: Advanced creativity - latent space arithmetic

• AI for advanced music composition, generative art, and creative writing.

• Advanced injection: Cross-modal attention & latent manifolds. Understand the internals of how CLIP (contrastive language-image pre-training) aligns text and image tensors in a shared latent space. Deep dive into MIDI-tensor representations and why transformer-based music models require long-range attention kernels to maintain rhythmic consistency.

• Mini project 1: Use AI to generate complex musical compositions.

• Advanced: Build a music transformer decoder from scratch. Use a MIDI-to-tensor encoding scheme and implement relative positional embeddings to preserve musical timing over long sequences.

• Mini project 2: Develop an AI system for creative writing.

• Advanced: Implement steerable generation using latent space arithmetic. Take two text embeddings (e.g., sad and poem) and mathematically add them to guide the LLM's output without re-training the model.

Day 129: AI & complex systems - emergence & chaos

• Modeling complex systems, simulation, AI for system analysis.

• Advanced injection: Cellular automata and chaotic attractors. Understand how simple local rules create complex global emergence (e.g., Conway's Game of Life). Deep dive into neural cellular automata — neural networks that learn the rules of growth and regeneration. Relate this to the self-organization of weights during training.

• Mini project 1: Model a complex system using AI.

• Advanced: Implement the Game of Life using PyTorch 2D convolutions. By treating the rules as a fixed-kernel convolution, you can run millions of cells in parallel on the GPU.

• Mini project 2: Simulate the behavior of a complex system.

• Advanced: Build a simulation of a Lorenz attractor. Use an AI model (RNN or LSTM) to attempt to predict the next state of this chaotic system and analyze where the butterfly effect makes prediction impossible.

Day 130: Advanced optimization - second-order methods

• Advanced optimization algorithms, AI for optimization problems, applications of AI in optimization.

• Advanced injection: Newton's method & the Hessian. Beyond Adam and SGD: understand second-order optimization. Deep dive into the Hessian matrix (matrix of second-order partial derivatives). Learn why calculating the full Hessian is O(N²) and how algorithms like L-BFGS and Shampoo (Kronecker-factored preconditioning) approximate it for high-performance AI training.

• Mini project 1: Implement an advanced optimization algorithm.

• Advanced: Implement the L-BFGS algorithm from scratch in NumPy. Use it to optimize a non-convex function (like the Rosenbrock function) and compare its convergence speed to standard gradient descent.

• Mini project 2: Use AI to solve a real-world optimization problem.

• Advanced: Solve a constrained portfolio optimization problem using an AI model. Implement an interior point method to ensure the model respects budget and risk constraints during the optimization loop.

Day 131: AI & simulation - digital twins & agent-based modeling

• AI for simulation, agent-based modeling, AI in virtual environments.

• Advanced injection: High-fidelity physics & GPU environments. Understand the architecture of digital twins. Deep dive into how AI agents are trained in high-performance virtual environments (like NVIDIA Omniverse or Isaac Sim) where the simulation kernel and the AI model share the same GPU memory space for zero-copy data transfer.

• Mini project 1: Develop an AI agent for a simulation.

• Advanced: Build an agent-based model (ABM) for a simulated economy. Use 10,000 agents, each with its own tiny neural network brain, and simulate market emergence.

• Mini project 2: Design a virtual environment using AI.

• Advanced: Use a neural radiance field (NeRF) from day 78 to create a photorealistic virtual environment from 2D images, then deploy an AI agent to navigate within that 3D neural reconstruction.

Day 132: AI & decision making - strategic game theory

• Decision theory, multi-criteria decision making, AI for decision support.

• Advanced injection: Pareto frontiers & Nash equilibrium. In complex decision-making, you often have conflicting goals (e.g., maximize speed vs. minimize fuel). Deep dive into multi-objective optimization and the Pareto frontier. Learn how AI models (like AlphaGo) use Monte Carlo tree search (MCTS) to make strategic decisions in competitive environments.

• Mini project 1: Implement a decision-making model.

• Advanced: Implement a multi-criteria decision analysis (MCDA) solver using the analytic hierarchy process (AHP). Use NumPy to solve for the weight eigenvectors that represent the most balanced decision.

• Mini project 2: Design an AI system for decision support.

• Advanced: Build a game theory solver for a 2-player zero-sum game. Use the minimax algorithm with alpha-beta pruning and benchmark the number of states the AI explores per second.

Day 133: AI and game theory - massive multi-agent scaling

• Game theory concepts, AI for game playing, multi-agent systems.

• Advanced injection: Imperfect information and asynchronous execution. Understand why algorithms that beat chess/Go (perfect information) fail at poker or StarCraft (imperfect information). Deep dive into counterfactual regret minimization (CFR). Learn the high-performance architecture of self-play frameworks (like Ray/RLlib), where thousands of CPU environment workers stream state-tensors asynchronously to a centralized GPU cluster for policy updates.

• Mini project 1: Implement AI for a game-playing agent.

• Advanced: Implement the counterfactual regret minimization (CFR) algorithm from scratch in Python to solve a simplified game of poker, proving mathematically that the agent converges to a Nash equilibrium.

• Mini project 2: Analyze a game-theoretic scenario using AI.

• Advanced: Build a multi-agent environment where two RL agents compete in a zero-sum game. Architect the training loop so that agent A and agent B update their weights asynchronously without blocking each other's execution threads.

Day 134: Robotics - advanced control & high-frequency edge inference

• Adaptive control, robust control, learning control.

• Advanced injection: Control barrier functions (CBFs) and deterministic latency. In physical robotics, a late inference is a failed inference. Deep dive into mathematically guaranteed safety bounds using CBFs. Understand how to deploy adaptive control networks onto real-time operating systems (RTOS) or FPGAs, ensuring the control loop executes at exactly 1000Hz (1 millisecond per cycle) without operating system jitter.

• Mini project 1: Implement an adaptive control algorithm for a robot.

• Advanced: Implement an adaptive model predictive controller (MPC). Write the optimization solver using NumPy, and profile the code to ensure it can solve the system constraints in under 5 milliseconds.

• Mini project 2: Design a robust control system for a robot.

• Advanced: Integrate a control barrier function (CBF) into a deep learning policy. Prove mathematically that no matter what action the neural network outputs, the CBF will override it to prevent the robot from violating a predefined spatial boundary.

Day 135: Advanced CV - visual SLAM & GPU sparse solvers

• 3D scene understanding, visual SLAM, and advanced image analysis.

• Advanced injection: Bundle adjustment and memory topology. Visual SLAM (simultaneous localization and mapping) is mathematically equivalent to minimizing the reprojection error of thousands of 3D points tracked across multiple 2D camera frames. Understand the Jacobian sparsity structure of this problem and how specialized C++ solvers (like Ceres Solver) map this sparse matrix directly into GPU memory hierarchies for real-time robotic navigation.

• Mini project 1: Implement a 3D scene understanding system.

• Advanced: Process a depth map and an RGB image into a 3D point cloud tensor. Implement a voxel downsampling algorithm from scratch using NumPy to compress the point cloud density, making it small enough to feed into a 3D-CNN.

• Mini project 2: Develop a visual SLAM application.

• Advanced: Write the core pose graph optimization math. Given a set of noisy camera odometry measurements and loop closures, construct the sparse adjacency matrix and solve for the globally optimized camera trajectory.

Day 136: Advanced NLP - structured decoding & semantic routing

• Natural language understanding, dialogue systems, and advanced NLP applications.

• Advanced injection: Function calling internals and constrained decoding. How do LLMs output perfect JSON? Understand how the raw output logits are intercepted by a finite state machine (FSM) that forces the probabilities of invalid syntax tokens to zero before the softmax layer. Deep dive into semantic routing: using ultra-fast embedding similarity searches to route incoming user queries to different specialized LLMs or API endpoints with minimal latency.

• Mini project 1: Build a sophisticated dialogue system.

• Advanced: Build a semantic router from scratch. Create an embedding index of 50 different intent categories, and write a script that classifies incoming user queries in under 10 milliseconds without invoking a generative LLM.

• Mini project 2: Implement a natural language understanding system.

• Advanced: Implement a logit processor class. Intercept the generation loop of a small language model and mathematically force it to only output words that exist within a predefined Python dictionary list.

Day 137: Audio processing - streaming tensors & Whisper internals

• Speech recognition, audio analysis, music information retrieval.

• Advanced injection: The math of spectrograms and cross-attention. Audio is just a 1D time-series tensor with extreme high frequency (e.g., 16,000 samples per second). Understand the short-time Fourier transform (STFT) and how it is implemented as a fixed-weight 1D convolutional layer. Deep dive into the OpenAI Whisper architecture: how the decoder uses cross-attention to map textual tokens directly to the continuous audio encoder latent space.

• Mini project 1: Implement a speech recognition system.

• Advanced: Write a streaming audio buffer. Instead of processing a whole audio file at once, implement a rolling chunk window that continuously feeds 3-second audio tensors into an inference engine, maintaining hidden states between chunks.

• Mini project 2: Analyze audio data using AI.

• Advanced: Implement the Mel-filterbank algorithm purely in NumPy. Take a raw audio waveform, apply the STFT, and multiply it by the Mel-transformation matrix to generate the exact Mel-spectrogram input required by modern audio models.

Day 138: Time series - stateful inference & dilated convolutions

• Advanced time series models, forecasting, and anomaly detection.

• Advanced injection: Receptive fields in high-frequency data. RNNs/LSTMs are slow because they are sequential. Understand how 1D dilated causal convolutions (used in WaveNet) achieve exponential historical context windows while allowing massive parallelization on the GPU. Deep dive into stateful model deployment, where the server must hold the hidden state of thousands of concurrent data streams (like IoT sensors or stock tickers) in VRAM.

• Mini project 1: Build a time series forecasting model.

• Advanced: Build a 1D dilated convolutional network from scratch using PyTorch. Trace the receptive field to mathematically prove how many historical time-steps influence a single prediction output.

• Mini project 2: Implement an anomaly detection system for time series data.

• Advanced: Implement the matrix profile algorithm for anomaly detection. Optimize the sliding dot-product calculations using fast Fourier transforms (FFT) to process a million-tick financial time series in seconds.

Day 139: Network analysis - billion-scale graph neural networks

• Social network analysis, network modeling, AI for network optimization.

• Advanced injection: SpMM (sparse matrix-matrix multiplication) and graph partitioning. Standard matrices cannot represent social networks (a 1-billion user adjacency matrix requires an impossible amount of RAM). Deep dive into graph neural networks (GNNs). Understand how frameworks like PyTorch Geometric (PyG) use optimized SpMM CUDA kernels to perform message passing across sparse edges. Learn graph partitioning algorithms (like METIS) used to split massive graphs across multiple GPU nodes.

• Mini project 1: Analyze a social network.

• Advanced: Represent a social network using compressed sparse row (CSR) format. Implement a basic PageRank algorithm using pure sparse-matrix multiplications to find the most influential nodes.

• Mini project 2: Develop an AI system for network optimization.

• Advanced: Build a custom graph convolutional network (GCN) layer in NumPy. Manually code the self-loop addition, the degree-matrix normalization, and the message passing matrix multiplication.

Day 140: Advanced recommender systems - the two-tower architecture

• Advanced recommender techniques, personalization, and context-aware recommendations.

• Advanced injection: Retrieval vs. ranking stages. Understand the two-tower model (user tower and item tower) used by tech giants. Deep dive into the system design of embedding caching: how to serve personalized recommendations to 100 million users by performing approximate nearest neighbor (ANN) lookups in high-dimensional vector spaces. Understand the DLRM (deep learning recommendation model) architecture and how it handles categorical features via massive embedding tables.

• Mini project 1: Build a personalized recommender system.

• Advanced: Implement a matrix factorization model using a specialized library like implicit or LightFM, focusing on optimizing the warp loss for ranking rather than just minimizing error.

• Mini project 2: Implement a context-aware recommendation system.

• Advanced: Build a factorization machine (FM) from scratch in NumPy that accounts for contextual variables (like time of day or device type) by modeling second-order feature interactions in $O(n)$ time.

Day 141: Advanced IR - vector databases & HNSW internals

• Advanced search techniques, semantic search, and question answering systems.

• Advanced injection: Dense vs. sparse retrieval. Compare BM25 (keyword-based) with BERT-based dense embeddings. Deep dive into HNSW (hierarchical navigable small world) graphs — the algorithm powering modern vector databases. Understand why standard indexing fails for high-dimensional vectors and how graph-based search allows for logarithmic search time.

• Mini project 1: Implement a semantic search engine.

• Advanced: Build a vector search engine using FAISS (Facebook AI similarity search). Implement an HNSW index, benchmark the recall vs. speed tradeoff, and analyze how product quantization (PQ) compresses vectors to save RAM.

• Mini project 2: Build a question-answering system.

• Advanced: Implement a RAG (retrieval-augmented generation) pipeline where the retrieval step uses a hybrid approach (combining keyword and vector search) to fetch context for an LLM.

Day 142: Knowledge graphs - GraphRAG & triple-stores

• Knowledge graph construction, knowledge representation, and reasoning.

• Advanced injection: Knowledge graph embeddings (TransE, RotatE). Understand how to represent triples (subject-predicate-object) as vector translations in a geometric space. Deep dive into GraphRAG: the cutting-edge technique of using knowledge graphs to provide structured context to LLMs, allowing them to perform multi-hop reasoning that standard vector-only RAG systems cannot handle.

• Mini project 1: Build a knowledge graph for a specific domain.

• Advanced: Use a graph database like Neo4j or a library like NetworkX to build a domain-specific graph. Populate it with entities and relationships extracted from a text corpus using an LLM.

• Mini project 2: Implement a reasoning system using a knowledge graph.

• Advanced: Implement a path-finding reasoning algorithm (like breadth-first search over the graph) to find connections between two seemingly unrelated entities, then use an LLM to verbalize the reasoning path.

Day 143: Explainable AI (XAI) - mechanistic interpretability

• Explainable AI techniques, model interpretability, and transparency.

• Advanced injection: Attribution math and saliency maps. Deep dive into integrated gradients and SHAP (Shapley additive explanations) to mathematically assign credit for a prediction to specific input features. Introduction to mechanistic interpretability: probing the internal circuits of a transformer to understand which specific attention heads are responsible for grammar, facts, or reasoning.

• Mini project 1: Implement an XAI technique to explain a model's decisions.

• Advanced: Implement the LIME (local interpretable model-agnostic explanations) algorithm from scratch for a classification model, using local perturbations to build a linear proxy model.

• Mini project 2: Evaluate the interpretability of a machine learning model.

• Advanced: Use the Captum library in PyTorch to visualize integrated gradients on a CNN or transformer, identifying which specific input pixels or tokens triggered the highest activation.

Day 144: Advanced ethics - privacy-preserving ML

• Advanced ethical issues in AI, AI and policy, future of AI ethics.

• Advanced injection: Algorithmic auditing and secure computation. Shift from theory to technical enforcement. Understand differential privacy in training loops — adding noise to gradients to ensure individual data points cannot be reconstructed. Explore homomorphic encryption and secure multi-party computation (SMPC) architectures that allow training on encrypted data without ever seeing the raw values.

• Mini project 1: Research and propose policies for AI ethics.

• Mini project 2: Discuss the future of AI ethics.

• Advanced: Implement a differential privacy training wrapper using a library like Opacus (PyTorch). Measure the epsilon (privacy budget) vs. model accuracy tradeoff to prove the cost of data protection.

Day 145: The future - scaling laws & world models

• Emerging trends in AI, future challenges and opportunities, AI and the singularity.

• Advanced injection: The Chinchilla scaling laws. Understand the mathematical relationship between compute budget, model parameters, and dataset size. Deep dive into the architecture of world models (like Sora or Wayve) that attempt to predict the physical future of a video sequence. Explore the shift from next token prediction to system 2 reasoning (using internal thought-chains like OpenAI's o1 model).

• Mini project 1: Research and present on emerging AI trends.

• Mini project 2: Discuss the potential future of AI.

• Advanced: Build a test-time compute simulation. Implement an LLM inference loop that uses self-correction — letting the model generate multiple drafts, score them, and pick the best one — to prove that more compute at inference time can improve reasoning performance.

Phase 3: Project

• Project development

• These days are dedicated to working on a significant AI project that integrates AI internals, high-performance computing, and system architecture.

• Infrastructure constraint: Strictly CPU / Apple Silicon (M-series). No massive NVIDIA GPU clusters allowed. You will utilize Apple's MLX framework, pure C++ inference (like llama.cpp), memory-mapped files, and CPU-level SIMD instructions (NEON/AVX2) to train and serve models directly from standard RAM.

Project themes

1. AI-driven personalized healthcare (focus: RAG internals, llama.cpp, and CPU inference)

• Develop a secure, locally-hosted AI medical assistant running purely on a Mac Mini CPU. You will fine-tune a small language model using Apple's MLX framework and build a high-performance vector database from scratch optimized for unified memory.

1. AI for sustainable agriculture (focus: CPU intrinsics, custom C inference)

• Focus on edge AI without GPUs. You will train a lightweight CNN for crop disease detection, then write a custom C inference engine from scratch that uses CPU loop unrolling and SIMD vectorization to process images in real-time.

1. AI-enhanced smart city application (focus: multithreading, cache locality, and streaming)

• Build a real-time traffic prediction engine. You will process massive streams of data using graph neural networks (GNNs), focusing on OpenMP multithreading and CPU cache locality to prevent memory bottlenecks.

Project 1: AI-driven personalized healthcare system (CPU/MLX deep dive)

• Description: Develop an offline AI system that retrieves patient history and medical guidelines. The entire pipeline must run smoothly on a Mac Mini using unified memory without thermal throttling.

• Focus areas: GGML/GGUF internals, Apple MLX framework, parameter-efficient fine-tuning (PEFT) on CPU, and memory-mapped vector DBs.

• 5-day implementation plan:

• Day 1: The zero-copy data pipeline

  • Define the scope (e.g., matching patient symptoms with a database of medical guidelines). Download a medical dataset (e.g., PubMed abstracts). From scratch/HPC challenge: Write a high-performance text chunker in Python. Instead of keeping all text in RAM, use mmap (memory-mapped files) to read terabytes of text directly from the Mac's SSD into memory with zero-copy overhead.

• Day 2: The from scratch vector database (CPU optimized)

  • Generate embeddings for the medical guidelines using a lightweight CPU model (e.g., MiniLM loaded via ONNX Runtime CPU). From scratch/HPC challenge: Implement the cosine similarity search using pure NumPy. Optimize the search by utilizing CPU cache blocking techniques — chunking the vector arrays to fit perfectly inside the Mac Mini's L2/L3 cache to maximize memory bandwidth.

• Day 3: Fine-tuning on unified memory (Apple MLX)

  • From scratch/HPC challenge: Do not use PyTorch. Use Apple MLX (an array framework designed specifically for Apple Silicon). Fine-tune a small language model (like Llama-3-8B or Qwen-1.5B) using LoRA. Understand how MLX's lazy evaluation and unified memory architecture allow you to train an 8B model directly on a Mac Mini without moving data over a PCIe bus.

• Day 4: GGUF quantization & C++ inference engine

  • From scratch/HPC challenge: Export your fine-tuned model weights to the GGUF format. Understand the internals of the GGML tensor library. Quantize your model to 4-bit integer precision (Q4_K_M). Run the inference strictly using a C++ backend (similar to llama.cpp) to achieve 20+ tokens per second on a CPU.

• Day 5: System integration & hardware profiling

  • Connect the vector DB to your GGUF-powered LLM to complete the RAG pipeline. From scratch/HPC challenge: Use Apple's Instruments app or standard CPU profilers to analyze the CPU thread utilization and memory pressure. Ensure your retrieval step and generation step are not causing memory swapping (page faults) on the OS level.

Project 2: AI for sustainable agriculture (CPU edge deep dive)

• Description: Design an AI solution to detect plant diseases from drone imagery. The model must run on an embedded CPU (like a Raspberry Pi or the Mac Mini CPU) without any AI framework installed — just pure C code.

• Focus areas: Custom CNN architecture, static memory allocation, SIMD intrinsics, and bare-metal execution.

• 5-day implementation plan:

• Day 1: Dataset & data augmentation

  • Gather an agricultural dataset (e.g., PlantVillage). From scratch/HPC challenge: Write a custom image augmentation pipeline. Avoid heavy libraries like OpenCV. Write a pure C/Python script to perform image rotations and cropping using direct pixel array manipulation.

• Day 2: Training a lightweight CNN (NumPy/PyTorch)

  • From scratch/HPC challenge: Design a custom CNN inspired by MobileNet. Train it on your machine. Understand exactly what a convolutional layer is geometrically. Extract the raw FP32 floating-point weights into a plain text or binary file.

• Day 3: Building a pure C inference engine

  • From scratch/HPC challenge: Discard Python completely. Write a pure C program to load your raw weights. Implement the 2D convolution, max-pooling, and ReLU functions manually using nested for loops. Allocate memory strictly using malloc and avoid dynamic allocation during inference to prevent memory fragmentation.

• Day 4: Hardware vectorization (SIMD)

  • Your raw C code will be slow. Time to optimize. From scratch/HPC challenge: Rewrite your inner convolution loops using SIMD intrinsics (NEON instructions for Apple Silicon/ARM, or AVX2 for Intel/x86). Process 4 or 8 pixels simultaneously in a single CPU clock cycle. Measure the 4x to 8x execution speedup.

• Day 5: Memory layout optimization & deployment

  • From scratch/HPC challenge: Reformat your memory layout from NCHW (standard PyTorch) to NHWC (channels last). Explain in your project documentation why NHWC is drastically faster for CPU cache lines during convolution operations. Present your final, dependency-free C executable that runs an AI model in milliseconds.

Project 3: AI-enhanced smart city application (CPU multithreading deep dive)

• Description: Create an AI application to optimize traffic lights in a smart city grid. You will process massive continuous data streams using graph neural networks (GNNs), relying heavily on multi-core CPU parallelization.

• Focus areas: Graph algorithms, OpenMP multithreading, lock-free data structures, and sparse matrix math.

• 5-day implementation plan:

• Day 1: Graph representation & lock-free streaming

  • Model a city's road network (e.g., 1,000 intersections) as a graph. From scratch/HPC challenge: Simulate a high-frequency sensor data stream. Implement a lock-free queue (ring buffer) in C++ or Python (via multiprocessing) to ingest data concurrently across multiple CPU cores without causing thread contention or mutex locking bottlenecks.

• Day 2: Sparse matrix operations on CPU

  • From scratch/HPC challenge: Represent the city adjacency matrix using compressed sparse row (CSR) format. Implement the matrix-vector multiplication manually. Optimize it by aligning the arrays in memory to prevent CPU cache thrashing when jumping between sparse indices.

• Day 3: Building the CPU-optimized GNN

  • From scratch/HPC challenge: Implement a graph convolutional network (GCN) layer. Since you are strictly on a CPU, optimize the message passing step by partitioning the graph. Assign specific neighborhoods of the graph to specific CPU cores (using thread pools) to calculate updates in parallel.

• Day 4: Real-time optimization & multi-processing

  • Once the model predicts congestion, the system must act. From scratch/HPC challenge: Implement a heuristic optimization algorithm (e.g., simulated annealing) to adjust traffic lights. Use OpenMP (in C/Cython) or the Python multiprocessing module to run the optimization search across all available CPU cores (e.g., all 8 cores of a Mac Mini) simultaneously.

• Day 5: Dashboarding & systems architecture review

  • Build a real-time visualization dashboard (using Plotly/Dash) running on a separate thread to show the city graph and congestion predictions. From scratch/HPC challenge: Document the entire system architecture. Prove mathematically how your multi-threaded CPU approach handles the streaming data throughput, and analyze the IPC (instructions per clock) efficiency of your graph algorithms.

Phase 4: Prompt engineering & MLOps fundamentals

Day 161: Generative AI fundamentals & the softmax bottleneck

• Introduction to prompt engineering, understanding the role of prompts in eliciting desired responses from LLMs, basic prompting techniques: clear instructions, keywords, context setting. Introduction to generative AI, overview and key features of generative AI, ethical considerations and biases.

• Advanced injection: The mechanics of generation. Understand how a prompt physically manipulates the logits (raw scores) of the model's output layer. Deep dive into sampling parameters: temperature, top-P (nucleus), and top-K. Learn how context window limits are actually memory limits in the KV-cache.

• Mini project 1: Design prompts for various tasks and experiment with a basic model.

• Advanced: Run a 1B or 3B model (like Llama-3.2-3B) on your Mac Mini. Use a Python script to visualize how changing the temperature from 0.1 to 2.0 shifts the probability distribution of the next predicted token.

• Mini project 2: Analyze ethical considerations and biases.

• Advanced: Jailbreak testing. Experiment with adversarial prompting (e.g., DAN-style prompts) to understand where the model's alignment math fails and how to build a system prompt that acts as a hard security boundary.

Day 162: Advanced prompt engineering & programmatic prompting

• Advanced prompting techniques: few-shot learning, chain-of-thought prompting, role-playing, iterative refinement, prompt engineering for different types of LLMs, evaluating and refining prompts.

• Advanced injection: DSPy and logical pipelines. Move beyond vibes-based prompting. Understand the concept of chain-of-thought as an internal search through a latent space. Explore system 2 reasoning: how to force the model to allocate more test-time compute by prompting it to think step-by-step.

• Mini project 1: Implement few-shot learning to guide an LLM.

• Advanced: Implement a dynamic few-shot system. Use a vector database (from your previous projects) to retrieve the 3 most relevant examples from a local dataset and inject them into the prompt in real-time based on the user's query.

• Mini project 2: Design a system that iteratively refines prompts based on LLM feedback.

• Advanced: Build an actor-critic prompt loop. One LLM generates an answer, and a second critic LLM identifies errors. The first LLM then uses the feedback to rewrite the answer until a specific pass-condition is met.

Days 163–172: MLOps (high-performance platform engineering)

Day 163: Introduction to MLOps & system resource profiling

• Definition and importance of MLOps, MLOps lifecycle, comparison with DevOps, challenges in deploying machine learning models.

• Advanced injection: The hidden technical debt of AI. Understand why AI deployment is harder than web deployment (data drift, model drift). Deep dive into Mac Mini resource constraints: how to monitor unified memory pressure and CPU throttling during heavy inference loads using command-line tools like top, htop, and Apple's powermetrics.

• Mini project 1: Outline the MLOps pipeline for a machine learning project.

• Advanced: Design a minimalist MLOps architecture for your healthcare project. Include steps for data ingestion, model quantization (GGUF), and local API serving.

• Mini project 2: Research the benefits and challenges of MLOps.

Day 164: Version control for machine learning & DVC internals

• Versioning data, models, and code, tools for version control (Git, DVC), managing experiments and reproducibility.

• Advanced injection: Data version control (DVC) architecture. Git is for code; DVC is for blobs. Understand how DVC uses content-addressable storage (hashing) to track multi-gigabyte model weights without slowing down your Git repository.

• Mini project 1: Set up a Git repository for a machine learning project.

• Mini project 2: Use DVC to version control data and models.

• Advanced: Set up a DVC remote (using a local folder or S3). Version a 5GB medical dataset and a 4-bit quantized model. Practice time-traveling: roll back your entire environment to a previous version of both code and data to prove 100% reproducibility.

Day 165: Data management & zero-copy pipelines

• Data storage and retrieval, data validation and quality control, data pipelines and data transformations.

• Advanced injection: High-throughput data validation. In production, bad data kills models. Understand data contracts. Explore the internals of Apache Arrow and how it allows for zero-copy data transfer between different stages of your pipeline on a CPU.

• Mini project 1: Design a data pipeline for a machine learning project.

• Mini project 2: Implement data validation checks for a dataset.

• Advanced: Use a library like Great Expectations or write a custom Python script to perform schema enforcement on a CSV dataset. If the dataset has unexpected nulls or the distribution of a feature shifts by more than 10%, the pipeline should automatically trigger a fail-fast alarm.

Day 166: Model development, training & Apple MLX tuning

• Model selection and training, hyperparameter tuning, model evaluation and validation.

• Advanced injection: HPC tuning on CPU. Understand why standard hyperparameter tuning is expensive. Explore Bayesian optimization. Deep dive into Apple MLX for training on Mac: how it uses unified memory to avoid the data-transfer overhead that kills performance on Intel-based systems.

• Mini project 1: Implement hyperparameter tuning for a machine learning model.

• Advanced: Use the Optuna library to run an automated search for the best LoRA rank (4, 8, 16, or 32) for a small model (like TinyLlama) on your Mac Mini.

• Mini project 2: Evaluate the performance of a trained model using different metrics.

• Advanced: Beyond accuracy. Implement perplexity calculation for your language model. Benchmark how different quantization levels (Q4_K_M vs Q8_0) affect both perplexity (quality) and tokens-per-second (speed) on your Mac Mini.

Day 167: Model serving & CPU-optimized deployment

• Different deployment strategies (batch, online, edge), containerization (Docker), model serving frameworks.

• Advanced injection: llama.cpp vs. web frameworks. How to serve models on CPU with ultra-low latency. Understand the server-sent events (SSE) protocol for streaming. Explore how Docker interacts with Apple Silicon (Rosetta vs. native ARM containers).

• Mini project 1: Containerize a machine learning model using Docker.

• Mini project 2: Deploy a model using a model serving framework.

• Advanced: Deploy a quantized model using llama.cpp's built-in server. Build a FastAPI wrapper around it to handle high-concurrency requests and benchmark the throughput on your Mac Mini.

Day 168: Monitoring & drift detection

• Monitoring model performance, detecting model drift, logging and metrics.

• Advanced injection: The silent killer: data drift. Understand the KL-divergence (from your math phase) as a tool to measure if new incoming data is different from the training data.

• Mini project 1: Implement a system to monitor model performance.

• Mini project 2: Detect and visualize model drift.

• Advanced: Create a drift monitor dashboard. Simulate 1000 API requests with slightly different data distributions and use a script to trigger an alert when the cosine similarity between the input embeddings and the training embeddings drops below a threshold.

Day 169: CI/CD/CD (continuous deployment for AI)

• Automation tools and techniques, CI/CD pipelines for machine learning, orchestration and scheduling.

• Advanced injection: GitOps for ML. Understand how tools like ArgoCD can manage model deployments. Learn how to automate the quantization step — every time you push a new model weight file, the CI/CD pipeline should automatically convert it to GGUF.

• Mini project 1: Automate the model training and deployment process.

• Mini project 2: Build a CI/CD pipeline for a machine learning project.

Day 170: MLOps security & compliance

• Best practices for MLOps implementation, security and compliance in MLOps, scalability and reliability in MLOps.

• Advanced injection: Securing the AI supply chain. Understand model poisoning and prompt injection as platform security risks. Learn how to implement RBAC (role-based access control) for your model APIs to ensure banking-level compliance.

• Mini project 1: Design an MLOps system that incorporates security best practices.

• Mini project 2: Develop a plan for scaling an MLOps pipeline.

Day 171: Advanced MLOps - feature stores & registries

• Feature stores, model registries, experiment tracking, metadata management.

• Advanced injection: The feature store internals. Understand how to maintain a single source of truth for features between training and inference. Explore MLflow as a model registry.

• Mini project 1: Implement a feature store for a machine learning project.

• Mini project 2: Design a model registry for versioning models.

Day 172: End-to-end MLOps capstone project

• End-to-end MLOps project, implementing the complete MLOps lifecycle for a machine learning application.

• Final project challenge: Build a zero-touch pipeline

1. Add new data to a folder →

2. DVC detects change →

3. Automated script fine-tunes a LoRA (TinyLlama) →

4. Model is quantized to 4-bit →

5. Model is deployed to a FastAPI endpoint →

6. A monitoring script confirms the API is healthy.

Phase 5: Multi-agent systems (more detailed) and infrastructure (MCP) & others

Day 173: MAS architecture - memory sharding & state machines

• Syllabus content:

• Agentic reasoning loops: Deep dive into ReAct (reason + act) and Reflexion patterns. Understand how an agent thinks by manipulating its own context window.

• Context window engineering: Internals of sliding window memory vs. summarization memory. How to prevent context drift in long-running agent loops.

• State persistence: Implementing checkpointing in agentic workflows. How to serialize a running agent's state into a binary format (like Protobuf or MessagePack) to resume after a crash.

• Mini project 1: The pure ReAct engine.

  • Build a ReAct agent from scratch without libraries. Implement a custom context manager that automatically prunes irrelevant tokens using a priority-based decay algorithm to keep the prompt length optimal for the CPU's cache.

• Mini project 2: Multi-turn recursive state machine.

  • Simulate a complex negotiation between two agents. Implement a state store using a local key-value database (like RocksDB or a high-speed NoSQL) to persist the conversation state at every thought step.

Day 174: Advanced MAS - conflict resolution & distributed consensus

• Syllabus content:

• Concurrent agent orchestration: Handling race conditions when multiple agents call the same tool simultaneously.

• Agentic consensus protocols: Introduction to Raft/Paxos for AI. How to ensure a swarm of agents reaches a single, non-hallucinated truth in a shared environment.

• Game theory in MAS: Nash equilibrium in multi-agent auctions. Understanding the mathematical bounds of cooperation vs. competition in autonomous systems.

• Mini project 1: The auctioneer protocol.

  • Implement a Vickrey-Clarke-Groves (VCG) auction for 5 agents competing for limited CPU/memory resources. Use Python's asyncio to handle simultaneous bidding and implement a winner determination algorithm with zero-lock contention.

• Mini project 2: Distributed shared memory.

  • Create a shared blackboard where 4 agents solve a massive data-processing task. Use atomic operations (compare-and-swap) to ensure agents don't overwrite each other's partial solutions.

Day 175: Swarm intelligence - ECS & high-density simulation

• Syllabus content:

• Swarm mechanics: Emergent behavior (flocking, foraging). How local simple rules create global complex intelligence.

• ECS (entity component system) for AI: Moving away from heavy OOP agents to data-oriented design. How to manage 10,000 tiny agents by separating data (components) from logic (systems) to maximize CPU L1/L2 cache hits.

• Parallel spatial hashing: Optimizing neighbor searches in agent swarms using spatial partitioning.

• Mini project 1: The 10k swarm simulator.

  • Develop an ant colony optimization simulation using an ECS architecture. Use NumPy vectorization to calculate the movement and pheromone updates for 10,000 agents in parallel, aiming for 60 FPS on a single CPU core.

• Mini project 2: Swarm-based routing.

  • Design a multi-agent system for real-time network packet routing. Implement a digital pheromone algorithm that dynamically updates the routing table based on simulated network congestion.

Day 176: Infrastructure I - model context protocol (MCP) internals

• Syllabus content:

• The problem: Tool fragmentation and the N-to-N connection nightmare.

• MCP architecture: Deep dive into the MCP specification. Understand the JSON-RPC 2.0 transport layer.

• Transport mechanics: Comparing stdio (standard input/output) vs. SSE (server-sent events) for connecting LLMs to local tools.

• Schema-first discovery: How an MCP server describes its capabilities (tools, resources, prompts) so any LLM can understand them without custom glue code.

• Mini project 1: The secure MCP file server.

  • Build an MCP server in Python/TypeScript that allows an LLM to read and write files within a strict, sandboxed directory. Implement token-based authorization to ensure the LLM cannot escape the sandbox.

• Mini project 2: Database-to-LLM bridge.

  • Create an MCP server that connects to a local database (like MongoDB or SQLite). Implement a schema explorer tool that allows the LLM to query the database structure before writing optimized queries.

Day 177: Infrastructure II - edge orchestration & CNI latency

• Syllabus content:

• The latency wall: Analyzing the overhead of inter-agent communication.

• High-speed interconnects: How gRPC and shared memory bypass the slow HTTP/REST overhead for agent communication.

• Edge AI constraints: Deploying MAS on resource-constrained hardware. Using quantized embeddings for local agent memory.

• Observability: Implementing OpenTelemetry for agentic workflows. How to track a single user request as it bounces across 10 different autonomous agents.

• Mini project 1: The non-blocking agent gateway.

  • Build a high-concurrency API gateway using FastAPI and Redis Streams. The gateway must receive user requests, hand them off to a background agent swarm, and provide a persistent WebSocket connection for real-time status updates.

• Mini project 2: Secure agent tunneling.

  • Implement an mTLS (mutual TLS) connection between two agent nodes. Prove that even if the network is compromised, the command and control signals between agents remain cryptographically secure.

Day 178: LLMOps - PagedAttention & KV-cache optimization

• Syllabus content:

• The memory bottleneck: Understanding the KV-cache. Why generating text is memory-bandwidth bound, not compute bound.

• PagedAttention (vLLM internals): How to manage GPU/CPU memory like a virtual operating system. Dividing the KV-cache into pages to allow for 10x higher throughput and continuous batching.

• Speculative decoding: Using a drafter model (small) to predict tokens and a verifier model (large) to check them in parallel.

• Mini project 1: Manual KV-cache manager.

  • Write a Python script that simulates a generation loop. Manually manage a cache matrix. After every token generated, update the cache and observe how the memory grows linearly. Then, implement a basic eviction strategy to keep memory constant.

• Mini project 2: High-throughput serving benchmark.

  • Deploy an LLM using vLLM or llama.cpp. Use a load-testing tool to measure how continuous batching affects the time to first token (TTFT) vs. tokens per second (TPS) under heavy user load.

Day 179: Diffusion models - the math of reverse entropy

• Fundamentals of generative models, diffusion model architectures (DDPM, Stable Diffusion), training and inference techniques, applications in image and text generation.

• Advanced injection: Stochastic differential equations (SDEs). Understand diffusion as a process of transforming a data distribution into Gaussian noise and then learning the reverse score function. Deep dive into the U-Net architecture with cross-attention. Understand noise schedules (linear vs. cosine) and how they impact the convergence of the reverse diffusion process.

• Mini project 1: Diffusion from scratch.

  • Implement a 1D diffusion model in NumPy to generate a simple mathematical distribution (e.g., a Swiss roll). Manually code the forward noise addition and the reverse denoising step to see how the denoising score is calculated.

• Mini project 2: Latent diffusion inference on CPU.

  • Use a pre-trained Stable Diffusion model but implement a custom tiled VAE decoder. This allows you to generate high-resolution images on your Mac Mini by processing small chunks of the latent space, bypassing the RAM limits for full-image decoding.

Day 180: AI-powered data analytics - feature engineering at scale

• Advanced data preprocessing, automated feature engineering, AI-driven EDA, predictive analytics using ensemble methods (XGBoost, LightGBM).

• Advanced injection: Information gain & histogram-based splitting. Deep dive into the internals of gradient boosted decision trees (GBDT). Understand how LightGBM uses EFB (exclusive feature bundling) and GOSS (gradient-based one-side sampling) to process billions of rows with minimal CPU cycles.

• Mini project 1: Automated feature engineering pipeline.

  • Build a pipeline that uses an LLM (like Llama-3 running on MLX) to analyze a database schema and automatically generate Python code for new, high-value feature engineering (e.g., days since last transaction for banking churn).

• Mini project 2: High-performance ensemble system.

  • Implement a custom stacking ensemble from scratch. Train 3 different models and write a meta-learner that uses the weights of the previous models to make the final prediction. Profile the CPU overhead of the inference step.

Day 181: Edge AI & TinyML - extreme model compression

• Fundamentals of edge computing, model compression (quantization, pruning), TinyML frameworks, deployment on resource-constrained devices.

• Advanced injection: Quantization-aware training (QAT) vs. PTQ. Understand the hardware-level impact of INT8 and FP8. Deep dive into model pruning: identifying dead neurons and using sparse matrix representations to reduce the binary size of a model. Explore TVM (tensor virtual machine) as a compiler for edge hardware.

• Mini project 1: Model pruner & quantizer.

  • Take a pre-trained CNN and implement a magnitude-based pruning script from scratch. Remove the bottom 30% of weights and then convert the remaining weights to 8-bit integers. Measure the final .bin file size compared to the original.

• Mini project 2: Deployment on ARM (Mac Mini/Pi).

  • Deploy a quantized model using ExecuTorch or TensorFlow Lite. Measure the power consumption and inference latency to see how many millijoules of energy are required per prediction.

Day 182: AI-driven cybersecurity - adversarial defense

• Threat detection, anomaly detection, AI-powered IDS, adversarial ML.

• Advanced injection: Weight poisoning & prompt injection detection. In a banking context, security is non-negotiable. Understand backdoor attacks: how a malicious actor could poison a fine-tuning dataset so the model acts normally until it sees a specific trigger (e.g., a specific account number).

• Mini project 1: High-speed anomaly detection for network traffic.

  • Build an isolation forest or an autoencoder from scratch to detect outlier network packets in a simulated stream of 1 million transactions per second.

• Mini project 2: The red-team malware classifier.

  • Develop a GNN (graph neural network) that treats a binary executable's control-flow graph as an input to classify it as malware. Try to trick your own model by slightly altering the code structure (adversarial attack).

Day 183: Technical communication for solution architects

• Effective communication of AI concepts, presenting to non-technical audiences, data visualization.

• Advanced injection: The abstractions ladder. Learn to explain stochastic gradient descent as a ball rolling down a hill to stakeholders, but as the negative gradient of the loss function to engineers. Master system architecture diagramming for AI pipelines.

• Mini project 1: The executive pitch.

  • Create a 5-slide deck proposing a transition from a centralized GPU cloud to an edge-AI/Mac Mini cluster for VPBank, highlighting the ROI and privacy benefits.

• Mini project 2: High-dimensional visualization.

  • Use t-SNE or UMAP to visualize the latent space of a medical or financial dataset. Create a dashboard that explains why the model grouped certain data points together.

Day 184: Critical thinking - AI ethical risk assessment

• Analytical thinking, creative problem-solving, ethical considerations.

• Advanced injection: Formal verification of safety. How do you prove an AI won't discriminate? Understand the math of demographic parity and equalized odds. Learn to apply the red-team mindset to every architectural choice.

• Mini project 1: The failure mode analysis.

  • Analyze a case study (e.g., a failed AI loan approval system) and use a fault tree analysis to identify whether the failure was in the data, the objective function, or the deployment.

• Mini project 2: Fairness-aware training.

  • Implement a fairness penalty in a training loss function that mathematically penalizes the model if its error rate differs significantly between two demographic groups.

Day 185: Project management for AI - the data-first lifecycle

• AI project lifecycle, agile for AI, resource management.

• Advanced injection: Agile vs. the R&D loop. Understand why standard Scrum often fails for AI (because research is unpredictable). Learn to manage compute budgets as a primary project constraint.

• Mini project 1: The AI implementation roadmap.

  • Create a detailed project plan for a 6-month AI initiative at a bank. Include data collection, baseline testing, quantization/optimization, and compliance audit as critical milestones.

• Mini project 2: Resource allocation simulation.

  • Design a GPU/CPU queue strategy for a team of 10 engineers, ensuring that low-priority research doesn't block high-priority production inference.

Day 186: Research skills - reading ArXiv like a pro

• Literature review, evaluating research papers, synthesizing info.

• Advanced injection: Spotting the hype vs. hardware. When reading a paper, learn to look at the ablation study first — this tells you which part of the model actually matters. Look at the hardware used section to see if the results are reproducible on your Mac Mini.

• Mini project 1: The literature synthesis.

  • Conduct a review of 3 recent papers on low-rank adaptation (LoRA) and write a 1-page summary focusing on the trade-off between rank size and memory usage.

• Mini project 2: The paper critic.

  • Choose a popular AI research paper and find one potential scaling flaw (e.g., this wouldn't work on a CPU because the memory bandwidth required is too high).

Day 187: Software development methodologies - AI CI/CD

• Agile/Scrum for AI, DevOps in AI, CI/CD for models.

• Advanced injection: Continuous integration for weights. Understand that in AI, code is only half the story. Your CI/CD pipeline must test the weights (accuracy/bias) as well as the code (API latency).

• Mini project 1: The AI sprint plan.

  • Design a 2-week sprint plan that includes data cleaning, model fine-tuning, and quantization testing as story points.

• Mini project 2: The automated testing pipeline.

  • Set up a script that automatically runs an accuracy check on a model every time a new dataset is added to the folder. If accuracy drops below 80%, the pipeline should automatically reject the data.

Day 188: Collaborative AI development - remote swarms

• Team dynamics, cross-functional collaboration, remote tools.

• Advanced injection: Model merging & weight averaging. How do 10 engineers work on the same model weights? Understand weight averaging (stochastic weight averaging) and model soups as a way to combine different versions of a model trained by different team members.

• Mini project 1: The team collaboration protocol.

  • Design a Git/DVC workflow for a team of 4 engineers where everyone is fine-tuning the same base model (e.g., Phi-3) on different subsets of data.

• Mini project 2: The model soup experiment.

  • Train two small models on slightly different data, then implement a script to linearly average their weights and measure the performance of the merged model.

Day 189: Data privacy, security & cryptographic AI

• Data protection regulations (GDPR, CCPA), privacy-preserving AI techniques, security best practices.

• Advanced injection: Privacy-preserving computation (PPC). Deep dive into the math of differential privacy (adding specifically calibrated noise to gradients). Understand k-anonymity, l-diversity, and t-closeness. Explore homomorphic encryption — the ability to perform tensor math on encrypted data without ever decrypting it.

• Mini project 1: Conduct a privacy impact assessment for an AI application.

• Advanced: Perform a re-identification attack on a toy dataset to prove why simple name-removal is insufficient for banking security.

• Mini project 2: Implement a data anonymization technique for an AI dataset.

• Advanced: Implement a differential privacy training loop using a library like Opacus on your Mac Mini. Track the privacy budget (epsilon) and visualize the trade-off between privacy strength and model accuracy.

Day 190: Technical documentation & architecture decision records (ADR)

• Writing technical specifications, documenting models/algorithms, creating user guides.

• Advanced injection: System observability & model cards. Moving beyond how-to guides. Learn to write ADRs to justify why you chose a specific quantization level or vector database. Document the computational graph and memory-profiling results of your model.

• Mini project 1: Write a technical specification for an AI model.

• Advanced: Create a model card (following Google/HuggingFace standards) for your healthcare project. Document its environmental impact (carbon footprint of training on Mac Mini) and out-of-distribution failure modes.

• Mini project 2: Create a user guide for an AI-powered application.

Day 191: AI business strategy & GPU/CPU ROI

• AI value proposition, implementation strategies, measuring ROI.

• Advanced injection: The economics of AI infrastructure. Calculate the total cost of ownership (TCO) comparing cloud GPUs vs. a localized Mac Mini farm for VPBank. Understand time-to-market vs. model accuracy trade-offs.

• Mini project 1: Develop a business case for implementing AI in a specific company function.

• Advanced: Build a financial model for a local LLM deployment for internal banking use. Factor in the cost of electricity, hardware depreciation, and the privacy premium of not sending data to OpenAI.

• Mini project 2: Create a framework for measuring the success of an AI initiative.

Day 192: Containerization & Docker for HPC

• Overview of containerization, introduction to Docker (architecture, commands), Dockerfiles, Docker Compose.

• Advanced injection: Multi-stage builds & ARM64 optimization. How to keep AI images small (under 2GB instead of 10GB). Deep dive into BuildKit. Understand the difference between virtualization and containerization regarding CPU register access and memory latency.

• Mini project 1: Containerize a simple Python application and create a Docker Compose file.

• Advanced: Dockerize an Apple MLX or llama.cpp application. Use multi-stage builds to ensure the final image contains zero build-tools (compilers), only the optimized binary and weights.

• Mini project 2: Explore Docker BuildKit for optimized image building.

Day 193: Advanced Docker & multi-process tensor sharing

• Docker for ML (dependencies, artifacts), Docker Swarm basics, networking, Docker volumes.

• Advanced injection: Shared memory (--shm-size) and inter-process communication (IPC). Understand how multiple containers share a single GPU/CPU memory space. Deep dive into Docker networking latency and how it affects distributed training.

• Mini project 1: Containerize a machine learning API with specific dependencies.

• Advanced: Deploy an LLM API in a container and tune the --shm-size parameter. Benchmark the performance to see how insufficient shared memory crashes multi-headed attention processes.

• Mini project 2: Set up a simple Docker Swarm and deploy a containerized application.

Day 194: Kubernetes architecture for AI platforms

• K8s concepts, architecture, objects (pods, deployments, services), kubectl.

• Advanced injection: The K8s control plane for AI. Understand how the K8s scheduler handles resource requests vs limits for memory-hungry AI pods. Introduction to device plugins (how K8s sees a GPU or an NPU).

• Mini project 1: Deploy a multi-container application on a Kubernetes cluster.

• Advanced: Set up a local K8s cluster (using Kind or Minikube) on your Mac Mini. Deploy a RAG pipeline where the vector DB and the LLM API are in separate pods, connected via a K8s service.

• Mini project 2: Explore Kubernetes namespaces for managing different environments.

Day 195: Advanced K8s & scalable inference

• Deploying ML models on K8s, stateful applications, horizontal pod autoscaling (HPA), Helm charts.

• Advanced injection: Custom metrics autoscaling. Standard K8s scales on CPU/RAM usage. AI needs to scale on GPU duty cycle or KV-cache pressure. Learn how to use KEDA (Kubernetes event-driven autoscaling) for AI workloads.

• Mini project 1: Deploy a scalable machine learning service using HPA.

• Advanced: Create a Helm chart for your smart city project. Define different resource tiers (small, medium, large) so the system can be deployed on anything from a Mac Mini to a massive server.

• Mini project 2: Create a basic Helm chart for an AI application.

Day 196: K8s/MLOps integration & GitOps

• GitOps, Crossplane (cloud infra), Cloud Foundry, monitoring/logging, CI/CD for K8s.

• Advanced injection: Infrastructure as code (IaC) for AI. Using ArgoCD to implement GitOps — where your model weights are treated as code. If the weight hash changes in Git, ArgoCD automatically redeploys the pods.

• Mini project 1: Design a GitOps workflow for deploying an AI application.

• Advanced: Set up a local ArgoCD instance. Link it to a GitHub repo. Push a change to a quantization config and watch K8s automatically roll out a new version of your model without downtime.

• Mini project 2: Explore Cloud Foundry as a deployment platform.

Day 197: System design foundations for AI

• Fundamentals of system design, AI-specific principles, user needs, architecture overview.

• Advanced injection: The CAP theorem in AI. Availability vs. consistency in real-time inference. Understand load balancing for LLMs: why traditional round-robin fails (because some prompts take longer to generate than others) and why least-loaded or continuous batching is required.

• Mini project 1: Analyze system design considerations for a given AI application.

• Mini project 2: Design a basic system architecture for a simple AI application.

• Advanced: Design a banking virtual assistant architecture. Show how a request flows through a firewall, a semantic router, a vector DB, and finally the LLM, all while maintaining a <500ms latency.

Day 198: Data engineering & high-throughput pipelines

• Data acquisition/preprocessing, storage/management, pipeline design, quality/validation.

• Advanced injection: Feature stores and lambda architecture. How to handle both batch training data and real-time inference data. Understand data lineage — tracking a specific model prediction back to the exact version of the raw data used to train it.

• Mini project 1: Design a data pipeline for a specific AI task.

• Mini project 2: Develop a data validation strategy for an AI dataset.

• Advanced: Design a pipeline that ingests 1 million transactions per hour (for fraud detection). Use a dead letter queue (DLQ) to handle malformed data tensors without stopping the pipeline.

Day 199: AI system integration & complexity

• Designing overall architecture, integrating components (perception/reasoning/action), interface design, challenges/solutions.

• Advanced injection: Asynchronous orchestration. Moving away from synchronous APIs to event-driven AI. Understand how a reasoning agent can trigger actions in a banking core system via webhooks and idempotency keys (ensuring a transaction is never executed twice).

• Mini project 1: Design the architecture for a complex AI system.

• Advanced: Architect a self-driving banking auditor. It must perceive transaction logs, reason using a knowledge graph, and take action by flagging suspicious accounts. Map out the internal tensor interfaces between these three stages.

• Mini project 2: Develop an interface for a user to interact with an AI system.

Day 200: Advanced topics & the singularity engineer

• Real-time AI, distributed AI, robustness/fault tolerance, security/privacy, ethics in design.

• Advanced injection: Chaos engineering for AI. What happens if the vector DB goes down? What if the GPU overheats? Learn to design for graceful degradation — where the AI falls back to a smaller, faster model or a rule-based system if the primary system fails.

• Mini project 1: Design a distributed AI system.

• Advanced: Design a multi-region AI platform. If the Hanoi data center fails, how does the system reroute the context/KV-cache to the Ho Chi Minh City data center without losing the user's conversation state?

• Mini project 2: Analyze the security and privacy implications of an AI system design.

Phase 6: Frontier internals & production-scale AI (Optional deep dive)

• This phase exists because "understanding internals" up to Day 200 still leaves several gaps that separate a strong self-taught engineer from someone who could operate inside a frontier AI lab: sparse/MoE architectures, real multi-GPU distributed training, writing actual GPU kernels, post-PPO alignment techniques, pretraining-scale data engineering, and rigorous evaluation. Phase 6 closes those gaps.

• Infrastructure note: Unlike Phase 3, some of these days genuinely require renting cloud GPU time (a single A100/H100 spot instance for a few hours is enough for every exercise below). This is intentional — CPU-only substitutes exist for concepts, but distributed training and CUDA kernels cannot be understood without touching real GPU hardware.

Day 201: Mixture of Experts (MoE) I - routing & load balancing

• Syllabus content: Sparse activation, expert networks, gating functions.

• Advanced injection: Understand why a MoE layer (e.g., Mixtral, DeepSeek-V3, Grok) replaces a single dense FFN with N expert FFNs plus a lightweight router that selects the top-k experts per token. Deep dive into the auxiliary load-balancing loss (and DeepSeek's auxiliary-loss-free strategy) that prevents "expert collapse," where the router learns to always pick the same one or two experts, wasting the rest of the parameter budget.

• Mini Project 1: Implement a dense feedforward transformer block as a baseline.

• Advanced: Convert the FFN into a top-2 MoE layer from scratch in PyTorch (8 experts, router = single linear + softmax). Manually compute and log the load-balancing auxiliary loss and plot expert utilization over a training run to visually confirm the load stays balanced.

• Mini Project 2: Benchmark active vs. total parameter count.

• Advanced: Calculate the exact "effective FLOPs" of your MoE layer vs. an equivalently-sized dense layer, proving mathematically why MoE models can have 8x the total parameters while only using ~2x the compute per token.

Day 202: Mixture of Experts II - expert parallelism & production systems

• Advanced injection: Deep dive into how MoE models are actually served: expert parallelism (sharding different experts across different GPUs), the "all-to-all" communication pattern that routes tokens to the GPU hosting their chosen expert, and why this creates a network bottleneck at scale. Study how frameworks like DeepSpeed-MoE and Megatron-Core handle this.

• Mini Project 1: Simulate expert parallelism.

• Advanced: Write a multi-process simulation (using Python's multiprocessing) where 4 "GPU" processes each host 2 experts. Implement the all-to-all token-routing communication pattern using pipes/queues and measure the communication overhead as the batch size grows.

• Mini Project 2: Capacity factor & token dropping.

• Advanced: Implement the "capacity factor" mechanism that caps how many tokens an expert can process per batch, and implement token dropping when an expert is overloaded. Measure how dropped tokens affect downstream loss.

Day 203: Attention variants - GQA/MQA & sparse attention

• Advanced injection: Standard multi-head attention (MHA) keeps one KV-cache per head, which becomes a memory bottleneck at long context. Deep dive into multi-query attention (MQA, one shared KV head) and grouped-query attention (GQA, a middle ground used in Llama-2/3, Mistral) and calculate the exact KV-cache memory reduction. Explore sliding-window attention (Mistral) and block-sparse attention patterns as architectural (not just kernel-level) ways to cut the O(N²) cost.

• Mini Project 1: Implement standard multi-head attention from scratch.

• Advanced: Refactor it into GQA with a configurable number of KV groups. Benchmark KV-cache memory usage and inference latency for MHA vs. GQA vs. MQA at increasing context lengths.

• Mini Project 2: Sliding-window attention.

• Advanced: Implement a sliding-window attention mask from scratch and empirically verify the effective receptive field grows linearly with layer depth (like a dilated CNN), proving how a model can "see" far-away tokens indirectly through stacked layers.

Day 204: Normalization internals - training stability

• Advanced injection: LayerNorm vs. RMSNorm (used in Llama, Mistral, most modern LLMs) — understand why removing the mean-centering step still works and is cheaper to compute. Deep dive into Pre-LN vs. Post-LN placement and why virtually all modern large-scale transformers use Pre-LN (or variants like Pre-LN + final norm) specifically because Post-LN causes training instability/divergence at depth without a careful warmup schedule.

• Mini Project 1: Implement LayerNorm and RMSNorm from scratch in NumPy, verifying they match PyTorch's built-in implementations.

• Advanced: Train two tiny transformers (Pre-LN vs. Post-LN) on the same toy dataset without a learning-rate warmup, and empirically reproduce the divergence of the Post-LN model to prove the stability claim yourself.

• Mini Project 2: Explore QK-Norm.

• Advanced: Implement QK-normalization (normalizing queries/keys before the dot product, used in some modern models to prevent attention logit explosion) and measure its effect on attention entropy over training.

Day 205: Long-context extension - RoPE scaling & YaRN

• Advanced injection: Revisit RoPE (Day 122) and go deeper: understand why a model trained at a 4K context breaks down catastrophically when naively run at 32K. Deep dive into position interpolation (PI), NTK-aware scaling, and YaRN (yet another RoPE extensioN) — the exact mathematical technique of non-uniformly stretching different RoPE frequency bands to preserve high-frequency (local) information while compressing low-frequency (long-range) information.

• Mini Project 1: Implement RoPE from scratch and visualize the rotation of query/key vectors at different position indices.

• Advanced: Implement linear position interpolation and NTK-aware scaling on top of your RoPE implementation. Empirically test a model's perplexity on long sequences with vs. without scaling to prove the technique works.

• Mini Project 2: The "needle in a haystack" benchmark.

• Advanced: Build a needle-in-a-haystack evaluation harness: insert a specific fact at varying depths inside a long context and measure retrieval accuracy, mapping out exactly where a model's effective context window degrades.

Day 206: Distributed training I - data parallelism & DeepSpeed ZeRO

• Infrastructure note: Rent a 2-4 GPU cloud instance for this day and Day 207-208.

• Advanced injection: Standard data parallelism (DDP) replicates the full model on every GPU — understand why this becomes impossible once a model's optimizer states no longer fit in a single GPU's VRAM. Deep dive into DeepSpeed ZeRO stages 1 (optimizer state sharding), 2 (+ gradient sharding), and 3 (+ parameter sharding), and calculate the exact memory savings formula for each stage.

• Mini Project 1: Train a small model with standard PyTorch DDP across multiple GPUs.

• Advanced: Convert the same training script to use DeepSpeed ZeRO stage 2, and progressively increase the model size until stage 2 fails but stage 3 succeeds, empirically demonstrating the memory-vs-communication tradeoff of each ZeRO stage.

• Mini Project 2: Gradient accumulation & mixed precision.

• Advanced: Implement gradient accumulation and BF16 mixed-precision training manually (without a high-level wrapper) to understand exactly what a training framework does under the hood, including loss scaling to prevent gradient underflow.

Day 207: Distributed training II - tensor parallelism & Megatron-LM

• Advanced injection: Deep dive into tensor parallelism: splitting a single weight matrix (e.g., the attention QKV projection or the FFN) column-wise or row-wise across GPUs so that a single layer's computation is distributed, not just the batch. Understand the exact all-reduce communication points required in Megatron-style tensor parallelism and why tensor parallelism requires extremely fast interconnects (NVLink) compared to data parallelism.

• Mini Project 1: Implement column-parallel and row-parallel linear layers from scratch using torch.distributed.

• Advanced: Combine a column-parallel layer followed by a row-parallel layer (the standard Megatron MLP pattern) and verify that only a single all-reduce is needed for the full block, rather than one per layer, proving the mathematical elegance of the pattern.

• Mini Project 2: Sequence parallelism.

• Advanced: Extend your implementation with sequence parallelism for the LayerNorm/dropout operations (which aren't naturally tensor-parallelizable), reducing activation memory further.

Day 208: Distributed training III - pipeline parallelism & 3D parallelism

• Advanced injection: Deep dive into pipeline parallelism: splitting the model's layers (not weights) across GPUs, and understand the "bubble" problem (idle GPU time) this creates. Learn how GPipe and PipeDream-style micro-batching schedules (including 1F1B - one-forward-one-backward) minimize the bubble. Understand how production LLM training combines data + tensor + pipeline parallelism simultaneously ("3D parallelism").

• Mini Project 1: Implement a naive pipeline-parallel forward pass across simulated stages (using multiprocessing if multi-GPU isn't available) and measure the pipeline bubble.

• Advanced: Implement micro-batching with a 1F1B schedule and empirically measure the reduction in bubble time/GPU idle time compared to the naive version.

• Mini Project 2: Design a 3D parallelism plan.

• Advanced: On paper (and in a config file), design the exact data/tensor/pipeline parallel degree split you would use to train a 70B-parameter model on a cluster of 512 GPUs, justifying each choice with the memory and communication-bandwidth math from Days 206-208.

Day 209: Writing real CUDA kernels I - the GPU programming model

• Advanced injection: Move from "understanding" GPU concepts to writing them. Deep dive into the CUDA execution model: grids, blocks, threads, warps, and the SIMT (single instruction, multiple threads) execution style. Understand global memory vs. shared memory vs. registers, and why naive kernels are almost always memory-bandwidth bound rather than compute bound (echoing the roofline model from Day 115).

• Mini Project 1: Write a "hello world" CUDA kernel (vector addition) and compile/run it, comparing its execution time to a NumPy equivalent at increasing array sizes.

• Advanced: Write a naive CUDA matrix multiplication kernel. Profile it with nvidia-nsight or nvprof and identify exactly why it is slow (uncoalesced memory access).

• Mini Project 2: Tiled/shared-memory matrix multiplication.

• Advanced: Rewrite the matrix multiplication kernel using shared-memory tiling (echoing the CPU cache-tiling concept from Day 40, but now on the GPU) and measure the speedup, connecting the abstract "tiling" concept you learned early in the syllabus to real, working hardware code.

Day 210: Writing real CUDA kernels II - Triton kernel authoring

• Advanced injection: Raw CUDA C++ is powerful but painful. Deep dive into OpenAI Triton: a Python-embedded language that compiles to efficient GPU kernels while handling memory coalescing and thread scheduling automatically. Understand why Triton is the backbone of torch.compile and how it lets ML engineers (not just systems engineers) write custom fused kernels.

• Mini Project 1: Rewrite your Day 209 matrix multiplication kernel in Triton and compare code complexity and performance against your raw CUDA version.

• Advanced: Write a fused Triton kernel that combines a matrix multiplication with a bias-add and a ReLU activation in a single kernel launch (kernel fusion), and measure the reduction in memory reads/writes vs. calling three separate PyTorch ops.

• Mini Project 2: A minimal FlashAttention kernel.

• Advanced: Implement a simplified, single-head FlashAttention forward pass in Triton (tiled softmax with online/running max-subtraction for numerical stability), directly connecting the "IO-awareness" concept from Day 118 to a kernel you wrote yourself.

Day 211: Alignment beyond PPO - DPO internals

• Advanced injection: Revisit RLHF (Day 73) and understand why PPO is complex and unstable in practice (it needs a separate reward model, a value model, and careful hyperparameter tuning). Deep dive into Direct Preference Optimization (DPO): the mathematical derivation showing that the RLHF objective has a closed-form optimal policy, letting you skip the reward model entirely and optimize preference pairs directly via a modified cross-entropy-style loss.

• Mini Project 1: Implement the DPO loss function from scratch in PyTorch given a batch of (prompt, chosen response, rejected response) triples and a frozen reference model.

• Advanced: Fine-tune a small open-weight model (e.g., a 1-3B model) on a preference dataset using your from-scratch DPO loss. Compare log-probability shifts on chosen vs. rejected responses before and after training.

• Mini Project 2: DPO vs. PPO comparison.

• Advanced: Write a technical comparison document benchmarking training stability, GPU memory footprint (DPO needs no reward/value model), and wall-clock time between your DPO run and a PPO-based pipeline on the same preference dataset.

Day 212: Reward modeling & preference learning internals

• Advanced injection: Deep dive into how a reward model is actually trained: the Bradley-Terry model for pairwise preference probability, and the exact loss function (log-sigmoid of the reward difference between chosen and rejected completions) used to train it. Understand "reward hacking" — how a policy can learn to exploit quirks of an imperfect reward model (e.g., excessive length, sycophancy) rather than genuinely improving quality.

• Mini Project 1: Train a reward model from scratch: take a base LLM, replace the LM head with a scalar regression head, and train it on a preference dataset using the Bradley-Terry loss.

• Advanced: Deliberately construct a reward-hacking scenario (e.g., a reward model that's overly sensitive to response length) and demonstrate how a policy optimized against it degenerates, then fix it with length normalization.

• Mini Project 2: Reward model calibration.

• Advanced: Evaluate your reward model's agreement rate with held-out human preference labels and compute its calibration (does a reward gap of X actually correspond to X% human preference rate?).

Day 213: Reasoning models - GRPO & test-time RL

• Advanced injection: Deep dive into how "reasoning models" (OpenAI o1/o3, DeepSeek-R1) are trained beyond next-token prediction. Understand Group Relative Policy Optimization (GRPO): instead of a learned value/critic model like PPO, GRPO samples a group of completions per prompt and uses the group's mean reward as the baseline, dramatically simplifying and stabilizing RL for reasoning. Understand how a simple, verifiable reward (e.g., "did the final answer match the ground truth math answer") can be enough to bootstrap long chain-of-thought behavior.

• Mini Project 1: Implement GRPO's group-relative advantage calculation from scratch given a batch of sampled completions and their rewards.

• Advanced: Train a small model with GRPO on a verifiable-reward task (e.g., arithmetic or a simple logic puzzle dataset with programmatically checkable answers) and plot how average completion length grows over training as the model learns to "think longer."

• Mini Project 2: Verifiable reward design.

• Advanced: Design and implement a reward function for a code-generation task that runs the generated code against unit tests to produce a binary/graded reward, and discuss why verifiable rewards avoid the reward-hacking problem from Day 212.

Day 214: Pretraining data pipelines I - dedup & quality filtering

• Advanced injection: Understand why raw web-scraped data (like Common Crawl) is mostly unusable without heavy processing. Deep dive into near-duplicate detection at scale using MinHash and locality-sensitive hashing (LSH) — the exact technique used to deduplicate trillion-token pretraining corpora without pairwise comparison (which would be computationally impossible). Explore quality classifiers (small models trained to score "is this text high-quality, textbook-like content") used by pipelines like FineWeb-Edu.

• Mini Project 1: Implement exact deduplication using content hashing on a text corpus.

• Advanced: Implement MinHash + LSH from scratch in Python to find near-duplicate documents (not just exact matches) in a large text corpus, and benchmark it against a naive O(N²) pairwise Jaccard similarity approach to show why LSH is necessary at scale.

• Mini Project 2: Train a quality classifier.

• Advanced: Train a lightweight quality classifier (e.g., a small fastText or logistic regression model on n-gram features) using a small labeled set of "good" vs. "bad" text, then use it to filter a larger unlabeled corpus.

Day 215: Pretraining data pipelines II - data mixing & synthetic data

• Advanced injection: Understand that pretraining data is never used in its raw natural proportions — deep dive into data mixing strategies (e.g., DoReMi) that use a small proxy model to learn the optimal sampling weights across data domains (code, books, web text, math) to maximize downstream performance. Explore synthetic data generation: using a strong LLM to generate large volumes of high-quality training data (e.g., textbook-style content, as in the Phi model series, or distilled reasoning traces).

• Mini Project 1: Implement a simple data-mixing sampler that draws from multiple weighted domains according to a fixed ratio.

• Advanced: Implement a miniature version of the DoReMi proxy-model approach: train a tiny model on a candidate data mix, measure per-domain loss, and adjust domain weights to upweight domains where a reference model out-performs your proxy, iterating toward a better mix.

• Mini Project 2: Synthetic data generation pipeline.

• Advanced: Build a pipeline that uses an LLM (e.g., running locally via llama.cpp) to generate synthetic instruction-following examples from a set of seed topics, then implement an automated quality-filtering pass (using the classifier from Day 214) to keep only the best synthetic examples.

Day 216: Tokenizer training from scratch

• Advanced injection: Days 23-24 covered how a BPE tokenizer processes text at inference time — now go one level deeper and understand how a tokenizer is trained. Deep dive into the BPE training algorithm itself (iteratively merging the most frequent adjacent byte/character pairs to build a vocabulary), and the practical engineering choices that matter: vocabulary size tradeoffs (bigger vocab = fewer tokens per sequence but a bigger, slower embedding matrix), byte-level fallback (ensuring any Unicode input is representable), and special token design (chat template tokens, tool-call tokens).

• Mini Project 1: Implement the BPE training algorithm from scratch in pure Python (count pair frequencies, merge the most frequent pair, repeat) on a small text corpus, and print the learned merge rules.

• Advanced: Train a full byte-level BPE tokenizer (vocab size ~32K) on a real multi-gigabyte text corpus using HuggingFace's tokenizers library (Rust-backed for speed), then benchmark your from-scratch pure-Python version against it to feel the exact performance gap that motivates writing tokenizers in Rust/C++.

• Mini Project 2: Vocabulary size tradeoff analysis.

• Advanced: Train three tokenizers at different vocabulary sizes (8K, 32K, 128K) on the same corpus, measure the average tokens-per-document for each, and quantify the exact tradeoff between sequence length (compute cost) and embedding table size (memory cost).

Day 217: Evaluation methodology - benchmarks, contamination & LLM-as-judge

• Advanced injection: Understand why a high benchmark score can be meaningless: deep dive into benchmark contamination (when test-set examples leak into pretraining data, inflating scores) and how to detect it via n-gram overlap analysis between a training corpus and a benchmark's test set. Deep dive into LLM-as-judge methodology: using a strong model to grade another model's open-ended outputs, including known biases (position bias, verbosity bias, self-preference bias) and mitigation techniques (randomized answer order, pairwise comparison instead of absolute scoring).

• Mini Project 1: Implement an n-gram contamination checker that scans a training corpus for overlapping text against a benchmark's test questions.

• Advanced: Build a full LLM-as-judge pairwise evaluation harness: given two model outputs for the same prompt, call a judge model twice with randomized answer order to control for position bias, and aggregate results into a win-rate leaderboard.

• Mini Project 2: RAG-specific evaluation.

• Advanced: Implement RAGAS-style metrics from scratch (faithfulness: does the answer only use facts from the retrieved context; answer relevancy: does the answer actually address the question) using embedding similarity and an LLM-as-judge faithfulness check.

Day 218: Multimodal I - CLIP & vision-language model architecture

• Advanced injection: Day 128 mentioned CLIP briefly — now go deep into the actual architecture and training. Understand CLIP's dual-encoder contrastive training (image encoder + text encoder, trained so matching image-text pairs have high cosine similarity and non-matching pairs have low similarity, via the InfoNCE/contrastive loss on a batch-wide similarity matrix). Deep dive into how modern vision-language models (LLaVA-style) connect a frozen vision encoder to a frozen LLM via a small trainable "projector" module that maps image patch embeddings into the LLM's token embedding space.

• Mini Project 1: Implement the CLIP contrastive loss from scratch given a batch of image and text embeddings, including the symmetric image-to-text and text-to-image cross-entropy terms.

• Advanced: Build a minimal LLaVA-style architecture: take a pretrained vision encoder (e.g., a small ViT) and a small LLM, freeze both, and train only a linear/MLP projector to map vision patch embeddings into the LLM's embedding space on an image-captioning dataset.

• Mini Project 2: Zero-shot image classification with CLIP.

• Advanced: Use a pretrained CLIP model to perform zero-shot classification by comparing an image embedding against text embeddings of class-name prompts ("a photo of a {class}"), and analyze failure cases where prompt phrasing significantly changes accuracy.

Day 219: Multimodal II - text-to-speech & vocoder internals

• Advanced injection: Day 137 covered speech-to-text (Whisper); now go the other direction. Deep dive into the modern TTS pipeline: text/phoneme encoder → acoustic model (predicting a mel-spectrogram, similar structurally to the diffusion/autoregressive models you've already studied) → vocoder (a specialized neural network, e.g., HiFi-GAN, that converts a mel-spectrogram back into a raw audio waveform). Understand why vocoders are typically GANs: they need to generate perceptually convincing high-frequency detail extremely fast, and adversarial training produces sharper results than pure regression losses.

• Mini Project 1: Implement the Mel-spectrogram-to-waveform problem conceptually by inverting your Day 137 STFT/Mel pipeline using the Griffin-Lim algorithm (a classical, non-neural phase-reconstruction baseline).

• Advanced: Train (or fine-tune) a small neural vocoder on a mel-spectrogram-to-waveform dataset and compare its output quality against your Griffin-Lim baseline, explaining why the learned model captures phase information the classical algorithm cannot.

• Mini Project 2: End-to-end TTS pipeline.

• Advanced: Wire together a text-to-phoneme frontend, a pretrained acoustic model, and your vocoder into a single streaming TTS pipeline, and measure the end-to-end real-time factor (RTF) to determine if it's fast enough for a live conversational agent.

Day 220: Advanced model merging - SLERP, TIES & DARE

• Advanced injection: Day 188 covered basic linear weight averaging ("model soups") — now go deeper into the modern merging toolkit used to combine specialized fine-tunes without any additional training. Deep dive into SLERP (spherical linear interpolation, which merges weights along the surface of a hypersphere rather than a straight line, better preserving each model's directional information), TIES-merging (which resolves sign conflicts between task vectors and trims redundant low-magnitude parameter changes before merging), and DARE (which randomly drops and rescales a large fraction of each task vector's deltas before merging, empirically improving results by reducing interference between merged tasks).

• Mini Project 1: Implement linear averaging and SLERP merging from scratch given two fine-tuned models' state dicts, and compare the resulting merged model's behavior on a simple eval set.

• Advanced: Implement TIES-merging from scratch: compute task vectors (fine-tuned minus base weights) for 2-3 models, resolve sign conflicts by majority vote, trim the smallest-magnitude deltas, and merge. Compare against naive linear averaging on a multi-task benchmark to demonstrate the reduction in "task interference."

• Mini Project 2: DARE + TIES combined pipeline.

• Advanced: Implement the DARE random-drop-and-rescale step as a pre-processing pass before your TIES merge, and write up a final benchmark comparing four merge strategies (linear, SLERP, TIES, DARE+TIES) on a held-out multi-task evaluation suite, closing out the syllabus with a rigorous, from-scratch understanding of the entire modern model-merging toolkit.