Module 4 · Math toolkit (visual first) · ~25 min
4.3 exp and log
Two functions run all through microgpt: exp, which turns any number into a positive one, and log, which turns multiplying into adding. They undo each other.
1Watch
Start with powers you know: 2³ = 2 × 2 × 2 = 8. A log asks the question backwards: “what power of 2 gives 8?” The answer is 3, written log₂(8) = 3. Likewise log₂(16) = 4, because 2⁴ = 16.
Here’s the trick that makes logs useful. Multiplying powers adds the powers: 2³ × 2⁴ = 8 × 16 = 128 = 2⁷, and 3 + 4 = 7. So a log turns multiplying into adding: log(a × b) = log(a) + log(b).
Computers use a special number instead of 2: e ≈ 2.718. exp(x) means e to the power x, and log(x) asks “what power of e gives x?” This log is called the natural log, written ln; in Python it’s math.log. Since one asks the other’s question backwards, they undo each other: log(exp(x)) = x.
| x | exp(x) |
|---|---|
| −1 | 0.37 |
| 0 | 1 |
| 1 | 2.718 |
| 2 | 7.39 |
| 3 | 20.1 |
| p | log(p) |
|---|---|
| 1 | 0 |
| 2.718 | 1 |
| 1/2 | −0.69 |
| 1/27 | −3.30 |
exp is always positive, even for negative x: exp(−1) is about 0.37. And the log of a number below 1 is negative, because you need a negative power of e to get something small.
Chances are always 1 or less, so the log of a chance is negative (or 0). Put a minus sign in front and you get a positive number called the surprise: −log(p). A sure thing (p = 1) has surprise 0; an unlikely thing has a big surprise. A 1-in-27 guess: −log(1/27) = 3.30. Chances multiply when things happen one after another, so thanks to the log their surprises simply add. Later we’ll use surprise to score how good a model’s guesses are.
2Explore
Multiplying becomes adding
a = 2.0
b = 4.0
log a = 0.693
log b = 1.386
log a + log b = 2.079
a × b = 8.00, log(a × b) = 2.079
The orange and blue bars laid end to end always match the grey bar below. Move a or b below 1: its log turns negative and its bar points left.
exp and log undo each other
x = 1.0
exp(1.0) = 2.718 → log(2.718) = 1.0
Flip the orange exp curve over the dashed line y = x and you get the blue log curve. exp never touches 0, even for very negative x, so its answers are always positive.
3Build
One blank: surprise(p) is minus the natural log of p. Write it as -math.log(p): math.log is the natural log (math.log10 is a different one, and plain log isn’t defined).
import math
# exp(x) is e to the power x (e is about 2.718). log asks the reverse
# question: "what power of e gives this number?" They undo each other.
# Because powers add when you multiply (2**3 * 2**4 = 2**7),
# log turns multiplying into adding: log(a * b) = log(a) + log(b)
a, b = 0.5, 0.25
print('log(a * b) =', math.log(a * b))
print('log(a) + log(b) =', math.log(a) + math.log(b))
print('exp(log(7)) =', math.exp(math.log(7)), ' (not exactly 7: computers store decimals approximately)')
# Surprise: how surprised you should be by something that had chance p.
# Write it as code with math.log (just "log" on its own isn't defined here).
def surprise(p):
return 0 # TODO: minus the natural log of p (math.log is the natural log)
print('surprise of 1/27:', round(surprise(1 / 27), 4)) # should be 3.2958
print('surprise of a sure thing:', surprise(1)) # should be 0
4Check yourself
5Unlocked in microgpt
Lines 48 and 49 give microgpt’s numbers a log and an exp. The extra bits (like 1/self.data, a slope from 4.2) will make sense in Module 7.
Progress is saved in this browser. Sign in to keep it across devices.
microgpt.py52 / 175 lines learned
1"""
2The most atomic way to train and run inference for a GPT in pure, dependency-free Python.
3This file is the complete algorithm.
4Everything else is just efficiency.
5
6@karpathy
7"""
8
9import os # os.path.exists
10import math # math.log, math.exp
11import random # random.seed, random.choices, random.gauss, random.shuffle
12random.seed(42) # Let there be order among chaos
13
14# Let there be a Dataset `docs`: list[str] of documents (e.g. a list of names)
15if not os.path.exists('input.txt'):
16 import urllib.request
17 names_url = 'https://raw.githubusercontent.com/karpathy/makemore/988aa59/names.txt'
18 urllib.request.urlretrieve(names_url, 'input.txt')
19docs = [line.strip() for line in open('input.txt') if line.strip()]
20random.shuffle(docs)
21print(f"num docs: {len(docs)}")
22
23# Let there be a Tokenizer to translate strings to sequences of integers ("tokens") and back
24uchars = sorted(set(''.join(docs))) # unique characters in the dataset become token ids 0..n-1
25BOS = len(uchars) # token id for a special Beginning of Sequence (BOS) token
26vocab_size = len(uchars) + 1 # total number of unique tokens, +1 is for BOS
27print(f"vocab size: {vocab_size}")
28
29# Let there be Autograd to recursively apply the chain rule through a computation graph
30class Value:
31 __slots__ = ('data', 'grad', '_children', '_local_grads') # Python optimization for memory usage
32
33 def __init__(self, data, children=(), local_grads=()):
34 self.data = data # scalar value of this node calculated during forward pass
35 self.grad = 0 # derivative of the loss w.r.t. this node, calculated in backward pass
36 self._children = children # children of this node in the computation graph
37 self._local_grads = local_grads # local derivative of this node w.r.t. its children
38
39 def __add__(self, other):
40 other = other if isinstance(other, Value) else Value(other)
41 return Value(self.data + other.data, (self, other), (1, 1))
42
43 def __mul__(self, other):
44 other = other if isinstance(other, Value) else Value(other)
45 return Value(self.data * other.data, (self, other), (other.data, self.data))
46
47 def __pow__(self, other): return Value(self.data**other, (self,), (other * self.data**(other-1),))
48 def log(self): return Value(math.log(self.data), (self,), (1/self.data,))
49 def exp(self): return Value(math.exp(self.data), (self,), (math.exp(self.data),))
50 def relu(self): return Value(max(0, self.data), (self,), (float(self.data > 0),))
51 def __neg__(self): return self * -1
52 def __radd__(self, other): return self + other
53 def __sub__(self, other): return self + (-other)
54 def __rsub__(self, other): return other + (-self)
55 def __rmul__(self, other): return self * other
56 def __truediv__(self, other): return self * other**-1
57 def __rtruediv__(self, other): return other * self**-1
58
59 def backward(self):
60 topo = []
61 visited = set()
62 def build_topo(v):
63 if v not in visited:
64 visited.add(v)
65 for child in v._children:
66 build_topo(child)
67 topo.append(v)
68 build_topo(self)
69 self.grad = 1
70 for v in reversed(topo):
71 for child, local_grad in zip(v._children, v._local_grads):
72 child.grad += local_grad * v.grad
73
74# Initialize the parameters, to store the knowledge of the model
75n_layer = 1 # depth of the transformer neural network (number of layers)
76n_embd = 16 # width of the network (embedding dimension)
77block_size = 16 # maximum context length of the attention window (note: the longest name is 15 characters)
78n_head = 4 # number of attention heads
79head_dim = n_embd // n_head # derived dimension of each head
80matrix = lambda nout, nin, std=0.08: [[Value(random.gauss(0, std)) for _ in range(nin)] for _ in range(nout)]
81state_dict = {'wte': matrix(vocab_size, n_embd), 'wpe': matrix(block_size, n_embd), 'lm_head': matrix(vocab_size, n_embd)}
82for i in range(n_layer):
83 state_dict[f'layer{i}.attn_wq'] = matrix(n_embd, n_embd)
84 state_dict[f'layer{i}.attn_wk'] = matrix(n_embd, n_embd)
85 state_dict[f'layer{i}.attn_wv'] = matrix(n_embd, n_embd)
86 state_dict[f'layer{i}.attn_wo'] = matrix(n_embd, n_embd)
87 state_dict[f'layer{i}.mlp_fc1'] = matrix(4 * n_embd, n_embd)
88 state_dict[f'layer{i}.mlp_fc2'] = matrix(n_embd, 4 * n_embd)
89params = [p for mat in state_dict.values() for row in mat for p in row] # flatten params into a single list[Value]
90print(f"num params: {len(params)}")
91
92# Define the model architecture: a function mapping tokens and parameters to logits over what comes next
93# Follow GPT-2, blessed among the GPTs, with minor differences: layernorm -> rmsnorm, no biases, GeLU -> ReLU
94def linear(x, w):
95 return [sum(wi * xi for wi, xi in zip(wo, x)) for wo in w]
96
97def softmax(logits):
98 max_val = max(val.data for val in logits)
99 exps = [(val - max_val).exp() for val in logits]
100 total = sum(exps)
101 return [e / total for e in exps]
102
103def rmsnorm(x):
104 ms = sum(xi * xi for xi in x) / len(x)
105 scale = (ms + 1e-5) ** -0.5
106 return [xi * scale for xi in x]
107
108def gpt(token_id, pos_id, keys, values):
109 tok_emb = state_dict['wte'][token_id] # token embedding
110 pos_emb = state_dict['wpe'][pos_id] # position embedding
111 x = [t + p for t, p in zip(tok_emb, pos_emb)] # joint token and position embedding
112 x = rmsnorm(x) # note: not redundant due to backward pass via the residual connection
113
114 for li in range(n_layer):
115 # 1) Multi-head Attention block
116 x_residual = x
117 x = rmsnorm(x)
118 q = linear(x, state_dict[f'layer{li}.attn_wq'])
119 k = linear(x, state_dict[f'layer{li}.attn_wk'])
120 v = linear(x, state_dict[f'layer{li}.attn_wv'])
121 keys[li].append(k)
122 values[li].append(v)
123 x_attn = []
124 for h in range(n_head):
125 hs = h * head_dim
126 q_h = q[hs:hs+head_dim]
127 k_h = [ki[hs:hs+head_dim] for ki in keys[li]]
128 v_h = [vi[hs:hs+head_dim] for vi in values[li]]
129 attn_logits = [sum(q_h[j] * k_h[t][j] for j in range(head_dim)) / head_dim**0.5 for t in range(len(k_h))]
130 attn_weights = softmax(attn_logits)
131 head_out = [sum(attn_weights[t] * v_h[t][j] for t in range(len(v_h))) for j in range(head_dim)]
132 x_attn.extend(head_out)
133 x = linear(x_attn, state_dict[f'layer{li}.attn_wo'])
134 x = [a + b for a, b in zip(x, x_residual)]
135 # 2) MLP block
136 x_residual = x
137 x = rmsnorm(x)
138 x = linear(x, state_dict[f'layer{li}.mlp_fc1'])
139 x = [xi.relu() for xi in x]
140 x = linear(x, state_dict[f'layer{li}.mlp_fc2'])
141 x = [a + b for a, b in zip(x, x_residual)]
142
143 logits = linear(x, state_dict['lm_head'])
144 return logits
145
146# Let there be Adam, the blessed optimizer and its buffers
147learning_rate, beta1, beta2, eps_adam = 0.01, 0.85, 0.99, 1e-8
148m = [0.0] * len(params) # first moment buffer
149v = [0.0] * len(params) # second moment buffer
150
151# Repeat in sequence
152num_steps = 1000 # number of training steps
153for step in range(num_steps):
154
155 # Take single document, tokenize it, surround it with BOS special token on both sides
156 doc = docs[step % len(docs)]
157 tokens = [BOS] + [uchars.index(ch) for ch in doc] + [BOS]
158 n = min(block_size, len(tokens) - 1)
159
160 # Forward the token sequence through the model, building up the computation graph all the way to the loss
161 keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
162 losses = []
163 for pos_id in range(n):
164 token_id, target_id = tokens[pos_id], tokens[pos_id + 1]
165 logits = gpt(token_id, pos_id, keys, values)
166 probs = softmax(logits)
167 loss_t = -probs[target_id].log()
168 losses.append(loss_t)
169 loss = (1 / n) * sum(losses) # final average loss over the document sequence. May yours be low.
170
171 # Backward the loss, calculating the gradients with respect to all model parameters
172 loss.backward()
173
174 # Adam optimizer update: update the model parameters based on the corresponding gradients
175 lr_t = learning_rate * (1 - step / num_steps) # linear learning rate decay
176 for i, p in enumerate(params):
177 m[i] = beta1 * m[i] + (1 - beta1) * p.grad
178 v[i] = beta2 * v[i] + (1 - beta2) * p.grad ** 2
179 m_hat = m[i] / (1 - beta1 ** (step + 1))
180 v_hat = v[i] / (1 - beta2 ** (step + 1))
181 p.data -= lr_t * m_hat / (v_hat ** 0.5 + eps_adam)
182 p.grad = 0
183
184 print(f"step {step+1:4d} / {num_steps:4d} | loss {loss.data:.4f}", end='\r')
185
186# Inference: may the model babble back to us
187temperature = 0.5 # in (0, 1], control the "creativity" of generated text, low to high
188print("\n--- inference (new, hallucinated names) ---")
189for sample_idx in range(20):
190 keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
191 token_id = BOS
192 sample = []
193 for pos_id in range(block_size):
194 logits = gpt(token_id, pos_id, keys, values)
195 probs = softmax([l / temperature for l in logits])
196 token_id = random.choices(range(vocab_size), weights=[p.data for p in probs])[0]
197 if token_id == BOS:
198 break
199 sample.append(uchars[token_id])
200 print(f"sample {sample_idx+1:2d}: {''.join(sample)}")
Was this lesson clear?