Stanford CS230 | Autumn 2025 | Lecture 4: Adversarial Robustness and Generative Models

This lecture lays the foundation for understanding what machine learning (ML) is, why it is useful, and how its main branches differ. It begins with a simple motivation: many real-world tasks are too complicated to encode with explicit, hand-written rules. For example, in image recognition, trying to program "look for pointy ears, whiskers, and a tail" quickly breaks down because there are endless exceptions: lighting changes, weird angles, partial views, and look-alike objects. Machine learning avoids rigid rule lists by learning directly from data—thousands of examples labeled as “cat” or “not cat”—so the computer itself discovers reliable patterns. This allows ML models to detect subtle features humans may never think to write down, such as tiny texture cues or certain color combinations.

The lecture offers two helpful definitions of ML. First, ML is the field that gives computers the ability to learn without being explicitly programmed. Second, ML is the process of building models from data. A model is a compact representation of how inputs (x) relate to outputs (y). Once trained, a model can predict outputs for new inputs, which is what makes ML useful in real applications.

The talk then categorizes the three primary types of ML: supervised learning, unsupervised learning, and reinforcement learning. Supervised learning trains on labeled data where each example comes with the correct answer, such as "this image is a cat" or "this email is spam." It aims to learn a function f that maps input x to output y. Two common supervised tasks are regression—predicting a continuous number like house price—and classification—predicting a class like dog vs. cat. Unsupervised learning has no labels and tries to find structure, such as grouping customers by similar purchasing behavior (clustering) or simplifying high-dimensional data into fewer variables while keeping important information (dimensionality reduction). Reinforcement learning is different: an agent interacts with an environment by taking actions and receives rewards or penalties as feedback, like learning to play chess or Go by trying moves and learning which strategies pay off.

A central practical message is the importance of splitting data into a training set and a test set. Training teaches the model the patterns in the data. The test set, which the model never sees during training, measures how well the model generalizes to brand-new examples. If you only evaluate on training data, you might think your model is great when it has actually just memorized answers, a failure called overfitting. The lecture uses a school analogy: memorizing practice answers instead of understanding the material works on the practice test but fails on the real exam. The model should understand the underlying patterns, not just memorize the training set.

To ground this, the lecture presents a simple regression example: predicting house price from square footage using linear regression. The model assumes a straight-line relationship, f(x) = ax + b, and training finds the a and b that best fit the data. Then, to price a new house, you plug in its size to get the prediction. This example captures the flow of supervised learning: define inputs and outputs, choose a model form, train its parameters on labeled data, and test how well it predicts new cases.

Finally, the lecture visits the common problem of overfitting and how to address it. Overfitting means the model learned training examples too perfectly and fails on new ones. Three straightforward remedies are suggested: use a simpler model, gather more data, and apply regularization (a technique that discourages overly complex solutions). The session closes by acknowledging there are many regression methods beyond linear regression—like polynomial regression, support vector regression, and decision tree regression—which help handle non-linear or complex data. Throughout, the main theme is learning from data to make predictions that hold up in the real world, with careful evaluation to ensure models truly generalize.

This lecture is suitable for beginners. You only need a basic comfort with the idea of inputs, outputs, and the concept of a function. After completing it, you will understand the key categories of ML, the idea of training versus testing, the meaning of overfitting, and how a simple model like linear regression works. You will be able to explain why ML is useful, describe the difference between regression and classification, and articulate why evaluating on a test set is essential. The structure is straightforward: start with the motivation for ML, define ML and models, outline the three types of learning, dive deeper into supervised learning with a concrete regression example, and finish with overfitting and practical remedies, plus a preview of other regression options.

1. Overall Architecture/Structure of the ML Workflow

• Problem Framing: We start by deciding what kind of prediction we need. If it’s a number (like price or temperature), it’s a regression problem. If it’s a category (like cat vs. dog), it’s a classification problem. If there are no labels and we just want structure (like groups of similar customers), it’s unsupervised learning. If we’re choosing actions in a situation to get more reward (like a game), it’s reinforcement learning. Clear framing keeps us from using the wrong tools.

• Data and Labels: In supervised learning, every example is a pair (x, y). The x (input) could be an image, text, or numeric features; y (output) is the correct answer (label). The goal is to learn a mapping f such that f(x) ≈ y for future x's we haven’t seen yet. Without labels, in unsupervised learning, we just have x and want to find structure in it.

• Model Choice: We pick a model family with a certain shape. For simple numeric predictions, linear regression is a common first choice: f(x) = ax + b with a slope (a) and intercept (b). For more complex patterns, we might need more flexible models (e.g., polynomial shapes or tree-based splits). The model choice balances simplicity (easy to understand, less likely to overfit) with flexibility (able to capture complex patterns).

• Training vs. Testing: We split data into a training set (to fit the model) and a test set (to estimate real-world performance). The model adjusts its parameters based on training examples, trying to minimize mistakes on that set. Then we measure performance on the test set, which was never seen during training, to check generalization. Good performance on the test set signals the model learned real patterns, not just memorized training answers.

• Evaluation and Overfitting: If the model scores great on training but poorly on testing, it is likely overfitting—memorizing training quirks and noise. Overfitting is like memorizing a practice test. The solution is to prefer simpler models, use more data, and (at a high level) apply regularization to discourage overly complex fits. The best model is the one that does well on unseen data.

• Deployment Mindset: Though not deeply covered in this session, once a model is trustworthy on new data, it can be used in real applications: predicting future prices, filtering spam, or recognizing images. A cycle of data collection, model training, evaluation, and improvement continues as new data arrives.

1. Supervised Learning in Detail

• Learning a Function f: The heart of supervised learning is mapping inputs to outputs. Imagine a scatterplot of house sizes (x) and prices (y). We want to draw a curve or line that goes through the cloud of points in a way that represents the relationship well. Linear regression assumes a straight line is a good fit: f(x) = ax + b. The parameters a and b are learned from the data to minimize overall error.

• Why Linear Regression First: Linear regression is easy to understand and interpret. The slope a tells you how much the output changes per unit change in input, and b is the baseline level when the input is zero. Even when relationships are not perfectly linear, a straight line can be a strong baseline. If the line is not enough, then you consider more complex models.

• Training Concept (High-Level): The model starts with some guess for a and b. It checks how far off its predictions are from the true prices on the training set. Then it updates a and b to reduce these errors. This process repeats until the line fits as well as possible without going wild on new data. The exact math for fitting is beyond this session, but the idea is simple: adjust until errors shrink.

• Generalization: We care about how well the model does on houses it hasn’t seen before. A model that memorizes the training set might match every training price exactly by bending and twisting (if it were allowed to be complex), but would then fail on new houses. Linear regression’s simple shape makes it naturally more resistant to this kind of overfitting. Still, we only trust it after we test it on new data.

• Regression vs. Classification: Regression outputs a number (e.g., $423,000). Classification outputs a label from a short list (e.g., “spam” or “not spam”). Both are supervised because they learn from labeled examples. The choice depends on what question you need answered.

1. Unsupervised Learning in Detail

• Clustering: Without labels, we group similar items. Customer purchase histories may cluster into a few types: frequent big spenders, coupon lovers, or seasonal buyers. Clustering helps create targeted marketing, better product placement, and personalized experiences, even though we didn’t know the groups ahead of time.

• Dimensionality Reduction: Some datasets have many variables (like hundreds of product attributes). Dimensionality reduction compresses this down to a handful of new variables that still capture the main patterns. This makes it easier to visualize and analyze, and can help other algorithms work better.

1. Reinforcement Learning in Detail

• Agent-Environment Loop: In RL, the agent observes the state of the environment (like a chessboard), chooses an action (a move), and gets a reward signal (win, loss, or points). Over time, the agent learns a policy—a rule for picking actions in each kind of situation—that maximizes long-term reward. It’s learning by doing and being scored.

• Trial and Error: Unlike supervised learning, there is no single labeled “correct” action for each state at the start. The agent must try actions and learn from the rewards to discover good strategies. This setup fits games and many control problems.

1. Overfitting Explained Clearly

• What It Is: Overfitting happens when a model pays too much attention to the training data’s quirks and noise. The lecture’s analogy—memorizing practice questions without understanding the subject—is perfect. You may ace the practice test (training set) but stumble on the real exam (test set).

• Why It’s Bad: Models that overfit look good in development but fail in real life. That wastes time and can cause bad decisions (like wrong prices or missed fraud).

• Simple Fixes: Prefer simpler models (fewer ways to memorize), get more data (true patterns stand out), and use regularization approaches (which penalize needless complexity). Always validate on a separate test set.

1. The House-Price Example (Linear Regression)

• Setup: Input x is house size (square feet). Output y is house price (dollars). We assume a straight-line relationship and write f(x) = ax + b.

• Training: Use many past houses with known sizes and prices to fit a and b. The best line is the one that overall stays closest to all points. After training, the model has fixed values of a and b.

• Prediction: Given a new house size, plug x into f(x) to estimate price. This simple pipeline—from inputs to a trained line to a prediction—captures the supervised learning loop.

1. Why Separate Training and Test Sets

• Honest Measurement: If you test on the same data you trained on, you are grading your own homework with the answer key in hand. The score will look too high. A test set, never seen during training, shows how the model really handles new cases.

• Real-World Parallel: In the wild, your model will meet fresh data every day. You want to know how it behaves before you deploy it. Test-set performance is your best early hint.

1. Broader Model Choices for Regression (Preview)

• Polynomial Regression: When the relationship curves (e.g., price rises faster beyond a certain size), a simple line may be too stiff. A polynomial can bend to fit gentle curves.

• Support Vector Regression (SVR): A more sophisticated approach that can handle complex relationships by focusing on a margin of tolerance around the predicted function.

• Decision Tree Regression: Breaks the data into regions using simple rules (like “if size < X, then price ~ Y”). It is non-parametric, meaning it doesn’t assume a fixed equation shape.

• Choosing Models Wisely: Start simple (often linear), check performance, and only add complexity if you need it. More complex models can overfit more easily, so stay cautious.

1. Practical Examples Echoed from the Lecture

• Image Recognition: Hard to write rules for whiskers, ears, and tails because images vary. ML learns cues directly from pixels.

• Spam Filtering: Instead of rules like “if the word ‘free’ appears,” ML spots subtler patterns across many words and message structures.

• Customer Segmentation: With no labels, clustering finds natural groups for better marketing.

• Game Playing (RL): The agent tries moves, sees results, and improves its strategy to win more often.

1. Tips and Warnings

• Do Not Skip the Test Set: Without it, you won’t notice overfitting until too late.

• Prefer Simplicity First: A simple model that generalizes beats a fancy one that memorizes.

• Gather Quality Data: More and better data usually helps models see the real pattern.

• Regularization (Conceptual Reminder): Add a gentle push toward simpler solutions to resist noise-chasing.

• Clear Problem Type: Decide upfront if it’s regression, classification, unsupervised discovery, or RL. Using the right frame saves you from confusion later.

In summary, this session establishes the ML mindset: learn from data, not hand-coded rules; pick an appropriate model; train on labeled examples (for supervised tasks); evaluate on a separate test set to ensure generalization; avoid overfitting by keeping models and expectations grounded; and use simple, well-understood tools like linear regression as a strong starting point. It also previews unsupervised learning for discovering structure and reinforcement learning for trial-and-error decision making.

This session builds a clear mental model for what machine learning is and why it matters. Instead of hand-writing brittle rules, we let models learn patterns directly from data, which is crucial for messy tasks like recognizing cats in photos or filtering spam. The lecture clarifies that supervised learning uses labeled examples to learn a function f mapping inputs to outputs, with regression predicting numbers and classification predicting categories. A simple but representative example—predicting house prices from size using linear regression—shows how to define inputs and outputs, fit a model, and make predictions.

A core lesson is to split data into training and test sets so we can judge true generalization. Overfitting, the trap of memorizing training data, looks like success until the model meets new examples; the remedy is to use simpler models, gather more data, and apply regularization. The lecture also sketches unsupervised learning for pattern-finding without labels (like clustering customers) and reinforcement learning for agents that learn by trial and error to maximize rewards (like mastering games). Together, these three branches cover most ML tasks you’ll meet.

Right after this session, practice by framing a small supervised problem: pick inputs and outputs, choose linear regression for a numeric target, split into train/test, and assess your model’s generalization. Try a simple classification task too (e.g., spam vs. not spam) to experience the difference. As next steps, deepen your understanding of evaluation habits (like always using a test set), explore regularization ideas at a high level, and gain intuition for when data complexity pushes you to consider more flexible models like polynomial or tree-based regressors.

The core message to remember: ML is about learning patterns from examples so predictions work on new, unseen data. Keep your models honest with a proper test set, start simple, and only add complexity when you can justify it with better generalization. With these habits, you will build models that move beyond memorization to real understanding—delivering reliable results where hand-written rules fall short.