FMML_COURSE_ASSIGNMENTS: A Repo That Teaches Machine Learning by Showing Its Gears

The repo does not try to dazzle you with a polished framework. It tries to make machine learning feel physical. That is why it works as a teaching object: the notebooks keep turning abstract ideas into things you can draw, trace, and rebuild.

That choice matters. Many ML courses ask students to consume tools first and understand them later. FMML_COURSE_ASSIGNMENTS flips the order. It starts with the mechanisms underneath the tools, then lets the tools arrive as a convenience, not a mystery.

The point is not to use ML. It is to understand it.

The repository is a course archive, but the teaching philosophy is the real product. Its notebooks are built to show how machine learning behaves when you strip away the friendly abstractions. Data is not just fed into a model. It is transformed, measured, and re-expressed until the logic is visible.

That is the white-box trick. Instead of treating the model as a sealed object, the course keeps opening it up. Students see where features come from, how distances are computed, and why a classifier votes the way it does.

Why the linear algebra notebook is the best clue

The best proof is the linear algebra lab. In FMML_Aug22_M1Lab4_LinearAlgebra.ipynb, a transformation is not just a matrix on paper. It is a warped coordinate grid, and that difference changes the lesson completely.

When basis vectors bend, rotate, or shear, the math stops feeling ceremonial. You can see that matrix multiplication is not a symbolic ritual. It is a way of remapping space.

From text and numbers to features

The same logic shows up in the data augmentation and feature extraction labs. The repository uses raw text, frequency counts, and n-grams to teach a simple but important lesson: features are built. They are not discovered by magic.

That matters because it changes how students think about data. A model cannot reason with the world directly. It reasons with representations. Once the notebook makes that visible, the rest of machine learning starts to look like a chain of translations.

from collections import Counter

def predict(X_train, y_train, x, k=3):
    distances = []
    for row, label in zip(X_train, y_train):
        d = ((row - x) ** 2).sum() ** 0.5
        distances.append((d, label))
    nearest = sorted(distances, key=lambda t: t[0])[:k]
    votes = [label for _, label in nearest]
    return Counter(votes).most_common(1)[0][0]

That small function is a pedagogical statement. It tells the learner that a classifier is just a distance rule plus a vote. There is no hidden priesthood inside the library call.

KNN from scratch is the course’s honesty test

The KNN notebooks make the course’s point with almost rude clarity. They rebuild Euclidean distance, neighbor lookup, and voting by hand. You are not allowed to treat classification as a magical outcome. You have to assemble it.

That is valuable because it shows where the judgment comes from. KNN looks simple, but the simplicity is earned. Once students can write the rule themselves, they can also inspect its limits: scale sensitivity, noisy neighbors, and the cost of brute-force search.

This curriculum is a ladder, not a pile of notebooks

The structure of the repository matters as much as any single lab. It is not a random dump of assignments. It moves from Python basics into linear algebra, then into distance metrics, classification, and eventually multi-layer perceptrons. That sequence is doing real pedagogical work.

Each stage depends on the previous one. By the time a student reaches a classifier, they have already learned how to shape data, measure similarity, and think in transformed spaces. The curriculum is designed so that later abstractions land on top of earlier ones instead of floating in midair.

What FMML gets right, and what it trades away

The repo’s biggest strength is transparency. It teaches students what libraries usually conceal. That makes it unusually good for durable understanding, especially for learners who will later meet ML from the engineering side rather than the research side.

The trade-off is equally clear. This style takes more time and tolerates more friction. It is not the fastest way to produce confident notebook users. It is the better way to produce people who can explain what a notebook is doing.

That puts FMML in a useful middle ground. Compared with library-first education, it is far more legible. Compared with fast-moving top-down courses, it is more exacting. Compared with theory-only instruction, it is more concrete. That combination is rare.

Why this repo matters beyond the course

FMML_COURSE_ASSIGNMENTS is a model for teaching technical subjects when understanding matters more than speed. It does not merely cover machine learning topics. It stages a set of translation exercises that make the subject visible from multiple angles.

That is the deeper lesson. Good pedagogy does not always mean fewer steps. Sometimes it means more intermediate representations, more drawings, more hand-built logic, and more chances for the learner to see the gears turn.