Stanford CS230 | Autumn 2025 | Lecture 8: Agents, Prompts, and RAG

This lecture serves two purposes: first, to establish the logistics of the course, and second, to introduce the foundational ideas of machine learning (ML). On the logistics side, you learn the schedule (two lectures a week on Tuesday and Thursday, 11–1 Athens time), the delivery method (Blackboard Collaborate with a stable link), and the availability of recorded sessions posted on the course webpage. The instructor strongly encourages live attendance for real-time discussion and Q&A. Course materials will be posted online, there is no official textbook, but Bishop’s “Pattern Recognition and Machine Learning” is recommended as a reference that aligns well with the instructor’s teaching style.

Assessment is composed of two individual homeworks (each 20%) and one final exam (60%). The final exam is a two-hour closed-book exam covering the entire course. The instructor emphasizes that homeworks are essential to success: they mirror the thinking and problem types that will appear on the final exam. The course is challenging, and the grading scale is clear: A for scores ≥9, B for 7–9, C for 5–7, and fail for <5. Students are urged to work steadily, follow lectures, and invest sufficient time in study and assignments.

On tools, the course uses MATLAB as the principal programming language. While Python is popular in the ML community, MATLAB is preferred here for two reasons: it mirrors mathematical notation closely, making formula-to-code translation intuitive; and its debugging tools, especially for linear algebra operations, are robust and easy to use. This selection supports clear learning of mathematical foundations without getting lost in software engineering details.

The lecture then transitions to the central question: what is machine learning? A simple working definition is given—ML is the science of giving computers the ability to learn from data without being explicitly programmed. Compared to standard programming (where we input data and a hand-written program to get answers), ML reverses the pipeline: we provide data and the corresponding answers (labels), and the system learns a program (model) that can generalize to new data. This perspective sets the stage for understanding why ML is needed: some tasks (like speech recognition) are too complex to specify manually with rules, environments change and demand adaptive behavior, and vast datasets can reveal new patterns and knowledge that aren’t obvious to humans.

The lecture categorizes ML into three main types: supervised learning, unsupervised learning, and reinforcement learning. Supervised learning uses labeled examples to learn to predict labels on new inputs. It includes classification (predicting categories like spam vs. not spam, or cat vs. dog) and regression (predicting numbers like house prices or temperatures). Unsupervised learning works without labels to uncover structure in data—clustering similar customers and reducing dimensionality to keep the most informative features while compressing the rest (e.g., fewer pixels capturing the essence of an image, or fewer genes representing key variation in biological data). Reinforcement learning is about learning to act through trial and error, guided by rewards (e.g., a robot that improves at a game through experience).

A practical, end-to-end ML process is also laid out in six steps: data collection, data preprocessing, model selection, model training, model evaluation, and model deployment. Data quality is fundamental because poor inputs cripple outcomes. Preprocessing cleans and transforms raw data into a usable form. Model selection chooses the right approach for the task and data. Training adjusts parameters using data-driven feedback. Evaluation tests the model on unseen data to estimate generalization. Deployment puts the model into real-world use.

Finally, the lecture discusses common challenges: data scarcity, data quality issues, overfitting (when a model memorizes training data rather than learning patterns), interpretability (understanding why a model predicts what it does), and bias (when training data leads to unfair or skewed predictions). It rounds out with applications—image recognition, speech recognition, natural language processing (translation, summarization, question answering), recommendation systems, and fraud detection—and a forward-looking note that ML’s future is bright thanks to more powerful algorithms, increasing data, and expanding applications. The session concludes with Q&A confirming that homeworks are individual and a reminder to attend the next class at the same time.

Overall Architecture/Structure of the Course and Concepts

1. Course Logistics Architecture

• Delivery: Two live online lectures per week (Tuesdays and Thursdays, 11:00–13:00 Athens time) via a stable Blackboard Collaborate link. Recordings are posted on the course webpage alongside announcements, schedules, and materials. The recommended flow is to attend live for interactivity and use recordings for review and catch-up.
• Materials: No official textbook. Primary materials are lecture notes and slides on the course webpage. A recommended reference is “Pattern Recognition and Machine Learning” (PRML) by Christopher M. Bishop, which supports deeper study and aligns with the course’s mathematical approach.
• Assessment: Two homeworks (each 20%) and a final exam (60%). Homeworks are individual and mirror final exam thinking, building both conceptual and problem-solving skills. The final exam is closed-book, two hours, and covers all course content.
• Grading Scale: A (≥9), B (7–9), C (5–7), Fail (<5). This clarity sets expectations and underscores the course’s challenging nature. Steady effort, homework diligence, and regular study are emphasized as keys to success.
• Tools: MATLAB is the primary language. Reasons: (1) it closely mirrors mathematical notation, letting you translate equations directly into code; (2) it offers excellent debugging, especially for linear algebra (vectors, matrices), which are central to ML. While Python is popular, MATLAB reduces friction in learning core mathematical concepts.

1. Conceptual Architecture of Machine Learning Machine Learning reframes problem-solving from rule-writing to pattern-learning. Standard programming combines a human-written program with data to produce answers. ML combines data with answers (labels) to produce a program (model). This inversion is powerful for tasks with complex, fuzzy, or evolving rules.

Core ML Types:

• Supervised Learning: Learn from labeled data to predict labels on new inputs. Subtasks include classification (categorical outputs) and regression (continuous outputs). The model’s objective is to generalize beyond seen examples.
• Unsupervised Learning: Learn from unlabeled data to reveal structure—clusters, latent factors, or compressed representations. Useful when labels are scarce or to explore and understand data.
• Reinforcement Learning: Learn actions via interaction with an environment, using rewards as feedback to optimize a policy over time.

1. Data Flow in a Typical ML Project

• Data Collection → Data Preprocessing → Model Selection → Model Training → Model Evaluation → Deployment.
• Feedback loops: Evaluation informs further data collection or changes in preprocessing and model choice. Deployed models generate new data and insights that feed back into the pipeline.

Detailed Explanations by Step

Step 1: Data Collection

• Objective: Gather representative examples that mirror the variety and conditions of the real task. Balance across categories, demographics, time periods, and conditions reduces bias and improves robustness.
• Practicalities: Determine sources (databases, APIs, sensors), define what features and labels are needed, and log metadata (timestamps, conditions, devices). Obtain consent and adhere to privacy and compliance needs.
• Pitfalls: Sampling bias (over-representing one group), selection bias (excluding rare but important cases), and concept drift (environment changes over time) must be monitored.

Step 2: Data Preprocessing

• Cleaning: Handle missing values (impute, drop), remove duplicates, fix typos, and correct outlier entry errors. Consistency is key.
• Transformation: Normalize/standardize numerical features to stabilize learning; encode categorical variables (e.g., one-hot); extract features from raw modalities (e.g., MFCCs from audio, edges from images) if needed.
• Splits: Divide data into training, validation, and test sets to enable unbiased performance estimation. The test set should remain untouched until final evaluation.
• Documentation: Record all preprocessing steps to ensure reproducibility and to apply the same pipeline during deployment.

Step 3: Model Selection

• Choice depends on task (classification vs. regression), data size, feature types, and interpretability needs. For simple, tabular data, linear models or decision trees may work well; for images/audio, more complex models are often needed, but this course emphasizes math fundamentals over specific deep architectures in this lecture.
• Criteria: Bias-variance trade-off (simplicity vs. flexibility), computational cost, interpretability, and robustness to noise.
• Validation: Use cross-validation or a validation set to compare candidates before finalizing.

Step 4: Model Training

• Objective: Find parameters that minimize a loss function on training data. For regression, a common loss is mean squared error; for classification, cross-entropy is typical.
• Optimization: Iterative updates adjust parameters to reduce loss. Gradient-based methods are common in many settings; in MATLAB, linear algebra operations express these steps compactly.
• Regularization: Penalties (like L2) discourage overly complex models, combating overfitting.
• Monitoring: Track training and validation error curves to detect underfitting/overfitting and to tune hyperparameters.

Step 5: Model Evaluation

• Purpose: Estimate generalization—how well the model performs on new, unseen data.
• Metrics: Accuracy, precision/recall/F1 for classification; RMSE/MAE for regression; confusion matrices to understand error types. Always evaluate on a hold-out test set not used in training or model selection.
• Fairness and Bias Checks: Assess performance across subgroups to detect biases introduced by data or model design.

Step 6: Deployment

• Integration: Package the trained model and preprocessing pipeline into a service or application. Ensure the same feature extraction and scaling are applied at inference time.
• Monitoring: In production, track model performance, data drift, latency, and error rates. Plan retraining schedules or triggers when drift is detected.
• Maintenance: Update models with new data to retain accuracy as environments evolve.

Key ML Concepts with the Required Pattern

1. Machine Learning

• Definition: Giving computers the ability to learn from data instead of explicit programming.
• Analogy: Like a student learning from many examples rather than memorizing rules.
• Technical: Models map inputs to outputs using parameters tuned to minimize prediction error.
• Why It Matters: Explicit rules are infeasible for complex patterns and changing environments.
• Example: Learning to transcribe speech by training on paired audio and text.

1. Standard Programming vs. ML

• Definition: In standard programming, humans write rules; in ML, the machine learns rules from data.
• Analogy: Following a recipe vs. learning to write the recipe by tasting dishes.
• Technical: ML solves an optimization problem where the “program” is the fitted model.
• Why It Matters: Reduces brittle, hard-coded logic and scales to complex tasks.
• Example: Spam filters learned from labeled emails rather than manual keyword lists.

1. Supervised Learning

• Definition: Learning from labeled examples to predict labels for new inputs.
• Analogy: Using flashcards with the correct answers on the back.
• Technical: Choose a hypothesis class and minimize loss over labeled data.
• Why It Matters: Many real tasks provide labels (e.g., diagnoses, prices).
• Example: Cat vs. dog image classification; house price prediction.

1. Classification

• Definition: Predict discrete categories.
• Analogy: Sorting mail into bins.
• Technical: Outputs class probabilities or labels; uses metrics like accuracy.
• Why It Matters: Enables automated decision routing.
• Example: Spam vs. not spam.

1. Regression

• Definition: Predict continuous values.
• Analogy: Estimating tomorrow’s temperature from recent days.
• Technical: Fit functions minimizing numeric error (e.g., MSE).
• Why It Matters: Supports forecasting and planning.
• Example: Predicting house prices.

1. Unsupervised Learning

• Definition: Discovering structure in unlabeled data.
• Analogy: Grouping LEGO pieces by look without labels.
• Technical: Clustering and dimensionality reduction reveal latent patterns.
• Why It Matters: Labels are expensive; insights drive strategy.
• Example: Customer segmentation.

1. Clustering

• Definition: Grouping similar items together.
• Analogy: Pairing socks after laundry.
• Technical: Similarity metrics guide cluster formation.
• Why It Matters: Personalization and discovery.
• Example: Marketing segments.

1. Dimensionality Reduction

• Definition: Compressing features while retaining key information.
• Analogy: Shrinking a photo but keeping it recognizable.
• Technical: Transform to lower dimensions capturing most variance.
• Why It Matters: Reduces noise, speeds training, aids visualization.
• Example: Reducing pixels or gene features.

1. Reinforcement Learning

• Definition: Learning to act by maximizing rewards over time.
• Analogy: A pet learning tricks for treats.
• Technical: Policies map states to actions; feedback comes as rewards.
• Why It Matters: Handles sequential decisions with delayed feedback.
• Example: A robot improving at a game.

1. Overfitting

• Definition: Memorizing training data instead of learning general patterns.
• Analogy: Acing practice questions but failing the real test.
• Technical: Low training error, high test error; mitigated by regularization and more data.
• Why It Matters: Poor generalization harms real performance.
• Example: Spam filter failing on new emails.

1. Interpretability

• Definition: Ability to explain model predictions.
• Analogy: Asking, “Why did you think this was spam?”
• Technical: Interpretable models or post-hoc explanations reveal influential features.
• Why It Matters: Builds trust, enables debugging.
• Example: Highlighting words that triggered a spam decision.

1. Bias

• Definition: Systematic unfairness from data or design.
• Analogy: Studying only sunny days and being surprised by rain.
• Technical: Arises from sampling, labels, or features; requires checks and balanced data.
• Why It Matters: Unfair outcomes damage users and credibility.
• Example: Model underperforming on underrepresented groups.

Course Tools and Practices (MATLAB)

• MATLAB aligns code with mathematical expressions: vectors, matrices, and operations mirror equations. For example, matrix multiplication implements linear transformations succinctly. The debugger displays variable states and supports step-by-step execution, invaluable for diagnosing linear algebra issues. This reduces time spent on tooling and increases focus on understanding algorithms.

Step-by-Step Implementation Guide (Conceptual)

1. Define the Problem: Is it classification or regression? What is the target variable? What are the features?
2. Collect Data: Ensure diversity and coverage. Record metadata and ensure privacy compliance.
3. Preprocess Data: Clean missing values, normalize, encode categories, and split datasets.
4. Select a Model: Start simple (e.g., linear models) and escalate complexity if needed.
5. Train: Optimize the loss function on training data; apply regularization as needed.
6. Validate and Tune: Use a validation set to choose hyperparameters and avoid overfitting.
7. Test: Evaluate final performance on a hold-out test set.
8. Deploy: Package preprocessing + model; monitor in production for drift and errors.
9. Maintain: Periodically refresh with new data and re-evaluate fairness and performance.

Tips and Warnings

• Start with Data Quality: Even the best model cannot fix poor data.
• Prevent Leakage: Keep test data unseen during training and tuning.
• Watch for Overfitting: If training performance is great but test is poor, simplify, regularize, or get more data.
• Balance Classes: For classification, ensure balanced samples or use class weighting.
• Document Everything: Preprocessing steps, parameter choices, and evaluation protocols ensure reproducibility.
• Prefer Interpretability When Stakes Are High: In critical applications, simpler or explainable models may be better than opaque ones.
• Use MATLAB Debugger: Step through matrix computations to understand and fix numerical issues.

Applications Tied to Concepts

• Image Recognition: Supervised learning with labeled images; dimensionality reduction aids feature extraction.
• Speech Recognition: Supervised mapping from audio features to text; data diversity across accents is crucial.
• NLP: Supervised tasks like translation and summarization; preprocessing includes tokenization and normalization.
• Recommendation: Often combines supervised learning (predict ratings) with unsupervised techniques (latent factors, clustering).
• Fraud Detection: Supervised classification with strong emphasis on class imbalance and drift monitoring.

Future Outlook

• More Powerful Algorithms: Improved optimization and architectures increase capability.
• More Data: Broader and deeper datasets improve generalization if curated responsibly.
• More Applications: ML will expand into new sectors, driving automation and decision support.

In all, this lecture lays down the process, types, challenges, and practicalities that form the backbone of the course and real-world ML work.

This lecture accomplishes two major goals: setting clear course logistics and grounding you in the essential ideas of machine learning. You now know how to join live sessions, where to find materials and recordings, and how you’ll be graded. MATLAB is chosen to align code with math and to make debugging linear algebra straightforward, keeping your focus on concepts rather than tooling struggles. Assessment emphasizes two individual homeworks and a final exam, with homeworks designed to mirror exam-style thinking and ensure steady progress.

On the ML side, the lecture defines machine learning as learning from data rather than hand-crafted rules, contrasting it with standard programming. It organizes ML into supervised (classification and regression), unsupervised (clustering and dimensionality reduction), and reinforcement learning (reward-driven decision making). You also learned a practical six-step ML workflow: data collection, preprocessing, model selection, training, evaluation, and deployment. The instructor stresses that good data is the bedrock of good models and that evaluation on unseen data is essential for honest performance estimates.

You explored common challenges—data scarcity, data quality, overfitting, interpretability, and bias—and how they can derail projects if not addressed. Applications span from image and speech recognition to NLP, recommendation, and fraud detection, showing how these core ideas power everyday technologies. The future is promising, with more data, stronger algorithms, and more applications expanding ML’s reach.

To practice, begin by framing a small supervised learning task, collecting a clean dataset, and walking it through the six steps. Try a classification problem like spam detection or a regression problem like price prediction to experience the full pipeline. Next steps include deepening your understanding with Bishop’s PRML, experimenting with MATLAB’s linear algebra tools, and building intuition for model selection and overfitting control. The core message to remember: master the fundamentals—data quality, clear problem framing, and disciplined evaluation—because they decide success more than any single algorithm choice.