Machine Learning, A Working Session

Most machine learning problems fall into one of three setups, distinguished by what kind of feedback the model has to learn from. Supervised learning trains on examples that already have the right answer attached — a labeled photo, a priced house — and learns to predict that same kind of answer for new examples. Unsupervised learning has no right answer to check against; it looks for structure in the data itself, like grouping similar customers together with nobody having said in advance what the groups should be.

Reinforcement learning is different from both: there's no fixed dataset of right answers at all. An agent takes actions in an environment and learns from a reward signal that arrives afterward, adjusting its behavior toward whatever earned more reward over time — closer to learning through trial and error than to learning from an answer key.

A model can be trained until it fits its training examples almost perfectly — and that's not actually the goal. The real goal is generalization: performing well on new examples it never saw during training. A model that memorizes its training data rather than learning the underlying pattern will look excellent on paper and fail the moment it meets something slightly different — a failure mode called overfitting.

The practical check is a train/test split: holding a portion of the data back, never letting the model see it during training, and only checking performance on that held-out portion afterward. A model that does well on training data but poorly on the held-out test data is showing the classic signature of overfitting — it learned the training set, not the pattern the training set was supposed to represent.

A model never sees raw reality directly — it sees features, the specific measurements or properties chosen to represent each example. Classical machine learning depends heavily on a person choosing good features by hand: deciding that a house's square footage and location matter more than the color of its front door, before the model ever sees any data.

Deep learning changed this by learning its own feature representations directly from raw data — an image model doesn't need someone to hand-engineer "edge" and "curve" detectors; it discovers useful intermediate representations on its own during training. That shift, more than any single technique, is what separates most classical machine learning from the deep learning behind current generative AI.

A single accuracy number can hide a genuinely useless model. If 95% of a dataset belongs to one class, a model that always predicts that one class scores 95% accuracy while never actually learning anything — which is why evaluation needs metrics suited to the actual task, not just a headline percentage.

The right metric depends on what a wrong answer actually costs. A missed medical diagnosis and a misclassified email are both "errors," but the acceptable trade-off between catching more real cases and tolerating more false alarms is completely different between them — evaluation is a design decision about the task, not a fixed formula applied the same way everywhere.

A working ML system starts well before training — collecting and cleaning data, deciding what to predict and how to measure success — and continues well after it: deploying the model somewhere it can actually be used, and then watching it over time.

That last part matters more than it sounds: the real world changes after a model is deployed, a phenomenon called drift, and a model that performed well at launch can quietly degrade as the data it sees in production stops resembling the data it was trained on. Monitoring for that is part of the job, not an optional extra.