Quest 2

micrograd: one neuron, from scratch

Karpathy's micrograd is 150 lines that teach you every line of PyTorch. We adapt it to predict next-bar direction.

Lesson

micrograd in spirit

micrograd is a tiny autograd engine. You build expressions like x*w + b and it tracks gradients automatically through backprop.

For trading: a single neuron that takes (RSI, ROC, volume) and predicts P(next bar is up).

y_pred = sigmoid(w1*rsi + w2*roc + w3*volume + b)
loss = -y_actual * log(y_pred) - (1-y_actual) * log(1-y_pred)
# backprop — adjust w1, w2, w3, b to reduce loss

Why single neuron first?

Because you can hand-verify the math. When you later use 100M-parameter networks, that intuition stays.

Your task

Implement manual gradient descent for the single neuron below. Train it to predict whether tomorrow's BTC close is higher than today's, using today's RSI and ROC.

Target: train loss < 0.65 after 200 steps.

pythonEdit below, click Run tests

import math, random

# Synthetic BTC-like data: (rsi, roc, label) where label=1 if next bar is up
random.seed(42)
data = []
for _ in range(200):
    rsi = random.uniform(20, 80)
    roc = random.uniform(-0.05, 0.05)
    # Simple label: probability up increases with low RSI + positive ROC
    prob = 0.3 + 0.005*(50-rsi) + 3*roc
    prob = max(0.05, min(0.95, prob))
    label = 1 if random.random() < prob else 0
    data.append((rsi, roc, label))

# One neuron: y = sigmoid(w1*rsi_norm + w2*roc + b)
# Initialize
w1, w2, b = 0.01, 0.01, 0.0
lr = 0.1

def sigmoid(x): return 1.0 / (1.0 + math.exp(-x))

for step in range(200):
    total_loss = 0
    for rsi, roc, y in data:
        rsi_n = (rsi - 50) / 50  # normalize
        z = w1*rsi_n + w2*roc + b
        y_pred = sigmoid(z)
        y_pred = max(1e-9, min(1 - 1e-9, y_pred))
        loss = -y*math.log(y_pred) - (1-y)*math.log(1-y_pred)
        total_loss += loss
        # Gradients (derive by hand!)
        dL_dz = y_pred - y
        # TODO: update w1, w2, b using gradients + lr
        w1 -= lr * dL_dz * rsi_n / len(data)
        w2 -= lr * dL_dz * roc / len(data)
        b  -= lr * dL_dz / len(data)
    if step % 40 == 0:
        print(f"step {step} loss={total_loss/len(data):.4f}")

print(f"final w1={w1:.3f} w2={w2:.3f} b={b:.3f}")

ML for Trading