For Sarang. Written to help you pass the exam, really understand the ideas, and blog about them.

How to use this guide

• Read the In one line and Plain-English parts first. They build the picture.
• Then work the Worked example with pen and paper before you read the steps.
• Before the exam, do the Exam traps sections and the cheat sheet at the end.
• Every number in this guide was checked in Python (numpy).

1. Course at a glance

Instructor: Dr. Ketan Rajawat (IIT Kanpur). References he recommends: Boyd & Vandenberghe, Introduction to Applied Linear Algebra (VMLS). Strang, Linear Algebra for Everyone. The slides follow Boyd & Vandenberghe very closely, so use that book when you need more explanation.

Evaluation scheme (stated on the Introduction slides)

• Only the best (n − 1) of n assignments count, so you can drop one.
• If you miss the quiz and have valid documents, you get a make-up quiz.
• If you miss the end-sem exam, you get an incomplete/fail grade (the exact letter was lost in the PDF text).
• The instructor's advice: spend at least 1.5× the video length on each video. Work with pen and paper. Do not look up assignment solutions online or ask ChatGPT for them.

Week-by-week map (worked out from assignment and live-session dates)

The story of the course (one paragraph)

A vector is just a list of numbers, such as a pixel row, a word-count row or an embedding. Vector spaces are the "playgrounds" where you can add and scale those lists without falling out. A matrix is a machine that takes a vector in and sends a new vector out. Matrix multiplication chains those machines together. The inner product measures how much two vectors point the same way. Norms measure size. Together they give you angles, distances and projections. Then the payoff: every linear function is secretly a matrix. So "solve a system of equations" means "find the input that the machine sends to b". When there is no exact answer, least squares finds the closest one, and that is linear regression. To do it fast and stably, we factor matrices into simpler pieces. LU (two triangles) and QR (a rotation times a triangle) are the solvers. Finally, the SVD says that every matrix is "rotate, stretch, rotate". That one fact gives you rank, compression, PCA and low-rank approximation, the ideas behind embeddings and LoRA.

2. Topic sections

2.1 Vectors (Ch 1)

In one line: A vector is an ordered list of numbers, like a row in a table where each position means something specific.

Plain-English explanation

Think of a shipment record: [weight, volume, distance]. Order matters. [5, 2, 300] is not the same shipment as [300, 2, 5]. That is all a vector is: an ordered, finite list.

• Entries (also called elements or components): the numbers inside. The i-th entry of vector a is written a_i.
• Dimension n: how many entries it has. We write a ∈ R^n, which means "a is a list of n real numbers".
• Column vs. row: by default every vector in this course is a column (stacked vertically). A row vector is its transpose.
• Scalars are single numbers. Bold lowercase letters are vectors, plain letters are scalars.

Special vectors you must know

• Block (stacked) vectors: a = [b; c; d] just glues vectors end to end. If b ∈ R^2, c ∈ R^3 and d ∈ R^1, then a ∈ R^6.
• Subvectors: a_{r:s} is entries r through s. It has s − r + 1 entries, like Python's a[r-1:s].

Geometric picture (3Blue1Brown style): In 2D, [x, y] is an arrow from the origin to the point (x, y).

• A location vector is an arrow from the origin.
• A displacement vector is an arrow from one point to another: Δp = p_2 − p_1.
• Same arrow, different meaning: a location is just "displacement from the origin".

Applications from the slides

• Colour: RGB is a 3-vector.
• Image: an 800×600 greyscale image is a vector of 480,000 pixel intensities. A colour image has 3 numbers per pixel.
• Word counts: with the dictionary [apple, banana, orange], the text "I like apple and banana" becomes [1, 1, 0].
• One-hot coding: each category becomes a standard unit vector, e.g. Apple = e_1, Banana = e_2.

Worked example

You move a delivery bike from p_1 = (1, 2) to p_2 = (4, 6). What is the displacement?

1. Δp = p_2 − p_1 = (4 − 1, 6 − 2) = (3, 4).
2. Distance travelled in a straight line: √(3² + 4²) = √25 = 5. This previews the norm.

How many numbers are needed for an 800×600 colour image?

1. Pixels = 800 × 600 = 480,000.
2. Three intensities (R, G, B) per pixel: 480,000 × 3 = 1,440,000.

Why it matters in ML/AI

• Every data point a model sees is a vector: a feature row, an image, a token embedding.
• One-hot vectors are what goes into an embedding lookup. Multiplying an embedding matrix E by e_i just picks out column i.
• Bag-of-words vectors were the first document representations in NLP.

Exam traps

• Subvector length is s − r + 1, not s − r. c_{5:14} has 10 entries.
• You can only add vectors of the same size. Assignment 1 Q1 is a whole question of "is this expression even valid?"
• In b = [0; a] with a ∈ R^10 and b ∈ R^15, the zero block must be size 5. But in [0; a; 0] you cannot tell how the 5 zeros split between the two blocks. The instructor tests exactly this kind of ambiguity.
• [a b] (side by side) is a 10×2 matrix, not a 20-vector. [a; b] (stacked) is the 20-vector.

Blog angle: "Everything is a vector: how your photo, your playlist and your shopping cart become lists of numbers."

• Images, text and categories all become vectors, but the order of entries carries the meaning.
• One-hot coding and why it is wasteful, which is why embeddings exist.
• Location vs. displacement: the same arrow with two meanings, and why ML cares (positions vs. deltas/gradients).

Source tag: Course slides (Ch 1) + Assignment 1. Textbook fill-in (Boyd & Vandenberghe Ch 1) for the geometric picture.

2.2 Vector operations & linear combinations (Ch 2)

In one line: You can add vectors and stretch them. Doing both at once, a "linear combination", is the single most important move in the whole course.

Plain-English explanation

• Addition works entry by entry: (a + b)_i = a_i + b_i. Geometrically: walk along a, then along b (tip-to-tail).
• Scaling multiplies every entry by a scalar α. Geometrically it stretches the arrow.
• If α > 0, the arrow keeps its direction.
• If α < 0, it flips.
• If α = 0, it collapses to the zero vector.
• Properties:
• Addition is commutative (a + b = b + a) and associative.
• a + 0 = a and a + (−a) = 0.
• Scaling distributes over addition: α(a + b) = αa + αb and (α + β)a = αa + βa.

Linear combination: α_1 a_1 + α_2 a_2 + … + α_m a_m. The α's are coefficients (weights) and the a's are the component vectors.

Key fact: every vector is a linear combination of the standard unit vectors.

• Example: (3, −2, 4) = 3e_1 − 2e_2 + 4e_3.
• So the entries of a vector are just the weights on e_1, e_2, ….

Displacement logic: if you take displacements x_1, x_2, …, x_k and end where you started, then x_1 + … + x_k = 0. The intermediate positions cancel like a telescoping sum. (This is Assignment 1 Q4, the robot vacuum.)

Cost (flops):

• A flop is one floating-point add, subtract, multiply or divide.
• Adding two n-vectors costs n flops. Scaling one costs n flops.
• Adding N vectors of length L costs (N − 1)·L flops. The order of adding does not change this.
• Memory to hold two n-vectors in 64-bit floats: 2n × 64 bits.

Worked example

a = (1, −2, 4), b = (2, 3, −1).

1. a + b = (1 + 2, −2 + 3, 4 − 1) = (3, 1, 3).
2. b − a = (2 − 1, 3 − (−2), −1 − 4) = (1, 5, −5).
3. 2a − 3b = (2 − 6, −4 − 9, 8 + 3) = (−4, −13, 11).

Flops and storage (Assignment 1 Q3 style). You have 100 vectors, each of length 10^8, in 64-bit floats.

1. Storage = 100 × 10^8 numbers × 8 bytes = 8 × 10^10 bytes = 80 GB.
2. Flops to add them = (100 − 1) × 10^8 = 9.9 × 10^9.
3. At 10^9 flops/s, the time is 9.9 × 10^9 / 10^9 = 9.9 seconds.

Why it matters in ML/AI

• A neuron computes a weighted sum, i.e. a linear combination of its inputs.
• Word-vector arithmetic ("king − man + woman ≈ queen") is literally vector addition and scaling.
• Flop counting is how you estimate GPU cost. It is the same mental model as sizing a Kafka cluster from messages per second.

Exam traps

• Forgetting the N − 1 in "add N vectors". Adding 2 vectors is 1 round of additions, not 2.
• Storage: 64 bits = 8 bytes. Mixing up bits and bytes is the classic mistake.
• Robot question: the answer is the zero vector 0, not the scalar 0.

Blog angle: "Linear combinations: the one idea behind neurons, recipes and word-vector arithmetic."

• Recipe analogy: ingredients are vectors and quantities are weights.
• Every vector is "weights on unit vectors", so coordinates are just recipes.
• Counting flops: back-of-envelope estimates for ML compute.

Source tag: Course slides (Ch 2) + Assignment 1 + Live 26 Sep (AI outline: telescoping sum, N−1 additions).

2.3 Fields, vector spaces & subspaces (Ch 3)

In one line: A vector space is a set that you cannot escape by adding or scaling. A subspace is a smaller such set inside a bigger one, and it must pass through the origin.

Plain-English explanation

• Field F: where your scalars come from. You need to be able to add, subtract, multiply and divide (except by 0) inside it. Examples: R (reals), C (complex), Q (rationals). The integers are not a field, because 1/2 is not an integer.
• Vector space V over F: a set where every linear combination (with scalars from F) stays inside. Check three things: 1. 0 ∈ V (contains the zero vector). 2. Closed under addition: u, v ∈ V ⇒ u + v ∈ V. 3. Closed under scaling: v ∈ V, α ∈ F ⇒ αv ∈ V.
• Subspace W ⊆ V: a subset that is itself a vector space, so it passes the same three checks.

Geometric picture:

• In R^3, the only subspaces are {0}, lines through the origin, planes through the origin, and R^3 itself.
• A line or plane that misses the origin is not a subspace. Scale any point by 0 and you land on the origin, which isn't in the set.
• A circle, a disc, a box such as [0, 1]^n, or the half-plane x_1 ≥ 0 are not subspaces. Scaling or adding takes you outside.

Software analogy: a subspace is like a type that is closed under its operations. If adding two Money objects could give you a String, the type would be broken. A subspace guarantees "add or scale anything in here and you stay in here".

The field matters. R^2 sits inside C^2, but it is not a subspace of C^2 over F = C. Take v = (1, 1) ∈ R^2 and the scalar i ∈ C. Then iv = (i, i) ∉ R^2. Over F = R, though, it is a subspace.

Canonical examples:

• R^n over R, C^n over C, and R^(m×n) (matrices) over R are vector spaces.
• The natural numbers N are not a vector space over R: no negatives, and 0.5·1 ∉ N.

Worked example (Assignment 1 Q5 style)

(a) W = {x ∈ R^3 | x_1 + 2x_2 + 3x_3 = 0}.

1. Zero: 0 + 0 + 0 = 0 ✓.
2. Addition: if x and y satisfy it, then (x_1 + y_1) + 2(x_2 + y_2) + 3(x_3 + y_3) = 0 + 0 = 0 ✓.
3. Scaling: αx_1 + 2αx_2 + 3αx_3 = α·0 = 0 ✓.
4. Subspace. Geometrically it is a plane through the origin with normal vector (1, 2, 3).

(b) W = {x | x_1 = 2x_2 = 3x_3}.

1. Call the common value 6t. Then x = (6t, 3t, 2t) = t·(6, 3, 2).
2. This is a line through the origin, so it is a subspace.

(c) W = {x ∈ R^2 | x_1 + x_2 = b}.

1. Zero: 0 + 0 = b holds only if b = 0.
2. Adding two members gives a sum of 2b, which is not b unless b = 0.
3. So it is a subspace only when b = 0.

Why it matters in ML/AI

• The set of all outputs of a linear layer, {Wx}, is a subspace (the column space). A rank-r layer can only output vectors in an r-dimensional subspace. That is the core idea behind LoRA.
• PCA finds the best low-dimensional subspace to project data onto.
• Many "constraint sets" in optimisation (probability simplex, unit ball) are not subspaces. That is why they need projections or special solvers.

Exam traps

• Check the zero vector first. It is the fastest way to kill a non-subspace.
• To prove "not a subspace", one counterexample is enough. To prove "is a subspace", you must show the general case.
• Always ask "over which field?" The R^2-in-C^2 question was on Assignment 1 and was discussed in the 04 Oct live session.
• x_1 = 2x_2 = 3x_3 looks like two equations. Both are homogeneous (= 0 on the right after rearranging), so it is a subspace.

Blog angle: "Why your feature space must contain the origin: subspaces explained with lines, planes and LoRA."

• The 3-check test, plus "check zero first".
• Why an affine line (offset by b) fails, and how a bias term gets around it.
• The field matters: the R^2-inside-C^2 puzzle.

Source tag: Course slides (Ch 3) + Assignment 1 + Live 26 Sep & 04 Oct (AI outlines, cross-checked).

2.4 Matrices & basic matrix operations (Ch 4–5)

In one line: A matrix is a grid of numbers. Read it as a table, a stack of vectors, a graph, or (most importantly) a machine that transforms vectors.

Plain-English explanation

• An m × n matrix has m rows and n columns. A_ij is the entry in row i, column j. Shapes:
• Square: m = n.
• Tall: m > n.
• Wide: m < n.
• Columns view: A = [a_1 a_2 … a_n], each a_j ∈ R^m. Rows view: each row is a 1×n vector.
• Three interpretations from the slides: 1. Table: students × assignments, or regions × products. 2. Collection of vectors: e.g. N images, each a P-vector, as columns. 3. Relationship graph (adjacency matrix): A_ij = 1 if i → j (e.g. "i follows j on Instagram").
• Special matrices:
• Zero 0_{m×n}.
• Identity I_n (ones on the diagonal), which equals [e_1 … e_n].
• Diagonal Diag(d) and block-diagonal blkdiag(B_1, B_2, …).
• Upper triangular (zeros below the diagonal) and lower triangular (zeros above).
• Tensors: the same idea in more dimensions, e.g. a batch of colour images is an N × H × W × 3 tensor.

Storage & reshape. Memory is 1-D, so a matrix is stored as a long vector plus "shape" metadata.

• Fortran/MATLAB store column by column (column-major). C/C++/Python-numpy store row by row (row-major).
• Reshaping m×n to p×q needs mn = pq, and the result depends on the ordering.
• vec(A) stacks the columns.

Transpose flips the matrix across its diagonal: (A^T)_ij = A_ji.

• (A^T)^T = A and (A + B)^T = A^T + B^T.
• Symmetric means A = A^T.
• For block matrices, you transpose each block and swap the block positions.

Addition and scaling work entry by entry, with the usual commutative and associative rules. The set of all m×n matrices is itself a vector space.

Matrix-vector product: the "machine" view (the most important idea here).

Av = v_1 a_1 + v_2 a_2 + … + v_n a_n

In words, Av is a linear combination of the columns of A, with weights taken from v.

3Blue1Brown picture:

• Column a_j is where e_j lands after the transformation.
• So Av says: "go v_1 steps along where e_1 landed, v_2 steps along where e_2 landed, …".

Row view (equivalent): entry i of Av is the dot product of row i of A with v.

Handy tricks from the slides:

• Ae_i is column i of A. A^T e_j gives row j (as a column).
• A1 sums each row, i.e. adds the columns together. A^T 1 gives the column sums.
• A difference matrix (−1, 1 on each row) gives forward differences v_2 − v_1, v_3 − v_2, …. A lower-triangular all-ones matrix gives running (cumulative) sums.
• Properties: A(v + w) = Av + Aw, (A + B)v = Av + Bv, and (αA)v = α(Av) = A(αv).

Flops (n × n):

• Transpose: 0 (it is just re-indexing).
• Scaling and addition: n².
• Matrix-vector: n(2n − 1) ≈ 2n². Each of the n outputs needs n multiplications and n − 1 additions.

Worked example (the slide's "neural network" example)

A = [[2, 4], [1, 3], [5, 2]] (3×2), v = (3, 1).

1. Column view: Av = 3·(2, 1, 5) + 1·(4, 3, 2) = (6 + 4, 3 + 3, 15 + 2) = (10, 6, 17).
2. Row view check: - Row 1: 2·3 + 4·1 = 10. - Row 2: 1·3 + 3·1 = 6. - Row 3: 5·3 + 2·1 = 17 ✓.
3. Row sums A1 = (6, 4, 7). Column sums A^T 1 = (8, 9).

Block matrix (Assignment 2 Q1): A = [[I, B^T], [B, 0]] with B ∈ R^{3×5}.

1. B^T is 5×3 and sits in the top-right, so the top-left I must be 5×5 (same number of rows as B^T).
2. B is 3×5 and sits in the bottom-left, so the bottom-right 0 must be 3×3.
3. A is (5 + 3) × (5 + 3) = 8×8, square.
4. A^T = [[I^T, B^T], [(B^T)^T, 0^T]] = [[I, B^T], [B, 0]] = A, so A is symmetric.
5. "I and 0 are the same size" is false in general (5×5 vs 3×3). "The 0 block is square" is true.

Why it matters in ML/AI

• A dense layer is Wx + b. The live session pointed out that the bias can be absorbed: append a 1 to x and add b as an extra column of W.
• Adjacency matrices are the input to graph neural networks and PageRank.
• Row-major vs column-major is why numpy.reshape and torch.view sometimes scramble your data. It is also why .contiguous() exists.

Exam traps

• Transposing a block matrix: swap the off-diagonal blocks AND transpose each block.
• Reshape results differ between MATLAB and Python because of the ordering.
• Matrix-vector flops are 2n² (more precisely n(2n − 1)), not n².
• Shape checking: an m×n matrix times an n-vector gives an m-vector. The inner dimensions must match.

Blog angle: "A matrix is a machine: the column picture that makes neural networks click."

• Columns are "where the unit vectors land".
• Av = mix the columns. That one sentence explains linear layers.
• Four costumes for a matrix: table, image stack, graph, transformation.

Source tag: Course slides (Ch 4, Ch 5) + Assignment 2 Q1 (official solution) + Live 03 Oct (AI outline: bias trick, storage metadata).

2.5 Matrix multiplication (Ch 6)

In one line: AB means "do B, then do A". It is composing two machines, so order matters.

Plain-English explanation

Definition: if A is m×n and B is n×p, then C = AB is m×p with

C_ij = Σ_k A_ik B_kj (row i of A dotted with column j of B).

Shape rule: (m×n)(n×p) → m×p. The inner sizes must match.

Four equivalent views (the instructor stresses all of them):

1. Inner-product (entry) view: C_ij = (row i of A) · (column j of B).
2. Column view: AB = [Ab_1 Ab_2 … Ab_p]. A acts on each column of B.
3. Row view: each row of AB is (row i of A) times B.
4. Outer-product view: AB = a_1 b_1^T + a_2 b_2^T + … + a_n b_n^T. This is a sum of rank-1 matrices, one per column of A paired with the matching row of B. The SVD builds on exactly this view.

Geometric picture: if B rotates and A stretches, then AB rotates first and then stretches. BA stretches first and then rotates, which is usually different. Hence:

• Not commutative: AB ≠ BA in general, even when both are defined.
• Still associative: (AB)C = A(BC).
• Distributive: A(B + C) = AB + AC.
• Transpose reverses order: (AB)^T = B^T A^T. Think "socks and shoes": you take them off in reverse order.
• Identity: AI = IA = A.

Special products:

• Inner product u^T v gives a scalar.
• Outer product u v^T gives a matrix with (uv^T)_ij = u_i v_j. Every outer product of non-zero vectors has rank 1. In general uv^T ≠ vu^T.
• Gram matrix G = A^T A has G_ij = a_i^T a_j, the dot products between columns. It is always symmetric.
• Trace: tr(A) = sum of the diagonal entries (square matrices only).
• It is linear.
• tr(AB) = tr(BA) even when AB ≠ BA.
• Cyclic: tr(ABC) = tr(BCA) = tr(CAB). But tr(ABC) ≠ tr(BAC) in general.
• Hadamard product A ⊙ B multiplies entry by entry (same shapes only). It is commutative.

Flops: an n×n by n×n product costs n²(2n − 1) ≈ 2n³.

Worked example

A = [[1, 2], [3, 4]], B = [[5, 6], [7, 8]].

1. AB: - (1,1) = 1·5 + 2·7 = 19 - (1,2) = 1·6 + 2·8 = 22 - (2,1) = 3·5 + 4·7 = 43 - (2,2) = 3·6 + 4·8 = 50 - So AB = [[19, 22], [43, 50]].
2. BA: - (1,1) = 5·1 + 6·3 = 23 - (1,2) = 5·2 + 6·4 = 34 - (2,1) = 7·1 + 8·3 = 31 - (2,2) = 7·2 + 8·4 = 46 - So BA = [[23, 34], [31, 46]] ≠ AB.
3. Traces: tr(AB) = 19 + 50 = 69 and tr(BA) = 23 + 46 = 69. Equal, as the theorem promises.
4. Hadamard: A ⊙ B = [[5, 12], [21, 32]].

Outer-product symmetry (Assignment 2 Q2): x = (1, 3), y = (2, 5).

• xy^T = [[2, 5], [6, 15]] but yx^T = [[2, 6], [5, 15]]. They are not equal.
• In general, entry (i, j) needs x_i y_j = x_j y_i, i.e. x_i / y_i = x_j / y_j for all i, j. So xy^T = yx^T iff y is a scalar multiple of x.

Matrix powers (Assignment 2 Q4): S = [[0,0,0,1],[1,0,0,0],[0,1,0,0],[0,0,1,0]], x = (1, 2, 3, 4).

1. Sx = (x_4, x_1, x_2, x_3) = (4, 1, 2, 3). This is a downward circular shift.
2. S²x = (3, 4, 1, 2), S³x = (2, 3, 4, 1), and S⁴x = x, so S⁴ = I.
3. In general Sⁿ = S^((n−1) mod 4 + 1). For example S⁶x = S²x = (3, 4, 1, 2).

Nilpotent (Assignment 2 Q3): N = [[0, 1], [0, 0]] gives N² = 0 even though N ≠ 0. So does [[1, 1], [−1, −1]].

Why it matters in ML/AI

• A deep network is a chain of matrix products with nonlinearities between them. Without the nonlinearities, W_3 W_2 W_1 collapses into one matrix. That is why activations matter.
• Attention is Q K^T (all pairwise dot products, a Gram-like matrix), then softmax, then times V.
• Training cost estimates ("~6 × params × tokens flops") come straight from the 2n³-style counting.
• The trace trick tr(ABC) = tr(CAB) is used constantly in deriving gradients of matrix losses.

Exam traps

• Shape-check first. If AB is 3×5 and B is 4×5, then A must be 3×4.
• AB = 0 does not imply A = 0 or B = 0 (see nilpotent matrices).
• (AB)^T = B^T A^T, not A^T B^T. The same reversal applies to inverses.
• tr(AB) = tr(BA) holds even for non-square A (m×n) and B (n×m). Then AB is m×m and BA is n×n, yet the traces match.
• Permutation and shift matrices: test with a symbolic vector (x_1, x_2, x_3, x_4), as the instructor advises.

Blog angle: "Why AB ≠ BA: matrix multiplication as function composition (and why your neural net needs ReLU)."

• Four ways to see a matrix product, and when each one helps.
• Composition picture: rotate-then-stretch vs stretch-then-rotate.
• The outer-product view previews the SVD and low-rank adapters.

Source tag: Course slides (Ch 6) + Assignment 2 (official solutions) + Live 03 & 04 Oct (AI outlines, checked against the solutions).

2.6 Inner products (Ch 7)

In one line: The inner (dot) product multiplies matching entries and adds them up. It tells you how much two vectors point the same way.

Plain-English explanation

Definition: <u, v> = u^T v = u_1 v_1 + u_2 v_2 + … + u_n v_n. The result is a scalar.

Properties:

• Commutative: <u, v> = <v, u>.
• <au, bv> = ab <u, v>.
• Distributive: <u + v, w> = <u, w> + <v, w>.
• Together these make the inner product bilinear: linear in each argument separately.

The most-used expansion: <u + v, u + v> = <u, u> + 2<u, v> + <v, v>. This is just (a + b)² for vectors. Most proofs in Assignment 3 come down to this line.

Geometric meaning: <u, v> = ||u|| ||v|| cos θ. Equivalently, "length of the shadow of u on v, times the length of v".

• Large and positive: the vectors point the same way.
• Zero: they are perpendicular (orthogonal).
• Negative: they point in opposite directions.

Useful special cases:

• <e_i, v> = v_i picks out one entry.
• <1, v> = sum of the entries.
• <v, v> = sum of the squares = ||v||².
• Co-occurrence: with indicator vectors of two sets, <v_A, v_B> counts the common elements.
• Polynomial evaluation: p(a) = <coefficients, (a^(n−1), …, a, 1)>.

Matrix-vector, row view: (Ax)_i = <row i of A, x>.

Moving a matrix across: <y, Ax> = <A^T y, x>.

• Proof: y^T A x is a scalar, so it equals its own transpose: (y^T A x)^T = x^T A^T y.
• This "move A to the other side as A^T" trick is everywhere in backprop.

Block vectors: <[v_1; v_2], [w_1; w_2]> = <v_1, w_1> + <v_2, w_2>.

Matrix inner product: <A, B> = Σ_ij A_ij B_ij = tr(A^T B) = <vec(A), vec(B)>.

Cost: n multiplications + (n − 1) additions = 2n − 1 flops.

Worked example

u = (1, 2, 3), v = (4, 5, 6).

1. <u, v> = 1·4 + 2·5 + 3·6 = 4 + 10 + 18 = 32.
2. ||u|| = √14 ≈ 3.742 and ||v|| = √77 ≈ 8.775.
3. cos θ = 32 / (√14·√77) ≈ 0.9746, so θ ≈ 12.9°. The vectors are very similar in direction.

Orthogonal pair: (3, 1)·(−1, 3) = −3 + 3 = 0, a right angle.

Co-occurrence: A = {1, 3, 4, 6} and B = {2, 3, 5, 6} over the universe {1..6}.

• v_A = (1, 0, 1, 1, 0, 1) and v_B = (0, 1, 1, 0, 1, 1).
• <v_A, v_B> = 2. The common elements are {3, 6}.

Matrix inner product: A = [[2, 4], [1, 3]], B = [[1, −1], [0, 2]].

• <A, B> = 2 − 4 + 0 + 6 = 4.

Why it matters in ML/AI

• Attention scores are q^T k, dot products between a query and keys.
• Cosine similarity between embeddings drives semantic search and RAG retrieval. The live session's example: "bus·car" is high, "bus·man" is near 0, "good·bad" is negative.
• A single neuron before activation is w^T x + b.
• The <y, Ax> = <A^T y, x> identity is why backprop multiplies by W^T.

Exam traps

• A dot product of two vectors is a scalar. Don't write it as a matrix.
• <u + v, u + v> has 2, not . You need the commutativity step to combine the two cross terms.
• The zero vector is orthogonal to everything.
• <A, B> = tr(A^T B), not tr(AB).

Blog angle: "The dot product is the most important operation in AI: from attention to semantic search."

• The shadow picture: projection length × length.
• Cosine similarity is a dot product with the size normalised away.
• The transpose trick <y, Ax> = <A^T y, x> and why gradients flow backwards through W^T.

Source tag: Course slides (Ch 7) + Live 10 Oct (AI outline: word similarity examples).

2.7 Norms, angles, orthogonal decomposition & inequalities (Ch 8)

In one line: A norm measures the size of a vector. With the dot product, it gives you distance, angle, projection, and the two inequalities that every proof uses.

Plain-English explanation

Three common vector norms

Matrix norm (Frobenius):

• ||A||_F = √(Σ A_ij²) = ||vec(A)||_2 = √tr(A^T A).
• Its square equals the sum of the squared column norms, and also the sum of the squared row norms.

What makes something a norm. It needs four properties:

1. Non-negativity: ||x|| ≥ 0.
2. Homogeneity: ||cx|| = |c|·||x||. Note the absolute value.
3. Definiteness: ||x|| = 0 ⇔ x = 0.
4. Triangle inequality: ||x + y|| ≤ ||x|| + ||y||.

Only norms that come from an inner product satisfy ||v|| = √. The 2-norm and the Frobenius norm do. The 1-norm and the ∞-norm do not.

"If and only if" (⇔) proofs have two separate directions: assume A and prove B, then assume B and prove A. The instructor warns: keep them separate to avoid circular reasoning.

Norm of a sum: ||u + v||² = ||u||² + 2u^T v + ||v||².

• If u ⊥ v, this becomes the Pythagorean theorem: ||u + v||² = ||u||² + ||v||².
• Change v to −v and you get ||u − v||² = ||u||² − 2u^T v + ||v||².

Orthogonal decomposition (projection). Any u can be split into "the part along v" plus "the part perpendicular to v":

u = α v + w, with α = u^T v / ||v||² and w = u − α v, where w ⊥ v.

Derivation in two lines: we want v^T w = 0, so v^T(u − αv) = 0, which gives α = u^T v / v^T v. The instructor says to remember this two-step logic rather than memorise the formula.

Cauchy-Schwarz: |u^T v| ≤ ||u|| ||v||, with equality iff u and v are parallel.

• Proof idea: ||u||² = (u^T v)²/||v||² + ||w||² ≥ (u^T v)²/||v||².
• Picture: a shadow can never be longer than the stick.

Triangle inequality from Cauchy-Schwarz:

• ||u + v||² ≤ ||u||² + 2||u|| ||v|| + ||v||² = (||u|| + ||v||)².
• Equality holds when u is a non-negative multiple of v.

Reverse triangle inequality: ||u − v|| ≥ | ||u|| − ||v|| |.

• Trick: write u = (u − v) + v and apply the ordinary triangle inequality.

Angle:

• cos θ = u^T v / (||u|| ||v||). Cauchy-Schwarz guarantees this lies in [−1, 1].
• θ = 0: same direction.
• θ = 90° (π/2): orthogonal.
• θ = 180°: opposite directions.

Orthonormal vectors: v_i^T v_j = 0 for i ≠ j, and ||v_i|| = 1.

Stacked vectors: ||[x_1; x_2]||² = ||x_1||² + ||x_2||².

Cost: about 2n flops for a vector norm and 2n² for the Frobenius norm of an n×n matrix.

Parallelogram law (Assignment 3 Q1):

• ||u + v||² + ||u − v||² = 2(||u||² + ||v||²).
• Proof: add the two expansions above. The ±2u^T v cross terms cancel.

Young's / "ε-trick" (Live 10–11 Oct):

• 2a^T b ≤ ε||a||² + (1/ε)||b||² for any ε > 0.
• Why it holds: ||√ε a − b/√ε||² ≥ 0. Expand it and rearrange.
• Use it whenever you have a product and need sums of squares.

Worked examples

(1) Norms of x = (3, −4, 12):

• ||x||_1 = 3 + 4 + 12 = 19.
• ||x||_2 = √(9 + 16 + 144) = √169 = 13.
• ||x||_∞ = 12.

(2) Orthogonal decomposition of u = (4, 2) along v = (1, 1):

1. u^T v = 4 + 2 = 6 and ||v||² = 2, so α = 6/2 = 3.
2. The part along v is 3·(1, 1) = (3, 3).
3. w = u − (3, 3) = (1, −1).
4. Check: w^T v = 1 − 1 = 0 ✓, and (3, 3) + (1, −1) = (4, 2) ✓.

The slide example works the same way: u = (2, 3) and v = (1, 1/3) give α = 2.7 and w = (−0.7, 2.1).

(3) Parallelogram law in use. Given ||u + v|| = 6, ||u − v|| = 4 and ||u|| = 3, find ||v||.

1. 36 + 16 = 2(9 + ||v||²), so 26 = 9 + ||v||², so ||v||² = 17.
2. For u^T v, subtract the two expansions: ||u + v||² − ||u − v||² = 4u^T v, so u^T v = (36 − 16)/4 = 5.

(4) Assignment 3 Q3 (official answer). Find u ∥ (1, 3) and v ⊥ (1, 3) with u + v = (1, 2).

1. Set u = α(1, 3) and v = (v_1, v_2). Then v_1 + 3v_2 = 0, α + v_1 = 1 and 3α + v_2 = 2.
2. Solving gives α = 7/10, so u = (0.7, 2.1) and v = (0.3, −0.1).
3. This is exactly orthogonal decomposition: α = (1, 2)·(1, 3)/||(1, 3)||² = 7/10.

Why it matters in ML/AI

• L2 regularisation (ridge, weight decay) penalises ||w||_2². L1 (lasso) penalises ||w||_1 and pushes weights to exactly zero.
• Normalising embeddings (u/||u||) turns dot products into cosine similarities. Most vector databases do this.
• Projection is the heart of least squares, PCA and Gram-Schmidt.
• The ε-trick appears in every convergence proof for SGD.
• Gradient clipping caps ||g||.

Exam traps

• Homogeneity is |c|·||x||. Forgetting the absolute value loses marks.
• Never square an inequality blindly. −5 < 4, but 25 > 16. Square only when both sides are ≥ 0 (norms are; inner products may not be).
• "For all α, β" (Assignment 3 Q2) means one example is not a proof. Expand in general: the difference is (α² − β²)(||u||² − ||v||²), which is zero for all α, β iff ||u|| = ||v||.
• Projection uses ||v||² in the denominator, not ||v||.
• The 1-norm and ∞-norm are not induced by any inner product.

Blog angle: "Cauchy-Schwarz in one picture: why a shadow can't be longer than the stick (and why cosine similarity works)."

• Three norms, three distance notions: crow, taxi, worst coordinate.
• Projection as "how much of u lives along v". It is the core of regression and PCA.
• The ε-trick: turning products into sums, the most useful inequality in ML theory.

Source tag: Course slides (Ch 8) + Assignment 3 (official solutions) + Live 10 & 11 Oct (AI outlines; corrected one outline claim that norms are "strictly positive", since ||0|| = 0).

2.8 Linear functions (Ch 9)

In one line: A function is linear if "scale and add the inputs" gives "scale and add the outputs". Every such function is a dot product (scalar output) or a matrix (vector output).

Plain-English explanation

Notation: f : R^n → R takes vectors to scalars. f : R^n → R^m takes vectors to vectors. The input set is the domain; the output set is the co-domain.

Linear means superposition:

• Additivity: f(u + v) = f(u) + f(v).
• Homogeneity: f(αu) = αf(u).
• Combined: f(α_1 v_1 + α_2 v_2) = α_1 f(v_1) + α_2 f(v_2).

Big result (the Riesz representation theorem, finite-dimensional case). Every linear f : R^n → R is f(x) = a^T x for a unique a, and you can find it by feeding in the unit vectors: a = (f(e_1), f(e_2), …, f(e_n)).

• Why: x = Σ x_i e_i, so f(x) = Σ x_i f(e_i) = a^T x.
• Uniqueness: if u^T x = v^T x for all x, then putting x = e_i gives u_i = v_i.

Vector-valued version: each output is its own linear function a_i^T x. Stack them as rows and you get f(x) = Ax.

• 3Blue1Brown: "a linear transformation is completely determined by where it sends the basis vectors". Those images are the columns of A.

Software analogy: a linear function is like a pure, stateless pricing function with no fixed fee. Double the order and the price doubles. Combine two orders and the price is the sum. Once you know the price of one unit of each item (f(e_i)), you know the price of every order.

Examples:

• Scaling: S(x) = Diag(s)x.
• Projection onto the x-axis: p(x, y) = (x, 0).
• In 3D, P = [[1,0,0],[0,1,0],[0,0,0]] drops z. Projections are idempotent: P² = P, because projecting twice is the same as projecting once.

Non-examples:

• f(x) = a^T x + c with c ≠ 0 is affine, not linear, because f(0) ≠ 0.
• ||x||², max_i x_i and |x| are not linear.

Worked example

f(x) = 2x_1 − x_2 + 3x_3.

1. f(e_1) = 2, f(e_2) = −1 and f(e_3) = 3, so a = (2, −1, 3).
2. f(1, 2, 3) = 2 − 2 + 9 = 9.

Assignment 4 Q2: f(x) = (||x − c||² − ||c||²) − (||x − d||² − ||d||²).

1. Expand: ||x − c||² = ||x||² − 2c^T x + ||c||². So the first bracket is ||x||² − 2c^T x.
2. In the same way, the second bracket is ||x||² − 2d^T x.
3. Subtract: f(x) = −2c^T x + 2d^T x = 2(d − c)^T x.
4. So f is linear, with a = 2(d − c). (Checked numerically with random c, d, x.)

Why it matters in ML/AI

• A linear layer is a linear function. Adding the bias makes it affine. With the "append a 1" trick it becomes linear in a bigger space.
• Linear probes in interpretability: if a concept is linearly decodable, there is an a with concept ≈ a^T h.
• The Riesz result is why every linear readout or classifier is "a dot product with a weight vector".

Exam traps

• Check f(0) = 0 first. If f(0) ≠ 0, the function is not linear.
• Showing linearity needs the general superposition argument, not a numeric example.
• Projection matrices satisfy P² = P. They are generally not invertible (they lose information).
• In Assignment 4 Q2 type problems, expand the norms. The ||x||² terms must cancel. If they don't, the function isn't linear.

Blog angle: "Every linear function is a dot product: the theorem behind linear probes and readout heads."

• Superposition explained with pricing or shipping costs.
• "Feed it the unit vectors" recovers the weights: a 3-line proof.
• Why the bias breaks linearity, and the homogeneous-coordinates fix.

Source tag: Course slides (Ch 9) + Assignment 4 Q2 (solution derived here, no official solution yet). The slide's "Reisz" is the Riesz representation theorem (textbook fill-in).

2.9 Linear systems, inverses, orthogonal matrices & least squares (Ch 10)

In one line: Solving Ax = b means finding the input that the machine A turns into b. If no exact answer exists, least squares finds the input whose output is closest to b. That is linear regression.

Plain-English explanation

Linear system: m equations a_i^T x = b_i, written compactly as Ax = b. Per the slides, linear algebra "is all about solving linear systems, exactly or approximately".

Inverse (square matrices only):

• B is the inverse of A if AB = BA = I. It is written A^(−1).
• Invertible / non-singular: the inverse exists.
• Singular: it doesn't.
• Picture: A^(−1) is the "undo" button. A singular A squashes space flat (for example, onto a line), and you can't un-squash.
• Properties (all proved on the slides):
• The inverse is unique: B = BI = B(AC) = (BA)C = C.
• (AB)^(−1) = B^(−1) A^(−1). Order reverses again, like transpose.
• (A^(−1))^(−1) = A.
• (A^T)^(−1) = (A^(−1))^T.
• 2×2 formula: [[a, b], [c, d]]^(−1) = (1/(ad − bc))·[[d, −b], [−c, a]]. It fails when ad = bc.
• Diagonal matrices invert entry by entry: Diag(2, 3)^(−1) = Diag(1/2, 1/3).
• If A is invertible, then x = A^(−1) b is the unique solution. Computing A^(−1) costs about n³.

Orthogonal matrices Q (square) satisfy Q^T Q = Q Q^T = I, i.e. Q^(−1) = Q^T.

• The columns are orthonormal, and so are the rows.
• Example: the rotation R(θ) = [[cos θ, −sin θ], [sin θ, cos θ]].
• They preserve lengths and angles: ||Qu|| = ||u|| and = . Think "rigid rotation or reflection".
• So solving Qx = b is just x = Q^T b, which costs n² instead of n³.
• Caution: a tall matrix with orthonormal columns (m > n) has A^T A = I_n but A A^T ≠ I_m. It is not called orthogonal.

Gradients and minimisation: at a minimum of a smooth h(x), every partial derivative is zero: ∇h(x*) = 0.

• Scalar example: h(x) = log x − ax has h'(x) = 1/x − a = 0, so x* = 1/a. (This point is actually the maximum of that function. The slide uses it only to illustrate setting the derivative to zero.)
• Vector example: h(x) = ||x − b||² has ∂h/∂x_i = 2(x_i − b_i) = 0, so x* = b.

Least squares (LS). When A is tall (m > n: more equations than unknowns), Ax = b usually has no solution. So minimise the squared error instead:

x* = argmin_x ||Ax − b||²

• Set the gradient to zero: ∇h = 2(A^T A x − A^T b) = 0. This gives the normal equations: A^T A x = A^T b.
• If A^T A is invertible (which needs m ≥ n and independent columns), then x* = (A^T A)^(−1) A^T b.
• Geometric picture (the key insight). Ax ranges over the column space of A (a plane, say). b sticks out of that plane. The closest point Ax* is the foot of the perpendicular from b. The residual r = b − Ax* is orthogonal to every column of A, which is exactly A^T r = 0, the normal equations. Least squares is orthogonal projection.
• n = 1 case: the best multiple of a to approximate b is x* = a^T b / a^T a. This is the projection coefficient α from the norms chapter.
• Fitting a line y = wx + b: stack the rows [x_i, 1] into X and solve min ||y − X[w; b]||². Closed form:
• w* = Σ(x_i − x̄)(y_i − ȳ) / Σ(x_i − x̄)²
• b* = ȳ − w* x̄
• Fitting a parabola: use columns [x², x, 1]. It is still linear in the unknowns, so it is still least squares.
• History: Gauss used least squares at age 18 (1795) and used it to predict where the asteroid Ceres would reappear (1801). Legendre published first (1805).

Worked examples

(1) Inverse: A = [[2, 1], [5, 3]].

1. ad − bc = 6 − 5 = 1.
2. A^(−1) = (1/1)·[[3, −1], [−5, 2]] = [[3, −1], [−5, 2]].
3. Check: [[2,1],[5,3]]·[[3,−1],[−5,2]] = [[6 − 5, −2 + 2], [15 − 15, −5 + 6]] = I ✓.

(2) Rotation: rotate p = (2, 1) by 45°.

1. R = [[0.7071, −0.7071], [0.7071, 0.7071]].
2. p' = (0.7071·2 − 0.7071·1, 0.7071·2 + 0.7071·1) = (0.7071, 2.1213).
3. Length check: ||p'|| = √5 = ||p|| ✓, as rotation preserves length.

(3) Least-squares line through (1, 1), (2, 2), (3, 2), (4, 4).

1. X = [[1,1],[2,1],[3,1],[4,1]] and y = (1, 2, 2, 4).
2. X^T X = [[Σx², Σx], [Σx, m]] = [[30, 10], [10, 4]]. X^T y = (Σxy, Σy) = (27, 9).
3. Solve [[30, 10], [10, 4]]·[w; b] = [27; 9]: - From the second row: b = (9 − 10w)/4. - Substitute into the first row: 30w + 10(9 − 10w)/4 = 27, so 30w + 22.5 − 25w = 27, so 5w = 4.5, so w = 0.9 and b = 0.
4. Cross-check with the centred formula. x̄ = 2.5 and ȳ = 2.25. - Σ(x − x̄)(y − ȳ) = 1.875 + 0.125 − 0.125 + 2.625 = 4.5. - Σ(x − x̄)² = 5. - So w = 4.5/5 = 0.9 ✓ and b = 2.25 − 0.9·2.5 = 0 ✓.
5. Residuals r = y − Xw = (0.1, 0.2, −0.7, 0.4). Sum of squares = 0.7. Check X^T r = (0, 0) ✓, so the residual is orthogonal to the columns.

(4) Assignment 4 Q4 numerically: a = (1, 2, 2), b = (3, 0, 3).

1. x* = a^T b / a^T a = 9/9 = 1.
2. Residual: ||a·1 − b||² = ||(−2, 2, −1)||² = 9.
3. Formula check: ||b||² sin²θ = 18·(1 − 81/(9·18)) = 18·0.5 = 9 ✓.

Why it matters in ML/AI

• Linear regression is literally least squares. The normal equations are its closed-form solution, and gradient descent on MSE converges to the same answer.
• The "residual ⊥ features" condition is why OLS residuals are uncorrelated with every feature.
• Orthogonal matrices keep signal norms stable. That is why orthogonal weight initialisation and rotations (RoPE positional encoding uses 2×2 rotation blocks) are popular.
• Ridge regression changes the normal equations to (A^T A + λI)x = A^T b, which is always invertible.

Exam traps

• Only square matrices have (two-sided) inverses. "Orthogonal" requires square.
• (AB)^(−1) = B^(−1) A^(−1), not A^(−1) B^(−1).
• In practice, don't compute A^(−1) to solve Ax = b. Factor A instead (LU/QR, next section).
• Least squares needs A^T A invertible. This requires m ≥ n (the slide says m > n; m = n is fine too) and independent columns.
• In "find θ for the closest point on a line" (Assignment 4 Q3), rewrite the point as v + θ(u − v) and it becomes the n = 1 LS problem:
• θ* = (p − v)^T(u − v) / ||u − v||².
• Rotations: R(θ)R(ω) = R(θ + ω) = R(ω)R(θ). 2-D rotations do commute. In 3-D they generally don't.

Blog angle: "Least squares is just dropping a perpendicular: the geometry behind linear regression."

• No exact solution? Then find the closest reachable point.
• Normal equations = "the error is perpendicular to everything the model can express".
• From Gauss tracking Ceres to sklearn.LinearRegression.

Source tag: Course slides (Ch 10) + Assignment 4 (solutions derived here; no official solutions yet). Textbook fill-in for the projection geometry.

2.10 LU and QR factorisation (Ch 11)

In one line: Break a hard matrix into easy pieces (triangles, rotations). Then solving Ax = b becomes two quick substitution passes.

Plain-English explanation

Why factor? Triangular systems are easy. In Ux = b (U upper triangular), the last equation has one unknown. Solve it, plug it into the equation above, and repeat. This is back-substitution:

x_i = (b_i − Σ_{j>i} U_ij x_j) / U_ii, which needs every U_ii ≠ 0.

It costs about n² flops. Lower-triangular systems use forward-substitution, also about n².

LU decomposition: A = LU (L lower triangular, U upper triangular).

• It is basically Gaussian elimination with the multipliers saved in L.
• It is not unique. It may not exist (for example, if the top-left entry is 0).
• PLU (A = PLU) always exists. P is a permutation matrix (a row-shuffled identity):
• Left-multiplying by P permutes rows. Right-multiplying permutes columns.
• P is orthogonal: P^(−1) = P^T.
• To solve Ax = b: 1. Factor A = LU (about n³, done once). 2. Solve Ly = b (n²). 3. Solve Ux = y (n²).
• Payoff: with many right-hand sides b_1, b_2, …, you pay n³ once and then only n² each. It is like building a database index once and then querying cheaply.

QR decomposition: A = QR, with Q orthogonal and R upper triangular.

• To solve: Qy = b gives y = Q^T b (n², no real solving). Then solve Rx = y by back-substitution.
• To invert: A^(−1) comes from solving R x_i = Q^T e_i for each column, about n³ in total.
• Picture: Q is a rotation that lines up the coordinate system with A's columns. R records how each column is built from the ones before it.
• QR is the numerically stable way to do least squares. The normal equations become R x = Q^T b, which avoids forming A^T A.

2×2 general formulas (Assignment 5 Q1–Q2), for a ≠ 0

LU: [[a, b], [c, d]] = [[1, 0], [x, 1]]·[[u, v], [0, w]].

1. Multiply out the right side: [[u, v], [xu, xv + w]].
2. Match entries: u = a, v = b, x = c/a, w = d − bc/a.

QR with rotation Q = R(θ):

1. The first column of A must equal u·(cos θ, sin θ).
2. So u = √(a² + c²), cos θ = a/u, sin θ = c/u. Equivalently θ = atan2(c, a). (You could also take u negative and θ shifted by 180°.)
3. Second column: (b, d) = v(cos θ, sin θ) + w(−sin θ, cos θ).
4. So v = (ab + cd)/u and w = (ad − bc)/u.

Worked examples

(1) Back-substitution (slide): [[2, 4, 5], [0, 3, −1], [0, 0, 1]]·x = (−1, −4, 1).

1. x_3 = 1/1 = 1.
2. x_2 = (−4 − (−1)(1))/3 = −3/3 = −1.
3. x_1 = (−1 − 4(−1) − 5(1))/2 = (−1 + 4 − 5)/2 = −1.
4. So x = (−1, −1, 1).

(2) Solve Ax = b with the slide's LU. A = [[1, 3, 2], [2, 7, 3], [4, 13, 10]] = LU, with L = [[1,0,0],[2,1,0],[4,1,1]] and U = [[1,3,2],[0,1,−1],[0,0,3]]. Take b = (6, 12, 27).

1. Forward: y_1 = 6, y_2 = 12 − 2·6 = 0, y_3 = 27 − 4·6 − 1·0 = 3. So y = (6, 0, 3).
2. Back: x_3 = 3/3 = 1, x_2 = 0 − (−1)(1) = 1, x_1 = 6 − 3·1 − 2·1 = 1.
3. So x = (1, 1, 1). Check: row 1 gives 1 + 3 + 2 = 6 ✓.

(3) Assignment 5 Q1 check with [[1, 2], [3, 4]].

1. x = 3/1 = 3, u = 1, v = 2, w = 4 − 2·3/1 = −2.
2. Check: [[1,0],[3,1]]·[[1,2],[0,−2]] = [[1, 2], [3, 6 − 2]] = [[1, 2], [3, 4]] ✓.

(4) QR of the same matrix.

1. u = √(1 + 9) = √10 ≈ 3.162, and θ = atan2(3, 1) ≈ 71.57°.
2. v = (1·2 + 3·4)/√10 = 14/√10 ≈ 4.427.
3. w = (1·4 − 2·3)/√10 = −2/√10 ≈ −0.632.
4. Multiplying back gives [[1, 2], [3, 4]] ✓.

Why it matters in ML/AI

• numpy.linalg.solve and lstsq call LU or QR under the hood. Knowing this explains their speed and stability.
• The many-right-hand-sides trick appears in Gaussian processes, Kalman filters and second-order optimisers.
• QR (Gram-Schmidt) is used to orthogonalise weight matrices and in some optimisers that re-orthogonalise updates.

Exam traps

• Back-substitution needs non-zero diagonal entries U_ii.
• LU is not unique and may not exist. PLU always exists.
• Solve-cost summary: factorisation ≈ n³, each triangular solve ≈ n², orthogonal solve (Q^T b) ≈ n². Examiners like "which is cheaper" questions.
• Left vs right multiplication by a permutation: left moves rows, right moves columns.
• In the 2×2 QR, w = det(A)/u. A quick check: det(A) = det(Q)det(R) = 1·u·w.

Blog angle: "Why your solver never inverts a matrix: LU, QR and the art of solving Ax = b."

• Triangular systems are dominoes: solve one, and the next falls.
• Factor once, solve many times: the database-index analogy.
• QR as "rotate to make it triangular", and why it is the stable route to regression.

Source tag: Course slides (Ch 11) + Assignment 5 Q1–Q2 (solutions derived here and verified numerically).

2.11 Singular value decomposition (SVD) (Ch 12)

In one line: Every matrix, whatever its shape, is "rotate, then stretch along the axes, then rotate again". The stretch factors (singular values) tell you everything important about it.

Plain-English explanation

The decomposition: A = U Σ V^T, where A is m×n.

• U (m×m) and V (n×n) are orthogonal.
• Σ (m×n) is zero except for the top-left block Σ_1 = Diag(σ_1, …, σ_r).
• The σ_i > 0 are the singular values, sorted σ_1 ≥ σ_2 ≥ … ≥ σ_r.
• It always exists, for every matrix.

3Blue1Brown picture. To compute b = Ax = U Σ V^T x:

1. V^T x: rotate (or reflect) x in the input space R^n.
2. Σ(…): stretch each axis by σ_i. Drop some coordinates (σ = 0), or pad with zeros if m > n. Now you are in R^m.
3. U(…): rotate in the output space R^m.

So a matrix maps the unit circle to an ellipse. The σ_i are the semi-axis lengths of that ellipse, the columns of V are the input directions that map onto the axes, and the columns of U are the axis directions.

Rank:

• rank(A) = r = the number of non-zero singular values, and r ≤ min(m, n).
• Plain English: the number of independent directions A can actually output.

Inverse: if A is square and full-rank, A^(−1) = V Σ^(−1) U^T, i.e. un-rotate, un-stretch (1/σ_i), un-rotate.

Compact (economic) SVD: A = U_1 Σ_1 V_1^T keeps only the r non-zero σ's.

• U_1 (m×r) and V_1 (n×r) have orthonormal columns, but they are not square, so they are not "orthogonal matrices".

Uniqueness:

• The singular values are unique.
• U and V are not. For example, (−U)Σ(−V)^T also works.
• The identity has infinitely many SVDs: I = U I U^T for any orthogonal U.

Rank-one expansion (outer-product view of multiplication):

A = σ_1 u_1 v_1^T + σ_2 u_2 v_2^T + … + σ_r u_r v_r^T

• Each term is a rank-1 "layer". For an image, each term is a simple striped pattern, and the image is the sum of these patterns.
• Because σ's are sorted, later terms matter less. Keep the first k for a rank-k approximation. This is the optimal rank-k approximation (the Eckart-Young theorem, textbook fill-in).
• Storage for rank-k of an m×n matrix: m·k + k + k·n numbers (the U columns, the σ's, the V columns) versus m·n.

Classic examples:

• The all-ones n×n matrix 11^T = z·n·z^T with z = 1/√n. Rank 1, σ_1 = n.
• A rank-1 matrix xy^T has compact SVD (x/||x||)·(||x|| ||y||)·(y/||y||)^T. So σ_1 = ||x|| ||y||.
• SVD of A^T: A^T = V Σ^T U^T. Same non-zero σ's, so rank(A) = rank(A^T) (Assignment 5 Q4b).
• A·V = U Σ (multiply A = UΣV^T on the right by V). Its SVD is U Σ I^T.
• A·V² = U Σ V. Since V^T is also orthogonal, this is an SVD with right factor (V^T)^T, so the singular values are unchanged.

Worked examples

(1) Assignment 5 Q3: A = [[1, 4, 2], [2, 8, 4], [−1, −4, −2]].

1. Every row is a multiple of (1, 4, 2): row 2 = 2× row 1 and row 3 = −1× row 1. So A = x y^T with x = (1, 2, −1) and y = (1, 4, 2).
2. ||x|| = √(1 + 4 + 1) = √6 and ||y|| = √(1 + 16 + 4) = √21.
3. Compact SVD: A = u_1 σ_1 v_1^T with u_1 = (1, 2, −1)/√6, σ_1 = √6·√21 = √126 = 3√14 ≈ 11.225, and v_1 = (1, 4, 2)/√21.
4. Rank = 1. numpy confirms the singular values are (11.225, 0, 0).

(2) A small full-rank SVD: A = [[3, 0], [4, 5]].

1. Claimed factors: σ_1 = √45 ≈ 6.708 and σ_2 = √5 ≈ 2.236, with v_1 = (1, 1)/√2, v_2 = (1, −1)/√2, u_1 = (1, 3)/√10, u_2 = (3, −1)/√10.
2. Check Av_1 = (3, 9)/√2. Its length is √90/√2 = √45 = σ_1 ✓, and its direction is (1, 3)/√10 = u_1 ✓.
3. Check Av_2 = (3, −1)/√2. Its length is √10/√2 = √5 = σ_2 ✓.
4. Sanity check: ||A||_F² = 9 + 0 + 16 + 25 = 50 = σ_1² + σ_2² = 45 + 5 ✓. In general ||A||_F² = Σ σ_i².
5. Best rank-1 approximation: σ_1 u_1 v_1^T = [[1.5, 1.5], [4.5, 4.5]]. Its Frobenius error is exactly σ_2 = √5 ≈ 2.236.
6. (How to find these by hand uses eigenvalues of A^T A = [[25, 20], [20, 25]], which come later in the course.)

(3) Image compression (slide). A 402×600 image has 241,200 pixels.

(4) Assignment 5 Q5: A = uv^T + xy^T, with no zero entries.

• rank 0 (A = 0): happens iff xy^T = −uv^T, i.e. x = αu and y = −v/α for some α ≠ 0.
• rank ≤ 1: happens iff x ∥ u or y ∥ v. Write x = αu; then A = u(v + αy)^T. So rank = 1 iff (x ∥ u or y ∥ v) and A ≠ 0.
• Otherwise the rank is 2. Checked numerically: x = 2u gives rank 1, a cancelling choice gives rank 0, and random vectors give rank 2.

Why it matters in ML/AI

• PCA: centre the data matrix and take its SVD. The top right-singular vectors are the principal directions, and σ_i²/(m − 1) are the explained variances.
• Embeddings / LSA: the SVD of a word-document or co-occurrence matrix gives dense word vectors, the precursor to word2vec.
• LoRA: a fine-tuning update ΔW = BA is constrained to low rank r. It is the rank-k approximation idea used as a training trick. Model compression truncates the SVD of weight matrices.
• Recommenders: Netflix-prize matrix factorisation is a low-rank approximation of the user × item matrix.
• The condition number σ_1/σ_n says how numerically fragile solving Ax = b is.

Exam traps

• rank = the number of non-zero σ's. For a rank-1 xy^T, σ_1 = ||x|| ||y||. Normalise x and y to unit vectors for U and V.
• Singular values are non-negative. Push any sign into U or V.
• In the compact SVD, U_1 and V_1 have orthonormal columns but are not orthogonal matrices unless square.
• SVD is not unique (signs, and any rotation within repeated σ's). The σ's themselves are unique.
• (AV) means you multiply on the right, so the V^T cancels: AV = UΣ.
• Rank-k storage: don't forget the k singular values in the middle term.

Blog angle: "Every matrix is rotate–stretch–rotate: the SVD, from JPEG-style compression to LoRA."

• The circle-to-ellipse picture: what σ's, U and V mean geometrically.
• An image as a sum of rank-1 layers. Keep the top k and you have compressed it.
• LoRA, PCA and recommenders are three faces of the same low-rank idea.

Source tag: Course slides (Ch 12) + Assignment 5 Q3–Q5 (solutions derived here and verified numerically). Textbook fill-in: Eckart-Young theorem, ||A||_F² = Σσ², PCA link.

2.12 Live sessions 17 Oct & 18 Oct 2026

Not covered, because no material is available. No AI outline or slides exist for these sessions yet. Judging by the pattern of earlier sessions (one concept session and one assignment-discussion session per weekend), they probably covered Assignment 4 (linear functions, least squares, orthogonal matrices) and/or LU/QR/SVD. Watch the recordings when the portal is back up (after 25 Oct).

3. Formula / cheat sheet

4. Assignment-pattern analysis

What has been set so far

Patterns

• Proofs vs numericals vs conceptual: roughly 45% short proofs/derivations, 30% symbolic computation, 25% small numericals or true/false-with-reason. Numbers are always tiny (2×2, 3×3, or vectors like (1, 3)). The instructor tests structure, not arithmetic stamina.
• Favourite proof toolkit (most proofs use one of these): 1. Expand ‖u ± v‖² = ‖u‖² ± 2uᵀv + ‖v‖². 2. Look at the (i, j) entry. 3. Use the triangle inequality on a clever split such as u = (u − v) + v. 4. Use the ε-trick 2aᵀb ≤ ε‖a‖² + ‖b‖²/ε. 5. Set a derivative or gradient to zero.
• Iff and "for all" questions recur. You must show both directions and argue in general, not with an example.
• The "find the parameter" style: find α so that A is orthogonal (answer: α = ±1/2), find θ, u, v, w in a factorisation, find α, v in a decomposition. Approach: write the unknowns, match entries, solve the small system.
• Difficulty: each question is 1–2 marks and 5–15 minutes if you know the trick. The hardest items are inequality proofs (A3 Q5, whose official solution is missing; see the question bank's long answers) and the rank-of-a-sum reasoning (A5 Q5).
• Live sessions walk through exactly these problems and emphasise common errors: squaring inequalities, "for all" vs one example, which field.

What the next exam (quiz / online end-sem, 55%) will probably look like

• Format guess (not stated in the material): online, so expect MCQs and numeric-entry questions modelled on assignment problems. Possibly 1–2 short derivations.
• Likely content:
• Validity and shape checks.
• Subspace yes/no (with the field twist).
• Matrix-product properties (AB ≠ BA, transposes, trace, nilpotent and permutation powers).
• Norm and inner-product identities (parallelogram, polarisation, projection coefficient, Cauchy-Schwarz equality case).
• Linearity tests and finding a.
• Inverses and orthogonality (2×2 inverse, α for orthogonality, preserved lengths).
• Least-squares normal equations and a tiny line fit.
• Flop counts (2n², 2n³, n²).
• LU/QR of 2×2, back-substitution.
• SVD of rank-1 matrices, rank from singular values, rank-k storage.
• Likely new material before the end-sem: fundamental subspaces, linear independence, bases, eigenvalues (all listed on the intro slide). Expect them to be examined.
• Preparation plan: 1. Redo A2–A5 without notes. 2. Drill the five-tool proof toolkit above. 3. Do the question bank (LA_questions.json) under timed conditions. 4. Memorise the cheat sheet's flop counts and SVD facts.

Notes on sources:

• The PDF of Assignment 5 is headed "EE951 Assignment 4, 17 Oct 2026", although the portal lists it as Assignment 5.
• The Assignment 3 solutions PDF has no solution for Q5. A full model solution is in LA_questions.json → long.
• AI-generated live-session outlines were cross-checked against the slides and solutions, and minor errors were corrected silently.

Prepared for Sarang, 23 Oct 2026. Built from the course's AI-generated lecture outlines (14 lectures, 3 live sessions) and the Assignment 1 PDF. The outlines were cross-checked against Bishop's Pattern Recognition and Machine Learning (PRML) and corrected where they were wrong. Every number in the worked examples was checked with numpy.

How to use this guide:

• Read sections 1 to 13 in order. Each one builds on the one before.
• For each section, read In one line, then the Worked example. Do the example yourself on paper before you read the steps.
• Go over the Exam traps the night before the exam.
• Use the cheat sheet (section 14) and the question bank (ML_questions.json) for revision.

0. Course at a glance

Instructor and references

• Instructor: Dr. Sayak Ray Chowdhury.
• Assignment queries: a TA. The email address is in the Assignment 1 PDF.
• Main textbook: Bishop, Pattern Recognition and Machine Learning. The lectures cite PRML Ch 1.1, 2, 3.1, 4.1 and Appendix B.
• Other references: the scikit-learn documentation (practical intuition) and Gilbert Strang, Linear Algebra.

Evaluation scheme (from the live sessions of 26 Sep and 10 Oct)

• Grading is relative, not absolute.
• The instructor said the exams will be about 80% conceptual / MCQ and 20% short derivations or calculations. He said exams test understanding and logical derivation, not memorised formulas.
• Assignment 1 is ridge regression on the California Housing data. It is worth 10 marks and is due 31 Oct 2026, 23:59 IST.

Week-by-week map

The material gives no dates for each week. This order is inferred from the lecture numbering. The course runs for 11 weeks of lectures in total.

The story of the course

Machine learning means choosing a function from data instead of writing it by hand. To do that, you first turn each example into a vector (linear algebra). Then you write down a loss, a number that says how wrong a candidate function is. Then you minimise the loss, either by setting its gradient to zero or by walking downhill with gradient descent (calculus). Because data is noisy, you describe uncertainty with probability.

With these tools:

• Regression fits a line by least squares. Ridge and lasso stop it from going wild.
• Classification keeps the same linear score w^T x but changes the loss. The loss now cares about the sign and the margin. The sigmoid and softmax turn the score into probabilities.
• Clustering removes the labels altogether. K-means finds groups by repeating two steps: "assign to the nearest centre" and "move each centre to the mean".

Every algorithm has the same three parts: model, loss, optimiser. Only the details change.

1. What machine learning is (Introduction Part 1)

In one line: ML is learning a function y = F(x) from examples instead of hand-coding the rules.

Plain-English explanation

• Traditional software: a person writes the rules, and the program applies them to inputs. ML: you give examples of (input, correct output), and the algorithm finds the rules.
• ML pays off when rules are too hard to write. Examples: handwriting, speech, driving, spam filtering, recommendations.
• Features x: the inputs, written as a vector of D numbers. For a house: area, age, distance to the metro.
• Label y: the answer. It is a real number in regression (price) or a category in classification (spam / not spam).
• Parameters: the knobs of F that are learned from data, for example the weights w in y = w^T x.
• Three families:
• Supervised: you have both x and y. Covers regression and classification.
• Unsupervised: you have only x and look for structure. Examples: clustering, and language-model pre-training on raw text.
• Reinforcement learning: an agent acts, gets a reward, and improves. Examples: chess, robot navigation.
• Regression vs classification: a continuous output (price, temperature) vs a discrete output (cat/dog).
• Training set vs test set: you learn on the training set. You report performance on the test set, which the model has never seen.

Worked example A logistics firm wants to predict delivery delay in minutes from distance (km) and number of stops.

• Feature vector for one order: x = [12, 4]. Label: y = 35 minutes. This is regression.
• Suppose the target were "late (1) or on time (0)". The same x would then be a classification problem.
• Suppose you only had x for 10,000 orders and wanted to find natural "route types". That is clustering, which is unsupervised.

Why it matters in ML/AI: every model you will meet, up to LLMs, is an F with parameters learned by minimising a loss. LLM pre-training is (self-)supervised next-token prediction on unlabelled text. RLHF is reinforcement learning.

Exam traps

• "Learns from labelled data" means supervised. "Discovers structure without labels" means unsupervised. Do not swap them.
• Predicting a number is regression, even if the number is an integer, such as a house price in lakhs.
• Parameters are learned. Hyperparameters are set before training. This is covered in section 2.

Blog angle: "Stop writing rules: the one-paragraph mental model of machine learning for engineers."

• Software 1.0 is rules plus data giving answers. ML is data plus answers giving rules.
• Every ML system is model + loss + optimiser.
• How to decide whether a problem is regression, classification or clustering, with logistics examples.

Source tag: AI outline (L01) + textbook fill-in (PRML Ch 1.1).

2. Evaluating models and tuning hyperparameters (Introduction Part 2 + live sessions 26 Sep, 3 Oct, 10 Oct)

In one line: pick a metric that matches what a mistake costs you, tune knobs on a validation set, and touch the test set only once.

Plain-English explanation

Classification: the confusion matrix. Rows are the true class and columns are the predicted class.

• Accuracy = (TP + TN) / total. It misleads when one class is rare.
• Precision = TP / (TP + FP). Of everything I flagged, how much was real? Precision matters when false alarms are costly. Examples: a spam filter that might bin a real email, or a fraud system that blocks good customers.
• Recall (sensitivity) = TP / (TP + FN). Of everything real, how much did I catch? Recall matters when misses are costly. Examples: cancer screening and search engines. Missing a tumour is far worse than ordering one extra test.
• F1 = 2PR / (P + R). This is the harmonic mean, which is pulled towards the smaller value. If either P or R is 0, then F1 is 0.
• Multi-class: compute P and R for each class, one-vs-rest.

Regression metrics.

• MSE = (1/N) Σ (y_i − ŷ_i)². It is smooth and differentiable, which leads to clean linear equations. It is very sensitive to outliers, because squaring makes big errors huge.
• MAE = (1/N) Σ |y_i − ŷ_i|. It is less sensitive to outliers.
• Median absolute error is the most robust of the three when outliers are present.

Parameters vs hyperparameters.

• Parameters (w) are learned by training.
• Hyperparameters are chosen by you before training. Examples: the polynomial degree, the regularisation λ, the learning rate η, and K in k-means.

The tuning workflow.

1. Split the data into train / validation / test sets.
2. For each hyperparameter value, train on the train set and score on the validation set.
3. Pick the value with the best validation score.
4. Retrain on train + validation if you wish. Then report the test score once.

K-fold cross-validation does the validation step K times, each time on a different fold, and averages the scores. This gives a more reliable estimate than a single split. Grid search over λ usually uses a log scale, such as 10^-3 … 10^3.

Worked example 1: a rare-disease screen on 1,000 patients TP = 40, FP = 10, FN = 20, TN = 930. That is 60 actual positives.

• Accuracy = (40 + 930) / 1000 = 0.97
• Precision = 40 / (40 + 10) = 0.80
• Recall = 40 / (40 + 20) = 0.667
• F1 = 2(0.8)(0.667) / (0.8 + 0.667) = 0.727
• A "dumb" model that predicts negative for everyone gets TN = 940 and accuracy 0.94, but its recall is 0. This is why accuracy alone misleads on imbalanced data.

Worked example 2: MSE vs MAE and an outlier y = [3, 5, 2, 8] and ŷ = [2.5, 5, 4, 7].

• The errors are 0.5, 0, −2, 1.
• Squared errors: 0.25, 0, 4, 1. Sum = 5.25, so MSE = 1.3125.
• Absolute errors: 0.5, 0, 2, 1. Sum = 3.5, so MAE = 0.875.
• Now change the last prediction to 18, so that error becomes −10.
• MSE jumps to (0.25 + 0 + 4 + 100) / 4 = 26.06, about 20 times larger.
• MAE only rises to (0.5 + 0 + 2 + 10) / 4 = 3.125, about 3.6 times larger.

Why it matters in ML/AI: choosing a metric is a product decision. Fraud models, content moderation and LLM evaluations all trade precision against recall. Validation discipline (never tune on test) is what separates real results from leaderboard overfitting.

Exam traps

• Mixing up FP and FN. FP means predicted positive but actually negative.
• "Medical screening" usually means recall, not precision. Some course notes get this backwards. Reason from the cost of a miss.
• F1 uses the harmonic mean, not the arithmetic mean. With P = 0.5 and R = 1.0, F1 = 0.667, not 0.75.
• Tuning λ on the test set is cheating. The validation set exists for tuning.
• MSE is the loss of choice because it is differentiable and gives a closed-form solution, not because it is the most robust.

Blog angle: "99% accurate and completely useless: choosing the right metric."

• The all-negative classifier that scores 94% accuracy.
• Precision vs recall as "false-alarm cost vs miss cost", with fraud and screening examples.
• Train / validation / test as the "staging vs prod" of ML.

Source tag: AI outline (L02) + live-session outlines (26 Sep, 3 Oct, 10 Oct). The precision/recall use-cases were corrected against standard texts.

3. Linear algebra for ML (Math Basics Part 1 + live session 26 Sep)

In one line: data points are vectors. Similarity is a dot product, distance is a norm, and a matrix is a machine that transforms vectors.

Plain-English explanation

• Dataset notation: {(x_i, y_i)} for i = 1..N. Each x_i is a column vector in R^D and each y_i is a scalar.
• Centroid (mean vector): x̄ = (1/N) Σ x_i. Average each coordinate separately.
• Dot product: a^T b = Σ a_j b_j, which is a single number. Geometrically, a^T b = ||a|| ||b|| cos θ. It is large when the vectors point the same way and are long.
• Norms (the "length" of a vector):
• L2 (Euclidean): ||a||_2 = sqrt(a^T a).
• L1 (Manhattan): ||a||_1 = Σ |a_j|. Think of city blocks.
• L0 counts the non-zero entries. It is not a true norm. It is the "sparsity" that lasso tries to approximate.
• Distances:
• ||a − b||_2 and ||a − b||_1.
• A useful expansion: ||a − b||² = ||a||² + ||b||² − 2 a^T b.
• Weighted distance: sqrt((a − b)^T M (a − b)). With M = Σ^-1 this is the Mahalanobis distance.
• Cosine similarity: cos θ = a^T b / (||a|| ||b||). It lies in [−1, 1], where 1 means the same direction, 0 means perpendicular and −1 means opposite. It ignores length. For unit vectors, ||a − b||² = 2 − 2 cos θ, so high cosine similarity means small distance.
• Outer product: a b^T is an m × n matrix. Compare the inner product a^T b, which is 1 × 1.
• Covariance matrix: Σ = (1/N) Σ (x_i − x̄)(x_i − x̄)^T. It is D × D and symmetric. Entry (j, k) says how features j and k move together, and the diagonal holds the variances. You must subtract the mean. Without centering you get the second-moment matrix, not the covariance.
• Matrix–vector product: Ax. Entry i is (row i of A) · x. Equivalently, Ax is a linear combination of the columns of A, with weights x.
• Eigenvectors: Av = λv. The matrix only stretches v, by the factor λ, without turning it. You find λ from det(A − λI) = 0.
• Useful facts:
• trace(A) = Σ λ_i and det(A) = Π λ_i.
• A is invertible ⇔ det ≠ 0 ⇔ no eigenvalue equals 0 ⇔ full rank.
• Rank = the number of linearly independent rows or columns.

Software analogy: a vector is a fixed-schema row, like [distance_km, stops, weight_kg]. A matrix is a batch transform. Eigenvectors are the input directions that the transform leaves pointing the same way.

Worked example 1: vectors a = [3, 4] and b = [4, 3].

• a^T b = 3·4 + 4·3 = 24
• ||a||_2 = sqrt(9 + 16) = 5, and likewise ||b||_2 = 5.
• cos θ = 24 / (5 · 5) = 0.96, so they point in very similar directions.
• L1 distance = |3 − 4| + |4 − 3| = 2. L2 distance = sqrt(1 + 1) = 1.414.
• Outer product a b^T = [[3·4, 3·3], [4·4, 4·3]] = [[12, 9], [16, 12]]

Worked example 2: eigenvalues of A = [[2, 1], [1, 2]]

• det(A − λI) = (2 − λ)² − 1 = 0, so 2 − λ = ±1, which gives λ = 1 or 3.
• Check: the sum of eigenvalues is 4 = trace (2 + 2), and the product is 3 = det (4 − 1). Both are correct.
• Eigenvectors: for λ = 3, v = [1, 1], since A[1, 1] = [3, 3]. For λ = 1, v = [1, −1], since A[1, −1] = [1, −1].
• Both eigenvalues are non-zero, so A is invertible.

Worked example 3: covariance of 3 points (2, 1), (4, 3), (6, 2)

• Mean x̄ = (12/3, 6/3) = (4, 2).
• Centered points: (−2, −1), (0, 1), (2, 0).
• Their outer products:
• (−2, −1): [[4, 2], [2, 1]]
• (0, 1): [[0, 0], [0, 1]]
• (2, 0): [[4, 0], [0, 0]]
• Sum = [[8, 2], [2, 2]]. Divide by 3 to get Σ = [[2.667, 0.667], [0.667, 0.667]]
• Feature 1 varies more (2.667 vs 0.667). The positive off-diagonal says the two features tend to rise together.

Why it matters in ML/AI

• Dot product: a linear model's score w^T x, and transformer attention (q^T k).
• Cosine similarity: embedding search and RAG retrieval.
• Covariance and its eigenvectors: PCA, which comes in Assignment 2.
• Eigenvalues: whether X^T X is invertible, which is the whole reason ridge regression exists (section 8).

Exam traps

• a^T b is a scalar but a b^T is a matrix. Check the dimensions: (1 × D)(D × 1) = 1 × 1.
• Covariance needs mean-centering.
• Cosine similarity ignores magnitude: [1, 1] and [10, 10] have cosine 1.
• The L1 norm is a sum of absolute values. It is not sqrt(Σ |x|).
• det = product of eigenvalues, trace = sum. Do not swap them.
• A 1 × D row vector times a D × D matrix gives a 1 × D row vector.

Blog angle: "The dot product is all you need: from cosine similarity to attention."

• One operation measures alignment, and that drives search, recommendations and attention.
• Why cosine beats Euclidean distance for embeddings.
• Eigenvectors explained as "directions a transform does not rotate".

Source tag: AI outline (L03) + live session 26 Sep. The covariance formula was corrected (centering added) using PRML Appendix C.

4. Multivariate calculus and optimisation (Math Basics Part 2)

In one line: the gradient is a vector that points uphill. Set it to zero to find the bottom of a convex bowl, or step against it to walk down.

Plain-English explanation

• Training means: find the w that minimises a loss F(w), where w is a vector.
• Gradient: ∇F = [∂F/∂w_1, …, ∂F/∂w_D]. It has the same shape as w. Each entry says how F changes if you nudge that one weight. The gradient points in the direction of steepest increase.
• Hessian: ∇²F, the D × D matrix of second derivatives, H_jk = ∂²F/∂w_j∂w_k. It measures curvature, the "bowl-ness" of F.
• Two identities you must know (both come from writing the sums out by hand): 1. ∇_w (a^T w) = a. Compare the 1-D rule d(aw)/dw = a. 2. ∇_w (w^T A w) = (A + A^T) w. If A is symmetric, this is 2Aw. Compare d(aw²)/dw = 2aw.
• Convex function: a single bowl. Any local minimum is the global minimum, and "set the gradient to zero" finds it. For a twice-differentiable function, convexity ⇔ the Hessian is positive semi-definite everywhere (all eigenvalues ≥ 0).
• Non-convex function: many valleys. Gradient methods can get stuck in a local minimum. Neural-network losses are non-convex.
• First-order optimality condition: at a minimum of a smooth function, ∇F = 0.

Worked example: F(w) = w^T A w with A = [[1, 2], [0, 3]], at w = [1, 2]

• Expand: F = w1² + 2·w1·w2 + 3·w2². The 0 entry contributes nothing.
• At (1, 2): F = 1 + 4 + 12 = 17.
• Partial derivatives:
• ∂F/∂w1 = 2w1 + 2w2 = 6
• ∂F/∂w2 = 2w1 + 6w2 = 14
• Identity check: A + A^T = [[2, 2], [2, 6]], and (A + A^T)w = [2 + 4, 2 + 12] = [6, 14]. It matches. Note that 2Aw = [10, 12] would be wrong, because A is not symmetric.
• Hessian = A + A^T = [[2, 2], [2, 6]]. Its eigenvalues are ≈ 1.17 and 6.83, both positive, so F is convex.

Why it matters in ML/AI: these two identities derive OLS and ridge in one line each (sections 7 and 8). The gradient is what backpropagation computes for every weight in a neural network. Convexity explains why linear and logistic regression always train reliably while deep networks do not come with that guarantee.

Exam traps

• Forgetting the A + A^T when A is not symmetric.
• The gradient of a scalar with respect to a D-vector is a D-vector, and the Hessian is D × D. Check shapes every time.
• "Gradient = 0" guarantees the global minimum only for convex functions. It could also be a maximum or a saddle point.
• Gradient descent moves along minus the gradient. Plus would be ascent.

Blog angle: "Gradients for engineers: the two identities that derive half of machine learning."

• The gradient as "the sensitivity report for every knob".
• Why ∇(w^T A w) = (A + A^T)w, proved in 5 lines.
• Convex vs non-convex: why your regression always converges and your neural network sometimes does not.

Source tag: AI outline (L04) + textbook fill-in (the Hessian convexity test, the symmetric-A pitfall).

5. Probability basics (Math Basics Part 3 + live session 3 Oct)

In one line: probability is a share of outcomes. Joint, marginal and conditional are different ways of slicing one table, and Bayes' rule flips the condition.

Plain-English explanation

• Probability = favourable outcomes / total outcomes, when all outcomes are equally likely.
• Discrete random variable: described by a PMF, P(X = x_i) = p_i, with p_i ≥ 0 and Σ p_i = 1.
• Continuous random variable: described by a PDF f(x) ≥ 0, with ∫ f(x) dx = 1.
• P(X = exactly a) = 0. Probabilities are areas: P(a ≤ X ≤ b) = ∫_a^b f(x) dx.
• A PDF value can be greater than 1. It is a density, not a probability.
• CDF: F(x) = P(X ≤ x). It rises from 0 to 1. For a continuous variable, F(x) = ∫_{−∞}^x f(t) dt.
• Joint: P(X = x, Y = y), one cell of a table.
• Marginal (sum rule): P(X = x) = Σ_y P(X = x, Y = y), a row total.
• Conditional: P(Y = y | X = x) = P(X = x, Y = y) / P(X = x). "Zoom into one row and renormalise."
• Product rule: P(X, Y) = P(Y | X) P(X) = P(X | Y) P(Y).
• Bayes' rule: P(Y | X) = P(X | Y) P(Y) / P(X), where P(X) = Σ_y P(X | y) P(y).
• P(Y) is the prior, P(X | Y) is the likelihood, and P(Y | X) is the posterior.
• Independence: P(X, Y) = P(X) P(Y). Equivalently, P(X | Y) = P(X): knowing Y tells you nothing about X.

Worked example 1: the 24 balls (colour × number)

• Marginals: P(Blue) = 4/24 = 1/6, P(Red) = 14/24 = 7/12, P(number = 1) = 4/24 = 1/6.
• Joint: P(Blue, 1) = 1/24.
• Conditional: P(1 | Blue) = 1/4 = 0.25. Zoom into the Blue row: there are 4 blue balls and one of them is a "1".
• Independence test: P(Blue)·P(1) = 1/36 ≈ 0.028, but P(Blue, 1) = 1/24 ≈ 0.042. They differ, so colour and number are not independent.
• Conditioning is not symmetric: P(Red | 3) = 3/4 = 0.75, but P(3 | Red) = 3/14 ≈ 0.214.

Worked example 2: Bayes on a medical test

• The disease has prior 1%. The test catches 90% of the sick (P(+ | D) = 0.9). Its false-positive rate is 5% (P(+ | no D) = 0.05).
• P(+) = 0.9 × 0.01 + 0.05 × 0.99 = 0.009 + 0.0495 = 0.0585
• P(D | +) = 0.009 / 0.0585 = 0.154
• So a positive result means only about a 15% chance of disease. The prior matters a lot.

Why it matters in ML/AI: classifiers output P(y | x), a conditional probability. Bayes' rule is the basis of Naive Bayes spam filters and of Bayesian ML. Product and sum rules let you factor complex models. LLMs are chains of conditionals: P(token_t | previous tokens).

Exam traps

• P(A | B) ≠ P(B | A). This is the "prosecutor's fallacy".
• A PDF value is not a probability and can exceed 1.
• Independence needs P(X, Y) = P(X)P(Y) for every cell, not just one.
• Marginalising means summing over the other variable. Do not multiply.
• For a continuous variable, P(X = a) = 0.

Blog angle: "A 15% chance after a 90%-accurate test: Bayes' rule for builders."

• Joint, marginal and conditional explained with a single pivot table.
• Why base rates dominate alerts (monitoring and fraud alarms).
• Every classifier is secretly estimating P(y | x).

Source tag: AI outline (L05) + live session 3 Oct. The ball table was constructed to match the outline's counts (Red 14, Blue 4, four balls per number).

6. Expectation, variance, covariance and the Gaussian (Math Basics Part 4 + live session 10 Oct)

In one line: expectation is the long-run average, variance is the typical squared wobble around it, and the Gaussian is the bell curve described by those two numbers.

Plain-English explanation

• Expectation:
• Discrete: E[X] = Σ x_i p_i. Continuous: E[X] = ∫ x f(x) dx.
• E[g(X)] = Σ g(x_i) p_i.
• Linear: E[αX + βY] = αE[X] + βE[Y]. This holds always, even when X and Y are dependent.
• E[XY] = E[X]E[Y] only if X and Y are independent (strictly, uncorrelated).
• Variance: Var(X) = E[(X − E[X])²] = E[X²] − (E[X])².
• Var(aX + b) = a² Var(X). Adding a constant does not change the spread.
• Covariance: Cov(X, Y) = E[(X − E X)(Y − E Y)]. Note that Cov(X, X) = Var(X).
• Correlation: ρ = Cov(X, Y) / sqrt(Var X · Var Y). It always lies in [−1, 1], a consequence of the Cauchy–Schwarz inequality. ρ = ±1 means a perfectly linear relationship.
• Bernoulli(p): X ∈ {0, 1} with P(X = 1) = p. Then E[X] = p and Var(X) = p(1 − p).
• Gaussian N(μ, σ²): f(x) = (1 / sqrt(2πσ²)) · exp(−(x − μ)² / (2σ²)).
• Mean μ and variance σ². A larger σ gives a flatter, wider curve.
• Multivariate Gaussian N(μ, Σ): f(x) = (2π)^(−D/2) · det(Σ)^(−1/2) · exp(−½ (x − μ)^T Σ^-1 (x − μ)).
• The quadratic form (x − μ)^T Σ^-1 (x − μ) is a scalar, the squared Mahalanobis distance.

Worked example 1: a discrete distribution X ∈ {0, 1, 2} with probabilities 0.2, 0.5, 0.3. For instance, the number of failed deliveries on a route.

• E[X] = 0(0.2) + 1(0.5) + 2(0.3) = 1.1
• E[X²] = 0 + 1(0.5) + 4(0.3) = 1.7
• Var(X) = 1.7 − 1.1² = 1.7 − 1.21 = 0.49, so the standard deviation is 0.7.
• Var(2X + 3) = 4 × 0.49 = 1.96

Worked example 2: a 2-D Gaussian density μ = [0, 0], Σ = diag(1, 4), x = [1, 2].

• Σ^-1 = diag(1, 0.25). The quadratic form = 1²·1 + 2²·0.25 = 2.
• det Σ = 4, so the normaliser = 1 / (2π · sqrt 4) = 1 / (4π).
• f(x) = e^(−1) / (4π) = 0.0293
• Note that the point is 2 units out on the second axis, but that axis has variance 4. So it counts as "1 standard deviation" away, the same as the 1 unit on the first axis.

Worked example 3: correlation of the points (1, 2), (2, 4), (3, 5)

• E[X] = 2 and E[Y] = 11/3 ≈ 3.667.
• Cov = (1/3)[(−1)(−1.667) + 0 + (1)(1.333)] = 1.0
• Var X = 2/3 ≈ 0.667 and Var Y ≈ 1.556.
• ρ = 1 / sqrt(0.667 × 1.556) = 0.982, almost perfectly linear.

Why it matters in ML/AI: least squares is exactly maximum likelihood under Gaussian noise (PRML 3.1.1). That is why squared error is everywhere. Bernoulli is the probability model behind logistic regression. Covariance matrices drive PCA and Gaussian mixtures.

Exam traps

• Var(X) = E[X²] − (E[X])². Do not write E[X²] − E[X].
• Var(aX + b) = a² Var(X), not a·Var(X).
• E[XY] = E[X]E[Y] needs independence. Linearity of expectation does not.
• Zero covariance does not imply independence. The classic counterexample is Y = X² with X symmetric around 0.
• Bernoulli variance p(1 − p) is largest at p = 0.5.
• The Gaussian peak height 1 / sqrt(2πσ²) can exceed 1 when σ is small.

Blog angle: "Why squared error? The Gaussian hiding inside every linear regression."

• Mean and variance as "SLA target and jitter".
• Maximising a Gaussian likelihood is the same as minimising squared error, with a 3-line derivation.
• Correlation vs dependence: the Y = X² trap.

Source tag: AI outline (L06) + live session 10 Oct (correlation, Cauchy–Schwarz) + textbook (PRML Ch 2, Appendix B).

7. Linear regression and ordinary least squares (Regression Part 1)

In one line: fit the line that makes the total squared vertical error as small as possible. Calculus gives a one-shot formula for it.

Plain-English explanation

• Model: ŷ = w^T x = w_1 x_1 + … + w_D x_D.
• Bias trick: to include an intercept c, append a constant 1 to every x and append c to w: x' = [x, 1] and w' = [w, c]. Now ŷ = w'^T x' with no separate intercept term. (The assignment puts the 1 first. The position does not matter, as long as you are consistent.)
• Design matrix: X (N × D) has row i equal to x_i^T. Stack the labels into the vector y (N × 1). Then the predictions are Xw.
• Loss (sum of squared errors): L(w) = Σ (y_i − x_i^T w)² = ||y − Xw||².
• Derivation (use the section 4 identities): 1. Expand: L = y^T y − 2 w^T X^T y + w^T X^T X w. 2. Take the gradient: ∇L = −2 X^T y + 2 X^T X w. 3. Set it to 0 to get the normal equations: X^T X w = X^T y. 4. Solve: w* = (X^T X)^-1 X^T y. In sum form, this is (Σ x_i x_i^T)^-1 (Σ x_i y_i).
• L is convex, because its Hessian 2 X^T X is positive semi-definite. So this w* is the global minimum.
• Geometry: Xw* is the projection of y onto the column space of X. The residual r = y − Xw* is orthogonal to every column: X^T r = 0.

Worked example: fit y = c + m·x to (1, 2), (2, 3), (3, 5), (4, 6)

• Design matrix with a ones column: X = [[1, 1], [1, 2], [1, 3], [1, 4]], and y = [2, 3, 5, 6].
• X^T X = [[4, 10], [10, 30]]. The entries are [N, Σx], [Σx, Σx²].
• X^T y = [16, 47]. The entries are [Σy, Σxy] = [16, 2 + 6 + 15 + 24].
• det(X^T X) = 4·30 − 10·10 = 20, so (X^T X)^-1 = (1/20)[[30, −10], [−10, 4]].
• w* = (1/20)[30·16 − 10·47, −10·16 + 4·47] = (1/20)[10, 28] = [0.5, 1.4]. So ŷ = 0.5 + 1.4x.
• Predictions: 1.9, 3.3, 4.7, 6.1. Residuals: 0.1, −0.3, 0.3, −0.1. SSE = 0.2.
• Check: X^T r = [0.1 − 0.3 + 0.3 − 0.1, 0.1 − 0.6 + 0.9 − 0.4] = [0, 0]. The residuals are orthogonal to the columns, as the theory says.

Why it matters in ML/AI: OLS is the "hello world" of ML and the baseline for every regression problem. The same normal-equation pattern shows up in Kalman filters and in the closed-form final layer of some models. Assignment 1 is built directly on it.

Exam traps

• The shapes: X is N × D, w is D × 1, and X^T X is D × D, not N × N.
• Forgetting the column of ones means the line is forced through the origin.
• (X^T X)^-1 X^T y is not X^-1 y. X is usually not square.
• "Linear" regression means linear in w. Polynomial features (x, x², x³) are still linear regression.
• The residuals of a model with an intercept sum to zero.

Blog angle: "Least squares from scratch: the formula behind every trend line."

• The loss as "the sum of squared surprises".
• The one-line gradient derivation using two identities.
• Residuals are orthogonal to the features: a picture worth a thousand equations.

Source tag: AI outline (L08) + live session 3 Oct + textbook (PRML 3.1). The orthogonality check was added.

8. Ridge regression and cross-validation (Regression Part 2 + live session 10 Oct)

In one line: add a penalty λ||w||² that charges the model for big weights. This makes the solution stable and always computable.

Plain-English explanation

• Problem 1: X^T X may not be invertible. This happens when D > N, or when features are duplicates or near-duplicates (collinear). Then rank(X^T X) ≤ min(N, D) < D, some eigenvalue is 0, and the inverse does not exist.
• Problem 2: overfitting. When features are nearly collinear, OLS can choose huge, opposite-sign weights that fit the noise.
• Ridge loss: L(w) = ||y − Xw||² + λ ||w||².
• Derivation: 1. The penalty λ w^T w has gradient 2λw. 2. So ∇L = −2X^T y + 2X^T X w + 2λw = 0. 3. This gives w = (X^T X + λI)^-1 X^T y.
• Why it is always invertible: X^T X has eigenvalues ≥ 0. Adding λI adds λ to every eigenvalue (same eigenvectors). With λ > 0, all eigenvalues are now > 0, so the matrix is invertible.
• The role of λ:
• λ = 0 gives OLS.
• λ → ∞ forces w → 0, which underfits.
• λ in between trades training fit against simplicity. This is the bias–variance trade-off.
• Geometry: the contours of the squared loss are ellipses around the OLS solution. The constraint ||w||² ≤ t is a circle. The ridge solution is where the smallest ellipse touches (is tangent to) the circle. That point is usually not on an axis, so ridge shrinks weights but rarely makes them exactly 0.
• Choosing λ: grid search on a log scale, scored by validation error or K-fold cross-validation. Then report the test error once.

Worked example 1: shrinkage in 1-D (no intercept) x = [1, 2, 3], y = [1, 2, 2].

• x^T y = 1 + 4 + 6 = 11 and x^T x = 14, so w(λ) = 11 / (14 + λ).
• λ = 0: w = 0.786 (OLS)
• λ = 1: w = 0.733
• λ = 10: w = 0.458
• As λ grows, the weight shrinks smoothly towards 0.

Worked example 2: fixing a singular X^T X X = [[1, 1], [2, 2]], y = [1, 2]. The two features are identical.

• X^T X = [[5, 5], [5, 5]]. Its eigenvalues are 0 and 10, so it is singular and OLS fails.
• Add I (λ = 1): [[6, 5], [5, 6]] has eigenvalues 1 and 11, so it is invertible.
• X^T y = [5, 5]. By symmetry, w1 = w2 = w, and 6w + 5w = 5 gives w = 5/11 ≈ 0.4545 each.
• Ridge splits the credit equally between the twin features, which is a sensible answer.

Worked example 3: choosing λ with a validation set (practice Long Q2 in the question bank works this fully)

• Train on (0, 1), (1, 3), (2, 2), (3, 5) with an intercept. Validate on (4, 5), (5, 7). The intercept is penalised too, as in the course's formulation.
• Validation SSE: λ = 0 gives 0.41, λ = 1 gives 0.392, λ = 10 gives 8.16.
• So λ = 1 wins. A small penalty helped slightly. A big penalty underfits badly.

Why it matters in ML/AI: ridge is weight decay, the L2 penalty used to train almost every neural network, including LLMs (AdamW). "Add λI to make it invertible" also appears in Gaussian processes, Kalman filters and numerical stabilisation generally.

Exam traps

• Ridge rarely gives exact zeros. That is lasso's job.
• λ = 0 is OLS, and a larger λ means simpler, not more complex.
• The identity I is D × D, matching X^T X, not N × N.
• Adding λI shifts eigenvalues by λ. It does not multiply them.
• λ must be picked on validation data, never on test data.
• Many textbooks do not penalise the intercept. Assignment 1's formula, as written, regularises the full augmented w. Know both conventions and follow the question.

Blog angle: "Ridge regression: the one-line fix that makes a broken matrix invertible."

• Collinear features as "two metrics that always move together": OLS panics and ridge splits the credit.
• The eigenvalue view: +λ on every eigenvalue.
• From ridge to weight decay in LLM training.

Source tag: AI outline (L09) + live session 10 Oct + textbook (PRML 3.1.4). The geometry was corrected from "intersection" to "tangency".

9. Lasso, gradient descent and the D vs N cases (Regression Part 3 + live session 10 Oct)

In one line: an L1 penalty pushes useless weights to exactly zero (automatic feature selection), and gradient descent finds the minimum step by step when a matrix inverse is too expensive.

Plain-English explanation

• Lasso: L(w) = ||y − Xw||² + λ ||w||_1, where ||w||_1 = Σ |w_j|.
• Why lasso gives zeros:
• The L1 constraint region |w1| + |w2| ≤ t is a diamond, with sharp corners on the axes. The loss ellipses usually touch it first at a corner, and a corner means some w_j = 0.
• In 1-D the same thing shows up in the algebra. The penalty's slope is a constant ±λ, even near 0. So once λ outweighs the data's pull, w snaps to 0. Ridge's slope 2λw fades near 0, so w never quite reaches it.
• Trade-off: |w| has a kink at 0, so lasso has no closed form and is harder to optimise. Ridge is smooth and has a closed form.
• Gradient descent (GD):
• Update: w_{t+1} = w_t − η ∇L(w_t).
• It is needed when D is huge: inverting a D × D matrix costs O(D³), while each GD step costs about O(ND).
• Stop after a fixed number of iterations, or when the loss stops changing.
• Learning rate η:
• Too small: slow convergence.
• Too large: oscillates or diverges.
• For a quadratic loss, GD is stable only when η < 2 / (largest eigenvalue of the Hessian).
• Regression as a system of equations: Xw = y has N equations and D unknowns.
• N = D (square, full rank): w = X^-1 y, an exact fit.
• N > D (more data than unknowns, the usual case): there is no exact solution. Use OLS, (X^T X)^-1 X^T y.
• D > N (more unknowns than data): there are infinitely many solutions and X^T X is singular. Use ridge.

Worked example 1: lasso vs ridge in 1-D Same data as section 8: x = [1, 2, 3], y = [1, 2, 2]. The squared loss is 14w² − 22w + 9.

• Ridge: w = 11 / (14 + λ). Lasso (for w > 0): 28w − 22 + λ = 0, so w = (22 − λ) / 28 when λ < 22, and 0 otherwise.

Lasso hits exactly zero. Ridge only gets smaller.

Worked example 2: gradient descent on the same loss ∇L = 28w − 22. Start at w0 = 0.

• η = 0.02:
• w1 = 0 − 0.02(−22) = 0.44
• w2 = 0.44 − 0.02(28·0.44 − 22) = 0.634
• w3 = 0.719
• This steadily approaches the optimum 0.786.
• η = 0.1: w1 = 2.2, w2 = −1.76, w3 = 5.37. It diverges.
• The Hessian is 28, so the stable range is η < 2/28 ≈ 0.071.

Why it matters in ML/AI: gradient descent, in its stochastic and Adam variants, is how every neural network is trained. Learning-rate tuning is the first knob anyone touches. L1 sparsity is used for feature selection, compressed sensing and model pruning. D > N is normal in genomics and in text with huge vocabularies.

Exam traps

• Lasso → sparse (exact zeros). Ridge → small but non-zero weights. The diamond goes with L1 and the circle with L2.
• Lasso has no closed-form solution in general. Ridge does.
• GD subtracts η∇L. "Too large η" means divergence, not just slowness.
• The D vs N cases: D > N means X^T X is singular. Do not say "N > D means singular".
• GD on a convex loss reaches the global minimum, given a suitable η.

Blog angle: "Lasso vs ridge: why a diamond deletes features and a circle does not."

• The diamond-corner picture in one diagram.
• The 1-D algebra where lasso snaps to zero at λ = 22.
• Learning rates: the exact stability bound η < 2/λ_max, with an example that diverges.

Source tag: AI outline (L10) + live session 10 Oct + textbook (PRML 3.1.4, 3.1.3). The 1-D lasso closed form and the η bound were added.

10. Linear classifiers, margins and loss functions (Classification Part 1)

In one line: compute a score w^T x and predict its sign. A good loss rewards a confident and correct sign, not an exact score value.

Plain-English explanation

• Labels are y ∈ {+1, −1}.
• Score: f(x) = w^T x (+ b). Prediction: ŷ = sign(f(x)).
• Decision boundary: w^T x = 0, a line in 2-D or a hyperplane in general. w is perpendicular to the boundary and points towards the +1 side.
• Distance to the boundary: |w^T x + b| / ||w||. The raw score is a scaled distance. A larger |score| means more confidence.
• Margin: m = y · f(x). If m > 0 the prediction is correct, if m < 0 it is wrong, and |m| is the confidence.
• Candidate losses, as functions of the margin m:
• Squared: (y − f)² = (1 − m)², since y² = 1. It is smooth, but it penalises confident correct points (m = 3 gives loss 4). That is bad for classification.
• 0-1: 1 if m ≤ 0, else 0. This is what we actually care about. But it is flat and then jumps, so the gradient is useless and it cannot be optimised directly.
• Hinge: max(0, 1 − m). It is zero once m ≥ 1 and grows linearly for wrong or unconfident points. It is used by the SVM. It is not differentiable at m = 1.
• Logistic: log(1 + e^(−m)). It is smooth, always positive, tends to 0 for large m and is about −m for very negative m. It is used by logistic regression.
• Hinge and logistic are convex surrogates for the 0-1 loss. Hinge is an upper bound on it; logistic is an upper bound only when the log is taken base 2 (with ln, it equals ln 2 ≈ 0.693 at m = 0).

Worked example 1: score and distance w = [1, 1], b = −3, so the boundary is the line x1 + x2 = 3. Point x = (3, 2).

• Score = 3 + 2 − 3 = 2 > 0, so predict +1.
• Distance = |2| / sqrt(1 + 1) = 2 / 1.414 = 1.414.

Worked example 2: the losses side by side

Look at the first row. Squared loss punishes a confidently correct point more than a barely-correct one. That is the main reason not to use squared loss for classification.

Why it matters in ML/AI: "score, then a squashing function, then a margin-based loss" is the blueprint of every classifier, up to neural-network output layers. Hinge loss gives SVMs and logistic loss gives logistic regression. Margins also appear in contrastive and embedding training (triplet loss).

Exam traps

• w is perpendicular (normal) to the boundary, not parallel to it.
• Distance = |score| / ||w||. Do not forget to divide by the norm.
• A negative margin means misclassified, regardless of which class.
• Hinge is zero only when m ≥ 1, not when m ≥ 0.
• The reason 0-1 loss is not used is that it is non-differentiable and non-convex, not that it is "inaccurate".

Blog angle: "Why your classifier should not use squared error: margins explained."

• The table above: squared loss punishing a correct answer.
• Hinge vs logistic as "pass/fail with a buffer" vs "smooth confidence".
• Geometric intuition: w as the arrow pointing at the positive class.

Source tag: AI outline (L12) + textbook (PRML 4.1, 7.1.2).

11. Logistic regression (Classification Part 2)

In one line: squash the score w^T x through a sigmoid to get a probability, then train by minimising the negative log of the probability of the true label.

Plain-English explanation

• Sigmoid: σ(z) = 1 / (1 + e^(−z)). It maps (−∞, ∞) to (0, 1), with σ(0) = 0.5.
• Symmetry: σ(−z) = 1 − σ(z).
• Derivative: σ'(z) = σ(z)(1 − σ(z)), which is at most 0.25, at z = 0.
• The model: P(y = +1 | x) = σ(w^T x) and P(y = −1 | x) = σ(−w^T x). Compactly, for y ∈ {±1}: P(y | x) = σ(y w^T x).
• Where it comes from: assume the log-odds are linear, log[P(+1 | x) / P(−1 | x)] = w^T x. Solving for P(+1 | x) gives exactly σ(w^T x).
• Decision boundary: P(+1 | x) = 0.5 ⇔ w^T x = 0. This is still a linear boundary.
• Loss (negative log-likelihood): −log σ(y w^T x) = log(1 + e^(−y w^T x)). This is exactly the logistic loss from section 10.
• Total loss: L(w) = Σ_i log(1 + exp(−y_i w^T x_i)). It is convex, but it has no closed form, so you use gradient descent.
• Gradient: ∇L = −Σ_i y_i x_i σ(−y_i w^T x_i) = −Σ_i y_i x_i / (1 + exp(y_i w^T x_i)).
• Read it as: each point pushes w towards y_i x_i, weighted by how wrong the model currently is on that point.
• With the {0, 1} label convention the same model gives the "cross-entropy" form −[y log p + (1 − y) log(1 − p)]. It is identical, just written differently.

Worked example: one gradient step w = [1, −2], x = [3, 1], true y = +1. Learning rate η = 0.5.

• Score s = 3 − 2 = 1.
• P(y = +1 | x) = σ(1) = 0.731.
• Loss = −log 0.731 = 0.313.
• Gradient = −y · x · σ(−y s) = −[3, 1] × 0.269 = [−0.807, −0.269].
• New w = w − η·grad = [1 + 0.403, −2 + 0.134] = [1.403, −1.866].
• New score = 4.210 − 1.866 = 2.345. New P = σ(2.345) = 0.913. New loss = 0.092.
• One step moved the probability of the true label from 0.73 to 0.91.

Bonus: if P(+1 | x) = 0.8, the odds are 4 and the log-odds = ln 4 = 1.386 = w^T x.

Why it matters in ML/AI: logistic regression is the production workhorse for click-through, credit and churn models. The sigmoid-plus-NLL pairing is the output layer of every binary neural network classifier. The σ(1 − σ) derivative is the reason for vanishing gradients in deep sigmoid networks.

Exam traps

• Despite the name, logistic regression is a classification method.
• The boundary is where σ = 0.5, which means w^T x = 0. It is a linear boundary.
• σ(−z) = 1 − σ(z) and σ' = σ(1 − σ). Both are favourite short-derivation questions.
• There is no closed-form solution. Do not try to write (X^T X)^-1-style formulas.
• The gradient sign: the loss gradient has a leading minus. The GD update then adds η·Σ y_i x_i σ(−m_i).
• Know both label conventions, ±1 and 0/1, and that they give the same model.

Blog angle: "Logistic regression is just linear regression on the log-odds."

• From "score" to "probability" in one squashing function.
• Why −log p is the natural loss: surprise, measured in nats.
• The gradient as "each wrong example tugs the boundary towards itself".

Source tag: AI outline (L13) + textbook (PRML 4.3.2). The sign of the gradient was corrected.

12. Multi-class classification and softmax (Classification Part 3)

In one line: give every class its own weight vector and score, turn the scores into probabilities with softmax, and minimise cross-entropy.

Plain-English explanation

• K classes, with one weight vector w_k per class. Stack them into a matrix W.
• Scores: s_k = w_k^T x. The naive prediction is argmax_k s_k.
• Softmax: P(y = k | x) = exp(s_k) / Σ_j exp(s_j).
• All outputs are positive and sum to 1.
• Only score differences matter: adding a constant to every score changes nothing.
• For K = 2, softmax reduces to the sigmoid of the score difference.
• Loss (cross-entropy / NLL): L(W) = −Σ_i Σ_k γ_ik log P(k | x_i), where γ_ik = 1 if point i is in class k and 0 otherwise (one-hot). For each point this is just −log(probability of the true class).
• Geometry (one-vs-rest): each w_k separates class k from the rest. With linear boundaries, some regions are ambiguous or claimed by several classes. Taking the argmax of the scores (or softmax) settles every point, and the final regions are convex polygons. Truly curved boundaries need non-linear models, such as neural networks.

Worked example: softmax with scores s = [2, 1, 0] (cat, dog, cow)

• exp(s) = [7.389, 2.718, 1.000]. Sum = 11.107.
• P = [0.665, 0.245, 0.090]. Predict "cat".
• If the true label is "dog", loss = −ln 0.245 = 1.408. If it is "cat", loss = −ln 0.665 = 0.408.
• Shift test: scores [7, 6, 5] give the identical P.
• 2-class check: P(cat) / (P(cat) + P(dog)) = 0.731 = σ(2 − 1) = σ(1).

Why it matters in ML/AI: softmax plus cross-entropy is the output layer of image classifiers and of every LLM: the next token is a softmax over about 100k vocabulary scores. Softmax is also inside attention, where it normalises q^T k scores into weights. The temperature in LLM sampling divides the scores before the softmax.

Exam traps

• Softmax is invariant to adding a constant to all scores, not to multiplying them. Scaling changes the sharpness.
• Equal scores give a uniform distribution: [1, 1, 1] gives 1/3 each.
• The loss uses only the probability of the true class, which is what the one-hot γ selects.
• K classes need K weight vectors (one is technically redundant), not K − 1 boundaries drawn by hand.
• Softmax probabilities are not "calibrated truth". They are model outputs.

Blog angle: "From cat-vs-dog to ChatGPT: softmax is the last layer of everything."

• Scores to probabilities in three lines of arithmetic.
• Why only score differences matter, and why that is what makes temperature work.
• Cross-entropy as "how surprised the model was by the right answer".

Source tag: AI outline (L14) + textbook (PRML 4.1.2, 4.3.4).

13. Clustering and k-means (Clustering Parts 1–2)

In one line: with no labels, repeat two steps: assign each point to its nearest centre, then move each centre to the mean of its points. Stop when nothing moves.

Plain-English explanation

• Unsupervised learning: only x, no y. Find structure. Examples: customer segments, news topics, image regions, route types.
• A good clustering: points in the same cluster are close (high intra-cluster similarity), and points in different clusters are far apart. "Close" usually means Euclidean distance. Images become vectors of pixels.
• K-means objective (WCSS, within-cluster sum of squares): J = Σ_k Σ_{i in C_k} ||x_i − μ_k||².
• Lloyd's algorithm: 1. Initialise K centres. 2. Assign: γ(i) = argmin_j ||x_i − μ_j||². 3. Update: μ_k = (1/|C_k|) Σ_{i in C_k} x_i. 4. Repeat until the assignments stop changing.
• Why the mean is the best centre: 1. Minimise Σ_i ||x_i − p||² over p. 2. The gradient is −2 Σ (x_i − p) = 0. 3. So |C_k| p = Σ x_i, which gives p = mean.
• Each step can only lower J (or leave it the same), so k-means always converges, but only to a local minimum.
• Initialisation matters. k-means++ chooses the first centre at random. Each next centre is drawn with probability ∝ d(x)², the squared distance to the nearest centre already chosen. This spreads the starting centres out.
• Choosing K: the elbow method. Plot WCSS against K. WCSS always falls as K grows, reaching 0 at K = N. Pick the "elbow", where the gains suddenly flatten.
• Feature scaling is essential. Distances are dominated by large-range features (income in rupees vs age in years). Standardise each feature: x' = (x − μ) / σ.
• Soft k-means:
• Instead of a hard 0/1 membership, give point i a weight for each cluster: r_ik ∝ exp(−β ||x_i − μ_k||²), normalised so they sum to 1 over k.
• Update the centres as weighted means: μ_k = Σ_i r_ik x_i / Σ_i r_ik.
• This is a stepping-stone to Gaussian mixture models and EM (PRML Ch 9).
• In scikit-learn: KMeans(n_clusters, init='k-means++', n_init, tol).

Worked example 1: k-means by hand Points: A(1, 1), B(2, 1), C(1, 2), D(5, 4), E(6, 5), F(5, 5). K = 2. Bad start: μ1 = A = (1, 1), μ2 = B = (2, 1).

Iteration 1, assign (squared distances to μ1 / μ2):

• A: 0 / 1 → 1
• B: 1 / 0 → 2
• C: 1 / 2 → 1
• D: 25 / 18 → 2
• E: 41 / 32 → 2
• F: 32 / 25 → 2

So the clusters are {A, C} and {B, D, E, F}, and WCSS = 0 + 0 + 1 + 18 + 32 + 25 = 76.

Iteration 1, update: μ1 = mean(A, C) = (1, 1.5). μ2 = mean(B, D, E, F) = (18/4, 15/4) = (4.5, 3.75).

Iteration 2, assign: B is now 1.25 from μ1 and 13.81 from μ2, so B moves to cluster 1. The clusters are {A, B, C} and {D, E, F}.

Iteration 2, update: μ1 = (1.333, 1.333) and μ2 = (5.333, 4.667). WCSS = 2.667.

Iteration 3: the assignments do not change, so the algorithm has converged. WCSS fell 76 → 7.69 → 2.67.

Worked example 2: a bad local minimum Rectangle corners (0, 0), (0, 1), (4, 0), (4, 1). Start at μ = (2, 0) and (2, 1).

• Every bottom point is nearest (2, 0) and every top point is nearest (2, 1). Means: (2, 0) and (2, 1). Nothing moves.
• k-means is stuck with WCSS = 16.
• The natural left/right split has WCSS = 1. This is why you use k-means++ and multiple restarts (n_init).

Worked example 3: the elbow 1-D data {1, 2, 3, 10, 11, 12, 20, 21, 22}. Best WCSS for each K:

• K = 1: 548
• K = 2: 127.5
• K = 3: 6
• K = 4: 4.5
• K = 5: 3

The big drop stops at K = 3, so that is the elbow.

Worked example 4: k-means++ sampling Distances to the nearest chosen centre are 0, 1, 5, 10. Then d² = 0, 1, 25, 100, and the sampling probabilities are 0, 0.008, 0.198, 0.794. The far-away point is very likely to be picked next.

Why it matters in ML/AI: customer and route segmentation, and colour quantisation. Vector quantisation in vector databases (IVF indexes cluster the embeddings with k-means). Tokenising audio and images in generative models (VQ-VAE codebooks). Soft k-means leads to Gaussian mixtures and EM.

Exam traps

• K is a hyperparameter. It is chosen by you (elbow method), not learned.
• k-means is guaranteed to converge, but only to a local optimum. The result depends on initialisation.
• The update uses the mean, because that minimises squared distance. (The median minimises L1 distance, which is k-medians.)
• WCSS always decreases as K increases, so "lowest WCSS" is not a rule for picking K.
• Forgetting to standardise features when they have very different scales.
• k-means++ samples ∝ d², not ∝ d, and it does not deterministically choose the farthest point.
• Each k-means step needs O(NKD) work.

Blog angle: "K-means in two moves: how vector databases organise a billion embeddings."

• Assign and update, with a hand-traced example.
• Why it gets stuck, and how k-means++ fixes it with one probability rule.
• From k-means to IVF indexes and VQ codebooks in modern AI.

Source tag: AI outline (L16, L17) + textbook (PRML 9.1). The soft k-means normalisation and stiffness β were added. The examples were built and verified in numpy.

Live sessions: where each one went

• 26 Sep: course admin and the evaluation scheme (section 0), metrics (section 2), norms and cosine similarity (section 3).
• 3 Oct: OLS in matrix form (section 7), probability basics (section 5), the confusion matrix (section 2), and the statement that the exam is "conceptual, derivation-based".
• 10 Oct: assessment style (80/20), cross-validation and λ grid search (sections 2 and 8), polynomial regression (section 7), ridge vs lasso (sections 8 and 9), normal equations plus λI and the eigenvalue shift (section 8), correlation and Cauchy–Schwarz (section 6).
• 17 Oct and 18 Oct: not covered: no material available. Watch these recordings once the outlines are released. They may cover PCA ahead of Assignment 2.

14. Formula / cheat sheet

15. Assignment-pattern analysis

What material exists

There is one assignment: Assignment 1 (IS903E, 10 marks, due 31 Oct 2026, 23:59 IST). No solutions have been released. This guide does not solve it, because it is graded and still open. Everything below describes its pattern, so that you can practise on different problems.

Structure of Assignment 1

What this says about the instructor

• Question types: applied coding. The derivation is given in the PDF, and you are graded on implementing it correctly and following the workflow. The "from scratch, then with libraries" pairing is deliberate. The live sessions repeat this philosophy.
• Difficulty: the math is easy to moderate. The marks are lost on discipline:
• wrong shapes (m × 9 after augmentation)
• forgetting the ones column
• using the test set for tuning
• a non-log λ grid
• using a forbidden library in Q1, which gives zero marks
• not keeping one cell per part
• Proofs vs numericals vs conceptual: the assignments are numerical and coding. The exams are stated to be about 80% conceptual MCQ and 20% short derivations or calculations.
• Topics weighted most so far: regression (OLS → ridge → tuning λ) gets the most attention, in Assignment 1 and in two live sessions. Assignment 2 will be clustering + PCA. Assignment 3 will be trees or neural networks.

What the mid-sem / final will probably look like

Based on the stated 80/20 split, the topics the live sessions kept returning to, and the derivations shown in lectures:

1. Conceptual MCQs: - which metric suits which scenario - ridge vs lasso (sparsity, the geometry) - what λ → 0 or λ → ∞ does - the D vs N cases - convexity - σ properties - softmax shift-invariance - k-means convergence, initialisation and the elbow method - feature scaling
2. Short numericals: - P / R / F1 from a confusion matrix - MSE - dot product, norm, cosine similarity - a 2 × 2 eigenvalue problem - a Bayes or conditional probability from a table - E[X] and Var(X) for a small PMF - a 2-point OLS or 1-D ridge fit - one gradient-descent step - a sigmoid or softmax value - one k-means iteration
3. Short derivations: - the OLS and ridge closed forms - ∇(w^T A w) - σ(−z) = 1 − σ(z) and σ' = σ(1 − σ) - logistic loss = −log σ(y w^T x) - why the mean is the best k-means centre - Var = E[X²] − E[X]² - Bernoulli mean and variance

Practice problems in the same style (similar, but not the assignment)

These are in ML_questions.json under "long", with full model solutions:

• by-hand OLS with a bias column on a 4-point dataset
• by-hand ridge with validation-based λ selection on toy data
• a derivation of the ridge solution and its invertibility
• gradient descent vs the closed form, including learning-rate stability
• logistic regression: the derivation plus one GD step
• tracing k-means and comparing initialisations

These use tiny, different datasets and stress the ideas that Assignment 1 tests: augmentation, the ridge formula, validation-based tuning, and train / val / test hygiene. They do not use the California Housing pipeline.

Written for Sarang: an experienced Python engineer studying for exams and blog posts. The basics are kept short. The guide spends its time on what Dr. Sandhan stresses and examines. Every code output below was run in Python 3.13 / NumPy and checked.

1. Course at a glance

Instructor: Dr. Tushar Sandhan (sandhan@iitk.ac.in), IIT Kanpur. Many slides still carry the older code EE950: DADS (Data Analytics & Data Structures). The instructor explains that course numbers are administrative and can change, while the content follows the FCH (First Course Handout). The FCH also defines the evaluation metrics.

Course identity: IS901E means "Intelligent Systems 901 (Core), E". It combines four strands:

• Intro to Python (CS101 / CS350 style)
• Data Analytics & Data Structures (EE950)
• High-dimensional data visualisation (CS661 style)
• Agentic AI

It is a prerequisite for almost every later course, including Deep Learning, CV, LLMs and RL.

Week-by-week map (as reconstructed from the portal material)

Story of the course (one paragraph)

The course starts with the workbench: notebooks, IDEs and conda environments, so you can run anything anywhere. It then asks what Python is: a high-level, dynamic, multi-paradigm language whose source code is silently compiled to bytecode and executed by a virtual machine. With that model in place, it covers syntax and the most testable idea in Python, objects, references and mutability. Containers then grow into data structures (stacks, queues, frozensets, custom lists and dicts) and into OOP, where inheritance and the C3 method resolution order decide which code actually runs. Next come data readers: bytes, CSV parsing and the collections toolbox that turns raw files into structured data for NumPy and pandas. The second half (still to come) uses this toolkit for shell automation, high-dimensional visualisation and finally agentic AI: agents, RAG and deployment. All of these are Python programs built from exactly these pieces.

Evaluation scheme (as stated in the material)

Other points from the material:

• Quiz format: MCQs, possibly with multiple correct options. A mock quiz is given first. Use your IITK email ID.
• Relative grading. Grades are letters (A*, A, B+, B, C+, C, D, E, F) mapped to points (A = 10, B+ = 8, and so on). CPI is the average of the points. There are no percentages.
• "I" grade: if you miss the end exam, you can sit it the next time the course runs without redoing quizzes.
• Mixed difficulty: the instructor says experienced students get harder questions.
• Inconsistency to note: the older DADS outline (L02) lists "class participation min 10%" plus quizzes, assignments and a final exam, with no weights. The IS901E live session gives the 20/20/60 split above. Treat 20/20/60 as current and confirm in the FCH.
• Calendar mismatch: the orientation says modules run 8 teaching weeks plus 2 exam weeks, while the FCH outline describes 11 weeks. Check the academic calendar for exam dates. None are stated in the material.

2. Topic sections

2.1 Notebooks as the lab bench (IPython, Jupyter, Colab, Kaggle, Markdown, multimedia)

In one line: A notebook is a JSON document of cells that talks to a live kernel. Shell commands, magics, Markdown and even embedded video all live inside that JSON.

Plain-English explanation.

• IPython means Interactive Python, an enhanced REPL. Jupyter is the browser GUI that uses IPython as its kernel. A .ipynb file is plain JSON: cells, metadata and outputs.
• Colab is Jupyter on Google VMs. The runtime is ephemeral: files and installed packages vanish when the session ends, so sync to Drive. You can switch between CPU, GPU and TPU. Kaggle offers similar notebooks with a quota of about 30 hours.
• Three prefixes the instructor tests:
• !cmd runs a shell command in a fresh subprocess each time.
• %magic is a line magic. %cd changes directory persistently.
• %%magic is a cell magic, e.g. %%writefile hello.py writes the cell to a file.
• Others mentioned: %lsmagic, %time (run once), %timeit (repeated, robust), %tb (traceback), plus %%bash, %%javascript and %%html for other languages.
• Markdown cells: #, ## and so on for headings, **bold**, *italic*, ~~strike~~, pipe tables, fenced code, and LaTeX with $$...$$. Raw HTML (tables, forms) also renders.
• Multimedia: from IPython.display import Image, Video, display. Video(path, embed=True) stores the video inside the JSON as a Base64 text string. Base64 maps every 3 bytes to 4 ASCII characters, so the notebook grows by about 4/3 of the media size. Without embed, the notebook only holds a link. SVG is vector-based and stays sharp at any zoom.
• Shortcuts: Esc puts you in command mode and Enter in edit mode. a and b insert a cell above or below, dd deletes, Shift+Enter runs and moves on, Ctrl+Enter runs and stays. Restart & Run All checks that the notebook does not depend on hidden out-of-order state. Export with nbconvert to HTML, PDF or .py. An HTML export cannot be run.

Worked example. A 300-byte image embedded as Base64 becomes 300 / 3 × 4 = 400 characters. This was checked with len(base64.b64encode(b'x'*300)) == 400. Directory trap:

!cd Python_test   # child shell changes dir, then exits
!pwd              # still prints the ORIGINAL directory
%cd Python_test   # kernel's cwd changes for the rest of the session

Why it matters in agentic AI / ML engineering. Notebooks are where you prototype agents, prompts and evaluation loops. Understanding .ipynb as JSON lets agents read and write notebooks programmatically (nbformat), diff them in git, and strip heavy Base64 outputs before committing. Base64 is also exactly how images are sent to multimodal LLM APIs.

Exam traps.

• !cd does not persist, but %cd does.
• % applies to one line and %% to a whole cell.
• IPython means Interactive Python, not "interpreted".
• Base64 is text, so the file grows by roughly 33%, not 0% and not 2×.
• An HTML export is static and cannot be run.
• Colab storage does not survive a session reset.

Blog angle: "Your notebook is a JSON file with a video hiding in it."

• Open an .ipynb in a text editor and find the Base64 blob.
• ! vs %: why your cd did not stick (subprocess vs kernel state).
• Restart & Run All as the cheapest reproducibility test you are not running.

Source tag: AI outlines (L03, L05, L19, live 26 Sep and 11 Oct) plus textbook fill-in for Base64 sizing and IPython naming.

DADS Homework (week 5, graded 5%, due today): an exploratory 2-page PDF report on (1) how video and images are stored inside a notebook when embedded, (2) dictionaries as key-to-value lookups in everyday objects, and (3) where lists, tuples, sets or dicts appear in your own corporate work. Topic noted only. Not solved here.

2.2 What Python is: interpreted + compiled, scripts, implementations, versions

In one line: CPython silently compiles your .py to bytecode (.pyc) and a virtual machine (the PVM) interprets that bytecode. That is why Python is called "interpreted" even though a compile step exists.

Plain-English explanation.

• Instructor's definition (memorise): "a modern, general-purpose, object-oriented, high-level programming language", which is dynamic, expressive, interpreted. Further slide points: dynamically typed, automatic memory management, modular, slow (interpreted + dynamically typed) compared with statically typed, compiled C/C++, and decentralised (many packages, environments and versions).
• Compiler vs interpreter (slide wording):
• A compiler converts program text into native machine language, the machine executes it, and the compiler can optimise the code.
• An interpreter "takes the program one statement at a time and converts it into bytecode to be executed by a virtual machine".
• Python is compiled + interpreted, and the compilation is hidden from the user (.py becomes .pyc).
• Pipeline: source .py → compiler → bytecode .pyc (cached in __pycache__/name.cpython-XY.pyc) → PVM. CPython recompiles when the source's modification time (and size) no longer match those recorded in the cache (a timestamp check by default). Force a compile with python -m py_compile hello.py. cat on a .pyc shows binary. Decompilers such as uncompyle6 exist but lag behind new Python versions.
• dis module: dis.dis(func) prints human-readable bytecode (LOAD_GLOBAL, LOAD_CONST, CALL, RETURN...). It works on code objects such as functions, not directly on .pyc files. A function call works like a jump plus a stack of frames.
• Error types: syntax errors are "unlawful things you did" in the text and are caught at compile time. Runtime errors occur during execution, e.g. divide by zero.
• Scripts: "loosely typed glue code that connects incompatible software components". Uses: batch commands (.bat, .sh) and text processing (sed, awk). Client side: JavaScript, jQuery, HTML, CSS, AJAX. Server side: PHP, Python, JSP, Perl, CGI.
• Implementations ("interpreters define the implementations"):
• CPython: the original, from python.org, written in C.
• Jython: runs on the Java platform.
• IronPython: .NET.
• Stackless: C and Python, microthreads.
• PyPy: written in RPython (a restricted subset of Python), uses a JIT, faster than CPython.
• Versions (slide table): 1.0 in 1994, 2.0 in 2000, 3.0 in 2008, 2.7 in 2010, 3.3 in 2012, 3.6 in 2016. Guido van Rossum started Python in 1990 in the Netherlands. Live sessions recommend 3.10 / 3.11 for AI library compatibility, and "stable" means the version the libraries support.
• Performance stance: high-level languages cut development time but cost CPU time. In AI, prototype in Python and port the proven hot path to C/C++ (instructor example: about 20 FPS in Python vs 40 FPS in C).

Worked example (verified on CPython 3.13).

import dis
def g(): print("Hello Sum")
dis.dis(g)
#  RESUME 0
#  LOAD_GLOBAL  1 (print + NULL)
#  LOAD_CONST   1 ('Hello Sum')
#  CALL 1
#  POP_TOP
#  RETURN_CONST 0 (None)

py_compile.compile('hello.py') produced __pycache__/hello.cpython-313.pyc. The tag 313 names the interpreter version, so a 3.10 interpreter would write ...cpython-310.pyc.

Why it matters in agentic AI / ML engineering.

• Agents deployed in containers benefit from pre-compiled .pyc files for faster cold starts.
• The interpreter and version tag explain why a wheel or pickle built for one Python breaks on another.
• PyPy vs CPython is the same trade-off as choosing an inference runtime: a JIT speeds up generic code, but C-extension libraries such as NumPy and PyTorch are tuned for CPython.
• "Prototype in Python, port the hot path" is how vLLM and llama.cpp-style stacks are built.

Exam traps.

• "Python is purely interpreted" is false per the slide: it is compiled + interpreted, with the compilation hidden.
• Bytecode is not machine code.
• PyPy is written in RPython and uses a JIT. CPython does not JIT-compile to bytecode: it compiles to bytecode ahead of execution. (One AI outline wrongly said JIT.) CPython 3.13 does ship an experimental JIT (bytecode to machine code), but it is off by default and needs a special build flag.
• Python 3.0 (2008) came before 2.7 (2010).
• .pyc files live in __pycache__ and the name carries cpython-XY.
• dis works on functions, not .pyc paths.

Blog angle: "Python is a compiled language, and you never noticed."

• Follow hello.py to __pycache__ to dis output.
• Why 3.10 cannot read 3.13's cache, and what the cpython-313 tag means.
• PyPy, Jython, IronPython: one language, many virtual machines.

Source tag: course slides (Week2-1, Week2-2) plus AI outlines (L13, L20, live 10 Oct and 11 Oct). Bytecode verified locally.

2.3 Programming paradigms: imperative vs declarative, and Python as multi-paradigm

In one line: Imperative code says how (a sequence of commands that change state). Declarative code says what (the desired result) and leaves the control flow to the system. Python lets you do both.

Plain-English explanation.

• Paradigm (slide): "a style of building the structure and elements of a program".
• Declarative: "expresses the logic of a computation without describing its control flow". The focus is WHAT. Examples: SQL, Prolog, Makefiles, functional programming. Sub-types are functional (pure functions, e.g. Haskell, Erlang) and logic (Prolog, classic AI).
• Imperative: low-level specifications (algorithm details, machine-management steps), with efficiency as the primary concern. The focus is HOW, as a sequence of commands. Examples: Fortran, Cobol, C, Pascal. Sub-types are procedural and object-oriented.
• Live-session nuances:
• Imperative code is closer to the hardware (registers, ALU), faster and more customisable, but harder to write and debug.
• Declarative code is better for prototyping and often sits as an abstraction layer over an imperative back end. SQL engines are written in C.
• Prompting an LLM is declarative programming. You still need imperative skill to verify, debug, optimise and save tokens.
• Python is multi-paradigm:
• Imperative and procedural: loops, mutation.
• OOP: classes.
• Functional: lambda, map, filter, functools.reduce, comprehensions, generators.
• A paper cited by the instructor (Samuel 2017, IEEE Spectrum ranking: 12 metrics, 48 languages) calls the paradigm "the kernel in any software design".

Worked example: the same task in two styles (both give 30).

# imperative: explicit state and steps
s = 0
for i in range(1, 5):
    s += i * i          # s: 1, 5, 14, 30
# declarative/functional: state the transformation
s2 = sum(map(lambda x: x * x, range(1, 5)))   # 30

Why it matters in agentic AI / ML engineering. Agent frameworks are declarative graphs (LangGraph nodes, DSPy signatures, YAML tool specs) running over imperative runtimes. PyTorch modules are OOP, torch.func and JAX are functional, and training loops are imperative. Knowing which layer you are in tells you where to debug.

Exam traps.

• Classify SQL, Prolog and Make as declarative, and C, Fortran, Cobol and Pascal as imperative.
• OOP sits under imperative in the slide's tree.
• "Declarative = no customisability" is an overstatement. It means less low-level control.
• Python is multi-paradigm, not "purely OOP".

Blog angle: "Prompting is declarative programming, and that is why you still need to know C."

• WHAT vs HOW with one task written both ways.
• Every declarative layer (SQL, Make, prompts) sits on an imperative engine.
• When to drop down a layer: optimisation, security, token budget.

Source tag: course slides (Week2-2) plus AI outlines (L14, live 3 Oct and 4 Oct).

2.4 Python environments and tooling

In one line: An environment is an isolated Python interpreter plus its packages. Conda (or venv) stops one project's NumPy version from breaking another's.

Plain-English explanation.

• Where Python runs (slide):
• Core CPython (the REPL)
• IPython (interactive shell)
• IPython/Jupyter notebook (HTML-based GUI)
• an IDE, i.e. editor + interpreter (Spyder, recommended for its Variable Explorer; also PyCharm and VS Code)
• a cross-platform package manager such as conda
• Ecosystem (slide): NumPy (numerical), SciPy (scientific), Matplotlib (graphics).
• Conda commands:
• conda create -n py36 python=3.6 -y
• conda activate py36 and conda deactivate
• conda env list
• conda install -c conda-forge notebook
• on Colab: pip install condacolab
• inside an env, pip list verifies the packages
• Windows PATH issues cause "conda not found" errors
• Linux (Ubuntu) is preferred for AI because GPU servers and research repositories target it. WSL is the bridge on Windows.
• Language facts the slides list: expressive, interpreted (compilation hidden), cross-platform, open source, OO, large standard library, GUI possible, integrates with C, C++, Java and Fortran.
• Keywords: 35 in Python 3.13. Only True, False and None are capitalised. Blocks are defined by indentation, not braces. pass is a no-op placeholder. yield makes a generator, which evaluates lazily.
• Exceptions: try / except stops errors from crashing the program and centralises error handling.

Worked example (verified).

import keyword
len(keyword.kwlist)                          # 35
[k for k in keyword.kwlist if k[0].isupper()]  # ['False', 'None', 'True']
def gen():
    yield 1; yield 2
G = gen(); next(G), next(G)                  # (1, 2): values produced on demand

Why it matters in agentic AI / ML engineering. Reproducible environments (lockfiles, conda env YAML, Docker) are what let an agent's tool-execution sandbox match production. Version pinning around CUDA, PyTorch and Python is the most common deployment failure. yield generators underpin streaming LLM tokens to a UI.

Exam traps.

• conda create makes an environment. activate only enters it.
• Conda manages both packages and environments, while pip manages packages only.
• Spyder's feature is the Variable Explorer.
• Keyword case: True, not true.
• pass is not continue.

Blog angle: "Environments are the containers before containers."

• Why the AI world standardised on Linux + conda.
• yield from the textbook to token streaming.
• Version pinning as an operational discipline, not a chore.

Source tag: course slides (Week2-3) plus AI outlines (L15, live 3 Oct, 4 Oct and 11 Oct). Keywords verified.

2.5 Python syntax: operators, precedence, types, functions, control flow

In one line: Precedence and type-mixing rules decide what an expression returns. The instructor's notebook deliberately shows the surprising cases.

Plain-English explanation.

• Operators:
• arithmetic: + - * / ** // %
• assignment: = += -= *=
• comparison: == != < <= > >=, which return True or False
• Precedence (slide), highest first: () → ** → * / → + - → comparisons. Same-precedence operators go left to right, except **, which is right-associative. Unary minus binds looser than **.
• Types:
• mixing int and float gives a float
• / always returns a float
• floats are binary approximations
• 'n1' + 'n3' concatenates strings
• 1 + 'a' raises a TypeError
• type() inspects the type
• eval('n6') evaluates a string as code. The instructor warns not to use eval on untrusted input.
• Functions: def name(args): then an indented body. No return means the function returns None. operator.add(a, b) is the functional form of +.
• Control flow: if / elif / else.

Worked example (the course notebook, outputs verified).

n1, n2, n3, n4, n5, n6 = 10, -3., 7.0, -.5, 1.11, 9
n1 + n6          # 19
n1 + n3 + n5     # 18.11
n3 * n5          # 7.7700000000000005   (float representation error)
n3 ** n5         # 8.670793121567783
n6 = n6 + n1     # 19 -> n6 is now 19
n6 += n1         # 29   (the notebook shows 29 then 49 because cells were re-run)
operator.add(n1, n2)   # 7.0  (int + float -> float)
def plus2(a, b): a + b
None == plus2(3, 4)    # True
10 + 2*5   # 20      2 ** 3 ** 2   # 512 (= 2**9)     -2 ** 2   # -4
-7 // 2    # -4      -7 % 2        # 1                 0.1 + 0.2 == 0.3   # False

Step for 2 ** 3 ** 2: right-associative, so compute 3 ** 2 = 9 first, then 2 ** 9 = 512. Note: the printed course notebook shows n6 → 29 and then 49. That happened because cells ran more than once. Re-running a cell changes state, which is a notebook trap in its own right.

Why it matters in agentic AI / ML engineering.

• Float error is why you compare losses with tolerances (math.isclose).
• eval on LLM output is a classic prompt-injection to code-execution hole. Use ast.literal_eval, JSON or a sandbox instead.
• Implicit None returns cause silent bugs in tool functions that an agent calls.

Exam traps.

• ** is right-associative, and -2**2 = -4.
• // floors toward minus infinity: -7 // 2 = -4.
• / always returns a float.
• A function with no return gives None, not an error.
• 'n1' + 'n3' is string concatenation, not addition.
• Do not use eval.

Blog angle: "Five Python one-liners that fail code review."

• Right-associative ** and the unary-minus trap.
• 0.1 + 0.2 and why ML compares with tolerance.
• eval + LLM output = remote code execution.

Source tag: course notebook/PDF (3-Python-syntax) plus AI outline (L21). Outputs verified.

2.6 Objects, references and mutability (the most examinable idea)

In one line: A variable is a name tag on an object. Mutable objects change in place. Immutable objects never change, and "modifying" one actually creates a new object and moves the tag.

Plain-English explanation.

• Containers (course notebook, memorise the table):

• The re-binding reality (live 10 Oct): bb += (5, '5') on a tuple does not mutate it. Python builds a new tuple and points bb at it, so id(bb) changes. For a list, += mutates in place and the id stays the same.
• Aliasing: B = A copies the reference, not the list. Use A.copy() (shallow) or copy.deepcopy.
• in tests membership with ==. is tests identity (the same object in memory).
• Memory: del removes a name. When no names remain, the object can be freed, which matters on GPU or RAM-constrained jobs.
• Scope keywords: global refers to a module-level variable. nonlocal refers to a variable in an enclosing function.

Worked example (all verified).

bb = (3, 4, 6, 'ac', 'car', False); old = id(bb)
bb += (5, '5'); id(bb) == old        # False  -> new tuple
aa = [3, 4, 6]; old = id(aa)
aa += [5, '5']; id(aa) == old        # True   -> same list mutated
bb[:-3]   # (3, 4, 6, 'ac', 'car')       bb[-1]  # '5'
len({3, 5, 'dog', 'mouse', 3, 10, 'dog'})   # 5
x = ["apple","banana","cherry"]; z = ["apple","banana","cherry"]; w = z
x == z, x is z, w is z               # (True, False, True)
x = {12, 12, 13}                     # -> {12, 13}
x in [1, 12, 13, 0, -12, 9, {12}]    # False (no element equals {12,13})
t = (1, [2, 3]); t[1].append(4); t   # (1, [2, 3, 4])  tuple holds a mutable list
{[1, 2]: 3}                          # TypeError: unhashable type: 'list'

Why it matters in agentic AI / ML engineering.

• Shared mutable state is the number one source of bugs in multi-agent systems, e.g. two agents appending to the same "memory" list through an alias.
• Mutable default arguments leak conversation history across calls.
• Tensors work the same way: b = a aliases, and in-place ops (add_) break autograd.
• Immutable configs (tuples, frozen dataclasses) make agent runs reproducible.

Exam traps.

• += on a tuple works (it re-binds). Item assignment t[0] = 9 raises a TypeError.
• A set is not indexed.
• A dict key must be hashable, so frozenset is allowed and list and set are not.
• is vs ==.
• B = A is not a copy.
• The in result on nested containers (the course's {12, 13} in y example) is False.
• A tuple containing a list can still "change" through the list.

Blog angle: "Python variables are name tags, not boxes."

• Watch id() change on tuple += but not on list +=.
• The aliasing bug that will bite your multi-agent memory.
• Why frozen configs make ML experiments reproducible.

Source tag: course notebook (syntax), AI outline (live 10 Oct), and notebook "Python loops and functions". Verified.

2.7 Python programming summary: built-ins, functions, scope, lambda/map, loops

In one line: A small set of built-ins (any, len, sorted, map, enumerate, range) plus closures and comprehensions covers most data-wrangling code.

Plain-English explanation.

• Strings: single, double or triple quotes. Triple-quoted text right after def is a docstring, which help() shows.
• Built-ins:
• any(iterable): True if any element is truthy
• len: counts top-level items only
• callable(obj)
• sorted: returns a new list and sorts by code point, so uppercase comes before lowercase
• min, max, abs
• repr: the string form of an object
• Functions:
• Comma-separated returns give a tuple: x2, x3, x4 = powers(3).
• Default arguments look like do_something(a, b=3, c=4).
• Closures look up enclosing variables at call time.
• lambda args: expr is an anonymous function. map(f, it) returns a lazy one-shot iterator. Materialise it with list(...) or [*map(...)].
• Loops: while, for, range (lazy, memory-efficient), enumerate (index + value), list comprehensions [x**2 for x in range(5)], and dict.items() for key-value iteration (the course uses param = {'w1': .34, ...}, a model-weights dict).
• The notebook cell list(*map(lambda x: x**2, [1,2,3,4]),)) is a SyntaxError ("unmatched ')'"). The instructor may have left it in on purpose.

Worked example (verified).

powers(2)                         # (4, 8, 16)  -> a tuple
x = 3
def foo():
    x = 4
    def bar(): print(x)
    bar(); x = 5; bar()           # prints 4 then 5 (late binding)
m = map(lambda x: x**2, [1, 2, 3]); list(m), list(m)   # ([1, 4, 9], [])
do_something(2, -3)               # (2, -3, 4)
sorted(['ts','TS','zebra','iitk','01-20204'])  # ['01-20204','TS','iitk','ts','zebra']
any(e >= 10 for e in [4, 5, 8, 9, -10, 10])   # True
len([1, [2, 3], (4, 5, 6)])       # 3  (top level only)
list(range(2, 10, 3))             # [2, 5, 8]

Why it matters in agentic AI / ML engineering.

• Lazy iterators and generators power streaming pipelines: reading huge JSONL datasets and streaming tokens.
• The one-shot behaviour of map causes the classic "second epoch has no data" bug.
• Closures are how tool-calling frameworks bind context (API keys, session) into callables.
• Docstrings and type hints are what frameworks turn into the JSON schema the LLM sees for a tool.

Exam traps.

• map and generators are exhausted after one pass.
• len is top-level only.
• sorted puts 'TS' before 'iitk'.
• Comma-separated returns give a tuple.
• Closures bind late (4, then 5).
• range(stop) excludes stop.

Blog angle: "Your tool's docstring is now a prompt."

• How agent frameworks turn def + docstring into a tool schema.
• Lazy map and range, and the empty-second-pass bug.
• Closures as dependency injection for agents.

Source tag: course notebook (1-Python loops and functions) plus AI outline (L29). Verified.

2.8 Data analytics with basic data structures (NumPy + CSV by hand)

In one line: Load the data, clean it, convert it to numbers, then summarise and plot. NumPy arrays are the fast, typed container for that pipeline.

Plain-English explanation.

• The instructor's loop: Data (load into a variable, process or manipulate) → Visualisation (guess how the data looks) → adjust or select your data structure.
• NumPy:
• np.array, with .shape, .dtype, .size
• np.arange(n), .reshape(r, c)
• np.append, np.insert, np.delete: these return new arrays, and the original is unchanged
• statistics: mean, sum, min, max, var, median, sort
• import numpy as np keeps the namespace clean
• CSV by hand (AAPL 2019): with open(...) → readlines() → line.rsplit(',')[1:] → .replace('\n', '') → collect strings → np.delete(arr, 0) drops the header → .astype(float) → statistics → plt.plot.
• Variance formula: var = (1/n) Σ (x_i − mean)^2. NumPy's default ddof=0 gives the population variance. Pass ddof=1 for the sample variance (1/(n−1)) Σ ....

Worked example (verified). a = np.array([1, 2, 3, 4, 5])

1. mean = 15 / 5 = 3.0
2. deviations: −2, −1, 0, 1, 2 → squares 4, 1, 0, 1, 4 → sum = 10
3. np.var(a) = 10 / 5 = 2.0 (the sample variance would be 10 / 4 = 2.5); np.std(a) = √2 ≈ 1.41421; median = 3.0
4. np.insert(a, 3, 0) → [1 2 3 0 4 5]; np.delete(a, 4) → [1 2 3 4]; a is still [1 2 3 4 5]
5. np.arange(100).reshape(10, 10)[3, 7] = 37 (row 3 × 10 + column 7)

Mini CSV with closes 157.92, 142.19, 148.26: mean = 448.37 / 3 = 149.4567, median = 148.26. The course's full AAPL file gave 229 values, mean 201.4776, median 200.72, min 142.19, max 267.10, var 794.41. Note: the slide shows dtype: int32 because it ran on Windows with NumPy 1.x. On Linux and macOS, and on Windows since NumPy 2.0, the default is int64.

Why it matters in agentic AI / ML engineering. This hand-rolled pipeline is what a data-analysis agent writes for you. Knowing the steps lets you check its code. String-typed numbers are the most common silent failure when an agent reads CSVs. Population vs sample variance matters in normalisation layers and evaluation statistics.

Exam traps.

• Data read from text files is str and must be converted with .astype(float).
• np.append, np.insert and np.delete do not modify the array in place.
• np.var uses ddof=0 by default.
• reshape must preserve the total size.
• The dtype depends on the platform and NumPy version (int32 on Windows with NumPy 1.x, otherwise int64).

Blog angle: "Before pandas: parse a CSV with nothing but Python and NumPy."

• The load → clean → cast → summarise → plot loop.
• The '157.92' string that broke my mean.
• Population vs sample variance in 4 lines.

Source tag: course notebook/PDF (2-Data analytics using basic data structures) plus AI outline (L28). Verified.

2.9 More data structures: frozenset, stack, queue, UserList/UserDict

In one line: Pick the container whose access pattern matches the job: LIFO means a stack, FIFO means a queue, a fixed set means a frozenset, and a list or dict with extra behaviour means UserList or UserDict.

Plain-English explanation.

• The instructor's list: strings, lists, tuples, sets, dicts, classes, bytearray, frozensets, stacks, queues, UserList, UserDict.
• frozenset: an immutable set. It supports only operations that return new sets (union, intersection, difference, ^), has no add, and is hashable, so it can be a dict key or a member of another set. frozenset() with no arguments is empty.
• Stack (LIFO): a list with append (push) and pop() (pop from the top). The function call stack is a stack, which is why recursion works. Uses: undo/redo, parsing.
• Queue (FIFO): a list with append (enqueue) and pop(0) (dequeue). The slide warns that pop(0) is O(n) because every element shifts, so use collections.deque (O(1) at both ends). Uses: task scheduling, server requests, BFS.
• UserList / UserDict (from collections) wrap a real list or dict in self.data, so you can subclass safely and add methods (e.g. square_elements, double_values). Note: a UserList is list-like but isinstance(m, list) is False.

Worked example (verified).

stack = [5, 6, 7, 8]; stack += [9, 10, 12]
stack.pop(); stack.pop(); stack.pop()   # -> [5, 6, 7, 8]
queue = [2, 3, 4, 'apple', 'mango', 'orange']
queue.pop(0)                            # 2  -> [3, 4, 'apple', 'mango', 'orange']
f1, f2 = frozenset([1,2,3,4,5]), frozenset([4,5,6,7,8])
f1 | f2   # {1..8}   f1 & f2  # {4, 5}   f1 - f2  # {1, 2, 3}   f1 ^ f2  # {1, 2, 3, 6, 7, 8}
m = MyList([1,2,3,4,5]); m.square_elements()   # [1, 4, 9, 16, 25]; m[2] == 9
m[1] = 10                                      # [1, 10, 9, 16, 25]
MyDict({'a':1,'b':2,'c':3}).double_values()    # {'a': 2, 'b': 4, 'c': 6}

Why it matters in agentic AI / ML engineering.

• An agent's scratchpad or plan is often a stack: push sub-goals, pop when done.
• A task queue feeds tool calls (FIFO). BFS and DFS over a tool graph are the queue and stack versions of the same search.
• A frozenset of capability tags makes a hashable cache key for routing, e.g. picking a model by required features in an LLM router.
• UserDict is a clean way to build a validated agent-memory or config object.

Exam traps.

• pop() removes the last item, pop(0) the first.
• list.pop(0) is O(n).
• A frozenset has no add.
• difference is not symmetric (f1 - f2 ≠ f2 - f1).
• LIFO = FILO.
• UserList is not a list subclass, even though the slide says "designed as a subclass".

Blog angle: "Every agent is secretly a stack and a queue."

• Plan stack vs task queue in an agent loop.
• Why list.pop(0) quietly makes your scheduler O(n²).
• Frozensets as hashable cache keys for model routing.

Source tag: course PDF (2-DADS-some more data structures) plus AI outline (L31). Verified, with a textbook note on UserList's base class.

2.10 OOP in Python: classes, __init__, self, inheritance, modules, static and class methods

In one line: A class is a blueprint of attributes and methods. Objects are instances. Inheritance lets a child reuse and extend a parent through super().

Plain-English explanation.

• Course running example: Robot has x, y, move_forward(), move_robot(dx, dy) and get_dist(other). AerialRobot(Robot) adds z and move_upward().
• __init__ runs automatically when an object is created. It is the "dunder" (double-underscore) constructor-initialiser. Default arguments allow Robot(), Robot(10, 20) and so on.
• self is the current object. It is the first parameter of every instance method, and Python passes it implicitly.
• Inheritance: parent = superclass, child = subclass. The child inherits everything, can override methods, and can add new ones. The course contrasts copying all the code ("without inheritance") with super().__init__(x, y) and super().get_dist(o) ("with inheritance").
• Modules: a .py file holding classes or functions (%%writefile robot.py). Imports:
• import robot
• import robot as rb
• from robot import AerialRobot
• from robot import *: avoid, it pollutes the namespace
• Functions-only modules also work (e.g. multiplying.py with double, triple, quadruple).
• @staticmethod: no self and no cls, e.g. make_money_sound(). @classmethod: receives cls and reads class attributes (cls.bank + " " + cls.location). Both can be called on the class or on an instance.
• Raising errors: raise RuntimeError("Insufficient for withdrawal") in withdraw.

Worked example (verified). 3-D distance through super(): a = AerialRobot(0, 0, 0), b = AerialRobot(3, 4, 12)

1. super().get_dist(b) = √(3² + 4²) = √25 = 5
2. 3-D distance = √(5² + 12²) = √(25 + 144) = √169 = 13.0

Course case: Robot(33, 44) vs AerialRobot(33, 44, 85). The ground robot is wrapped as AerialRobot(33, 44, 0), giving √(0 + 0 + 85²) = 85. Client levels: balance + 100, then < 5000 is Basic, < 15000 is Intermediate, otherwise Advanced. Client("x", 4900) has balance 5000, so its level is Intermediate (5000 is not < 5000). List-of-objects trap: [Robot()] * 3 holds one robot three times, so moving bots[1] moves all three. [Robot() for _ in range(3)] creates three distinct robots.

Why it matters in agentic AI / ML engineering.

• nn.Module subclasses call super().__init__().
• Agent frameworks define BaseTool or BaseAgent with overridable run() methods.
• @classmethod constructors (from_pretrained, from_config) are the standard factory pattern in Hugging Face.
• The instructor's Robot to AerialRobot story is literally the course's later physical-agent (drone) module.

Exam traps.

• Forgetting self.
• __init__ is not the allocator (__new__ is).
• @staticmethod gets neither self nor cls.
• A class attribute is shared, an instance attribute is per-object.
• The [obj] * n aliasing.
• from module import * is bad practice.
• Boundary conditions in if/elif (5000 is Intermediate).

Blog angle: "From ground robot to drone: inheritance explained with super()."

• Copy-paste class vs subclass with super().
• @classmethod as the from_pretrained pattern.
• The [Robot()] * 3 bug.

Source tag: course PDF (1-DADS-OOPS) plus AI outline (L32). Verified.

2.11 Multiple inheritance and MRO: C3 linearisation

In one line: When a class has several parents, Python searches them in one fixed order, the MRO, computed by the C3 algorithm. C3 keeps your left-to-right base order, puts every class before its parents, and refuses to build a class if those rules contradict each other.

Plain-English explanation.

• MRO: the order in which base classes are searched for a method or attribute. It is visible as C.__mro__ or C.mro(). It matters only with multiple inheritance.
• History (Rossum's post):
• Classic classes used depth-first, left-to-right search, with duplicates allowed.
• Python 2.2 used depth-first but kept only the last occurrence of a duplicate. It was buggy and non-monotonic.
• Python 2.3 adopted C3, which is the only algorithm left in Python 3.
• The diamond problem: A ← B, A ← C, D(B, C), and C overrides save. Classic search (D, B, A, C, A) finds A.save, which is wrong because C is more specialised. C3 gives D, B, C, A, object, so C.save wins.
• C3 rule:
• L[C] = C + merge(L[B1], ..., L[Bn], [B1, ..., Bn])
• merge: take the first list's head. If it appears in no other list's tail (everything after the head), output it and remove it from all lists. Otherwise try the next list's head. If no head qualifies, the hierarchy is inconsistent → TypeError.
• Guarantees: (1) local precedence order (bases are kept in the order written); (2) monotonicity (a child's MRO extends each parent's MRO without reordering it); (3) consistency with the extended precedence graph.
• super() follows the MRO of the instance's class, not "the parent". This is the most examined point. In the course diamond, super() inside canFly calls canSwim, not Mammal.
• Optional 1996 paper (summary only): Barrett et al., A Monotonic Superclass Linearization for Dylan, OOPSLA '96. It defines desirable linearisation properties (acceptability, local precedence, monotonicity: inherited properties may not skip over direct superclasses). It shows CLOS's linearisation can be non-monotonic (the pedalo boat example) and proposes the Dylan linearisation. It then introduces C3, a merge of the parents' linearisations plus the local order, with a selection rule that also respects the extended precedence graph. C3 is the variant Python adopted.

Worked example 1 (the course slide). class C(A, B), where B(GreatB) and A has no parents.

• L[A] = A, O; L[B] = B, GreatB, O
• merge(A O, B GreatB O, A B): take A (not in any tail); O is in a tail → skip; take B, then GreatB, then O
• Result: C, A, B, GreatB, object (matches the slide's printed MRO)
• c.greetings(), super(C, c).greetings() and super(B, c).greetings() all find GreatB.greetings and print <class C>, because self.__class__ is C. super(GreatB, c).greetings() raises AttributeError, since only object is left.

Worked example 2 (the course diamond, verified output).

Animal(canFly, canSwim); canFly(Mammal); canSwim(Mammal)
MRO = Animal, canFly, canSwim, Mammal, object
Animal("Dog") prints:
Dog cannot fly
Dog cannot swim
Dog Is a mammal          <- Mammal runs ONCE

Worked example 3 (hand C3, verified). O; E(O); F(O); G(E, F); K1(E); K2(F); K3(K1, K2, G). L[K3] = K3 + merge(K1 E O, K2 F O, G E F O, K1 K2 G)

1. K1 → ok. 2. E is in the tail of G E F O → skip; K2 → ok. 3. E skip, F skip (both in G's tail); G → ok. 4. E, then F, then O. K3, K1, K2, G, E, F, O, object.

Worked example 4 (rejection, verified). X(A, B), Y(B, A), Z(X, Y) → TypeError: Cannot create a consistent method resolution order (MRO) for bases A, B.

Why it matters in agentic AI / ML engineering. Mixins are everywhere in agent and ML frameworks: LoggingMixin, RetryMixin and ToolMixin combined with BaseAgent, or Django/DRF views, or PyTorch Lightning hooks. Cooperative super() chains, where each mixin calls super() once, only work because of C3. Getting the base order wrong silently skips your retry or tracing logic. An "inconsistent MRO" error at import time is C3 protecting you.

Exam traps.

• super() means next in MRO, not "my parent".
• C3 is not depth-first. In a diamond, the shared base comes last.
• The written base order matters: S(Q, R) vs T(R, Q) give different methods (verified: Q vs R).
• Contradictory orders raise TypeError at class creation.
• Explicit A.__init__(self, a) calls (as in the slide's class C) bypass the MRO chain.
• Python 3 uses only C3. The classic and 2.2 algorithms are history.

Blog angle: "Why your mixin's super() called the wrong class: C3 in 5 minutes."

• Diamond inheritance and why depth-first gets it wrong.
• Do the merge by hand on a whiteboard (heads, tails, reject).
• C3 as "errors should never pass silently", the X(A, B) / Y(B, A) refusal.

Source tag: course PDF (OOPS, MRO section), Rossum's MRO post (reading), optional 1996 C3 paper (summary only), and textbook fill-in for the merge rule. All MROs verified in Python.

2.12 File IO and data readers: bytearray and the collections toolbox

In one line: Raw files are bytes. The collections module gives ready-made structures (OrderedDict, namedtuple, deque, defaultdict, Counter, ChainMap) that turn those bytes into well-organised data before pandas takes over.

Plain-English explanation.

• The instructor's list of data readers/handlers: strings, bytearray, structured data (ordered dictionaries), collections (namedtuple, deque, defaultdict, Counter, OrderedDict, ChainMap), and tabular data (pandas DataFrames, coming later).
• bytearray: a mutable sequence of bytes, each 0-255 (8 bits, 256 values). Supports ba[0] = 72 ('H') and .extend(b'...'). bytes(ba) gives the immutable counterpart, a pair like list/tuple. This is useful for binary formats (images, DICOM).
• OrderedDict: remembers insertion order (a doubly linked list internally) and adds move_to_end(key, last=True/False). Modern note: plain dict preserves insertion order since Python 3.7. What remains different is that OrderedDict equality is order-sensitive, it has move_to_end, and popitem(last=False). The slide's "unlike a dictionary it remembers order" comes from older Python.
• namedtuple: a tuple with named fields (p.name, plus p[1] and p._asdict()). Lightweight and self-documenting records.
• deque: a double-ended queue with O(1) append, appendleft, pop and popleft. maxlen turns it into a sliding window.
• defaultdict(factory): a missing key is created with factory(): int gives 0, list gives []. Use it for counting and grouping. Side effect: reading a missing key inserts it.
• Counter: a dict subclass for counting hashables. most_common(k) and update(iterable). Missing keys return 0 without inserting.
• ChainMap: a live view over several dicts. Lookups return the first match. new_child() pushes a new map at the front. Writes go to the first map only, and changes to the underlying dicts show through.
• with open(...) as f closes the file automatically, even when an exception is raised.

Worked example (verified).

ba = bytearray(b'Hello, World!'); ba[0] = 72; ba.extend(b' How are you?')
# bytearray(b'Hello, World! How are you?');  ord('h') == 104
od = OrderedDict(one=1, two=2, three=3); od.move_to_end('two')   # one, three, two
dq = deque([1,2,3,4,5]); dq.append(6); dq.append(7); dq.pop()    # 7
dq.appendleft(0); dq.appendleft(-1); dq.popleft()                # -1 -> deque([0..6])
fruits = ['apple','orange','banana','apple','banana','grape']
Counter(fruits).most_common(1)     # [('apple', 2)]  (tie with banana; first seen wins)
fc = defaultdict(int); [fc.__setitem__(f, fc[f]+1) for f in fruits]
fc['kiwi']  # 0, and now 'kiwi' in fc -> True, len(fc) == 5
d1 = {'apple':1,'banana':2}; d2 = {'banana':3,'orange':4}
cm = ChainMap(d1, d2); cm['banana']        # 2 (d1 first)
d2['orange'] = 40; cm['orange']            # 40 (live view)

Why it matters in agentic AI / ML engineering.

• deque(maxlen=N) is the standard sliding-window conversation memory for an agent.
• ChainMap is exactly layered configuration: run-level overrides → agent defaults → global defaults.
• Counter handles token or tool-call frequency analytics and eval tallies.
• defaultdict(list) groups retrieved RAG chunks by document.
• namedtuple makes cheap immutable records for tool results.
• bytearray and bytes are what you handle when streaming audio or images to multimodal models.

Exam traps.

• bytearray is mutable and bytes is immutable.
• Byte values range over 0-255.
• move_to_end defaults to the end (last=True).
• defaultdict inserts on read, while Counter does not.
• most_common returns a list of tuples.
• ChainMap returns the first match, writes to the first map, and is a live view (not a copy).
• deque gives O(1) at both ends, while list pop(0) is O(n).
• Insertion order is guaranteed for plain dicts since 3.7, but the exam may follow the slide's wording.

Blog angle: "Six collections classes every agent builder should know."

• deque(maxlen) as chat memory, ChainMap as layered config.
• defaultdict vs Counter: who silently inserts keys?
• From bytes to DataFrame: the data-reader ladder.

Source tag: course PDF (3-DADS File IO formats and data readers) plus AI outline (L34). Verified, with a textbook note on dict ordering.

2.13 Not covered: no material available

• Live sessions 17 Oct and 18 Oct 2026: not covered, no material available (no outline posted yet).
• Future syllabus items (per the FCH outline, not yet released): Linux shell scripting and remote servers, workflow automation and debugging, data visualisation and t-SNE, Big-O analysis (only touched on in the 4 Oct live session: asymptotic vs practical performance), queues and priority queues in depth, drones and physical agents, recommenders, agent frameworks, RAG, and deployment.

3. Formula and cheat sheet

4. Assignment-pattern analysis

What exists in the material. Two graded homeworks and no quiz papers or solutions:

1. Markdown-features homework (5%): build a notebook that shows at least two new Markdown/IPython features (HTML tables and forms, images, video, LaTeX, magics like %timeit), and submit both the .ipynb and an HTML/PDF export (via nbconvert). It is not executed for grading.
2. DADS week-5 homework (5%, due today): an exploratory report (at most 2 pages, PDF only) on how embedded media is stored in notebooks, key/value thinking with dictionaries, and where Python containers appear in your own work. Not solved in this guide.

Question types and style.

• The homeworks are exploratory and conceptual, not proofs or long numericals. The instructor rewards curiosity: "do not be limited by these questions", find something interesting, connect it to real life (phone books, textbook indexes, corporate projects), and keep it precise and short.
• Quizzes and exams are MCQ, with multiple correct options possible, a mock quiz first, mixed difficulty, and relative grading. The end-sem is 60% and centre-based.

What the next quiz or mid-sem will probably look like (prediction).

• Code-output prediction (about 40%): straight from the course notebooks. Precedence and **, implicit None, string concatenation, in vs is on nested lists, tuple += and id, set de-duplication, slicing with negative indices, map laziness, closures, [obj]*n, NumPy insert/delete/var, Counter, defaultdict, ChainMap, deque outputs, and MRO and super() print order.
• Conceptual true/false and classification (about 35%): compiled vs interpreted ("Python is compiled + interpreted, the compilation is hidden"), PVM, .pyc and __pycache__, PyPy/Jython/IronPython facts, version-year ordering, declarative vs imperative examples, conda commands, ! vs %, Base64 embedding, mutable vs immutable and indexed vs not, static vs class methods.
• Small numericals (about 15%): Base64 sizes, Euclidean distance between robots, variance and median of a short array, // and % with negatives, reshape indexing.
• MRO and C3 (about 10%, harder items): compute the MRO of a 2-3 level hierarchy, identify an inconsistent hierarchy, predict diamond super() output. The instructor assigned both Rossum's post and the optional C3 paper, so expect at least one MRO question.
• Difficulty: mostly easy to medium, with a few hard "multiple correct" traps aimed at experienced programmers (the instructor said harder questions go to experienced students).
• Prep strategy: re-run each course notebook cell by cell and predict every output before running it. Hand-compute three C3 MROs. Memorise the slide wording for the definition of Python, the compiler/interpreter bullets, the paradigm definitions and the implementations list.