Training Golem: One Gradient Step

Franklin Track

The Golem wants POWER 10.

His brain uses one rule:

prediction = input × weight

The input (signal) is stuck at 2. Only the weight can change.

1. Walk to the Training Golem.
2. Press + / − on the power weight.
3. Watch the bar. Too low? Raise the weight. Too high? Lower it.
4. When error is about zero: you found the good direction by feel.
5. Then hit AUTO TRAIN. The Golem does the same idea automatically, step by step.

That automatic nudge is called gradient descent.

Dad Track

Squared-error loss for one example:

prediction = input * weight
error      = prediction - target
loss       = error²
gradient   = d(loss)/d(weight) = 2 * error * input
weight    := weight - learning_rate * gradient

Pencil check with our defaults (input=2, weight=0.5, target=10, lr=0.05):

About a dozen more steps and prediction sits on the target. No PyTorch. Roughly fifteen lines of Python.

Franklin's Question

Yes. The sign of the gradient tells the furnace which way to nudge. The learning rate says how big the nudge is.

Could Franklin explain it back?

"A weight is how much the computer cares. The gradient tells it which way to change the care so the mistake gets smaller."

Scientific method (tiny)

1. QUESTION — Does AUTO TRAIN reach the target from a bad starting weight?
2. HYPOTHESIS — Yes, if learning rate is small enough.
3. EXPERIMENT — Run 14 gradient steps from weight 0.5.
4. CONTROL — Same input (2) and target (10).
5. MEASUREMENT — Absolute error |prediction − target|.
6. RESULT — Error falls toward zero (watch the quest bar).
7. CONCLUSION — Gradient descent works on this toy problem.
8. NEXT QUESTION — What if learning rate is huge? (EXP-001 later.)

Item crafted

Item crafted!

Learning Crystal

Glows brighter as error shrinks. Proof that one weight can learn by walking downhill.

• Gradient Sight I
• Learning Rate I

→

Achievement Get!

First Gradient

The command block

"""
Day 2: one gradient update by hand (squared error).

prediction = input * weight
error      = prediction - target
gradient   = 2 * error * input
weight     = weight - learning_rate * gradient

Pencil check with defaults:
  input=2, weight=0.5, target=10, lr=0.05
  prediction = 1.0
  error      = -9.0
  gradient   = 2 * (-9) * 2 = -36
  new weight = 0.5 - 0.05 * (-36) = 0.5 + 1.8 = 2.3
"""

INPUT = 2.0
WEIGHT = 0.5
TARGET = 10.0
LR = 0.05

prediction = INPUT * WEIGHT
error = prediction - TARGET
gradient = 2 * error * INPUT
new_weight = WEIGHT - LR * gradient

print(f"prediction = {prediction}")
print(f"error      = {error}")
print(f"gradient   = {gradient}")
print(f"new weight = {new_weight}")

print("\nAuto train (12 steps):")
w = WEIGHT
for step in range(1, 13):
    pred = INPUT * w
    err = pred - TARGET
    grad = 2 * err * INPUT
    w = w - LR * grad
    bar = "#" * min(10, int(round(pred))) + "." * max(0, 10 - int(round(pred)))
    print(f"Step {step:2d}  [{bar}]  pred={pred:.2f}  w={w:.4f}")

python3 content/lab/days/day-002/day02_gradient.py

No packages. Reproduce the first update with pencil and paper, then let Python check you.

Dad's Lab Notes (tap to open)

Wanted to learn

Understand one furnace tick: loss, gradient, learning rate, weight update.

Learned

Gradient descent is walking downhill on error. prediction = input × weight; gradient = 2 × error × input; weight -= lr × gradient. Manual feel first, then AUTO TRAIN.

Built

Playable Craft Lab world (WASD + joystick), Training Golem quest, ~15-line gradient script, Learning Crystal item, Redstone Heart golem part.

Confused me

Why multiply by input again in the gradient? (Chain rule: prediction depends on weight through input.)

Failed

Nothing broken. A huge learning rate would overshoot; we kept lr=0.05 on purpose.

Taught Franklin

Franklin trained by feel (+/− weight), then watched AUTO TRAIN. His words: gradient is the sign that says which way to change the care.

Tomorrow

Apply the same update many times to the full play-outside neuron, not just one toy weight.