CS 375: Wrap-Up

Core Concepts: The Four Pillars

Neural Computation

• Tensors as universal data structure
• Linear transformations + nonlinearities
• Learning via gradient descent

ML Systems

• Data pipelines: preprocessing → model → evaluation
• Abstractions: fit/predict APIs
• Systematic evaluation & generalization

Learning Machines

• Supervised learning: learning from examples
• Unsupervised learning: finding patterns
• Training, testing, and the generalization gap

Context & Implications

• What AI can vs. should solve
• Limitations: correlation ≠ causation
• AI in service of human flourishing

These four pillars form the foundation of our course and modern AI systems. Each represents a different perspective on the same technology, and together they give us a complete picture of how AI systems work, how they’re built, how they learn, and what their broader implications are.

Neural Computation: The Core

• Traditional vs. Neural computing
  • Traditional: Explicit instructions → Outputs
  • Neural: Data + Parameters + Architecture → Learned mapping
• Building blocks
  • Tensors (arrays) as fundamental data structure
  • Linear layers transform data
  • Nonlinearities (ReLU) add conditional logic
  • Gradient descent to adjust parameters

We’ve seen how we can build a computer out of blocks that do mathematical operations on vectors. The basic data structures are multidimensional arrays (tensors), where the most important information is their shape and value ranges.

We can use the same data structure for inputs, outputs, and intermediate representations. Linear transformations do the bulk of computing with parameters that can be adjusted. Non-linearities like ReLU add conditional logic so the network behaves differently depending on input characteristics.

Since every parameter has a measurable effect on output, we use gradient descent to adjust parameters during training: forward pass → loss → backward pass → parameter update.

ML Systems: Connecting to the World

• From raw data to predictions
  • Input transformation to structured tensors
  • Task-appropriate outputs and metrics
  • Systematic evaluation (train/val/test)
• Key abstractions
  • Data pipelines with clear stages
  • Common API patterns
  • Hyperparameters vs. learned parameters

Neural networks are powerful but need help connecting to the real world. We need conventional programs to:

• Feed data in formats they can work with
• Interpret results meaningfully
• Systematically evaluate performance

We treat neural networks as performing classification, regression, or other tasks based on how we interpret outputs and measure performance. We transform input data into batches of independent samples expressed as vectors.

We’ve developed the habit of holding out data to evaluate generalization. While gradient descent updates parameters, hyperparameters control the structure and training process, often requiring empirical testing.

Learning Machines: Improving from Experience

• Learning paradigms
  • Supervised: Mimicry from examples
  • Unsupervised: Pattern discovery without labels
  • Reinforcement: Learning from interaction and reward signals
• Error sources
  • Underfitting: Can’t represent training data well
  • Overfitting: Can’t generalize beyond training
  • Data issues: Biased or shifting distributions
  • Task misspecification: Optimizing the wrong thing

A neural computer with a program to feed it data and optimize parameters becomes a learning machine that improves with experience.

Supervised learning is mimicry: from examples, the machine learns to do likewise, for better or worse. Unsupervised learning finds patterns or relationships without known “right answers,” making success hard to measure.

Reinforcement learning combines supervised learning (evaluating actions in situations) with interactive exploration (taking actions to collect data about unseen situations).

Errors in real-world tasks come from: (1) underfitting - inability to represent training data well, (2) the generalization gap - inability to extend beyond training examples, (3) data shortcomings - e.g., assuming static conditions in a changing world, and (4) task misspecification - optimizing for the wrong objective.

Context & Implications: The Bigger Picture

• Possibilities and limitations
  • What problems can AI solve? Desk tasks with clear metrics
  • What should we use AI for? Love and service, not just efficiency
• Current limitations
  • Correlation vs. causation
  • Limited real-world interaction
  • Fixation on numeric metrics

What problems can AI solve? Ultimately, anything where you can quantify the quality of actions taken at a computer (or with sensors/motors connected to one).

What should we use AI for? To love and serve others better. Sometimes this means efficiency, but we shouldn’t mistake productivity for love.

Current limitations include: difficulty with causal understanding (correlation often suffices), lack of deep real-world interaction (breadth sometimes compensates but may be biased), absence of deep moral convictions despite appearances, and fixation on numeric metrics at the expense of other considerations.

Going Deeper: Neural Computation

• What we’ve seen
  • Basic building blocks: vectors, matrices, tensors
  • Linear layers and activation functions
  • Simple architectures (MLPs)
  • Gradient descent as learning mechanism
• What we haven’t seen
  • Deep networks with many layers
  • CNNs, RNNs, Transformers
  • Backpropagation internals
  • Advanced optimizers (Adam, etc.)

We’ve studied the fundamental building blocks, but haven’t explored:

• Deep networks with many hidden layers that can represent more complex computations but require additional training techniques
• Specialized architectures: CNNs (for spatial/temporal data), RNNs (adding memory), and Transformers (incorporating information through queries)
• The internal workings of backpropagation (which applies the chain rule of calculus)
• Optimizers beyond SGD, like Adam, which adaptively adjusts learning rates based on parameter update history

In the broader context, image classification networks use the same basic structure but add convolutional layers for efficient pattern extraction. Large language models store information in multilayer perceptrons similar to what we’ve studied, but add attention mechanisms allowing word context to shape processing. Ultimately, an LLM is a sophisticated classifier predicting the next token in a sequence.

Going Deeper: ML Systems

• What we’ve seen
  • Classification and regression tasks
  • Input transformations and batching
  • Performance metrics and evaluation
  • Hyperparameter tuning
• What we haven’t seen
  • Scaling models and abstractions to LLMs
  • Commercial APIs for embeddings
  • Converting real-world problems to ML tasks

Commercial ML APIs often simplify these details, allowing access to AI functionality through simple data structures like conversational interfaces.

In CS 376, we’ll see how these abstractions scale to LLMs (tokenization → model → sampling). Commercial APIs also provide embeddings useful for vector database lookups. Converting real-world situations to appropriate supervised learning tasks often requires creativity and practice.

Going Deeper: Learning Machines

• What we’ve seen
  • Basic supervised and unsupervised approaches
  • Generalization concepts
  • Error analysis and debugging
• What we haven’t seen
  • Self-supervised learning
  • Training at massive scale
  • RLHF for generative models
  • Scale as regularization

What we haven’t yet explored:

• Scale as regularization in modern AI: rather than multiple epochs on small data, doing fewer epochs on much larger datasets
• Self-supervised learning: turning unsupervised problems into supervised ones by hiding/blurring data and predicting what was concealed (e.g., LLMs predicting next words)
• Reinforcement learning from human feedback for generative models (chatbots, image generation, etc.)

Going Deeper: Context & Implications

• Questions we’ve explored
  • AI capabilities vs. appropriate uses
  • Evaluation beyond metrics
  • Ethical considerations and impacts
• Questions we’ll continue exploring
  • How AI systems align with human values
  • Navigating benefits and risks in deployment
  • Cultivating wisdom in technological development

We’ve examined what AI can do versus what it should do, how we evaluate systems beyond simple metrics, and various ethical considerations.

We’ll continue exploring how to align AI with human values, how to navigate the benefits and risks of deployment, and how to cultivate wisdom in technological development - questions that remain central as AI capabilities advance.

Connections: Modern AI Systems

• Image classifiers
  • Same basic structure as our simple networks
  • Addition of convolutional layers for pattern extraction
  • Hierarchical feature learning
• Large Language Models
  • At core: fancy classifier over next token
  • Feature extractors + linear/softmax layers
  • Addition of attention mechanisms for context
  • Self-supervised learning at massive scale

Image classification networks have the same basic structure as our simple networks but add convolutional layers to efficiently extract patterns from spatial data.

Large language models store information in structures similar to the multilayer perceptrons we’ve studied, but add attention mechanisms allowing context to shape processing. Ultimately, an LLM is a sophisticated classifier predicting the next token in a sequence: embedding the current context, then using linear and softmax layers to predict probabilities for the next token.

Looking Forward to CS 376

• Models for structured objects
  • Images, text, multimodal inputs
• Advanced architectures
  • CNN, RNN, Transformers
• Agent-based approaches
  • Advanced use of LLMs
  • Reinforcement learning for language/agents
  • Tool use and planning

In CS 376, we’ll explore:

• Models for structured objects (images, text)
• More advanced architectures (CNN, RNN, Transformers)
• Agent-based architectures (advanced use of LLMs)
• Reinforcement learning especially for language and agents

This Course: Reflecting Together

• We’ve prototyped education in an AI-pervasive world
• What worked? What didn’t?
• What did you appreciate?
• How might we think about the value of learning communities?

We’ve attempted to run this course as a prototype for education in an AI-pervasive world. Some aspects worked better than expected, others not as well. I sometimes reverted to old habits, but we’ve also explored new approaches.

Let’s reflect: What did you appreciate? What other ways could we think about the value of learning communities like this?