Quest 3

A tiny MLP: oversold bounce classifier

Stack three neurons + a hidden layer. Train to classify 'this oversold bar will bounce >1%' vs 'it won't'.

Lesson

Why a multi-layer perceptron?

A single neuron is a linear classifier. Market patterns aren't linear — RSI 25 means different things depending on whether BTC is trending or chopping.

An MLP with one hidden layer can learn non-linear combinations:

hidden = tanh(W1 * features + b1)
output = sigmoid(W2 * hidden + b2)

What features to use?

Start simple:

RSI(14) — momentum
ROC_20 — 20-bar return
stddev_20 — volatility
regime_flag — is BTC above/below its 50-bar SMA?

Each is a hand-crafted signal the network learns to combine.

Your task

Write a 4-2-1 MLP (4 inputs, 2 hidden, 1 output). Train it on labeled oversold-bar data. Report accuracy on a held-out test set.

Target: test accuracy >= 65%.

pythonEdit below, click Run tests

# A 4-2-1 MLP trained on synthetic "will this bar bounce" data
import math, random
random.seed(7)

# Features: [rsi_norm, roc_20, stddev_norm, regime_flag], Label: 1 if bounce
def gen(n):
  data = []
  for _ in range(n):
    rsi_n = random.uniform(-1, 1)
    roc = random.uniform(-0.05, 0.05)
    sd = random.uniform(0, 1)
    regime = random.choice([-1, 1])
    # "Bounce" if oversold + positive regime + moderate vol
    prob = 0.3 + 0.3*(-rsi_n) + 0.2*regime + 0.1*(0.5-abs(sd-0.3))
    label = 1 if random.random() < max(0.05, min(0.95, prob)) else 0
    data.append(([rsi_n, roc, sd, regime], label))
  return data

train = gen(300)
test = gen(100)

# TODO: implement forward pass + backprop for 4-2-1 MLP.
# (Skeleton provided — students complete the gradient updates.)
import math
def tanh(x): return math.tanh(x)
def sigmoid(x): return 1.0/(1.0+math.exp(-x))

W1 = [[random.gauss(0,0.3) for _ in range(4)] for _ in range(2)]
b1 = [0.0, 0.0]
W2 = [random.gauss(0,0.3) for _ in range(2)]
b2 = 0.0

lr = 0.1
for epoch in range(200):
  for x, y in train:
    # Forward
    h = [tanh(sum(W1[i][j]*x[j] for j in range(4)) + b1[i]) for i in range(2)]
    y_pred = sigmoid(sum(W2[i]*h[i] for i in range(2)) + b2)
    y_pred = max(1e-9, min(1-1e-9, y_pred))
    # TODO: Compute gradients and update W1,b1,W2,b2 (simplified)
    dL_dz = y_pred - y
    for i in range(2):
      W2[i] -= lr * dL_dz * h[i]
    b2 -= lr * dL_dz
    # Hidden layer gradients (chain rule through tanh)
    for i in range(2):
      dh = dL_dz * W2[i] * (1 - h[i]**2)
      for j in range(4):
        W1[i][j] -= lr * dh * x[j]
      b1[i] -= lr * dh

# Test accuracy
correct = 0
for x, y in test:
  h = [tanh(sum(W1[i][j]*x[j] for j in range(4)) + b1[i]) for i in range(2)]
  p = sigmoid(sum(W2[i]*h[i] for i in range(2)) + b2)
  if (p > 0.5) == (y == 1): correct += 1
print(f"test accuracy = {correct/len(test):.3f}")

ML for Trading