Day 1 — The Value Class & Computation Graphs

The future should be viewed not as a fixed outcome that’s destined to happen, but as a range of possibilities. In learning, every concept is a probability distribution — some paths lead to deep understanding, most lead to surface familiarity. Your job today is to shift that distribution. — Adapted from the Howard Marks framework, applied to learning

I. Where You Are — The Distribution of Understanding

Like an investment, your understanding of any concept follows a probability distribution. Most learners cluster around shallow familiarity — they’ve “heard of” backpropagation but can’t implement it. The goal of Day 1 is to push you rightward on this curve: from awareness to comprehension.

Exhibit A — Distribution of Understanding: “What is a Value Class?”

II. The Value Class — A Number That Remembers

A regular Python number like 3.0 is dead. It knows nothing about where it came from or what created it. The Value class is a number that is alive — it remembers its parents, the operation that created it, and can trace back through every step of its creation. This “memory” is what makes backpropagation possible.

Exhibit B — Computation Graph: How a + b × c Remembers Everything

The Key Insight

Every Value node stores: (1) its data, (2) its gradient, (3) its children (inputs), and (4) the operation that created it. This is the entire backbone of neural network training. Without this graph, gradients have no path to flow backward.

III. The Implementation — Code That Captures the Graph

class Value:

    def __init__(self, data, _children=(), _op=''):
        self.data = data              # the actual number
        self.grad = 0.0               # derivative of output w.r.t. this value
        self._prev = set(_children)  # what created me?
        self._op = _op               # what operation created me?

    def __add__(self, other):
        out = Value(self.data + other.data, (self, other), '+')
        return out

    def __mul__(self, other):
        out = Value(self.data * other.data, (self, other), '*')
        return out

    def __repr__(self):
        return f"Value(data={self.data})"

# Usage — this builds the graph from Exhibit B above:
a = Value(2.0)
b = Value(-3.0)
c = Value(10.0)
d = a * b          # Value(data=-6.0), _children=(a,b), _op='*'
e = d + c          # Value(data=4.0),  _children=(d,c), _op='+'
  

IV. The Pendulum — Where Beginners Swing Too Far

Howard Marks describes how markets oscillate between extremes, rarely resting at equilibrium. Learners do the same. Here’s the pendulum of Day 1 mistakes:

V. The Matrix — What Matters on Day 1

Just as Marks separates what you can know from what you can’t, here’s how to allocate your limited hours today:

High Understanding Value

Low Understanding Value

Quick to Do

🎯

DO FIRST

Install Python, PyTorch, Jupyter. Type out the Value class line by line. Run a + b and inspect ._prev and ._op.

⏭️

DO IF TIME

Prettify your notebook, add markdown headers, organize file structure. Nice but not essential today.

Slow to Do

🖐

DO CAREFULLY

Draw the computation graph by hand for 3 different expressions. This is slow but builds deep intuition for tomorrow’s backward pass.

🚫

AVOID TODAY

Reading ahead about backprop, watching 5 other videos “for context”, setting up a fancy IDE. Stay focused. Go deep on one thing.

VI. Today’s Deliverables

Environment: Python 3.10+, PyTorch, Jupyter Notebook — all working
Value class: Implement __init__, __add__, __mul__, __repr__
Test it: Create a = Value(2.0); b = Value(-3.0); c = a * b — verify c.data == -6.0
Trace it: Print c._prev and c._op — confirm the graph is being built
Draw it: Hand-draw the computation graph for (a * b) + c on paper
Stretch: Add __sub__ and __truediv__ on your own — think about what _children should be

The most important thing in learning, as in investing, is not what you know — it’s the quality of your understanding. A shallow grasp of 10 concepts will always lose to deep fluency in one. Today you master exactly one thing: a number that remembers where it came from. — Day 1 Principle

Day 1 Notebook — The Value Class & Computation Graphs Runnable Python

Complete, runnable implementation of the Value class with computation graph building, visualization, and exercises.

▶ Open in Colab View on GitHub nbviewer