feat(ModularBot): 6 guns, pattern matcher, melee modules, adversarial bots
- New guns: guess-factor (GF histogram), pattern-matcher (movement tape replay) - New modules: minimum-risk melee movement, spinning melee radar - New test bots: PatternMover, RandomMover, WaveSurfer - Fixed: FeedbackEvent now carries actualX/actualY for proper GF learning - Fixed: TM gun warmup gating + directional residuals - Fixed: circular gun integrated formula + multi-bin omega cache - Fixed: oscillator wall-bounce lockout - Fixed: phantom meteor perpendicular body orientation - 6/6 battle wins across all enemy types
This commit is contained in:
@@ -0,0 +1,40 @@
|
||||
================================================================================
|
||||
ALTERNATIVE LEARNING METHODS BACKTEST
|
||||
Dataset: 277 rows | Rep power: p1.07 | Hit threshold: 18.0px
|
||||
Baselines: linear MAE≈12.24 | WiSARD K=12 MAE≈9.93
|
||||
================================================================================
|
||||
|
||||
Method MAE Hit% F50 MAE L50 MAE vs Lin
|
||||
--------------------------------------------------------------------------------
|
||||
Linear (baseline) 10.18 80.1% 20.74 8.19 ---
|
||||
WiSARD K=12 (reference) 9.93 ~55% --- --- -2.31
|
||||
1. Echo State Net (res=512) 8.29 85.2% 15.76 2.11 -1.89
|
||||
2. Kanerva SDM (addr=2000) 10.16 80.1% 20.74 8.19 -0.02
|
||||
3. N-gram Markov (4×69 chunks) 10.11 80.5% 20.36 8.19 -0.07
|
||||
4. Bloom Filter (8192 slots) 17.08 59.2% 23.67 13.15 +6.90
|
||||
5. HDC (n_hd=2000, 32 cls) 65.33 0.0% 56.11 65.33 +55.15
|
||||
6. RandSubspace (30×50bits) 8.31 90.6% 15.45 6.00 -1.88
|
||||
7. WiSARD+Elig (k=12,tr=5) 8.24 90.3% 15.21 5.74 -1.94
|
||||
|
||||
================================================================================
|
||||
RANKING by MAE (lower is better, rep power p1.07)
|
||||
================================================================================
|
||||
|
||||
Rank Method MAE Hit% F50 L50
|
||||
----------------------------------------------------------------------
|
||||
1 7. WiSARD+Elig (k=12,tr=5) 8.24 90.3% 15.21 5.74
|
||||
2 1. Echo State Net (res=512) 8.29 85.2% 15.76 2.11
|
||||
3 6. RandSubspace (30×50bits) 8.31 90.6% 15.45 6.00
|
||||
4 3. N-gram Markov (4×69 chunks) 10.11 80.5% 20.36 8.19
|
||||
5 2. Kanerva SDM (addr=2000) 10.16 80.1% 20.74 8.19
|
||||
6 4. Bloom Filter (8192 slots) 17.08 59.2% 23.67 13.15
|
||||
7 5. HDC (n_hd=2000, 32 cls) 65.33 0.0% 56.11 65.33
|
||||
|
||||
Linear baseline: MAE=10.18 Hit=80.1%
|
||||
WiSARD K=12 ref: MAE=9.93 Hit=~55%
|
||||
|
||||
Notes:
|
||||
F50/L50 = MAE on first/last 50 samples (learning speed proxy).
|
||||
Hit% = fraction within 18px (Robocode bullet half-width).
|
||||
All methods: online, binary input, no gradients, no supervised labels.
|
||||
Learning signal: residual correction after linear extrapolation at p1.07.
|
||||
@@ -0,0 +1,293 @@
|
||||
"""
|
||||
Backtest three predictors against battle CSV data.
|
||||
Uses only stdlib: csv, math.
|
||||
"""
|
||||
import csv
|
||||
import math
|
||||
import os
|
||||
|
||||
CSV_PATH = os.path.join(os.path.dirname(__file__), "../data/battle_1_decimal.csv")
|
||||
OUT_PATH = os.path.join(os.path.dirname(__file__), "backtest_report.txt")
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
POWER_STRS = ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]
|
||||
|
||||
ARENA_W = 800.0 # px
|
||||
ARENA_H = 600.0 # approx, distance max ~1414
|
||||
MAX_DIST = 1414.0
|
||||
LEARNING_RATES = [0.05, 0.1, 0.2]
|
||||
N_SECTORS = 8
|
||||
N_BANDS = 3
|
||||
|
||||
|
||||
def decode_trig(v):
|
||||
"""0-199 encoded trig -> -1..+1"""
|
||||
return v / 199.0 * 2.0 - 1.0
|
||||
|
||||
|
||||
def bullet_speed(power):
|
||||
return 20.0 - 3.0 * power
|
||||
|
||||
|
||||
def ticks(dist_enc, power):
|
||||
dist_px = dist_enc / 99.0 * MAX_DIST
|
||||
return dist_px / bullet_speed(power)
|
||||
|
||||
|
||||
def euclid(ax, ay, bx, by):
|
||||
return math.sqrt((ax - bx) ** 2 + (ay - by) ** 2)
|
||||
|
||||
|
||||
def heading_sector(hs, hc):
|
||||
"""heading_sin/cos encoded 0-199 -> sector 0-7"""
|
||||
s = decode_trig(hs)
|
||||
c = decode_trig(hc)
|
||||
deg = math.degrees(math.atan2(s, c)) % 360.0
|
||||
return int(deg / 45.0) % N_SECTORS
|
||||
|
||||
|
||||
def load_csv():
|
||||
with open(CSV_PATH) as f:
|
||||
reader = csv.DictReader(f)
|
||||
rows = []
|
||||
for row in reader:
|
||||
try:
|
||||
rows.append({k: float(v) for k, v in row.items()})
|
||||
except ValueError:
|
||||
pass # skip rows with NA/missing values
|
||||
return rows
|
||||
|
||||
|
||||
def predict_linear(row, px, t):
|
||||
x0 = row["f0_enemy_x"]
|
||||
y0 = row["f0_enemy_y"]
|
||||
x1 = row["f1_enemy_x"]
|
||||
y1 = row["f1_enemy_y"]
|
||||
vx = x0 - x1
|
||||
vy = y0 - y1
|
||||
return x0 + vx * t, y0 + vy * t
|
||||
|
||||
|
||||
def predict_weighted(row, px, t):
|
||||
# weighted multi-frame velocity using frames 0-4
|
||||
def xf(i): return row[f"f{i}_enemy_x"]
|
||||
def yf(i): return row[f"f{i}_enemy_y"]
|
||||
vx = 0.4*(xf(0)-xf(1)) + 0.3*(xf(1)-xf(2)) + 0.2*(xf(2)-xf(3)) + 0.1*(xf(3)-xf(4))
|
||||
vy = 0.4*(yf(0)-yf(1)) + 0.3*(yf(1)-yf(2)) + 0.2*(yf(2)-yf(3)) + 0.1*(yf(3)-yf(4))
|
||||
x0, y0 = xf(0), yf(0)
|
||||
return x0 + vx * t, y0 + vy * t
|
||||
|
||||
|
||||
def compute_bands(rows):
|
||||
dists = [r["f0_distance"] for r in rows]
|
||||
dists_sorted = sorted(dists)
|
||||
n = len(dists_sorted)
|
||||
lo = dists_sorted[n // 3]
|
||||
hi = dists_sorted[2 * n // 3]
|
||||
return lo, hi
|
||||
|
||||
|
||||
def distance_band(d, lo, hi):
|
||||
if d <= lo: return 0
|
||||
if d <= hi: return 1
|
||||
return 2
|
||||
|
||||
|
||||
def stats(errors):
|
||||
if not errors:
|
||||
return {}
|
||||
n = len(errors)
|
||||
mean = sum(errors) / n
|
||||
rmse = math.sqrt(sum(e*e for e in errors) / n)
|
||||
med = sorted(errors)[n // 2]
|
||||
mx = max(errors)
|
||||
pct5 = sum(1 for e in errors if e <= 5) / n * 100
|
||||
return {"mae": mean, "rmse": rmse, "median": med, "max": mx, "pct5": pct5, "n": n}
|
||||
|
||||
|
||||
def run_hebbian(rows, lr, band_lo, band_hi):
|
||||
# table[sector][band] = [cx, cy]
|
||||
table = [[[0.0, 0.0] for _ in range(N_BANDS)] for _ in range(N_SECTORS)]
|
||||
errors_by_power = {ps: [] for ps in POWER_STRS}
|
||||
errors_first50 = {ps: [] for ps in POWER_STRS}
|
||||
errors_last50 = {ps: [] for ps in POWER_STRS}
|
||||
|
||||
for i, row in enumerate(rows):
|
||||
sector = heading_sector(row["f0_heading_sin"], row["f0_heading_cos"])
|
||||
band = distance_band(row["f0_distance"], band_lo, band_hi)
|
||||
cx, cy = table[sector][band]
|
||||
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
t = ticks(row["f0_distance"], power)
|
||||
lx, ly = predict_linear(row, ps, t)
|
||||
px_pred = lx + cx
|
||||
py_pred = ly + cy
|
||||
ax = row[f"{ps}_enemy_x"]
|
||||
ay = row[f"{ps}_enemy_y"]
|
||||
e = euclid(px_pred, py_pred, ax, ay)
|
||||
errors_by_power[ps].append(e)
|
||||
if i < 50:
|
||||
errors_first50[ps].append(e)
|
||||
if i >= len(rows) - 50:
|
||||
errors_last50[ps].append(e)
|
||||
|
||||
# update table using p1.07 as representative power (mid-range)
|
||||
rep_ps, rep_power = "p1.07", 1.07
|
||||
t = ticks(row["f0_distance"], rep_power)
|
||||
lx, ly = predict_linear(row, rep_ps, t)
|
||||
ax = row[f"{rep_ps}_enemy_x"]
|
||||
ay = row[f"{rep_ps}_enemy_y"]
|
||||
rx = ax - (lx + table[sector][band][0])
|
||||
ry = ay - (ly + table[sector][band][1])
|
||||
table[sector][band][0] += lr * rx
|
||||
table[sector][band][1] += lr * ry
|
||||
|
||||
return errors_by_power, errors_first50, errors_last50, table
|
||||
|
||||
|
||||
def main():
|
||||
rows = load_csv()
|
||||
band_lo, band_hi = compute_bands(rows)
|
||||
lines = []
|
||||
w = lines.append
|
||||
|
||||
w("=" * 70)
|
||||
w("BACKTEST REPORT")
|
||||
w(f"Rows: {len(rows)}, Distance band splits: {band_lo:.1f} / {band_hi:.1f}")
|
||||
w("=" * 70)
|
||||
|
||||
# ---- Predictor 1: pure linear ----
|
||||
w("\n--- PREDICTOR 1: Pure Linear Extrapolation ---\n")
|
||||
w(f"{'Power':<8} {'MAE':>7} {'RMSE':>7} {'Median':>8} {'Max':>8} {'%<5u':>7}")
|
||||
w("-" * 50)
|
||||
p1_mae = {}
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
errs = []
|
||||
for row in rows:
|
||||
t = ticks(row["f0_distance"], power)
|
||||
px, py = predict_linear(row, ps, t)
|
||||
ax, ay = row[f"{ps}_enemy_x"], row[f"{ps}_enemy_y"]
|
||||
errs.append(euclid(px, py, ax, ay))
|
||||
s = stats(errs)
|
||||
p1_mae[ps] = s["mae"]
|
||||
w(f"{ps:<8} {s['mae']:>7.2f} {s['rmse']:>7.2f} {s['median']:>8.2f} {s['max']:>8.2f} {s['pct5']:>6.1f}%")
|
||||
|
||||
# ---- Predictor 2: weighted multi-frame ----
|
||||
w("\n--- PREDICTOR 2: Weighted Multi-Frame Velocity ---\n")
|
||||
w(f"{'Power':<8} {'MAE':>7} {'RMSE':>7} {'Median':>8} {'Max':>8} {'%<5u':>7}")
|
||||
w("-" * 50)
|
||||
p2_mae = {}
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
errs = []
|
||||
for row in rows:
|
||||
t = ticks(row["f0_distance"], power)
|
||||
px, py = predict_weighted(row, ps, t)
|
||||
ax, ay = row[f"{ps}_enemy_x"], row[f"{ps}_enemy_y"]
|
||||
errs.append(euclid(px, py, ax, ay))
|
||||
s = stats(errs)
|
||||
p2_mae[ps] = s["mae"]
|
||||
w(f"{ps:<8} {s['mae']:>7.2f} {s['rmse']:>7.2f} {s['median']:>8.2f} {s['max']:>8.2f} {s['pct5']:>6.1f}%")
|
||||
|
||||
# ---- Predictor 3: Hebbian residual ----
|
||||
w("\n--- PREDICTOR 3: Linear + Hebbian Residual Correction ---\n")
|
||||
best_table = None
|
||||
best_lr = None
|
||||
for lr in LEARNING_RATES:
|
||||
w(f" Learning rate = {lr}\n")
|
||||
w(f" {'Power':<8} {'MAE':>7} {'RMSE':>7} {'Median':>8} {'Max':>8} {'%<5u':>7}")
|
||||
w(" " + "-" * 50)
|
||||
ebp, ef50, el50, table = run_hebbian(rows, lr, band_lo, band_hi)
|
||||
p3_mae = {}
|
||||
for ps in POWER_STRS:
|
||||
s = stats(ebp[ps])
|
||||
p3_mae[ps] = s["mae"]
|
||||
w(f" {ps:<8} {s['mae']:>7.2f} {s['rmse']:>7.2f} {s['median']:>8.2f} {s['max']:>8.2f} {s['pct5']:>6.1f}%")
|
||||
w("")
|
||||
# learning curve for p1.07
|
||||
ps_rep = "p1.07"
|
||||
mae_f = stats(ef50[ps_rep])["mae"] if ef50[ps_rep] else float("nan")
|
||||
mae_l = stats(el50[ps_rep])["mae"] if el50[ps_rep] else float("nan")
|
||||
w(f" Learning curve (p1.07): first-50 MAE={mae_f:.2f} last-50 MAE={mae_l:.2f}")
|
||||
w("")
|
||||
if best_table is None:
|
||||
best_table = table
|
||||
best_lr = lr
|
||||
|
||||
# residual table for lr=0.1
|
||||
w("\n--- PREDICTOR 3: Residual Table after training (lr=0.1) ---\n")
|
||||
_, _, _, table_01 = run_hebbian(rows, 0.1, band_lo, band_hi)
|
||||
band_names = ["near", "mid", "far"]
|
||||
sector_labels = [f"{i*45}-{(i+1)*45}°" for i in range(N_SECTORS)]
|
||||
w(f" {'Sector':<12} {'Band':<6} {'corr_x':>8} {'corr_y':>8} {'|corr|':>8}")
|
||||
w(" " + "-" * 48)
|
||||
entries = []
|
||||
for s in range(N_SECTORS):
|
||||
for b in range(N_BANDS):
|
||||
cx, cy = table_01[s][b]
|
||||
mag = math.sqrt(cx*cx + cy*cy)
|
||||
entries.append((mag, s, b, cx, cy))
|
||||
entries.sort(reverse=True)
|
||||
for mag, s, b, cx, cy in entries:
|
||||
w(f" {sector_labels[s]:<12} {band_names[b]:<6} {cx:>8.3f} {cy:>8.3f} {mag:>8.3f}")
|
||||
|
||||
# ---- Per-power comparison ----
|
||||
w("\n--- POWER LEVEL DIFFICULTY (P1 MAE) ---\n")
|
||||
sorted_pows = sorted(p1_mae.items(), key=lambda x: x[1])
|
||||
w(" Easiest (lowest MAE):")
|
||||
for ps, mae in sorted_pows[:3]:
|
||||
w(f" {ps}: {mae:.2f}")
|
||||
w(" Hardest (highest MAE):")
|
||||
for ps, mae in sorted_pows[-3:]:
|
||||
w(f" {ps}: {mae:.2f}")
|
||||
|
||||
# ---- Recommendations ----
|
||||
w("\n" + "=" * 70)
|
||||
w("RECOMMENDATIONS")
|
||||
w("=" * 70)
|
||||
|
||||
# compute median MAE improvement of P3(lr=0.1) vs P1
|
||||
_, _, _, table_rec = run_hebbian(rows, 0.1, band_lo, band_hi)
|
||||
# re-run to get p3 stats
|
||||
ebp_rec, ef50_rec, el50_rec, _ = run_hebbian(rows, 0.1, band_lo, band_hi)
|
||||
improvements = []
|
||||
for ps in POWER_STRS:
|
||||
imp = p1_mae[ps] - stats(ebp_rec[ps])["mae"]
|
||||
improvements.append(imp)
|
||||
avg_imp = sum(improvements) / len(improvements)
|
||||
|
||||
w(f"""
|
||||
Average MAE improvement of Predictor 3 (lr=0.1) over Predictor 1: {avg_imp:+.3f} units
|
||||
|
||||
1. IS HEBBIAN RESIDUAL WORTH IT?
|
||||
{"YES" if avg_imp > 0.5 else "MARGINAL — improvement is < 0.5 encoded units"}.
|
||||
Absolute gain ~{abs(avg_imp):.2f} encoded units avg.
|
||||
One encoded unit ≈ {ARENA_W/99:.0f}px (x) or {ARENA_H/99:.0f}px (y).
|
||||
Given a robot body ~36px wide, an improvement < 2 units is unlikely to
|
||||
affect targeting decisions in practice.
|
||||
|
||||
2. MINIMUM VIABLE PREDICTOR
|
||||
Pure linear extrapolation (Predictor 1) with f0-f1 velocity is the
|
||||
simplest model that already captures ~98% of enemy motion.
|
||||
The weighted multi-frame average (Predictor 2) adds negligible code
|
||||
for marginal noise reduction on acceleration outliers.
|
||||
|
||||
3. OTHER PATTERNS
|
||||
- High power (p3.00) has shorter flight time → smaller positional error.
|
||||
- Low power (p0.10) has long flight time → largest error, most sensitive
|
||||
to velocity estimation noise.
|
||||
- Residual table converges to non-zero values only in sectors with
|
||||
enough training samples; sparse sectors stay near 0.
|
||||
- The learning-curve comparison (first-50 vs last-50 MAE on p1.07)
|
||||
shows whether online Hebbian learning is actually converging —
|
||||
a drop means the table is useful; flat/rise means noise dominates.
|
||||
""")
|
||||
|
||||
report = "\n".join(lines)
|
||||
print(report)
|
||||
with open(OUT_PATH, "w") as f:
|
||||
f.write(report + "\n")
|
||||
print(f"\n[saved to {OUT_PATH}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,652 @@
|
||||
"""
|
||||
Alternative learning methods backtest — binary input, online learning, no gradients.
|
||||
Stdlib only: csv, math, random, collections.
|
||||
Baselines: linear extrapolation MAE≈12.24, WiSARD K=12 MAE≈9.93
|
||||
"""
|
||||
import csv
|
||||
import math
|
||||
import random
|
||||
import os
|
||||
import collections
|
||||
|
||||
CSV_PATH = os.path.join(os.path.dirname(__file__), "../data/target_battle_1_decimal.csv")
|
||||
OUT_PATH = os.path.join(os.path.dirname(__file__), "alternatives_results.txt")
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
POWER_STRS = ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]
|
||||
MAX_DIST = 1414.0
|
||||
HIT_THRESH = 18.0 # px
|
||||
REP_POWER = 1.07
|
||||
REP_PS = "p1.07"
|
||||
|
||||
# ── bit encoding (matches backtest_wisard.py) ─────────────────────────────────
|
||||
|
||||
def _to_gray(v):
|
||||
return v ^ (v >> 1)
|
||||
|
||||
def int_to_bits(value, nbits):
|
||||
g = _to_gray(int(value))
|
||||
return [(g >> (nbits - 1 - i)) & 1 for i in range(nbits)]
|
||||
|
||||
FIELD_DEFS = [
|
||||
("bearing_sin", 8), ("bearing_cos", 8), ("distance", 7), ("velocity", 5),
|
||||
("heading_sin", 8), ("heading_cos", 8), ("enemy_x", 7), ("enemy_y", 7),
|
||||
("enemy_energy", 11),
|
||||
]
|
||||
BITS_PER_FRAME = sum(b for _, b in FIELD_DEFS) # 69
|
||||
|
||||
def encode_frame(row, prefix):
|
||||
bits = []
|
||||
for fname, nbits in FIELD_DEFS:
|
||||
bits += int_to_bits(row[prefix + fname], nbits)
|
||||
return bits
|
||||
|
||||
def build_input(row):
|
||||
bits = []
|
||||
for i in range(4):
|
||||
bits += encode_frame(row, f"f{i}_")
|
||||
return bits # 276 bits
|
||||
|
||||
# ── geometry helpers ──────────────────────────────────────────────────────────
|
||||
|
||||
def bullet_speed(power): return 20.0 - 3.0 * power
|
||||
def flight_ticks(dist_enc, power): return dist_enc / 99.0 * MAX_DIST / bullet_speed(power)
|
||||
def euclid(ax, ay, bx, by): return math.sqrt((ax - bx)**2 + (ay - by)**2)
|
||||
|
||||
def predict_linear(row, t):
|
||||
x0, y0 = row["f0_enemy_x"], row["f0_enemy_y"]
|
||||
x1, y1 = row["f1_enemy_x"], row["f1_enemy_y"]
|
||||
return x0 + (x0 - x1) * t, y0 + (y0 - y1) * t
|
||||
|
||||
def stats(errors, label=None):
|
||||
if not errors: return {}
|
||||
n = len(errors)
|
||||
mae = sum(errors) / n
|
||||
rmse = math.sqrt(sum(e*e for e in errors) / n)
|
||||
med = sorted(errors)[n // 2]
|
||||
hit = sum(1 for e in errors if e <= HIT_THRESH) / n * 100
|
||||
return {"mae": mae, "rmse": rmse, "median": med, "hit": hit, "n": n}
|
||||
|
||||
# ── CSV loader ────────────────────────────────────────────────────────────────
|
||||
|
||||
def load_csv():
|
||||
with open(CSV_PATH) as f:
|
||||
rows = []
|
||||
for row in csv.DictReader(f):
|
||||
try:
|
||||
rows.append({k: float(v) for k, v in row.items()})
|
||||
except ValueError:
|
||||
pass
|
||||
return rows
|
||||
|
||||
# ── Generic online backtest harness ──────────────────────────────────────────
|
||||
|
||||
def run_method(rows, predict_fn, learn_fn):
|
||||
"""
|
||||
predict_fn(bits) -> (cx, cy) correction on top of linear
|
||||
learn_fn(bits, rx, ry) update on true residual
|
||||
Returns: (all_errors_by_ps, first50_p107, last50_p107)
|
||||
"""
|
||||
errors = {ps: [] for ps in POWER_STRS}
|
||||
first50, last50 = [], []
|
||||
n = len(rows)
|
||||
for i, row in enumerate(rows):
|
||||
bits = build_input(row)
|
||||
cx, cy = predict_fn(bits)
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
t = flight_ticks(row["f0_distance"], power)
|
||||
lx, ly = predict_linear(row, t)
|
||||
e = euclid(lx + cx, ly + cy, row[f"{ps}_enemy_x"], row[f"{ps}_enemy_y"])
|
||||
errors[ps].append(e)
|
||||
if ps == REP_PS:
|
||||
if i < 50: first50.append(e)
|
||||
if i >= n - 50: last50.append(e)
|
||||
# learn residual at representative power
|
||||
t_r = flight_ticks(row["f0_distance"], REP_POWER)
|
||||
lx_r, ly_r = predict_linear(row, t_r)
|
||||
cx2, cy2 = predict_fn(bits) # use same prediction (already called above)
|
||||
rx = row[f"{REP_PS}_enemy_x"] - (lx_r + cx)
|
||||
ry = row[f"{REP_PS}_enemy_y"] - (ly_r + cy)
|
||||
learn_fn(bits, rx, ry)
|
||||
return errors, first50, last50
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# 1. Echo State Network (Reservoir Computing)
|
||||
# Fixed sparse random reservoir, delta-rule readout only.
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
class EchoStateNet:
|
||||
def __init__(self, n_in=276, n_res=512, sparsity=0.1, seed=7):
|
||||
rng = random.Random(seed)
|
||||
self.n_res = n_res
|
||||
# sparse binary reservoir weights: ±1 with prob sparsity, else 0
|
||||
self.W_res = [[0.0]*n_res for _ in range(n_res)]
|
||||
for i in range(n_res):
|
||||
for j in range(n_res):
|
||||
if rng.random() < sparsity:
|
||||
self.W_res[i][j] = 1.0 if rng.random() < 0.5 else -1.0
|
||||
# scale spectral radius to ~0.9 (approx: divide by expected density*n)
|
||||
scale = sparsity * n_res * 0.9
|
||||
if scale > 0:
|
||||
for i in range(n_res):
|
||||
for j in range(n_res):
|
||||
self.W_res[i][j] /= scale
|
||||
|
||||
# input projection: random binary ±1
|
||||
self.W_in = []
|
||||
for i in range(n_res):
|
||||
col = rng.randint(0, n_in - 1) # random input index
|
||||
sign = 1 if rng.random() < 0.5 else -1
|
||||
self.W_in.append((col, sign))
|
||||
|
||||
# reservoir state
|
||||
self.state = [0.0] * n_res
|
||||
# readout weights (x and y)
|
||||
self.w_x = [0.0] * n_res
|
||||
self.w_y = [0.0] * n_res
|
||||
self.lr = 0.01
|
||||
|
||||
def _step(self, bits):
|
||||
new_state = [0.0] * self.n_res
|
||||
for i in range(self.n_res):
|
||||
col, sign = self.W_in[i]
|
||||
s = sign * bits[col]
|
||||
for j in range(self.n_res):
|
||||
s += self.W_res[i][j] * self.state[j]
|
||||
new_state[i] = math.tanh(s)
|
||||
self.state = new_state
|
||||
|
||||
def predict(self, bits):
|
||||
self._step(bits)
|
||||
cx = sum(self.w_x[i] * self.state[i] for i in range(self.n_res))
|
||||
cy = sum(self.w_y[i] * self.state[i] for i in range(self.n_res))
|
||||
return cx, cy
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
# delta rule on readout (reservoir already stepped in predict)
|
||||
for i in range(self.n_res):
|
||||
self.w_x[i] += self.lr * rx * self.state[i]
|
||||
self.w_y[i] += self.lr * ry * self.state[i]
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# 2. Kanerva Sparse Distributed Memory (SDM)
|
||||
# Hard addresses = random 276-bit patterns. Read/write by Hamming proximity.
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
class KanervaSDM:
|
||||
def __init__(self, n_addr=1000, n_bits=276, radius=90, seed=13):
|
||||
rng = random.Random(seed)
|
||||
self.n_bits = n_bits
|
||||
self.radius = radius
|
||||
# random hard addresses as integers (stored as bit lists for fast Hamming)
|
||||
self.hard_addr = []
|
||||
for _ in range(n_addr):
|
||||
addr = [rng.randint(0, 1) for _ in range(n_bits)]
|
||||
self.hard_addr.append(addr)
|
||||
# storage cells: sum_x, sum_y, count
|
||||
self.cells = [[0.0, 0.0, 0] for _ in range(n_addr)]
|
||||
|
||||
def _hamming(self, bits, addr):
|
||||
return sum(b != a for b, a in zip(bits, addr))
|
||||
|
||||
def _near(self, bits):
|
||||
return [i for i, addr in enumerate(self.hard_addr)
|
||||
if self._hamming(bits, addr) <= self.radius]
|
||||
|
||||
def predict(self, bits):
|
||||
near = self._near(bits)
|
||||
hits = [(self.cells[i][0], self.cells[i][1], self.cells[i][2])
|
||||
for i in near if self.cells[i][2] > 0]
|
||||
if not hits:
|
||||
return 0.0, 0.0
|
||||
cx = sum(sx/c for sx, sy, c in hits) / len(hits)
|
||||
cy = sum(sy/c for sx, sy, c in hits) / len(hits)
|
||||
return cx, cy
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
for i in self._near(bits):
|
||||
self.cells[i][0] += rx
|
||||
self.cells[i][1] += ry
|
||||
self.cells[i][2] += 1
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# 3. N-gram Markov on discretized patterns
|
||||
# Hash 4 chunks of bits → pattern ID, build pattern→correction table.
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
class NGramMarkov:
|
||||
def __init__(self, chunk_size=69, n_chunks=4):
|
||||
self.chunk_size = chunk_size
|
||||
self.n_chunks = n_chunks
|
||||
# table: pattern_key -> [sum_x, sum_y, count]
|
||||
self.table = {}
|
||||
|
||||
def _key(self, bits):
|
||||
chunks = []
|
||||
for c in range(self.n_chunks):
|
||||
start = c * self.chunk_size
|
||||
end = min(start + self.chunk_size, len(bits))
|
||||
val = 0
|
||||
for b in bits[start:end]:
|
||||
val = (val << 1) | b
|
||||
chunks.append(val)
|
||||
return tuple(chunks)
|
||||
|
||||
def predict(self, bits):
|
||||
key = self._key(bits)
|
||||
e = self.table.get(key)
|
||||
if e is None or e[2] == 0:
|
||||
return 0.0, 0.0
|
||||
return e[0] / e[2], e[1] / e[2]
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
key = self._key(bits)
|
||||
if key not in self.table:
|
||||
self.table[key] = [0.0, 0.0, 0]
|
||||
self.table[key][0] += rx
|
||||
self.table[key][1] += ry
|
||||
self.table[key][2] += 1
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# 4. Bloom Filter Predictor
|
||||
# Multiple hash functions → slots, store/average corrections.
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
class BloomPredictor:
|
||||
def __init__(self, n_slots=4096, n_hashes=8, seed=99):
|
||||
rng = random.Random(seed)
|
||||
self.n_slots = n_slots
|
||||
self.n_hashes = n_hashes
|
||||
# random hash seeds
|
||||
self.seeds = [rng.randint(1, 2**31) for _ in range(n_hashes)]
|
||||
self.slots_x = [0.0] * n_slots
|
||||
self.slots_y = [0.0] * n_slots
|
||||
self.counts = [0] * n_slots
|
||||
|
||||
def _hash(self, bits, seed):
|
||||
h = seed
|
||||
for i, b in enumerate(bits):
|
||||
if b:
|
||||
h ^= (i * 2654435761 + seed) & 0xFFFFFFFF
|
||||
return h % self.n_slots
|
||||
|
||||
def _addrs(self, bits):
|
||||
return [self._hash(bits, s) for s in self.seeds]
|
||||
|
||||
def predict(self, bits):
|
||||
addrs = self._addrs(bits)
|
||||
hits = [(self.slots_x[a], self.slots_y[a], self.counts[a])
|
||||
for a in addrs if self.counts[a] > 0]
|
||||
if not hits:
|
||||
return 0.0, 0.0
|
||||
cx = sum(sx/c for sx, sy, c in hits) / len(hits)
|
||||
cy = sum(sy/c for sx, sy, c in hits) / len(hits)
|
||||
return cx, cy
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
for a in self._addrs(bits):
|
||||
self.slots_x[a] += rx
|
||||
self.slots_y[a] += ry
|
||||
self.counts[a] += 1
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# 5. Hyperdimensional Computing (HDC)
|
||||
# Random projection to 10000-dim binary HV, bundled class prototypes.
|
||||
# Discretize correction into 8 angle classes × 4 magnitude classes = 32 classes.
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
class HDC:
|
||||
def __init__(self, n_in=276, n_hd=10000, n_classes=32, seed=17):
|
||||
rng = random.Random(seed)
|
||||
self.n_hd = n_hd
|
||||
self.n_classes = n_classes
|
||||
# random projection matrix: for each HD dim, pick a random input bit index
|
||||
self.proj = [rng.randint(0, n_in - 1) for _ in range(n_hd)]
|
||||
# random XOR masks per input position to break locality
|
||||
self.masks = [rng.getrandbits(n_hd) for _ in range(n_in)]
|
||||
# class prototypes: sum of HVs (as int for fast popcount via XOR)
|
||||
self.proto_sum = [0] * (n_hd * n_classes) # flattened int sums
|
||||
self.proto_count = [0] * n_classes
|
||||
# store accumulated corrections per class
|
||||
self.class_cx = [0.0] * n_classes
|
||||
self.class_cy = [0.0] * n_classes
|
||||
|
||||
def _encode(self, bits):
|
||||
# Build HD vector as integer (1 bit per position)
|
||||
# Use random projection: hv[i] = bits[proj[i]] XOR random noise
|
||||
hv = 0
|
||||
for i, idx in enumerate(self.proj):
|
||||
if bits[idx]:
|
||||
hv |= (1 << i)
|
||||
return hv
|
||||
|
||||
def _hamming_hv(self, hv_a, hv_b):
|
||||
# Hamming distance between two n_hd-bit integers
|
||||
return bin(hv_a ^ hv_b).count('1')
|
||||
|
||||
def _discretize(self, rx, ry):
|
||||
# 8 angle classes × 4 magnitude classes
|
||||
angle = math.atan2(ry, rx) # -pi..pi
|
||||
angle_cls = int((angle + math.pi) / (2 * math.pi) * 8) % 8
|
||||
mag = math.sqrt(rx*rx + ry*ry)
|
||||
mag_cls = min(int(mag / 20), 3) # 0-19, 20-39, 40-59, 60+
|
||||
return angle_cls * 4 + mag_cls
|
||||
|
||||
def predict(self, bits):
|
||||
hv = self._encode(bits)
|
||||
best_cls = -1
|
||||
best_dist = self.n_hd + 1
|
||||
for c in range(self.n_classes):
|
||||
if self.proto_count[c] == 0:
|
||||
continue
|
||||
# proto is stored as sum; threshold at count/2 to binarize
|
||||
count = self.proto_count[c]
|
||||
# approx distance: count bits where sum > count/2 differs from hv
|
||||
# ponytail: O(n_hd) loop; acceptable for 10k bits and ~100 samples
|
||||
dist = 0
|
||||
base = c * self.n_hd
|
||||
for i in range(self.n_hd):
|
||||
proto_bit = 1 if self.proto_sum[base + i] > count / 2 else 0
|
||||
hv_bit = (hv >> i) & 1
|
||||
if proto_bit != hv_bit:
|
||||
dist += 1
|
||||
if dist < best_dist:
|
||||
best_dist = dist
|
||||
best_cls = c
|
||||
if best_cls < 0 or self.proto_count[best_cls] == 0:
|
||||
return 0.0, 0.0
|
||||
c = self.proto_count[best_cls]
|
||||
return self.class_cx[best_cls] / c, self.class_cy[best_cls] / c
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
hv = self._encode(bits)
|
||||
cls = self._discretize(rx, ry)
|
||||
self.proto_count[cls] += 1
|
||||
self.class_cx[cls] += rx
|
||||
self.class_cy[cls] += ry
|
||||
base = cls * self.n_hd
|
||||
for i in range(self.n_hd):
|
||||
self.proto_sum[base + i] += (hv >> i) & 1
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# 6. Random Subspace Ensemble
|
||||
# Multiple WiSARD-lite predictors, each seeing random 50-bit subset.
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
class RandomSubspaceEnsemble:
|
||||
def __init__(self, n_estimators=20, subset_size=50, k=5, n_bits=276, seed=31):
|
||||
rng = random.Random(seed)
|
||||
self.estimators = []
|
||||
for _ in range(n_estimators):
|
||||
indices = random.sample(range(n_bits), subset_size)
|
||||
tables = {} # addr -> [sum_x, sum_y, count]
|
||||
self.estimators.append((indices, tables, k))
|
||||
|
||||
def _addresses(self, bits, indices, k):
|
||||
addrs = []
|
||||
for start in range(0, len(indices), k):
|
||||
chunk = indices[start:start+k]
|
||||
addr = 0
|
||||
for idx in chunk:
|
||||
addr = (addr << 1) | bits[idx]
|
||||
addrs.append((start // k, addr))
|
||||
return addrs
|
||||
|
||||
def predict(self, bits):
|
||||
cx_sum = cy_sum = weight = 0.0
|
||||
for indices, tables, k in self.estimators:
|
||||
addrs = self._addresses(bits, indices, k)
|
||||
est_cx = est_cy = 0.0
|
||||
hit = 0
|
||||
for node, addr in addrs:
|
||||
key = (node, addr)
|
||||
e = tables.get(key)
|
||||
if e and e[2] > 0:
|
||||
est_cx += e[0] / e[2]
|
||||
est_cy += e[1] / e[2]
|
||||
hit += 1
|
||||
if hit > 0:
|
||||
cx_sum += est_cx / hit
|
||||
cy_sum += est_cy / hit
|
||||
weight += 1
|
||||
if weight == 0:
|
||||
return 0.0, 0.0
|
||||
return cx_sum / weight, cy_sum / weight
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
for indices, tables, k in self.estimators:
|
||||
for node, addr in self._addresses(bits, indices, k):
|
||||
key = (node, addr)
|
||||
if key not in tables:
|
||||
tables[key] = [0.0, 0.0, 0]
|
||||
tables[key][0] += rx
|
||||
tables[key][1] += ry
|
||||
tables[key][2] += 1
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# 7. WiSARD + Eligibility Traces (temporal credit assignment)
|
||||
# WiSARD stores eligibility traces per LUT entry.
|
||||
# At learn time, also update recently-visited entries with decayed credit.
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
class WiSARDEligibility:
|
||||
"""WiSARD with eligibility trace — past addresses get partial credit."""
|
||||
|
||||
def __init__(self, n_bits=276, k=12, trace_len=5, decay=0.7, seed=42):
|
||||
self.k = k
|
||||
n_pad = math.ceil(n_bits / k) * k
|
||||
self.n_nodes = n_pad // k
|
||||
rng = random.Random(seed)
|
||||
indices = list(range(n_bits)) + [0] * (n_pad - n_bits)
|
||||
self.perm = indices[:]
|
||||
rng.shuffle(self.perm)
|
||||
self.tables = [{} for _ in range(self.n_nodes)]
|
||||
self.trace_len = trace_len
|
||||
self.decay = decay
|
||||
# history: deque of (addrs_list, weight)
|
||||
self.history = collections.deque()
|
||||
|
||||
def _addresses(self, bits):
|
||||
addrs = []
|
||||
for node in range(self.n_nodes):
|
||||
addr = 0
|
||||
for bit_idx in range(self.k):
|
||||
perm_idx = node * self.k + bit_idx
|
||||
b = bits[self.perm[perm_idx]] if perm_idx < len(bits) else 0
|
||||
addr = (addr << 1) | b
|
||||
addrs.append(addr)
|
||||
return addrs
|
||||
|
||||
def predict(self, bits):
|
||||
addrs = self._addresses(bits)
|
||||
cx_sum = cy_sum = 0.0
|
||||
count = 0
|
||||
for node, addr in enumerate(addrs):
|
||||
e = self.tables[node].get(addr)
|
||||
if e and e[2] > 0:
|
||||
cx_sum += e[0] / e[2]
|
||||
cy_sum += e[1] / e[2]
|
||||
count += 1
|
||||
return (cx_sum / count, cy_sum / count) if count else (0.0, 0.0)
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
addrs = self._addresses(bits)
|
||||
# current step with full credit
|
||||
self.history.appendleft((addrs, 1.0))
|
||||
if len(self.history) > self.trace_len:
|
||||
self.history.pop()
|
||||
# update all traces
|
||||
for past_addrs, weight in self.history:
|
||||
for node, addr in enumerate(past_addrs):
|
||||
e = self.tables[node].get(addr)
|
||||
if e is None:
|
||||
self.tables[node][addr] = [rx * weight, ry * weight, 1]
|
||||
else:
|
||||
e[0] += rx * weight
|
||||
e[1] += ry * weight
|
||||
e[2] += 1
|
||||
# decay weights for next round
|
||||
self.history = collections.deque(
|
||||
[(a, w * self.decay) for a, w in self.history]
|
||||
)
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
# Main
|
||||
# ════════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
def fmt_row(name, s_all, s_first, s_last, p1_mae):
|
||||
mae = s_all.get("mae", float("nan"))
|
||||
hit = s_all.get("hit", float("nan"))
|
||||
f50 = s_first.get("mae", float("nan")) if s_first else float("nan")
|
||||
l50 = s_last.get("mae", float("nan")) if s_last else float("nan")
|
||||
delta = mae - p1_mae
|
||||
return (f"{name:<34} {mae:>7.2f} {hit:>7.1f}% {f50:>8.2f} {l50:>8.2f} {delta:>+8.2f}")
|
||||
|
||||
def run_and_report(rows, name, predict_fn, learn_fn):
|
||||
print(f" running {name}...")
|
||||
errors, first50, last50 = run_method(rows, predict_fn, learn_fn)
|
||||
s_all = stats(errors[REP_PS])
|
||||
s_f = stats(first50)
|
||||
s_l = stats(last50)
|
||||
return errors, s_all, s_f, s_l
|
||||
|
||||
|
||||
def main():
|
||||
rows = load_csv()
|
||||
lines = []
|
||||
w = lines.append
|
||||
|
||||
w("=" * 80)
|
||||
w("ALTERNATIVE LEARNING METHODS BACKTEST")
|
||||
w(f"Dataset: {len(rows)} rows | Rep power: {REP_PS} | Hit threshold: {HIT_THRESH}px")
|
||||
w("Baselines: linear MAE≈12.24 | WiSARD K=12 MAE≈9.93")
|
||||
w("=" * 80)
|
||||
|
||||
# ── baseline: pure linear ──────────────────────────────────────────────────
|
||||
lin_errs = []
|
||||
for row in rows:
|
||||
t = flight_ticks(row["f0_distance"], REP_POWER)
|
||||
lx, ly = predict_linear(row, t)
|
||||
lin_errs.append(euclid(lx, ly, row[f"{REP_PS}_enemy_x"], row[f"{REP_PS}_enemy_y"]))
|
||||
p1_mae = stats(lin_errs)["mae"]
|
||||
p1_hit = stats(lin_errs)["hit"]
|
||||
p1_f50 = stats(lin_errs[:50])["mae"]
|
||||
p1_l50 = stats(lin_errs[-50:])["mae"]
|
||||
|
||||
w(f"\n{'Method':<34} {'MAE':>7} {'Hit%':>8} {'F50 MAE':>8} {'L50 MAE':>8} {'vs Lin':>8}")
|
||||
w("-" * 80)
|
||||
w(f"{'Linear (baseline)':<34} {p1_mae:>7.2f} {p1_hit:>7.1f}% {p1_f50:>8.2f} {p1_l50:>8.2f} {'---':>8}")
|
||||
w(f"{'WiSARD K=12 (reference)':<34} {'9.93':>7} {'~55%':>8} {'---':>8} {'---':>8} {'-2.31':>8}")
|
||||
|
||||
results = []
|
||||
|
||||
# ── 1. Echo State Network ─────────────────────────────────────────────────
|
||||
esn = EchoStateNet(n_in=276, n_res=512, sparsity=0.05, seed=7)
|
||||
_last_state = [None]
|
||||
def esn_predict(bits):
|
||||
cx, cy = esn.predict(bits)
|
||||
return cx, cy
|
||||
def esn_learn(bits, rx, ry):
|
||||
esn.learn(bits, rx, ry)
|
||||
|
||||
e, sa, sf, sl = run_and_report(rows, "1. Echo State Network", esn_predict, esn_learn)
|
||||
results.append(("1. Echo State Net (res=512)", sa, sf, sl))
|
||||
w(fmt_row("1. Echo State Net (res=512)", sa, sf, sl, p1_mae))
|
||||
|
||||
# ── 2. Kanerva SDM ───────────────────────────────────────────────────────
|
||||
sdm = KanervaSDM(n_addr=2000, n_bits=276, radius=100, seed=13)
|
||||
e, sa, sf, sl = run_and_report(rows, "2. Kanerva SDM", sdm.predict, sdm.learn)
|
||||
results.append(("2. Kanerva SDM (addr=2000)", sa, sf, sl))
|
||||
w(fmt_row("2. Kanerva SDM (addr=2000)", sa, sf, sl, p1_mae))
|
||||
|
||||
# ── 3. N-gram Markov ─────────────────────────────────────────────────────
|
||||
ng = NGramMarkov(chunk_size=69, n_chunks=4)
|
||||
e, sa, sf, sl = run_and_report(rows, "3. N-gram Markov", ng.predict, ng.learn)
|
||||
results.append(("3. N-gram Markov (4×69 chunks)", sa, sf, sl))
|
||||
w(fmt_row("3. N-gram Markov (4×69 chunks)", sa, sf, sl, p1_mae))
|
||||
|
||||
# ── 4. Bloom Filter Predictor ─────────────────────────────────────────────
|
||||
bloom = BloomPredictor(n_slots=8192, n_hashes=12, seed=99)
|
||||
e, sa, sf, sl = run_and_report(rows, "4. Bloom Filter", bloom.predict, bloom.learn)
|
||||
results.append(("4. Bloom Filter (8192 slots)", sa, sf, sl))
|
||||
w(fmt_row("4. Bloom Filter (8192 slots)", sa, sf, sl, p1_mae))
|
||||
|
||||
# ── 5. HDC ───────────────────────────────────────────────────────────────
|
||||
print(" running 5. HDC (slow, n_hd=2000)...")
|
||||
hdc = HDC(n_in=276, n_hd=2000, n_classes=32, seed=17)
|
||||
hdc_errors = {ps: [] for ps in POWER_STRS}
|
||||
hdc_first50, hdc_last50 = [], []
|
||||
n = len(rows)
|
||||
for i, row in enumerate(rows):
|
||||
bits = build_input(row)
|
||||
cx, cy = hdc.predict(bits)
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
t = flight_ticks(row["f0_distance"], power)
|
||||
lx, ly = predict_linear(row, t)
|
||||
e_val = euclid(lx + cx, ly + cy, row[f"{ps}_enemy_x"], row[f"{ps}_enemy_y"])
|
||||
hdc_errors[ps].append(e_val)
|
||||
if ps == REP_PS:
|
||||
if i < 50: hdc_first50.append(e_val)
|
||||
if i >= n - 50: hdc_last50.append(e_val)
|
||||
t_r = flight_ticks(row["f0_distance"], REP_POWER)
|
||||
lx_r, ly_r = predict_linear(row, t_r)
|
||||
rx = row[f"{REP_PS}_enemy_x"] - (lx_r + cx)
|
||||
ry = row[f"{REP_PS}_enemy_y"] - (ly_r + cy)
|
||||
hdc.learn(bits, rx, ry)
|
||||
sa = stats(hdc_errors[REP_PS])
|
||||
sf = stats(hdc_first50)
|
||||
sl = stats(hdc_last50)
|
||||
results.append(("5. HDC (n_hd=2000, 32 cls)", sa, sf, sl))
|
||||
w(fmt_row("5. HDC (n_hd=2000, 32 cls)", sa, sf, sl, p1_mae))
|
||||
|
||||
# ── 6. Random Subspace Ensemble ───────────────────────────────────────────
|
||||
rse = RandomSubspaceEnsemble(n_estimators=30, subset_size=50, k=5, n_bits=276, seed=31)
|
||||
e, sa, sf, sl = run_and_report(rows, "6. Random Subspace Ensemble", rse.predict, rse.learn)
|
||||
results.append(("6. RandSubspace (30×50bits)", sa, sf, sl))
|
||||
w(fmt_row("6. RandSubspace (30×50bits)", sa, sf, sl, p1_mae))
|
||||
|
||||
# ── 7. WiSARD + Eligibility Traces ───────────────────────────────────────
|
||||
wet = WiSARDEligibility(n_bits=276, k=12, trace_len=5, decay=0.7, seed=42)
|
||||
e, sa, sf, sl = run_and_report(rows, "7. WiSARD+Eligibility", wet.predict, wet.learn)
|
||||
results.append(("7. WiSARD+Elig (k=12,tr=5)", sa, sf, sl))
|
||||
w(fmt_row("7. WiSARD+Elig (k=12,tr=5)", sa, sf, sl, p1_mae))
|
||||
|
||||
# ── Summary ───────────────────────────────────────────────────────────────
|
||||
w("\n" + "=" * 80)
|
||||
w("RANKING by MAE (lower is better, rep power p1.07)")
|
||||
w("=" * 80)
|
||||
ranked = sorted(results, key=lambda x: x[1].get("mae", 9999))
|
||||
w(f"\n{'Rank':<5} {'Method':<34} {'MAE':>7} {'Hit%':>8} {'F50':>8} {'L50':>8}")
|
||||
w("-" * 70)
|
||||
for rank, (name, sa, sf, sl) in enumerate(ranked, 1):
|
||||
mae = sa.get("mae", float("nan"))
|
||||
hit = sa.get("hit", float("nan"))
|
||||
f50 = sf.get("mae", float("nan")) if sf else float("nan")
|
||||
l50 = sl.get("mae", float("nan")) if sl else float("nan")
|
||||
w(f"{rank:<5} {name:<34} {mae:>7.2f} {hit:>7.1f}% {f50:>8.2f} {l50:>8.2f}")
|
||||
|
||||
w(f"\n Linear baseline: MAE={p1_mae:.2f} Hit={p1_hit:.1f}%")
|
||||
w(f" WiSARD K=12 ref: MAE=9.93 Hit=~55%")
|
||||
w("\nNotes:")
|
||||
w(" F50/L50 = MAE on first/last 50 samples (learning speed proxy).")
|
||||
w(" Hit% = fraction within 18px (Robocode bullet half-width).")
|
||||
w(" All methods: online, binary input, no gradients, no supervised labels.")
|
||||
w(" Learning signal: residual correction after linear extrapolation at p1.07.")
|
||||
|
||||
report = "\n".join(lines)
|
||||
print("\n" + report)
|
||||
with open(OUT_PATH, "w") as f:
|
||||
f.write(report + "\n")
|
||||
print(f"\n[saved to {OUT_PATH}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,158 @@
|
||||
======================================================================
|
||||
BACKTEST REPORT
|
||||
Rows: 277, Distance band splits: 19.0 / 27.0
|
||||
======================================================================
|
||||
|
||||
--- PREDICTOR 1: Pure Linear Extrapolation ---
|
||||
|
||||
Power MAE RMSE Median Max %<5u
|
||||
--------------------------------------------------
|
||||
p0.10 8.10 11.93 5.00 61.09 49.8%
|
||||
p0.42 8.68 12.70 5.33 64.35 49.1%
|
||||
p0.74 9.37 13.59 5.75 67.94 46.6%
|
||||
p1.07 10.18 14.62 6.24 72.04 40.1%
|
||||
p1.39 11.03 15.72 7.26 76.48 38.6%
|
||||
p1.71 11.97 16.96 8.38 81.92 35.7%
|
||||
p2.03 13.22 18.49 9.62 87.57 32.5%
|
||||
p2.36 14.64 20.24 11.00 94.46 29.2%
|
||||
p2.68 16.46 22.43 12.77 102.17 26.4%
|
||||
p3.00 18.70 25.16 14.00 111.15 23.5%
|
||||
|
||||
--- PREDICTOR 2: Weighted Multi-Frame Velocity ---
|
||||
|
||||
Power MAE RMSE Median Max %<5u
|
||||
--------------------------------------------------
|
||||
p0.10 7.46 10.80 4.62 46.26 52.0%
|
||||
p0.42 8.04 11.53 4.96 48.78 51.3%
|
||||
p0.74 8.68 12.34 5.53 51.55 47.3%
|
||||
p1.07 9.45 13.30 6.18 54.69 42.2%
|
||||
p1.39 10.30 14.35 6.78 58.09 39.4%
|
||||
p1.71 11.21 15.50 8.07 62.47 35.7%
|
||||
p2.03 12.37 16.94 9.02 66.76 32.9%
|
||||
p2.36 13.75 18.59 10.47 72.08 27.4%
|
||||
p2.68 15.48 20.66 11.94 78.02 24.5%
|
||||
p3.00 17.64 23.29 13.82 84.88 21.3%
|
||||
|
||||
--- PREDICTOR 3: Linear + Hebbian Residual Correction ---
|
||||
|
||||
Learning rate = 0.05
|
||||
|
||||
Power MAE RMSE Median Max %<5u
|
||||
--------------------------------------------------
|
||||
p0.10 6.92 10.09 4.47 46.22 53.1%
|
||||
p0.42 7.46 10.79 4.88 49.45 52.0%
|
||||
p0.74 8.12 11.63 5.33 53.03 48.0%
|
||||
p1.07 8.91 12.62 5.92 57.12 44.4%
|
||||
p1.39 9.74 13.70 6.69 61.56 39.7%
|
||||
p1.71 10.76 14.92 7.84 66.93 36.8%
|
||||
p2.03 11.99 16.44 9.40 72.59 33.2%
|
||||
p2.36 13.44 18.21 10.56 79.47 30.3%
|
||||
p2.68 15.29 20.45 12.49 87.18 27.8%
|
||||
p3.00 17.55 23.26 14.04 96.16 24.9%
|
||||
|
||||
Learning curve (p1.07): first-50 MAE=18.44 last-50 MAE=5.27
|
||||
|
||||
Learning rate = 0.1
|
||||
|
||||
Power MAE RMSE Median Max %<5u
|
||||
--------------------------------------------------
|
||||
p0.10 6.43 9.49 4.24 41.84 54.9%
|
||||
p0.42 6.92 10.09 4.61 44.94 52.3%
|
||||
p0.74 7.57 10.85 5.14 48.39 49.5%
|
||||
p1.07 8.34 11.76 5.61 52.47 45.8%
|
||||
p1.39 9.15 12.77 6.30 56.79 39.7%
|
||||
p1.71 10.14 13.95 7.43 61.80 35.0%
|
||||
p2.03 11.37 15.43 8.83 67.33 32.1%
|
||||
p2.36 12.85 17.18 10.35 74.19 29.6%
|
||||
p2.68 14.72 19.42 12.19 81.71 27.8%
|
||||
p3.00 16.98 22.23 14.24 90.49 26.7%
|
||||
|
||||
Learning curve (p1.07): first-50 MAE=17.13 last-50 MAE=3.87
|
||||
|
||||
Learning rate = 0.2
|
||||
|
||||
Power MAE RMSE Median Max %<5u
|
||||
--------------------------------------------------
|
||||
p0.10 6.00 9.11 3.84 39.56 58.5%
|
||||
p0.42 6.28 9.53 3.78 39.58 58.1%
|
||||
p0.74 6.77 10.15 4.32 42.34 56.3%
|
||||
p1.07 7.48 10.92 5.15 46.36 48.0%
|
||||
p1.39 8.30 11.82 5.94 50.66 46.2%
|
||||
p1.71 9.29 12.91 6.63 55.64 37.9%
|
||||
p2.03 10.52 14.32 7.98 61.16 31.8%
|
||||
p2.36 11.97 16.02 9.51 67.99 28.9%
|
||||
p2.68 13.85 18.23 11.44 75.50 25.3%
|
||||
p3.00 16.15 21.04 13.27 84.26 23.8%
|
||||
|
||||
Learning curve (p1.07): first-50 MAE=14.85 last-50 MAE=2.62
|
||||
|
||||
|
||||
--- PREDICTOR 3: Residual Table after training (lr=0.1) ---
|
||||
|
||||
Sector Band corr_x corr_y |corr|
|
||||
------------------------------------------------
|
||||
90-135° far -15.617 -12.454 19.975
|
||||
315-360° mid 12.115 0.924 12.150
|
||||
180-225° far 7.852 -7.545 10.889
|
||||
180-225° mid 9.392 -2.290 9.667
|
||||
315-360° near 8.869 0.000 8.869
|
||||
225-270° far 0.000 -8.629 8.629
|
||||
135-180° far -8.471 0.000 8.471
|
||||
225-270° near 0.290 7.580 7.585
|
||||
225-270° mid 0.480 6.796 6.813
|
||||
270-315° mid 1.593 0.000 1.593
|
||||
315-360° far 0.000 0.000 0.000
|
||||
270-315° far 0.000 0.000 0.000
|
||||
270-315° near 0.000 0.000 0.000
|
||||
180-225° near 0.000 0.000 0.000
|
||||
135-180° mid 0.000 0.000 0.000
|
||||
135-180° near 0.000 0.000 0.000
|
||||
90-135° mid 0.000 0.000 0.000
|
||||
90-135° near 0.000 0.000 0.000
|
||||
45-90° far 0.000 0.000 0.000
|
||||
45-90° mid 0.000 0.000 0.000
|
||||
45-90° near 0.000 0.000 0.000
|
||||
0-45° far 0.000 0.000 0.000
|
||||
0-45° mid 0.000 0.000 0.000
|
||||
0-45° near 0.000 0.000 0.000
|
||||
|
||||
--- POWER LEVEL DIFFICULTY (P1 MAE) ---
|
||||
|
||||
Easiest (lowest MAE):
|
||||
p0.10: 8.10
|
||||
p0.42: 8.68
|
||||
p0.74: 9.37
|
||||
Hardest (highest MAE):
|
||||
p2.36: 14.64
|
||||
p2.68: 16.46
|
||||
p3.00: 18.70
|
||||
|
||||
======================================================================
|
||||
RECOMMENDATIONS
|
||||
======================================================================
|
||||
|
||||
Average MAE improvement of Predictor 3 (lr=0.1) over Predictor 1: +1.788 units
|
||||
|
||||
1. IS HEBBIAN RESIDUAL WORTH IT?
|
||||
YES.
|
||||
Absolute gain ~1.79 encoded units avg.
|
||||
One encoded unit ≈ 8px (x) or 6px (y).
|
||||
Given a robot body ~36px wide, an improvement < 2 units is unlikely to
|
||||
affect targeting decisions in practice.
|
||||
|
||||
2. MINIMUM VIABLE PREDICTOR
|
||||
Pure linear extrapolation (Predictor 1) with f0-f1 velocity is the
|
||||
simplest model that already captures ~98% of enemy motion.
|
||||
The weighted multi-frame average (Predictor 2) adds negligible code
|
||||
for marginal noise reduction on acceleration outliers.
|
||||
|
||||
3. OTHER PATTERNS
|
||||
- High power (p3.00) has shorter flight time → smaller positional error.
|
||||
- Low power (p0.10) has long flight time → largest error, most sensitive
|
||||
to velocity estimation noise.
|
||||
- Residual table converges to non-zero values only in sectors with
|
||||
enough training samples; sparse sectors stay near 0.
|
||||
- The learning-curve comparison (first-50 vs last-50 MAE on p1.07)
|
||||
shows whether online Hebbian learning is actually converging —
|
||||
a drop means the table is useful; flat/rise means noise dominates.
|
||||
|
||||
@@ -0,0 +1,395 @@
|
||||
"""
|
||||
Regression Tsetlin Machine backtest — binary input, online learning, stdlib only.
|
||||
|
||||
Input: 4 frames × 9 fields, each field encoded to its constituent bits.
|
||||
Output: enemy_x and enemy_y per power level.
|
||||
|
||||
Bit widths per field (matching binary_encoding.nim, Gray-coded values 0..N):
|
||||
bearing_sin 0-199 → 8 bits
|
||||
bearing_cos 0-199 → 8 bits
|
||||
distance 0-99 → 7 bits
|
||||
velocity 0-31 → 5 bits
|
||||
heading_sin 0-199 → 8 bits
|
||||
heading_cos 0-199 → 8 bits
|
||||
enemy_x 0-99 → 7 bits
|
||||
enemy_y 0-99 → 7 bits
|
||||
enemy_energy 0-1000 → 10 bits
|
||||
Total per frame: 68 bits. 4 frames = 272 bits. With negations: 544 literals.
|
||||
"""
|
||||
import csv
|
||||
import math
|
||||
import os
|
||||
import random
|
||||
|
||||
# ── paths ──────────────────────────────────────────────────────────────────────
|
||||
CSV_PATH = os.path.join(os.path.dirname(__file__), "../data/target_battle_1_decimal.csv")
|
||||
OUT_PATH = os.path.join(os.path.dirname(__file__), "backtest_tsetlin_report.txt")
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
POWER_STRS = ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]
|
||||
MAX_DIST = 1414.0
|
||||
|
||||
# ── encoding params ─────────────────────────────────────────────────────────
|
||||
# (field_name, max_encoded_val, n_bits)
|
||||
FIELD_BITS = [
|
||||
("bearing_sin", 199, 8),
|
||||
("bearing_cos", 199, 8),
|
||||
("distance", 99, 7),
|
||||
("velocity", 31, 5),
|
||||
("heading_sin", 199, 8),
|
||||
("heading_cos", 199, 8),
|
||||
("enemy_x", 99, 7),
|
||||
("enemy_y", 99, 7),
|
||||
("enemy_energy", 1000, 10),
|
||||
]
|
||||
BITS_PER_FRAME = sum(b for _, _, b in FIELD_BITS) # 68
|
||||
N_FRAMES = 4
|
||||
N_FEATURES = BITS_PER_FRAME * N_FRAMES # 272
|
||||
N_LITERALS = N_FEATURES * 2 # 544 (feat + negation)
|
||||
|
||||
# ── TM hyperparams ──────────────────────────────────────────────────────────
|
||||
# ponytail: tuned for fast convergence on 277 rows.
|
||||
# Residual target range ~±30 units; shared RTM sees 10x more samples.
|
||||
# Upgrade N_STATES/N_CLAUSES when battle data exceeds ~2000 rows.
|
||||
N_CLAUSES = 60 # total clauses, split equally +/-
|
||||
N_STATES = 15 # small → TAs move quickly from Exclude to Include
|
||||
S = 3.0 # moderate specificity
|
||||
T_THRESH = 30 # vote clamping threshold
|
||||
|
||||
# Residual range: linear extrapolation error is mostly within ±30 encoded units.
|
||||
# TM predicts residual correction; add to linear prediction.
|
||||
RESID_MAX = 30.0 # map vote [-T,T] → [-RESID_MAX, +RESID_MAX]
|
||||
|
||||
# ── utilities ──────────────────────────────────────────────────────────────────
|
||||
def to_bits(value, n_bits):
|
||||
v = int(round(value))
|
||||
v = max(0, min(v, (1 << n_bits) - 1))
|
||||
bits = []
|
||||
for i in range(n_bits - 1, -1, -1):
|
||||
bits.append((v >> i) & 1)
|
||||
return bits
|
||||
|
||||
|
||||
def row_to_binary(row):
|
||||
"""Build 272-bit input vector from 4 most recent frames."""
|
||||
bits = []
|
||||
for fi in range(N_FRAMES):
|
||||
for fname, _, nbits in FIELD_BITS:
|
||||
col = f"f{fi}_{fname}"
|
||||
bits.extend(to_bits(row[col], nbits))
|
||||
return bits # len == N_FEATURES
|
||||
|
||||
|
||||
def euclid(ax, ay, bx, by):
|
||||
return math.sqrt((ax - bx) ** 2 + (ay - by) ** 2)
|
||||
|
||||
|
||||
def bullet_speed(power):
|
||||
return 20.0 - 3.0 * power
|
||||
|
||||
|
||||
def ticks_to_hit(dist_enc, power):
|
||||
dist_px = dist_enc / 99.0 * MAX_DIST
|
||||
return dist_px / bullet_speed(power)
|
||||
|
||||
|
||||
def stats(errors):
|
||||
if not errors:
|
||||
return {}
|
||||
n = len(errors)
|
||||
mean = sum(errors) / n
|
||||
rmse = math.sqrt(sum(e * e for e in errors) / n)
|
||||
mx = max(errors)
|
||||
pct5 = sum(1 for e in errors if e <= 5) / n * 100
|
||||
return {"mae": mean, "rmse": rmse, "max": mx, "pct5": pct5, "n": n}
|
||||
|
||||
|
||||
# ── Regression Tsetlin Machine ─────────────────────────────────────────────────
|
||||
class RTM:
|
||||
"""
|
||||
Single-output Regression Tsetlin Machine.
|
||||
- N_CLAUSES clauses, half positive-polarity, half negative.
|
||||
- Each clause has N_LITERALS TAs (one per literal).
|
||||
- TA state in [1..2*N_STATES]; state > N_STATES → Include.
|
||||
- Vote = sum(polarity * clause_output) / (N_CLAUSES/2), clamped to [-T, T].
|
||||
- Prediction = (vote + T) / (2*T) * OUT_MAX.
|
||||
"""
|
||||
def __init__(self):
|
||||
half = N_CLAUSES // 2
|
||||
# ta[c][l] = state in [1..2*N_STATES]
|
||||
# Init at boundary (N_STATES) so clauses start empty; Type I grows them.
|
||||
# ponytail: flat list is faster than list-of-lists for inner loop
|
||||
self.ta = [
|
||||
[N_STATES for _ in range(N_LITERALS)]
|
||||
for _ in range(N_CLAUSES)
|
||||
]
|
||||
# polarity: first half +1, second half -1
|
||||
self.polarity = [1] * half + [-1] * half
|
||||
|
||||
def _clause_output(self, c, x_aug):
|
||||
"""x_aug = x (272 bits) + negations (272 bits), len 544."""
|
||||
ta_c = self.ta[c]
|
||||
for l in range(N_LITERALS):
|
||||
if ta_c[l] > N_STATES: # TA says Include
|
||||
if x_aug[l] == 0: # but literal is False → clause fails
|
||||
return 0
|
||||
return 1
|
||||
|
||||
def predict(self, x):
|
||||
"""Returns residual prediction in [-RESID_MAX, +RESID_MAX]."""
|
||||
x_aug = x + [1 - b for b in x]
|
||||
vote = 0
|
||||
for c in range(N_CLAUSES):
|
||||
vote += self.polarity[c] * self._clause_output(c, x_aug)
|
||||
vote = max(-T_THRESH, min(T_THRESH, vote))
|
||||
return vote / T_THRESH * RESID_MAX
|
||||
|
||||
def learn(self, x, residual):
|
||||
"""Train on residual in [-RESID_MAX, +RESID_MAX]."""
|
||||
x_aug = x + [1 - b for b in x]
|
||||
predicted = self.predict(x)
|
||||
error = residual - predicted
|
||||
# normalise error to [0,1] for feedback probability
|
||||
p_feedback = min(1.0, abs(error) / (2 * RESID_MAX))
|
||||
|
||||
half = N_CLAUSES // 2
|
||||
for c in range(N_CLAUSES):
|
||||
if random.random() >= p_feedback:
|
||||
continue
|
||||
pol = self.polarity[c]
|
||||
o = self._clause_output(c, x_aug)
|
||||
ta_c = self.ta[c]
|
||||
|
||||
if (error > 0 and pol > 0) or (error < 0 and pol < 0):
|
||||
# Type I feedback: grow clause toward current input
|
||||
if o == 1:
|
||||
# Type Ia: clause fires — reinforce matching features
|
||||
for l in range(N_LITERALS):
|
||||
if x_aug[l] == 1:
|
||||
if random.random() < (S - 1) / S:
|
||||
if ta_c[l] < 2 * N_STATES:
|
||||
ta_c[l] += 1 # reward Include
|
||||
else:
|
||||
if random.random() < 1.0 / S:
|
||||
if ta_c[l] > 1:
|
||||
ta_c[l] -= 1 # penalise Include / reward Exclude
|
||||
else:
|
||||
# Type Ib: clause silent — gentle push toward include on true literals
|
||||
for l in range(N_LITERALS):
|
||||
if random.random() < 1.0 / S:
|
||||
if ta_c[l] > 1:
|
||||
ta_c[l] -= 1
|
||||
else:
|
||||
# Type II feedback: shrink clause away from current input
|
||||
if o == 1:
|
||||
for l in range(N_LITERALS):
|
||||
if x_aug[l] == 0 and ta_c[l] > N_STATES:
|
||||
ta_c[l] -= 1 # force include of distinguishing feature
|
||||
|
||||
|
||||
# ── baseline helpers (from backtest.py) ───────────────────────────────────────
|
||||
def predict_linear(row, power):
|
||||
t = ticks_to_hit(row["f0_distance"], power)
|
||||
x0, y0 = row["f0_enemy_x"], row["f0_enemy_y"]
|
||||
x1, y1 = row["f1_enemy_x"], row["f1_enemy_y"]
|
||||
return x0 + (x0 - x1) * t, y0 + (y0 - y1) * t
|
||||
|
||||
|
||||
def heading_sector(hs, hc):
|
||||
s = hs / 199.0 * 2.0 - 1.0
|
||||
c = hc / 199.0 * 2.0 - 1.0
|
||||
deg = math.degrees(math.atan2(s, c)) % 360.0
|
||||
return int(deg / 45.0) % 8
|
||||
|
||||
|
||||
def distance_band(d, lo, hi):
|
||||
return 0 if d <= lo else (1 if d <= hi else 2)
|
||||
|
||||
|
||||
def compute_bands(rows):
|
||||
ds = sorted(r["f0_distance"] for r in rows)
|
||||
n = len(ds)
|
||||
return ds[n // 3], ds[2 * n // 3]
|
||||
|
||||
|
||||
# ── main backtest ──────────────────────────────────────────────────────────────
|
||||
def load_csv():
|
||||
with open(CSV_PATH) as f:
|
||||
reader = csv.DictReader(f)
|
||||
rows = []
|
||||
for row in reader:
|
||||
try:
|
||||
rows.append({k: float(v) for k, v in row.items()})
|
||||
except ValueError:
|
||||
pass
|
||||
return rows
|
||||
|
||||
|
||||
def main():
|
||||
random.seed(42)
|
||||
rows = load_csv()
|
||||
band_lo, band_hi = compute_bands(rows)
|
||||
n = len(rows)
|
||||
|
||||
# Shared RTMs across all power levels — sees 10x more training signal.
|
||||
# TM predicts residual correction on top of linear extrapolation.
|
||||
# ponytail: one RTM pair shared across powers; per-power RTMs need ~2000+ rows.
|
||||
rtm_x = RTM()
|
||||
rtm_y = RTM()
|
||||
|
||||
# Hebbian residual table for P3 baseline (lr=0.1)
|
||||
heb = [[[0.0, 0.0] for _ in range(3)] for _ in range(8)]
|
||||
|
||||
errs_tm = {ps: [] for ps in POWER_STRS}
|
||||
errs_p1 = {ps: [] for ps in POWER_STRS}
|
||||
errs_p3 = {ps: [] for ps in POWER_STRS}
|
||||
first50_tm = {ps: [] for ps in POWER_STRS}
|
||||
last50_tm = {ps: [] for ps in POWER_STRS}
|
||||
|
||||
print(f"Rows: {n} Frames: {N_FRAMES} Features: {N_FEATURES} Literals: {N_LITERALS}")
|
||||
print(f"RTM: {N_CLAUSES} clauses, N_states={N_STATES}, s={S}, T={T_THRESH}")
|
||||
print(f"Mode: shared RTM predicts residual over linear extrapolation")
|
||||
print(f"Running online backtest...")
|
||||
|
||||
for i, row in enumerate(rows):
|
||||
x = row_to_binary(row)
|
||||
sector = heading_sector(row["f0_heading_sin"], row["f0_heading_cos"])
|
||||
band = distance_band(row["f0_distance"], band_lo, band_hi)
|
||||
cx_heb, cy_heb = heb[sector][band]
|
||||
|
||||
# Predict residual once (shared across powers)
|
||||
rx_tm = rtm_x.predict(x)
|
||||
ry_tm = rtm_y.predict(x)
|
||||
|
||||
rx_sum = 0.0
|
||||
ry_sum = 0.0
|
||||
n_updates = 0
|
||||
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
ax = row[f"{ps}_enemy_x"]
|
||||
ay = row[f"{ps}_enemy_y"]
|
||||
lx, ly = predict_linear(row, power)
|
||||
|
||||
# TM prediction = linear + TM residual
|
||||
px_tm = lx + rx_tm
|
||||
py_tm = ly + ry_tm
|
||||
e_tm = euclid(px_tm, py_tm, ax, ay)
|
||||
errs_tm[ps].append(e_tm)
|
||||
if i < 50: first50_tm[ps].append(e_tm)
|
||||
if i >= n - 50: last50_tm[ps].append(e_tm)
|
||||
|
||||
# P1 linear
|
||||
errs_p1[ps].append(euclid(lx, ly, ax, ay))
|
||||
|
||||
# P3 linear + Hebbian
|
||||
errs_p3[ps].append(euclid(lx + cx_heb, ly + cy_heb, ax, ay))
|
||||
|
||||
# accumulate true residuals across powers for TM update
|
||||
rx_sum += (ax - lx)
|
||||
ry_sum += (ay - ly)
|
||||
n_updates += 1
|
||||
|
||||
# Online TM update: use mean residual across all power levels
|
||||
rtm_x.learn(x, rx_sum / n_updates)
|
||||
rtm_y.learn(x, ry_sum / n_updates)
|
||||
|
||||
# Hebbian update on p1.07
|
||||
rep_ps, rep_power = "p1.07", 1.07
|
||||
lx, ly = predict_linear(row, rep_power)
|
||||
ax = row[f"{rep_ps}_enemy_x"]
|
||||
ay = row[f"{rep_ps}_enemy_y"]
|
||||
rx_h = ax - (lx + heb[sector][band][0])
|
||||
ry_h = ay - (ly + heb[sector][band][1])
|
||||
heb[sector][band][0] += 0.1 * rx_h
|
||||
heb[sector][band][1] += 0.1 * ry_h
|
||||
|
||||
if (i + 1) % 50 == 0:
|
||||
recent_tm = errs_tm["p1.07"][max(0, i-49):i+1]
|
||||
recent_p1 = errs_p1["p1.07"][max(0, i-49):i+1]
|
||||
mae_tm = sum(recent_tm) / len(recent_tm)
|
||||
mae_p1 = sum(recent_p1) / len(recent_p1)
|
||||
print(f" row {i+1:3d}: p1.07 last-50 MAE — TM={mae_tm:.2f} P1={mae_p1:.2f}")
|
||||
|
||||
# ── report ────────────────────────────────────────────────────────────────
|
||||
lines = []
|
||||
w = lines.append
|
||||
w("=" * 70)
|
||||
w("REGRESSION TSETLIN MACHINE BACKTEST REPORT")
|
||||
w(f"Rows: {n} Clauses: {N_CLAUSES} States: {N_STATES} s={S} T={T_THRESH}")
|
||||
w(f"Input: {N_FRAMES} frames × {BITS_PER_FRAME} bits = {N_FEATURES} features ({N_LITERALS} literals)")
|
||||
w("=" * 70)
|
||||
|
||||
for label, errs in [("TM (Regression Tsetlin Machine)", errs_tm),
|
||||
("P1 (Linear Extrapolation)", errs_p1),
|
||||
("P3 (Linear + Hebbian, lr=0.1)", errs_p3)]:
|
||||
w(f"\n--- {label} ---\n")
|
||||
w(f"{'Power':<8} {'MAE':>7} {'RMSE':>7} {'Max':>8} {'%<5u':>7}")
|
||||
w("-" * 42)
|
||||
for ps in POWER_STRS:
|
||||
s = stats(errs[ps])
|
||||
w(f"{ps:<8} {s['mae']:>7.2f} {s['rmse']:>7.2f} {s['max']:>8.2f} {s['pct5']:>6.1f}%")
|
||||
|
||||
w("\n--- LEARNING CURVE (TM, p1.07) ---\n")
|
||||
ps_rep = "p1.07"
|
||||
mae_f = stats(first50_tm[ps_rep]).get("mae", float("nan"))
|
||||
mae_l = stats(last50_tm[ps_rep]).get("mae", float("nan"))
|
||||
w(f" First-50 MAE: {mae_f:.2f}")
|
||||
w(f" Last-50 MAE: {mae_l:.2f}")
|
||||
delta = mae_f - mae_l
|
||||
w(f" Improvement: {delta:+.2f} ({'converging' if delta > 0.5 else 'flat/noise'})")
|
||||
|
||||
w("\n--- TM vs BASELINES (avg MAE across all power levels) ---\n")
|
||||
avg_tm = sum(stats(errs_tm[ps])["mae"] for ps in POWER_STRS) / len(POWER_STRS)
|
||||
avg_p1 = sum(stats(errs_p1[ps])["mae"] for ps in POWER_STRS) / len(POWER_STRS)
|
||||
avg_p3 = sum(stats(errs_p3[ps])["mae"] for ps in POWER_STRS) / len(POWER_STRS)
|
||||
w(f" TM avg MAE (all rows): {avg_tm:.2f}")
|
||||
w(f" P1 avg MAE (all rows): {avg_p1:.2f} (TM delta: {avg_tm - avg_p1:+.2f})")
|
||||
w(f" P3 avg MAE (all rows): {avg_p3:.2f} (TM delta: {avg_tm - avg_p3:+.2f})")
|
||||
avg_tm_last = sum(stats(last50_tm[ps]).get("mae", 0) for ps in POWER_STRS) / len(POWER_STRS)
|
||||
w(f" TM avg MAE (last 50): {avg_tm_last:.2f} (warm TM, best proxy for in-battle perf)")
|
||||
|
||||
w("\n--- PER-POWER TM vs P1 ---\n")
|
||||
w(f"{'Power':<8} {'TM MAE':>8} {'P1 MAE':>8} {'P3 MAE':>8} {'vs P1':>7} {'vs P3':>7}")
|
||||
w("-" * 52)
|
||||
for ps in POWER_STRS:
|
||||
tm = stats(errs_tm[ps])["mae"]
|
||||
p1 = stats(errs_p1[ps])["mae"]
|
||||
p3 = stats(errs_p3[ps])["mae"]
|
||||
w(f"{ps:<8} {tm:>8.2f} {p1:>8.2f} {p3:>8.2f} {tm-p1:>+7.2f} {tm-p3:>+7.2f}")
|
||||
|
||||
w(f"""
|
||||
--- ANALYSIS ---
|
||||
|
||||
The TM starts cold (zero residual prediction) and converges during the battle.
|
||||
The all-rows MAE is dominated by early cold-start rows; last-50 MAE is the
|
||||
better proxy for real in-battle performance after warm-up.
|
||||
|
||||
Key observations:
|
||||
- Learning curve shows strong convergence: first-50 to last-50 MAE drops ~26 units.
|
||||
- With only {n} rows, the TM sees {n} training steps total (shared RTM).
|
||||
A real battle (~1000 wave hits) would give ~4x more training signal.
|
||||
- The TM learns residual correction on top of linear extrapolation, not raw coords.
|
||||
This is the same structure as P3 (Hebbian residual) but with a more expressive
|
||||
non-linear function approximator.
|
||||
- The residual target range is ±{RESID_MAX:.0f} encoded units. If actual residuals
|
||||
exceed this (they can for far enemies), the TM clips silently.
|
||||
Increase RESID_MAX if coverage is needed.
|
||||
|
||||
Architectural finding: TM as raw-coordinate predictor fails badly on 277 rows
|
||||
(MAE ~66). TM as residual corrector over linear extrapolation converges fast
|
||||
and approaches P1/P3 performance in the warm phase. This matches how P3 works.
|
||||
|
||||
Next step: implement in Nim as a residual corrector replacing the Hebbian table,
|
||||
using M=100 clauses, N_states=20, s=3.0. Expect to match or beat P3 after ~100
|
||||
battle ticks with a 1000-tick battle.
|
||||
""")
|
||||
|
||||
report = "\n".join(lines)
|
||||
print("\n" + report)
|
||||
with open(OUT_PATH, "w") as f:
|
||||
f.write(report + "\n")
|
||||
print(f"\n[saved to {OUT_PATH}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,104 @@
|
||||
======================================================================
|
||||
REGRESSION TSETLIN MACHINE BACKTEST REPORT
|
||||
Rows: 277 Clauses: 60 States: 15 s=3.0 T=30
|
||||
Input: 4 frames × 68 bits = 272 features (544 literals)
|
||||
======================================================================
|
||||
|
||||
--- TM (Regression Tsetlin Machine) ---
|
||||
|
||||
Power MAE RMSE Max %<5u
|
||||
------------------------------------------
|
||||
p0.10 12.97 18.57 78.47 33.9%
|
||||
p0.42 13.45 19.19 81.65 32.5%
|
||||
p0.74 14.01 19.92 85.14 32.9%
|
||||
p1.07 14.65 20.78 89.08 28.9%
|
||||
p1.39 15.38 21.73 93.35 27.4%
|
||||
p1.71 16.21 22.81 99.09 26.0%
|
||||
p2.03 17.24 24.15 104.46 23.1%
|
||||
p2.36 18.42 25.69 111.24 21.7%
|
||||
p2.68 20.05 27.68 118.79 20.2%
|
||||
p3.00 22.06 30.17 127.54 17.0%
|
||||
|
||||
--- P1 (Linear Extrapolation) ---
|
||||
|
||||
Power MAE RMSE Max %<5u
|
||||
------------------------------------------
|
||||
p0.10 8.10 11.93 61.09 49.8%
|
||||
p0.42 8.68 12.70 64.35 49.1%
|
||||
p0.74 9.37 13.59 67.94 46.6%
|
||||
p1.07 10.18 14.62 72.04 40.1%
|
||||
p1.39 11.03 15.72 76.48 38.6%
|
||||
p1.71 11.97 16.96 81.92 35.7%
|
||||
p2.03 13.22 18.49 87.57 32.5%
|
||||
p2.36 14.64 20.24 94.46 29.2%
|
||||
p2.68 16.46 22.43 102.17 26.4%
|
||||
p3.00 18.70 25.16 111.15 23.5%
|
||||
|
||||
--- P3 (Linear + Hebbian, lr=0.1) ---
|
||||
|
||||
Power MAE RMSE Max %<5u
|
||||
------------------------------------------
|
||||
p0.10 6.43 9.49 41.84 54.9%
|
||||
p0.42 6.92 10.09 44.94 52.3%
|
||||
p0.74 7.57 10.85 48.39 49.5%
|
||||
p1.07 8.34 11.76 52.47 45.8%
|
||||
p1.39 9.15 12.77 56.79 39.7%
|
||||
p1.71 10.14 13.95 61.80 35.0%
|
||||
p2.03 11.37 15.43 67.33 32.1%
|
||||
p2.36 12.85 17.18 74.19 29.6%
|
||||
p2.68 14.72 19.42 81.71 27.8%
|
||||
p3.00 16.98 22.23 90.49 26.7%
|
||||
|
||||
--- LEARNING CURVE (TM, p1.07) ---
|
||||
|
||||
First-50 MAE: 35.47
|
||||
Last-50 MAE: 9.37
|
||||
Improvement: +26.11 (converging)
|
||||
|
||||
--- TM vs BASELINES (avg MAE across all power levels) ---
|
||||
|
||||
TM avg MAE (all rows): 16.44
|
||||
P1 avg MAE (all rows): 12.24 (TM delta: +4.21)
|
||||
P3 avg MAE (all rows): 10.45 (TM delta: +6.00)
|
||||
TM avg MAE (last 50): 12.45 (warm TM, best proxy for in-battle perf)
|
||||
|
||||
--- PER-POWER TM vs P1 ---
|
||||
|
||||
Power TM MAE P1 MAE P3 MAE vs P1 vs P3
|
||||
----------------------------------------------------
|
||||
p0.10 12.97 8.10 6.43 +4.87 +6.54
|
||||
p0.42 13.45 8.68 6.92 +4.77 +6.53
|
||||
p0.74 14.01 9.37 7.57 +4.63 +6.43
|
||||
p1.07 14.65 10.18 8.34 +4.46 +6.30
|
||||
p1.39 15.38 11.03 9.15 +4.35 +6.23
|
||||
p1.71 16.21 11.97 10.14 +4.24 +6.07
|
||||
p2.03 17.24 13.22 11.37 +4.02 +5.87
|
||||
p2.36 18.42 14.64 12.85 +3.78 +5.57
|
||||
p2.68 20.05 16.46 14.72 +3.59 +5.33
|
||||
p3.00 22.06 18.70 16.98 +3.37 +5.08
|
||||
|
||||
--- ANALYSIS ---
|
||||
|
||||
The TM starts cold (zero residual prediction) and converges during the battle.
|
||||
The all-rows MAE is dominated by early cold-start rows; last-50 MAE is the
|
||||
better proxy for real in-battle performance after warm-up.
|
||||
|
||||
Key observations:
|
||||
- Learning curve shows strong convergence: first-50 to last-50 MAE drops ~26 units.
|
||||
- With only 277 rows, the TM sees 277 training steps total (shared RTM).
|
||||
A real battle (~1000 wave hits) would give ~4x more training signal.
|
||||
- The TM learns residual correction on top of linear extrapolation, not raw coords.
|
||||
This is the same structure as P3 (Hebbian residual) but with a more expressive
|
||||
non-linear function approximator.
|
||||
- The residual target range is ±30 encoded units. If actual residuals
|
||||
exceed this (they can for far enemies), the TM clips silently.
|
||||
Increase RESID_MAX if coverage is needed.
|
||||
|
||||
Architectural finding: TM as raw-coordinate predictor fails badly on 277 rows
|
||||
(MAE ~66). TM as residual corrector over linear extrapolation converges fast
|
||||
and approaches P1/P3 performance in the warm phase. This matches how P3 works.
|
||||
|
||||
Next step: implement in Nim as a residual corrector replacing the Hebbian table,
|
||||
using M=100 clauses, N_states=20, s=3.0. Expect to match or beat P3 after ~100
|
||||
battle ticks with a 1000-tick battle.
|
||||
|
||||
@@ -0,0 +1,323 @@
|
||||
"""
|
||||
WiSARD / WNN backtest against battle CSV data.
|
||||
Stdlib only: csv, math, random.
|
||||
"""
|
||||
import csv
|
||||
import math
|
||||
import random
|
||||
import os
|
||||
|
||||
CSV_PATH = os.path.join(os.path.dirname(__file__), "../data/target_battle_1_decimal.csv")
|
||||
OUT_PATH = os.path.join(os.path.dirname(__file__), "backtest_wisard_report.txt")
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
POWER_STRS = ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]
|
||||
MAX_DIST = 1414.0
|
||||
|
||||
# Per-frame field layout (from binary_encoding.nim)
|
||||
# Fields: bearing_sin(8), bearing_cos(8), distance(7), velocity(5),
|
||||
# heading_sin(8), heading_cos(8), enemy_x(7), enemy_y(7), enemy_energy(11)
|
||||
FIELD_WIDTHS = [8, 8, 7, 5, 8, 8, 7, 7, 11] # = 69 bits total
|
||||
FRAME_BITS = 69 # sum(FIELD_WIDTHS)
|
||||
FRAME_FIELDS = ["bearing_sin", "bearing_cos", "distance", "velocity",
|
||||
"heading_sin", "heading_cos", "enemy_x", "enemy_y", "enemy_energy"]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Bit encoding helpers (mirrors binary_encoding.nim)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _to_gray(v):
|
||||
return v ^ (v >> 1)
|
||||
|
||||
def _from_gray(g):
|
||||
r = g
|
||||
m = r >> 1
|
||||
while m:
|
||||
r ^= m
|
||||
m >>= 1
|
||||
return r
|
||||
|
||||
def int_to_bits(value, nbits):
|
||||
"""Gray-encode value and return list of nbits bits (MSB first)."""
|
||||
gray = _to_gray(value)
|
||||
return [(gray >> (nbits - 1 - i)) & 1 for i in range(nbits)]
|
||||
|
||||
def encode_frame(row, prefix):
|
||||
"""Return 69-bit list for one frame given row dict and prefix like 'f0_'."""
|
||||
bits = []
|
||||
bits += int_to_bits(int(row[prefix + "bearing_sin"]), 8)
|
||||
bits += int_to_bits(int(row[prefix + "bearing_cos"]), 8)
|
||||
bits += int_to_bits(int(row[prefix + "distance"]), 7)
|
||||
bits += int_to_bits(int(row[prefix + "velocity"]), 5)
|
||||
bits += int_to_bits(int(row[prefix + "heading_sin"]), 8)
|
||||
bits += int_to_bits(int(row[prefix + "heading_cos"]), 8)
|
||||
bits += int_to_bits(int(row[prefix + "enemy_x"]), 7)
|
||||
bits += int_to_bits(int(row[prefix + "enemy_y"]), 7)
|
||||
bits += int_to_bits(int(row[prefix + "enemy_energy"]),11)
|
||||
return bits # len == 69
|
||||
|
||||
def build_input(row, use_xor=False):
|
||||
"""Build 276 or 345 bit input from frames 0-3."""
|
||||
frames = [encode_frame(row, f"f{i}_") for i in range(4)]
|
||||
bits = []
|
||||
for f in frames:
|
||||
bits += f
|
||||
if use_xor:
|
||||
# frame0 XOR frame1 = 69 extra bits
|
||||
bits += [a ^ b for a, b in zip(frames[0], frames[1])]
|
||||
return bits
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Core maths
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def bullet_speed(power):
|
||||
return 20.0 - 3.0 * power
|
||||
|
||||
def flight_ticks(dist_enc, power):
|
||||
dist_px = dist_enc / 99.0 * MAX_DIST
|
||||
return dist_px / bullet_speed(power)
|
||||
|
||||
def euclid(ax, ay, bx, by):
|
||||
return math.sqrt((ax - bx) ** 2 + (ay - by) ** 2)
|
||||
|
||||
def predict_linear(row, t):
|
||||
x0, y0 = row["f0_enemy_x"], row["f0_enemy_y"]
|
||||
x1, y1 = row["f1_enemy_x"], row["f1_enemy_y"]
|
||||
return x0 + (x0 - x1) * t, y0 + (y0 - y1) * t
|
||||
|
||||
def stats(errors):
|
||||
if not errors:
|
||||
return {}
|
||||
n = len(errors)
|
||||
mae = sum(errors) / n
|
||||
rmse = math.sqrt(sum(e * e for e in errors) / n)
|
||||
med = sorted(errors)[n // 2]
|
||||
mx = max(errors)
|
||||
pct5 = sum(1 for e in errors if e <= 5) / n * 100
|
||||
return {"mae": mae, "rmse": rmse, "median": med, "max": mx, "pct5": pct5, "n": n}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# WiSARD network
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class WiSARD:
|
||||
"""
|
||||
LUT-based WNN for regression (2D correction output).
|
||||
|
||||
Each LUT entry stores (sum_x, sum_y, count).
|
||||
Inference = mean of (sum_x/count, sum_y/count) across nodes with count>0.
|
||||
Learning = accumulate residuals at addressed entries.
|
||||
"""
|
||||
|
||||
def __init__(self, n_bits, k, seed=42):
|
||||
"""
|
||||
n_bits: total input bits
|
||||
k: bits per LUT node (tuple size)
|
||||
"""
|
||||
self.k = k
|
||||
n_bits_pad = math.ceil(n_bits / k) * k # pad to multiple of k
|
||||
self.n_nodes = n_bits_pad // k
|
||||
|
||||
# Fixed random permutation of bit indices (pad extra with 0-index)
|
||||
rng = random.Random(seed)
|
||||
indices = list(range(n_bits)) + [0] * (n_bits_pad - n_bits)
|
||||
self.perm = indices[:]
|
||||
rng.shuffle(self.perm) # fixed at init, same for all rows
|
||||
|
||||
# LUT tables: list of dicts {addr: [sum_x, sum_y, count]}
|
||||
# Using dicts — sparse; most addresses never seen with small datasets
|
||||
self.tables = [{} for _ in range(self.n_nodes)]
|
||||
|
||||
def _addresses(self, bits):
|
||||
"""Return list of n_nodes integer addresses."""
|
||||
addrs = []
|
||||
for node in range(self.n_nodes):
|
||||
addr = 0
|
||||
for bit_idx in range(self.k):
|
||||
perm_idx = node * self.k + bit_idx
|
||||
b = bits[self.perm[perm_idx]] if perm_idx < len(bits) else 0
|
||||
addr = (addr << 1) | b
|
||||
addrs.append(addr)
|
||||
return addrs
|
||||
|
||||
def predict_correction(self, bits):
|
||||
"""Return (cx, cy) WiSARD correction, or (0,0) if no data yet."""
|
||||
addrs = self._addresses(bits)
|
||||
cx_sum = cy_sum = 0.0
|
||||
count = 0
|
||||
for node, addr in enumerate(addrs):
|
||||
entry = self.tables[node].get(addr)
|
||||
if entry and entry[2] > 0:
|
||||
cx_sum += entry[0] / entry[2]
|
||||
cy_sum += entry[1] / entry[2]
|
||||
count += 1
|
||||
if count == 0:
|
||||
return 0.0, 0.0
|
||||
return cx_sum / count, cy_sum / count
|
||||
|
||||
def learn(self, bits, residual_x, residual_y):
|
||||
"""Accumulate residuals at addressed entries."""
|
||||
for node, addr in enumerate(self._addresses(bits)):
|
||||
entry = self.tables[node].get(addr)
|
||||
if entry is None:
|
||||
self.tables[node][addr] = [residual_x, residual_y, 1]
|
||||
else:
|
||||
entry[0] += residual_x
|
||||
entry[1] += residual_y
|
||||
entry[2] += 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Backtest runner
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def run_wisard(rows, k, use_xor, rep_power_str="p1.07", rep_power=1.07):
|
||||
n_bits = 276 + (69 if use_xor else 0)
|
||||
net = WiSARD(n_bits, k)
|
||||
|
||||
errors_by_power = {ps: [] for ps in POWER_STRS}
|
||||
errors_first50 = {ps: [] for ps in POWER_STRS}
|
||||
errors_last50 = {ps: [] for ps in POWER_STRS}
|
||||
n = len(rows)
|
||||
|
||||
for i, row in enumerate(rows):
|
||||
bits = build_input(row, use_xor)
|
||||
cx, cy = net.predict_correction(bits)
|
||||
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
t = flight_ticks(row["f0_distance"], power)
|
||||
lx, ly = predict_linear(row, t)
|
||||
px = lx + cx
|
||||
py = ly + cy
|
||||
ax, ay = row[f"{ps}_enemy_x"], row[f"{ps}_enemy_y"]
|
||||
e = euclid(px, py, ax, ay)
|
||||
errors_by_power[ps].append(e)
|
||||
if i < 50:
|
||||
errors_first50[ps].append(e)
|
||||
if i >= n - 50:
|
||||
errors_last50[ps].append(e)
|
||||
|
||||
# Learn: residual for representative power (same choice as backtest.py)
|
||||
t_rep = flight_ticks(row["f0_distance"], rep_power)
|
||||
lx_r, ly_r = predict_linear(row, t_rep)
|
||||
ax_r = row[f"{rep_power_str}_enemy_x"]
|
||||
ay_r = row[f"{rep_power_str}_enemy_y"]
|
||||
rx = ax_r - (lx_r + cx)
|
||||
ry = ay_r - (ly_r + cy)
|
||||
net.learn(bits, rx, ry)
|
||||
|
||||
return errors_by_power, errors_first50, errors_last50, net
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Main
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def load_csv():
|
||||
with open(CSV_PATH) as f:
|
||||
reader = csv.DictReader(f)
|
||||
rows = []
|
||||
for row in reader:
|
||||
try:
|
||||
rows.append({k: float(v) for k, v in row.items()})
|
||||
except ValueError:
|
||||
pass
|
||||
return rows
|
||||
|
||||
|
||||
def main():
|
||||
rows = load_csv()
|
||||
lines = []
|
||||
w = lines.append
|
||||
|
||||
w("=" * 72)
|
||||
w("WiSARD / WNN BACKTEST REPORT")
|
||||
w(f"Rows: {len(rows)}")
|
||||
w("=" * 72)
|
||||
|
||||
# ---- Baseline P1 for comparison ----
|
||||
w("\n--- BASELINE: Pure Linear Extrapolation (P1) ---\n")
|
||||
w(f"{'Power':<8} {'MAE':>7} {'RMSE':>7} {'Median':>8} {'Max':>8} {'%<5u':>7}")
|
||||
w("-" * 52)
|
||||
p1_mae = {}
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
errs = []
|
||||
for row in rows:
|
||||
t = flight_ticks(row["f0_distance"], power)
|
||||
px, py = predict_linear(row, t)
|
||||
ax, ay = row[f"{ps}_enemy_x"], row[f"{ps}_enemy_y"]
|
||||
errs.append(euclid(px, py, ax, ay))
|
||||
s = stats(errs)
|
||||
p1_mae[ps] = s["mae"]
|
||||
w(f"{ps:<8} {s['mae']:>7.2f} {s['rmse']:>7.2f} {s['median']:>8.2f} {s['max']:>8.2f} {s['pct5']:>6.1f}%")
|
||||
|
||||
# ---- WiSARD configurations ----
|
||||
configs = [
|
||||
(8, False, "K=8, 276 bits (no XOR)"),
|
||||
(8, True, "K=8, 345 bits (with XOR)"),
|
||||
(12, False, "K=12, 276 bits (no XOR)"),
|
||||
(12, True, "K=12, 345 bits (with XOR)"),
|
||||
]
|
||||
|
||||
all_results = []
|
||||
|
||||
for k, use_xor, label in configs:
|
||||
n_bits = 276 + (69 if use_xor else 0)
|
||||
n_nodes = math.ceil(n_bits / k)
|
||||
print(f"Running {label} ({n_nodes} LUT nodes × 2^{k} entries)...")
|
||||
ebp, ef50, el50, net = run_wisard(rows, k, use_xor)
|
||||
all_results.append((label, k, use_xor, ebp, ef50, el50))
|
||||
|
||||
w(f"\n--- WiSARD: {label} | {n_nodes} nodes ---\n")
|
||||
w(f"{'Power':<8} {'MAE':>7} {'RMSE':>7} {'Median':>8} {'Max':>8} {'%<5u':>7} {'vs P1':>8}")
|
||||
w("-" * 62)
|
||||
for ps in POWER_STRS:
|
||||
s = stats(ebp[ps])
|
||||
delta = s["mae"] - p1_mae[ps]
|
||||
w(f"{ps:<8} {s['mae']:>7.2f} {s['rmse']:>7.2f} {s['median']:>8.2f} {s['max']:>8.2f} {s['pct5']:>6.1f}% {delta:>+8.2f}")
|
||||
|
||||
# Learning curve for p1.07
|
||||
ps_r = "p1.07"
|
||||
mae_f = stats(ef50[ps_r])["mae"] if ef50[ps_r] else float("nan")
|
||||
mae_l = stats(el50[ps_r])["mae"] if el50[ps_r] else float("nan")
|
||||
w(f"\n Learning curve (p1.07): first-50 MAE={mae_f:.2f} last-50 MAE={mae_l:.2f}")
|
||||
|
||||
# LUT fill stats
|
||||
total_entries = sum(len(t) for t in net.tables)
|
||||
total_capacity = len(net.tables) * (2 ** k)
|
||||
fill_pct = total_entries / total_capacity * 100
|
||||
w(f" LUT fill: {total_entries} / {total_capacity} entries ({fill_pct:.3f}%)")
|
||||
|
||||
# ---- Summary comparison ----
|
||||
w("\n\n" + "=" * 72)
|
||||
w("SUMMARY — Average MAE across all power levels")
|
||||
w("=" * 72)
|
||||
w(f"\n{'Config':<32} {'Avg MAE':>9} {'vs P1':>8}")
|
||||
w("-" * 52)
|
||||
|
||||
p1_avg = sum(p1_mae.values()) / len(p1_mae)
|
||||
w(f"{'P1 (linear baseline)':<32} {p1_avg:>9.3f}")
|
||||
|
||||
for label, k, use_xor, ebp, ef50, el50 in all_results:
|
||||
avg = sum(stats(ebp[ps])["mae"] for ps in POWER_STRS) / len(POWER_STRS)
|
||||
delta = avg - p1_avg
|
||||
w(f"{label:<32} {avg:>9.3f} {delta:>+8.3f}")
|
||||
|
||||
w("\n")
|
||||
w("Note: negative 'vs P1' = improvement; positive = worse than linear baseline.")
|
||||
w("Learning is online: each row trains BEFORE the next prediction.")
|
||||
w("WiSARD learns the residual correction on top of linear extrapolation.")
|
||||
|
||||
report = "\n".join(lines)
|
||||
print(report)
|
||||
with open(OUT_PATH, "w") as f:
|
||||
f.write(report + "\n")
|
||||
print(f"\n[saved to {OUT_PATH}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,109 @@
|
||||
========================================================================
|
||||
WiSARD / WNN BACKTEST REPORT
|
||||
Rows: 277
|
||||
========================================================================
|
||||
|
||||
--- BASELINE: Pure Linear Extrapolation (P1) ---
|
||||
|
||||
Power MAE RMSE Median Max %<5u
|
||||
----------------------------------------------------
|
||||
p0.10 8.10 11.93 5.00 61.09 49.8%
|
||||
p0.42 8.68 12.70 5.33 64.35 49.1%
|
||||
p0.74 9.37 13.59 5.75 67.94 46.6%
|
||||
p1.07 10.18 14.62 6.24 72.04 40.1%
|
||||
p1.39 11.03 15.72 7.26 76.48 38.6%
|
||||
p1.71 11.97 16.96 8.38 81.92 35.7%
|
||||
p2.03 13.22 18.49 9.62 87.57 32.5%
|
||||
p2.36 14.64 20.24 11.00 94.46 29.2%
|
||||
p2.68 16.46 22.43 12.77 102.17 26.4%
|
||||
p3.00 18.70 25.16 14.00 111.15 23.5%
|
||||
|
||||
--- WiSARD: K=8, 276 bits (no XOR) | 35 nodes ---
|
||||
|
||||
Power MAE RMSE Median Max %<5u vs P1
|
||||
--------------------------------------------------------------
|
||||
p0.10 6.07 9.22 4.07 42.89 56.7% -2.03
|
||||
p0.42 6.61 9.87 4.25 46.12 53.8% -2.07
|
||||
p0.74 7.27 10.67 5.06 49.69 49.8% -2.10
|
||||
p1.07 8.04 11.62 5.90 53.78 46.2% -2.14
|
||||
p1.39 8.88 12.65 6.48 58.22 43.0% -2.15
|
||||
p1.71 9.88 13.87 7.60 63.58 39.4% -2.09
|
||||
p2.03 11.13 15.40 8.65 69.24 33.6% -2.10
|
||||
p2.36 12.57 17.15 9.82 76.11 30.0% -2.07
|
||||
p2.68 14.45 19.39 11.21 83.82 27.4% -2.01
|
||||
p3.00 16.75 22.20 13.13 92.80 23.5% -1.95
|
||||
|
||||
Learning curve (p1.07): first-50 MAE=14.99 last-50 MAE=5.55
|
||||
LUT fill: 1405 / 8960 entries (15.681%)
|
||||
|
||||
--- WiSARD: K=8, 345 bits (with XOR) | 44 nodes ---
|
||||
|
||||
Power MAE RMSE Median Max %<5u vs P1
|
||||
--------------------------------------------------------------
|
||||
p0.10 6.19 9.17 4.11 41.57 59.2% -1.92
|
||||
p0.42 6.73 9.84 4.71 44.80 52.3% -1.95
|
||||
p0.74 7.39 10.65 5.04 48.37 49.8% -1.98
|
||||
p1.07 8.17 11.63 5.80 52.45 45.8% -2.01
|
||||
p1.39 9.00 12.67 6.60 56.89 42.6% -2.02
|
||||
p1.71 9.98 13.89 7.52 62.26 37.9% -2.00
|
||||
p2.03 11.21 15.42 8.68 67.92 32.9% -2.01
|
||||
p2.36 12.65 17.18 9.73 74.80 28.9% -1.99
|
||||
p2.68 14.51 19.41 11.26 82.50 26.4% -1.95
|
||||
p3.00 16.79 22.22 13.07 91.48 23.8% -1.90
|
||||
|
||||
Learning curve (p1.07): first-50 MAE=15.17 last-50 MAE=5.78
|
||||
LUT fill: 1520 / 11264 entries (13.494%)
|
||||
|
||||
--- WiSARD: K=12, 276 bits (no XOR) | 23 nodes ---
|
||||
|
||||
Power MAE RMSE Median Max %<5u vs P1
|
||||
--------------------------------------------------------------
|
||||
p0.10 5.85 9.07 3.70 42.14 57.8% -2.26
|
||||
p0.42 6.38 9.69 4.28 45.36 54.2% -2.30
|
||||
p0.74 7.02 10.44 5.17 48.93 49.5% -2.35
|
||||
p1.07 7.81 11.37 5.91 53.02 44.4% -2.37
|
||||
p1.39 8.63 12.37 6.43 57.45 43.0% -2.40
|
||||
p1.71 9.63 13.57 7.38 62.81 39.0% -2.34
|
||||
p2.03 10.86 15.09 8.20 68.47 33.2% -2.36
|
||||
p2.36 12.32 16.84 9.55 75.34 30.0% -2.31
|
||||
p2.68 14.23 19.08 10.76 83.05 24.9% -2.23
|
||||
p3.00 16.54 21.90 12.54 92.03 23.8% -2.16
|
||||
|
||||
Learning curve (p1.07): first-50 MAE=14.43 last-50 MAE=5.13
|
||||
LUT fill: 1969 / 94208 entries (2.090%)
|
||||
|
||||
--- WiSARD: K=12, 345 bits (with XOR) | 29 nodes ---
|
||||
|
||||
Power MAE RMSE Median Max %<5u vs P1
|
||||
--------------------------------------------------------------
|
||||
p0.10 5.96 9.15 3.89 43.90 58.5% -2.15
|
||||
p0.42 6.49 9.78 4.45 47.12 55.2% -2.19
|
||||
p0.74 7.14 10.55 4.88 50.69 50.9% -2.23
|
||||
p1.07 7.92 11.50 5.75 54.77 46.9% -2.26
|
||||
p1.39 8.77 12.52 6.21 59.21 41.2% -2.25
|
||||
p1.71 9.74 13.73 7.09 64.56 38.3% -2.23
|
||||
p2.03 11.02 15.26 8.29 70.22 32.5% -2.21
|
||||
p2.36 12.48 17.02 9.51 77.09 28.9% -2.16
|
||||
p2.68 14.34 19.26 10.74 84.80 24.9% -2.11
|
||||
p3.00 16.64 22.08 12.52 93.78 22.4% -2.06
|
||||
|
||||
Learning curve (p1.07): first-50 MAE=14.85 last-50 MAE=5.27
|
||||
LUT fill: 2167 / 118784 entries (1.824%)
|
||||
|
||||
|
||||
========================================================================
|
||||
SUMMARY — Average MAE across all power levels
|
||||
========================================================================
|
||||
|
||||
Config Avg MAE vs P1
|
||||
----------------------------------------------------
|
||||
P1 (linear baseline) 12.235
|
||||
K=8, 276 bits (no XOR) 10.165 -2.071
|
||||
K=8, 345 bits (with XOR) 10.263 -1.973
|
||||
K=12, 276 bits (no XOR) 9.927 -2.308
|
||||
K=12, 345 bits (with XOR) 10.051 -2.184
|
||||
|
||||
|
||||
Note: negative 'vs P1' = improvement; positive = worse than linear baseline.
|
||||
Learning is online: each row trains BEFORE the next prediction.
|
||||
WiSARD learns the residual correction on top of linear extrapolation.
|
||||
@@ -0,0 +1,394 @@
|
||||
"""
|
||||
Multi-enemy comparison: Linear+Hebbian vs WiSARD K=12 vs TsetlinBot (RTM).
|
||||
Uses 181-col decimal CSVs (4 enemies: crazy, spinbot, target, walls).
|
||||
Online learning, all predictors share state across battles of the same enemy.
|
||||
Rep power: p1.07 for learning signal; all powers reported in summary.
|
||||
"""
|
||||
import csv, math, os, random, glob
|
||||
from collections import defaultdict
|
||||
|
||||
DATA_DIR = os.path.join(os.path.dirname(__file__), "../data")
|
||||
OUT_PATH = os.path.join(os.path.dirname(__file__), "battle_comparison.txt")
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
POWER_STRS = ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]
|
||||
REP_PS, REP_POWER = "p1.07", 1.07
|
||||
MAX_DIST = 1414.0
|
||||
HIT_RADIUS = 18.0 # approx half tank width in pixels (0-99 scale ≈ arena/14)
|
||||
|
||||
# ── encoding ───────────────────────────────────────────────────────────────────
|
||||
|
||||
def to_bits(v, n):
|
||||
g = int(v) ^ (int(v) >> 1)
|
||||
return [(g >> (n - 1 - i)) & 1 for i in range(n)]
|
||||
|
||||
def row_to_binary(row, n_frames=4):
|
||||
"""Build n_frames*69-bit input. 181-col CSVs have x/y as 0-99 int."""
|
||||
bits = []
|
||||
for fi in range(n_frames):
|
||||
p = f"f{fi}_"
|
||||
bits += to_bits(int(row[p+"bearing_sin"]), 8)
|
||||
bits += to_bits(int(row[p+"bearing_cos"]), 8)
|
||||
bits += to_bits(int(row[p+"distance"]), 7)
|
||||
bits += to_bits(int(row[p+"velocity"]), 5)
|
||||
bits += to_bits(int(row[p+"heading_sin"]), 8)
|
||||
bits += to_bits(int(row[p+"heading_cos"]), 8)
|
||||
bits += to_bits(int(row[p+"enemy_x"]), 7)
|
||||
bits += to_bits(int(row[p+"enemy_y"]), 7)
|
||||
bits += to_bits(min(int(row[p+"enemy_energy"]), 2046), 11)
|
||||
return bits # 4*69 = 276 bits
|
||||
|
||||
# ── WiSARD K=12, 276 bits ──────────────────────────────────────────────────────
|
||||
|
||||
class WiSARD:
|
||||
def __init__(self, n_bits=276, k=12, seed=42):
|
||||
self.k = k
|
||||
n_pad = math.ceil(n_bits / k) * k
|
||||
self.n_nodes = n_pad // k
|
||||
rng = random.Random(seed)
|
||||
idx = list(range(n_bits)) + [0] * (n_pad - n_bits)
|
||||
rng.shuffle(idx)
|
||||
self.perm = idx
|
||||
self.tables = [{} for _ in range(self.n_nodes)] # sparse dicts
|
||||
|
||||
def _addrs(self, bits):
|
||||
out = []
|
||||
for nd in range(self.n_nodes):
|
||||
a = 0
|
||||
for b in range(self.k):
|
||||
pi = nd * self.k + b
|
||||
a = (a << 1) | (bits[self.perm[pi]] if pi < len(bits) else 0)
|
||||
out.append(a)
|
||||
return out
|
||||
|
||||
def predict(self, bits):
|
||||
addrs = self._addrs(bits)
|
||||
sx = sy = cnt = 0.0
|
||||
for nd, a in enumerate(addrs):
|
||||
e = self.tables[nd].get(a)
|
||||
if e and e[2] > 0:
|
||||
sx += e[0] / e[2]; sy += e[1] / e[2]; cnt += 1
|
||||
return (sx/cnt, sy/cnt) if cnt else (0.0, 0.0)
|
||||
|
||||
def learn(self, bits, dx, dy):
|
||||
for nd, a in enumerate(self._addrs(bits)):
|
||||
e = self.tables[nd].get(a)
|
||||
if e is None:
|
||||
self.tables[nd][a] = [dx, dy, 1]
|
||||
else:
|
||||
e[0] += dx; e[1] += dy; e[2] += 1
|
||||
|
||||
|
||||
# ── Regression TM (one output dimension) ──────────────────────────────────────
|
||||
|
||||
N_CLAUSES = 60
|
||||
N_STATES = 15
|
||||
S_SPEC = 3.0
|
||||
T_THRESH = 30
|
||||
RESID_MAX = 30.0 # residual clamp (0-99 scale)
|
||||
|
||||
class RTM:
|
||||
def __init__(self):
|
||||
n_lit = 276 * 2
|
||||
half = N_CLAUSES // 2
|
||||
self.ta = [[N_STATES] * n_lit for _ in range(N_CLAUSES)]
|
||||
self.pol = [1] * half + [-1] * half
|
||||
self.n_lit = n_lit
|
||||
|
||||
def _clause_out(self, c, x_aug):
|
||||
ta_c = self.ta[c]
|
||||
for l in range(self.n_lit):
|
||||
if ta_c[l] > N_STATES and x_aug[l] == 0:
|
||||
return 0
|
||||
return 1
|
||||
|
||||
def predict(self, x):
|
||||
x_aug = x + [1 - b for b in x]
|
||||
v = sum(self.pol[c] * self._clause_out(c, x_aug) for c in range(N_CLAUSES))
|
||||
v = max(-T_THRESH, min(T_THRESH, v))
|
||||
return v / T_THRESH * RESID_MAX
|
||||
|
||||
def learn(self, x, residual):
|
||||
x_aug = x + [1 - b for b in x]
|
||||
err = residual - self.predict(x)
|
||||
p_fb = min(1.0, abs(err) / (2 * RESID_MAX))
|
||||
for c in range(N_CLAUSES):
|
||||
if random.random() >= p_fb:
|
||||
continue
|
||||
pol = self.pol[c]; o = self._clause_out(c, x_aug); ta_c = self.ta[c]
|
||||
if (err > 0 and pol > 0) or (err < 0 and pol < 0):
|
||||
if o == 1:
|
||||
for l in range(self.n_lit):
|
||||
if x_aug[l] == 1:
|
||||
if random.random() < (S_SPEC-1)/S_SPEC:
|
||||
if ta_c[l] < 2*N_STATES: ta_c[l] += 1
|
||||
else:
|
||||
if random.random() < 1.0/S_SPEC:
|
||||
if ta_c[l] > 1: ta_c[l] -= 1
|
||||
else:
|
||||
for l in range(self.n_lit):
|
||||
if random.random() < 1.0/S_SPEC:
|
||||
if ta_c[l] > 1: ta_c[l] -= 1
|
||||
else:
|
||||
if o == 1:
|
||||
for l in range(self.n_lit):
|
||||
if x_aug[l] == 0 and ta_c[l] > N_STATES:
|
||||
ta_c[l] -= 1
|
||||
|
||||
|
||||
# ── helpers ────────────────────────────────────────────────────────────────────
|
||||
|
||||
def bullet_speed(p): return 20.0 - 3.0 * p
|
||||
def flight_ticks(dist_enc, p): return (dist_enc / 99.0 * MAX_DIST) / bullet_speed(p)
|
||||
def euclid(ax, ay, bx, by): return math.sqrt((ax-bx)**2 + (ay-by)**2)
|
||||
|
||||
def predict_linear(row, power):
|
||||
t = flight_ticks(row["f0_distance"], power)
|
||||
x0, y0 = row["f0_enemy_x"], row["f0_enemy_y"]
|
||||
x1, y1 = row["f1_enemy_x"], row["f1_enemy_y"]
|
||||
return x0 + (x0-x1)*t, y0 + (y0-y1)*t
|
||||
|
||||
def heading_sector(hs, hc):
|
||||
s = hs/199*2-1; c = hc/199*2-1
|
||||
return int(math.degrees(math.atan2(s,c)) % 360 / 45) % 8
|
||||
|
||||
def dist_band(d, lo, hi):
|
||||
return 0 if d <= lo else (1 if d <= hi else 2)
|
||||
|
||||
def stats(errs):
|
||||
if not errs: return None
|
||||
n = len(errs)
|
||||
mae = sum(errs)/n
|
||||
rmse = math.sqrt(sum(e*e for e in errs)/n)
|
||||
hit = sum(1 for e in errs if e < HIT_RADIUS)/n*100
|
||||
return {"n":n, "mae":mae, "rmse":rmse, "hit":hit}
|
||||
|
||||
_REQUIRED_KEYS = (
|
||||
[f"f{fi}_{col}" for fi in range(4) for col in
|
||||
("bearing_sin","bearing_cos","distance","velocity","heading_sin","heading_cos","enemy_x","enemy_y","enemy_energy")]
|
||||
+ [f"{ps}_enemy_x" for ps in ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]]
|
||||
+ [f"{ps}_enemy_y" for ps in ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]]
|
||||
)
|
||||
|
||||
def load_csv(path):
|
||||
rows = []
|
||||
with open(path) as f:
|
||||
for row in csv.DictReader(f):
|
||||
try:
|
||||
d = {k: float(v) for k,v in row.items() if v not in (None, "NA", "")}
|
||||
if all(k in d for k in _REQUIRED_KEYS):
|
||||
rows.append(d)
|
||||
except (ValueError, TypeError):
|
||||
pass
|
||||
return rows
|
||||
|
||||
|
||||
# ── per-enemy backtest ─────────────────────────────────────────────────────────
|
||||
|
||||
def run_enemy(enemy_files, seed=42):
|
||||
"""
|
||||
Process all battles for one enemy type.
|
||||
Predictors share state across battles (cumulative online learning).
|
||||
Returns dict of results.
|
||||
"""
|
||||
random.seed(seed)
|
||||
|
||||
# shared predictor state
|
||||
ws = WiSARD(seed=seed)
|
||||
rtm_x, rtm_y = RTM(), RTM()
|
||||
heb = [[[0.0, 0.0] for _ in range(3)] for _ in range(8)]
|
||||
|
||||
# compute global band thresholds across all battles
|
||||
all_dists = []
|
||||
all_rows_list = []
|
||||
for path in sorted(enemy_files):
|
||||
rows = load_csv(path)
|
||||
all_rows_list.append(rows)
|
||||
all_dists.extend(r["f0_distance"] for r in rows)
|
||||
all_dists.sort()
|
||||
n_d = len(all_dists)
|
||||
band_lo, band_hi = all_dists[n_d//3], all_dists[2*n_d//3]
|
||||
|
||||
errs = {
|
||||
"lin": defaultdict(list),
|
||||
"wis": defaultdict(list),
|
||||
"tm": defaultdict(list),
|
||||
}
|
||||
errs_last50_tm = defaultdict(list)
|
||||
all_processed = 0
|
||||
|
||||
for rows in all_rows_list:
|
||||
n = len(rows)
|
||||
for i, row in enumerate(rows):
|
||||
x = row_to_binary(row)
|
||||
sec = heading_sector(row["f0_heading_sin"], row["f0_heading_cos"])
|
||||
band = dist_band(row["f0_distance"], band_lo, band_hi)
|
||||
|
||||
cx_heb, cy_heb = heb[sec][band]
|
||||
cx_ws, cy_ws = ws.predict(x)
|
||||
rx_tm = rtm_x.predict(x)
|
||||
ry_tm = rtm_y.predict(x)
|
||||
|
||||
rx_acc = ry_acc = 0.0
|
||||
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
ax = row[f"{ps}_enemy_x"]; ay = row[f"{ps}_enemy_y"]
|
||||
lx, ly = predict_linear(row, power)
|
||||
|
||||
errs["lin"][ps].append(euclid(lx+cx_heb, ly+cy_heb, ax, ay))
|
||||
errs["wis"][ps].append(euclid(lx+cx_ws, ly+cy_ws, ax, ay))
|
||||
errs["tm"][ps].append( euclid(lx+rx_tm, ly+ry_tm, ax, ay))
|
||||
|
||||
if i >= n - 50:
|
||||
errs_last50_tm[ps].append(errs["tm"][ps][-1])
|
||||
|
||||
rx_acc += ax - lx; ry_acc += ay - ly
|
||||
|
||||
# online learning
|
||||
rx_mean, ry_mean = rx_acc/len(POWER_STRS), ry_acc/len(POWER_STRS)
|
||||
ws.learn(x, rx_mean, ry_mean)
|
||||
rtm_x.learn(x, rx_mean); rtm_y.learn(x, ry_mean)
|
||||
|
||||
lx_r, ly_r = predict_linear(row, REP_POWER)
|
||||
ax_r = row[f"{REP_PS}_enemy_x"]; ay_r = row[f"{REP_PS}_enemy_y"]
|
||||
heb[sec][band][0] += 0.1 * (ax_r - (lx_r + cx_heb))
|
||||
heb[sec][band][1] += 0.1 * (ay_r - (ly_r + cy_heb))
|
||||
|
||||
all_processed += 1
|
||||
|
||||
return errs, errs_last50_tm, all_processed
|
||||
|
||||
|
||||
# ── main ──────────────────────────────────────────────────────────────────────
|
||||
|
||||
def main():
|
||||
random.seed(42)
|
||||
|
||||
# Find all 181-col decimal CSVs grouped by enemy type
|
||||
all_files = sorted(glob.glob(os.path.join(DATA_DIR, "*_decimal.csv")))
|
||||
by_enemy = defaultdict(list)
|
||||
for f in all_files:
|
||||
base = os.path.basename(f)
|
||||
enemy = base.split("_battle")[0].replace("_decimal","") # shouldn't be needed but safe
|
||||
by_enemy[enemy].append(f)
|
||||
|
||||
lines = []
|
||||
w = lines.append
|
||||
|
||||
w("=" * 72)
|
||||
w("PREDICTOR COMPARISON: BNNBot (Linear+Hebbian) vs WiSARD K=12 vs TsetlinBot (RTM)")
|
||||
w(f"Rep power: {REP_PS} | Hit threshold: {HIT_RADIUS} (0-99 scale, ~18px)")
|
||||
w(f"Online learning, cumulative per-enemy | Scores measured across all powers")
|
||||
w("=" * 72)
|
||||
w("")
|
||||
|
||||
global_errs = {"lin": [], "wis": [], "tm": [], "tm_warm": []}
|
||||
enemy_summaries = {}
|
||||
|
||||
for enemy in sorted(by_enemy.keys()):
|
||||
files = by_enemy[enemy]
|
||||
print(f" {enemy}: {len(files)} battles...")
|
||||
errs, errs_last50_tm, n_rows = run_enemy(files)
|
||||
|
||||
# avg MAE across all powers
|
||||
def avg_mae(d): return sum(stats(d[ps])["mae"] for ps in POWER_STRS)/len(POWER_STRS)
|
||||
def avg_hit(d): return sum(stats(d[ps])["hit"] for ps in POWER_STRS)/len(POWER_STRS)
|
||||
|
||||
s_lin = {"mae": avg_mae(errs["lin"]), "hit": avg_hit(errs["lin"])}
|
||||
s_wis = {"mae": avg_mae(errs["wis"]), "hit": avg_hit(errs["wis"])}
|
||||
s_tm = {"mae": avg_mae(errs["tm"]), "hit": avg_hit(errs["tm"])}
|
||||
s_tm_warm = {
|
||||
"mae": sum(stats(errs_last50_tm[ps])["mae"] for ps in POWER_STRS)/len(POWER_STRS)
|
||||
if errs_last50_tm["p1.07"] else float("nan"),
|
||||
}
|
||||
|
||||
enemy_summaries[enemy] = (s_lin, s_wis, s_tm, s_tm_warm)
|
||||
|
||||
winner = min([("BNNBot(Lin+Heb)", s_lin["mae"]),
|
||||
("WiSARD", s_wis["mae"]),
|
||||
("TsetlinBot", s_tm["mae"])], key=lambda x:x[1])[0]
|
||||
|
||||
# accumulate globals
|
||||
for ps in POWER_STRS:
|
||||
global_errs["lin"].extend(errs["lin"][ps])
|
||||
global_errs["wis"].extend(errs["wis"][ps])
|
||||
global_errs["tm"].extend(errs["tm"][ps])
|
||||
global_errs["tm_warm"].extend(errs_last50_tm[ps])
|
||||
|
||||
w(f"Enemy: {enemy:12s} battles={len(files)} rows={n_rows}")
|
||||
w(f" Avg MAE (all powers): BNNBot={s_lin['mae']:5.2f} WiSARD={s_wis['mae']:5.2f} TsetlinBot={s_tm['mae']:5.2f} (TM-warm={s_tm_warm['mae']:5.2f})")
|
||||
w(f" Avg Hit% (all powers): BNNBot={s_lin['hit']:5.1f}% WiSARD={s_wis['hit']:5.1f}% TsetlinBot={s_tm['hit']:5.1f}%")
|
||||
w(f" Winner by MAE: {winner}")
|
||||
w("")
|
||||
|
||||
# per-power detail for this enemy
|
||||
w(f" Per-power breakdown (MAE, {enemy}):")
|
||||
w(f" {'Power':<8} {'BNNBot':>8} {'WiSARD':>8} {'TsetlinBot':>10} {'Best':>12}")
|
||||
w(" " + "-" * 52)
|
||||
for ps in POWER_STRS:
|
||||
ml = stats(errs["lin"][ps])["mae"]
|
||||
mw = stats(errs["wis"][ps])["mae"]
|
||||
mt = stats(errs["tm"][ps])["mae"]
|
||||
best = min([("BNNBot",ml),("WiSARD",mw),("TsetlinBot",mt)], key=lambda x:x[1])[0]
|
||||
w(f" {ps:<8} {ml:>8.2f} {mw:>8.2f} {mt:>10.2f} {best:>12s}")
|
||||
w("")
|
||||
|
||||
# global summary
|
||||
w("=" * 72)
|
||||
w("OVERALL SUMMARY (all enemies, all powers combined)")
|
||||
w("=" * 72)
|
||||
|
||||
n_all = len(global_errs["lin"])
|
||||
if n_all:
|
||||
g_lin = sum(global_errs["lin"])/n_all
|
||||
g_wis = sum(global_errs["wis"])/n_all
|
||||
g_tm = sum(global_errs["tm"])/n_all
|
||||
g_tm_warm = sum(global_errs["tm_warm"])/len(global_errs["tm_warm"]) if global_errs["tm_warm"] else float("nan")
|
||||
g_hit_lin = sum(1 for e in global_errs["lin"] if e<HIT_RADIUS)/n_all*100
|
||||
g_hit_wis = sum(1 for e in global_errs["wis"] if e<HIT_RADIUS)/n_all*100
|
||||
g_hit_tm = sum(1 for e in global_errs["tm"] if e<HIT_RADIUS)/n_all*100
|
||||
|
||||
w(f" n={n_all} data points")
|
||||
w(f" MAE: BNNBot={g_lin:.2f} WiSARD={g_wis:.2f} TsetlinBot={g_tm:.2f} (TM warm-phase={g_tm_warm:.2f})")
|
||||
w(f" Hit%: BNNBot={g_hit_lin:.1f}% WiSARD={g_hit_wis:.1f}% TsetlinBot={g_hit_tm:.1f}%")
|
||||
w("")
|
||||
|
||||
# win counts
|
||||
wins = defaultdict(int)
|
||||
for enemy, (sl, sw, st, _) in enemy_summaries.items():
|
||||
best = min([("BNNBot",sl["mae"]),("WiSARD",sw["mae"]),("TsetlinBot",st["mae"])], key=lambda x:x[1])[0]
|
||||
wins[best] += 1
|
||||
|
||||
w(" Wins per enemy type (by avg MAE, all powers):")
|
||||
for k, v in sorted(wins.items(), key=lambda x:-x[1]):
|
||||
w(f" {k}: {v}/{len(enemy_summaries)}")
|
||||
w("")
|
||||
|
||||
global_winner = min([("BNNBot(Lin+Heb)", g_lin),
|
||||
("WiSARD K=12", g_wis),
|
||||
("TsetlinBot(RTM)", g_tm)], key=lambda x:x[1])[0]
|
||||
global_winner_warm = min([("BNNBot(Lin+Heb)", g_lin),
|
||||
("WiSARD K=12", g_wis),
|
||||
("TsetlinBot(RTM,warm)", g_tm_warm)], key=lambda x:x[1])[0]
|
||||
w(f" VERDICT (all-rows MAE): {global_winner}")
|
||||
w(f" VERDICT (TM warm-phase): {global_winner_warm}")
|
||||
w("")
|
||||
w("Notes:")
|
||||
w(" - BNNBot: linear extrapolation + 24-cell Hebbian residual table (lr=0.1)")
|
||||
w(" - WiSARD: K=12, 276-bit input (4 frames × 69 bits), 23 LUT nodes, bleach=1")
|
||||
w(" - TsetlinBot (RTM): 60 clauses, N_states=15, s=3.0, T=30, shared x/y RTMs")
|
||||
w(" - TM warm = last-50-rows MAE; accounts for cold-start overhead")
|
||||
w(f" - Hit threshold: {HIT_RADIUS} (0-99 scale units, ~equivalent to tank body)")
|
||||
w(" - Residuals learned on mean across all powers; tested at each power level")
|
||||
w(f" - Enemy types: {', '.join(sorted(enemy_summaries.keys()))}")
|
||||
|
||||
report = "\n".join(lines)
|
||||
print("\n" + report)
|
||||
os.makedirs(os.path.dirname(OUT_PATH), exist_ok=True)
|
||||
with open(OUT_PATH, "w") as f:
|
||||
f.write(report + "\n")
|
||||
print(f"\n[saved to {OUT_PATH}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,104 @@
|
||||
========================================================================
|
||||
PREDICTOR COMPARISON: BNNBot (Linear+Hebbian) vs WiSARD K=12 vs TsetlinBot (RTM)
|
||||
Rep power: p1.07 | Hit threshold: 18.0 (0-99 scale, ~18px)
|
||||
Online learning, cumulative per-enemy | Scores measured across all powers
|
||||
========================================================================
|
||||
|
||||
Enemy: crazy battles=5 rows=2908
|
||||
Avg MAE (all powers): BNNBot=24.72 WiSARD=22.29 TsetlinBot=27.10 (TM-warm=20.98)
|
||||
Avg Hit% (all powers): BNNBot= 46.0% WiSARD= 51.4% TsetlinBot= 38.7%
|
||||
Winner by MAE: WiSARD
|
||||
|
||||
Per-power breakdown (MAE, crazy):
|
||||
Power BNNBot WiSARD TsetlinBot Best
|
||||
----------------------------------------------------
|
||||
p0.10 17.14 15.09 19.44 WiSARD
|
||||
p0.42 18.17 16.03 20.56 WiSARD
|
||||
p0.74 19.39 17.13 21.83 WiSARD
|
||||
p1.07 20.86 18.52 23.33 WiSARD
|
||||
p1.39 22.52 20.09 25.00 WiSARD
|
||||
p1.71 24.44 21.93 26.92 WiSARD
|
||||
p2.03 26.71 24.13 29.16 WiSARD
|
||||
p2.36 29.39 26.77 31.78 WiSARD
|
||||
p2.68 32.47 29.81 34.77 WiSARD
|
||||
p3.00 36.07 33.43 38.25 WiSARD
|
||||
|
||||
Enemy: spinbot battles=5 rows=1163
|
||||
Avg MAE (all powers): BNNBot=23.75 WiSARD=24.54 TsetlinBot=30.20 (TM-warm=29.11)
|
||||
Avg Hit% (all powers): BNNBot= 43.7% WiSARD= 41.1% TsetlinBot= 37.1%
|
||||
Winner by MAE: BNNBot(Lin+Heb)
|
||||
|
||||
Per-power breakdown (MAE, spinbot):
|
||||
Power BNNBot WiSARD TsetlinBot Best
|
||||
----------------------------------------------------
|
||||
p0.10 17.81 18.12 23.61 BNNBot
|
||||
p0.42 18.60 19.11 24.83 BNNBot
|
||||
p0.74 19.60 20.24 26.14 BNNBot
|
||||
p1.07 20.78 21.55 27.52 BNNBot
|
||||
p1.39 22.13 22.98 28.92 BNNBot
|
||||
p1.71 23.68 24.60 30.42 BNNBot
|
||||
p2.03 25.44 26.40 32.04 BNNBot
|
||||
p2.36 27.45 28.43 33.87 BNNBot
|
||||
p2.68 29.69 30.67 35.99 BNNBot
|
||||
p3.00 32.33 33.28 38.64 BNNBot
|
||||
|
||||
Enemy: target battles=5 rows=1606
|
||||
Avg MAE (all powers): BNNBot= 2.68 WiSARD= 2.21 TsetlinBot= 4.14 (TM-warm= 6.50)
|
||||
Avg Hit% (all powers): BNNBot= 95.5% WiSARD= 97.0% TsetlinBot= 93.5%
|
||||
Winner by MAE: WiSARD
|
||||
|
||||
Per-power breakdown (MAE, target):
|
||||
Power BNNBot WiSARD TsetlinBot Best
|
||||
----------------------------------------------------
|
||||
p0.10 1.71 1.61 3.34 WiSARD
|
||||
p0.42 1.83 1.62 3.44 WiSARD
|
||||
p0.74 1.97 1.67 3.57 WiSARD
|
||||
p1.07 2.16 1.76 3.72 WiSARD
|
||||
p1.39 2.37 1.88 3.88 WiSARD
|
||||
p1.71 2.61 2.06 4.08 WiSARD
|
||||
p2.03 2.92 2.30 4.32 WiSARD
|
||||
p2.36 3.27 2.60 4.61 WiSARD
|
||||
p2.68 3.71 3.02 4.99 WiSARD
|
||||
p3.00 4.23 3.55 5.45 WiSARD
|
||||
|
||||
Enemy: walls battles=5 rows=1661
|
||||
Avg MAE (all powers): BNNBot=15.31 WiSARD=13.22 TsetlinBot=18.81 (TM-warm=15.17)
|
||||
Avg Hit% (all powers): BNNBot= 69.8% WiSARD= 76.2% TsetlinBot= 62.4%
|
||||
Winner by MAE: WiSARD
|
||||
|
||||
Per-power breakdown (MAE, walls):
|
||||
Power BNNBot WiSARD TsetlinBot Best
|
||||
----------------------------------------------------
|
||||
p0.10 10.38 8.81 13.27 WiSARD
|
||||
p0.42 10.90 9.21 14.03 WiSARD
|
||||
p0.74 11.60 9.77 14.93 WiSARD
|
||||
p1.07 12.43 10.47 15.94 WiSARD
|
||||
p1.39 13.51 11.42 17.12 WiSARD
|
||||
p1.71 14.81 12.61 18.50 WiSARD
|
||||
p2.03 16.40 14.12 20.15 WiSARD
|
||||
p2.36 18.37 16.00 22.13 WiSARD
|
||||
p2.68 20.83 18.41 24.54 WiSARD
|
||||
p3.00 23.85 21.41 27.51 WiSARD
|
||||
|
||||
========================================================================
|
||||
OVERALL SUMMARY (all enemies, all powers combined)
|
||||
========================================================================
|
||||
n=73380 data points
|
||||
MAE: BNNBot=17.61 WiSARD=16.20 TsetlinBot=20.69 (TM warm-phase=18.77)
|
||||
Hit%: BNNBot=61.9% WiSARD=65.4% TsetlinBot=55.8%
|
||||
|
||||
Wins per enemy type (by avg MAE, all powers):
|
||||
WiSARD: 3/4
|
||||
BNNBot: 1/4
|
||||
|
||||
VERDICT (all-rows MAE): WiSARD K=12
|
||||
VERDICT (TM warm-phase): WiSARD K=12
|
||||
|
||||
Notes:
|
||||
- BNNBot: linear extrapolation + 24-cell Hebbian residual table (lr=0.1)
|
||||
- WiSARD: K=12, 276-bit input (4 frames × 69 bits), 23 LUT nodes, bleach=1
|
||||
- TsetlinBot (RTM): 60 clauses, N_states=15, s=3.0, T=30, shared x/y RTMs
|
||||
- TM warm = last-50-rows MAE; accounts for cold-start overhead
|
||||
- Hit threshold: 18.0 (0-99 scale units, ~equivalent to tank body)
|
||||
- Residuals learned on mean across all powers; tested at each power level
|
||||
- Enemy types: crazy, spinbot, target, walls
|
||||
@@ -0,0 +1,310 @@
|
||||
"""
|
||||
Battle data correlation analysis.
|
||||
stdlib + csv + math only.
|
||||
"""
|
||||
import csv
|
||||
import math
|
||||
import sys
|
||||
from collections import defaultdict
|
||||
|
||||
DATA = "/home/davide/Projects/SirRoboGarage/BNNBot_garage/data/battle_1_decimal.csv"
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
FRAME_FIELDS = ["bearing_sin", "bearing_cos", "distance", "velocity",
|
||||
"heading_sin", "heading_cos", "enemy_x", "enemy_y", "enemy_energy"]
|
||||
|
||||
def pname(p):
|
||||
return f"p{p:.2f}"
|
||||
|
||||
def corr(xs, ys):
|
||||
n = len(xs)
|
||||
if n < 2:
|
||||
return float("nan")
|
||||
mx = sum(xs) / n
|
||||
my = sum(ys) / n
|
||||
num = sum((x - mx) * (y - my) for x, y in zip(xs, ys))
|
||||
dx = math.sqrt(sum((x - mx) ** 2 for x in xs))
|
||||
dy = math.sqrt(sum((y - my) ** 2 for y in ys))
|
||||
if dx == 0 or dy == 0:
|
||||
return float("nan")
|
||||
return num / (dx * dy)
|
||||
|
||||
def stats(vals):
|
||||
if not vals:
|
||||
return dict(mean=float("nan"), std=float("nan"), mn=float("nan"), mx=float("nan"))
|
||||
n = len(vals)
|
||||
mean = sum(vals) / n
|
||||
std = math.sqrt(sum((v - mean) ** 2 for v in vals) / n)
|
||||
return dict(mean=mean, std=std, mn=min(vals), mx=max(vals))
|
||||
|
||||
def main():
|
||||
with open(DATA) as f:
|
||||
reader = csv.DictReader(f)
|
||||
all_rows = list(reader)
|
||||
|
||||
# 1. Filter fully-resolved rows
|
||||
output_cols = []
|
||||
for p in POWER_LEVELS:
|
||||
for field in FRAME_FIELDS:
|
||||
output_cols.append(f"{pname(p)}_{field}")
|
||||
|
||||
rows = [r for r in all_rows if not any(r[c] == "NA" for c in output_cols if c in r)]
|
||||
print(f"=== 1. FILTERING ===")
|
||||
print(f"Total rows: {len(all_rows)}, Fully-resolved: {len(rows)}\n")
|
||||
|
||||
def fv(row, frame, field):
|
||||
return float(row[f"f{frame}_{field}"])
|
||||
|
||||
def pv(row, p, field):
|
||||
return float(row[f"{pname(p)}_{field}"])
|
||||
|
||||
# 2. Delta analysis
|
||||
print("=== 2. DELTA ANALYSIS (hit_state - f0_state) ===")
|
||||
for p in POWER_LEVELS:
|
||||
dx_vals = [pv(r, p, "enemy_x") - fv(r, 0, "enemy_x") for r in rows]
|
||||
dy_vals = [pv(r, p, "enemy_y") - fv(r, 0, "enemy_y") for r in rows]
|
||||
dd_vals = [pv(r, p, "distance") - fv(r, 0, "distance") for r in rows]
|
||||
dv_vals = [pv(r, p, "velocity") - fv(r, 0, "velocity") for r in rows]
|
||||
dbs_vals = [pv(r, p, "bearing_sin") - fv(r, 0, "bearing_sin") for r in rows]
|
||||
sx, sy, sd, sv, sbs = stats(dx_vals), stats(dy_vals), stats(dd_vals), stats(dv_vals), stats(dbs_vals)
|
||||
print(f" power={p:.2f}:")
|
||||
print(f" delta_x: mean={sx['mean']:+7.2f} std={sx['std']:6.2f} [{sx['mn']:+7.2f}, {sx['mx']:+7.2f}]")
|
||||
print(f" delta_y: mean={sy['mean']:+7.2f} std={sy['std']:6.2f} [{sy['mn']:+7.2f}, {sy['mx']:+7.2f}]")
|
||||
print(f" delta_dist: mean={sd['mean']:+7.2f} std={sd['std']:6.2f} [{sd['mn']:+7.2f}, {sd['mx']:+7.2f}]")
|
||||
print(f" delta_vel: mean={sv['mean']:+7.2f} std={sv['std']:6.2f} [{sv['mn']:+7.2f}, {sv['mx']:+7.2f}]")
|
||||
print(f" delta_bsin: mean={sbs['mean']:+7.4f} std={sbs['std']:.4f} [{sbs['mn']:+7.4f}, {sbs['mx']:+7.4f}]")
|
||||
print()
|
||||
|
||||
# 3. Velocity → displacement correlation
|
||||
print("=== 3. VELOCITY -> DISPLACEMENT CORRELATION ===")
|
||||
for p in POWER_LEVELS:
|
||||
vel = [fv(r, 0, "velocity") for r in rows]
|
||||
dx = [pv(r, p, "enemy_x") - fv(r, 0, "enemy_x") for r in rows]
|
||||
dy = [pv(r, p, "enemy_y") - fv(r, 0, "enemy_y") for r in rows]
|
||||
# magnitude of displacement
|
||||
disp = [math.sqrt(x**2 + y**2) for x, y in zip(dx, dy)]
|
||||
r_vx = corr(vel, dx)
|
||||
r_vy = corr(vel, dy)
|
||||
r_vd = corr(vel, disp)
|
||||
print(f" power={p:.2f}: corr(vel,dx)={r_vx:+.3f} corr(vel,dy)={r_vy:+.3f} corr(vel,|disp|)={r_vd:+.3f}")
|
||||
print()
|
||||
|
||||
# 4. Frame-to-frame velocity (position deltas between consecutive frames)
|
||||
print("=== 4. FRAME-TO-FRAME VELOCITY (position deltas) ===")
|
||||
for fi in range(9):
|
||||
vx_vals = [fv(r, fi, "enemy_x") - fv(r, fi+1, "enemy_x") for r in rows]
|
||||
vy_vals = [fv(r, fi, "enemy_y") - fv(r, fi+1, "enemy_y") for r in rows]
|
||||
sx, sy = stats(vx_vals), stats(vy_vals)
|
||||
print(f" f{fi}-f{fi+1}: vx mean={sx['mean']:+6.3f} std={sx['std']:.3f} vy mean={sy['mean']:+6.3f} std={sy['std']:.3f}")
|
||||
|
||||
# check linearity: does velocity change frame-to-frame?
|
||||
accel_x = []
|
||||
accel_y = []
|
||||
for r in rows:
|
||||
vx0 = fv(r, 0, "enemy_x") - fv(r, 1, "enemy_x")
|
||||
vx1 = fv(r, 1, "enemy_x") - fv(r, 2, "enemy_x")
|
||||
vy0 = fv(r, 0, "enemy_y") - fv(r, 1, "enemy_y")
|
||||
vy1 = fv(r, 1, "enemy_y") - fv(r, 2, "enemy_y")
|
||||
accel_x.append(vx0 - vx1)
|
||||
accel_y.append(vy0 - vy1)
|
||||
sax, say = stats(accel_x), stats(accel_y)
|
||||
print(f" Accel_x (vx0-vx1): mean={sax['mean']:+.3f} std={sax['std']:.3f}")
|
||||
print(f" Accel_y (vy0-vy1): mean={say['mean']:+.3f} std={say['std']:.3f}")
|
||||
print()
|
||||
|
||||
# 5. Heading consistency
|
||||
print("=== 5. HEADING CONSISTENCY ACROSS 10 INPUT FRAMES ===")
|
||||
heading_vars = []
|
||||
for r in rows:
|
||||
# heading as angle from sin/cos
|
||||
headings = [math.atan2(fv(r, fi, "heading_sin"), fv(r, fi, "heading_cos")) for fi in range(10)]
|
||||
# circular variance: use mean resultant length
|
||||
s = sum(math.sin(h) for h in headings) / 10
|
||||
c = sum(math.cos(h) for h in headings) / 10
|
||||
R = math.sqrt(s**2 + c**2) # R=1 → perfectly consistent, R=0 → uniform
|
||||
heading_vars.append(1 - R) # variance-like
|
||||
s = stats(heading_vars)
|
||||
# bucket by variance
|
||||
low = [v for v in heading_vars if v < 0.1]
|
||||
mid = [v for v in heading_vars if 0.1 <= v < 0.3]
|
||||
hi = [v for v in heading_vars if v >= 0.3]
|
||||
print(f" Circular heading variance: mean={s['mean']:.4f} std={s['std']:.4f} min={s['mn']:.4f} max={s['mx']:.4f}")
|
||||
print(f" Stable (var<0.1): {len(low):4d} rows ({100*len(low)/len(rows):.1f}%)")
|
||||
print(f" Moderate (0.1-0.3): {len(mid):4d} rows ({100*len(mid)/len(rows):.1f}%)")
|
||||
print(f" Chaotic (>=0.3): {len(hi):4d} rows ({100*len(hi)/len(rows):.1f}%)")
|
||||
print()
|
||||
|
||||
# 6. Time-to-hit vs power
|
||||
print("=== 6. TIME-TO-HIT vs ACTUAL DISPLACEMENT ===")
|
||||
for p in POWER_LEVELS:
|
||||
bullet_speed = 20 - 3 * p
|
||||
# estimated ticks
|
||||
ticks_est = [fv(r, 0, "distance") / bullet_speed for r in rows]
|
||||
dx = [pv(r, p, "enemy_x") - fv(r, 0, "enemy_x") for r in rows]
|
||||
dy = [pv(r, p, "enemy_y") - fv(r, 0, "enemy_y") for r in rows]
|
||||
disp = [math.sqrt(x**2 + y**2) for x, y in zip(dx, dy)]
|
||||
r_td = corr(ticks_est, disp)
|
||||
mean_ticks = sum(ticks_est) / len(ticks_est)
|
||||
mean_disp = sum(disp) / len(disp)
|
||||
print(f" power={p:.2f}: bullet_speed={bullet_speed:.1f} est_ticks mean={mean_ticks:.1f} actual_disp mean={mean_disp:.2f} corr(ticks,disp)={r_td:+.3f}")
|
||||
print()
|
||||
|
||||
# 7. Simple linear extrapolation predictor
|
||||
print("=== 7. LINEAR EXTRAPOLATION PREDICTOR ERROR ===")
|
||||
for p in POWER_LEVELS:
|
||||
bullet_speed = 20 - 3 * p
|
||||
mae_x, mae_y, mae_total = [], [], []
|
||||
for r in rows:
|
||||
dist = fv(r, 0, "distance")
|
||||
ticks = dist / bullet_speed
|
||||
# velocity from f0-f1 position delta (f0 is most recent, f1 is one tick older)
|
||||
vx = fv(r, 0, "enemy_x") - fv(r, 1, "enemy_x")
|
||||
vy = fv(r, 0, "enemy_y") - fv(r, 1, "enemy_y")
|
||||
pred_x = fv(r, 0, "enemy_x") + vx * ticks
|
||||
pred_y = fv(r, 0, "enemy_y") + vy * ticks
|
||||
actual_x = pv(r, p, "enemy_x")
|
||||
actual_y = pv(r, p, "enemy_y")
|
||||
mae_x.append(abs(pred_x - actual_x))
|
||||
mae_y.append(abs(pred_y - actual_y))
|
||||
mae_total.append(math.sqrt((pred_x - actual_x)**2 + (pred_y - actual_y)**2))
|
||||
sx, sy, st = stats(mae_x), stats(mae_y), stats(mae_total)
|
||||
print(f" power={p:.2f}: MAE_x={sx['mean']:6.2f} MAE_y={sy['mean']:6.2f} MAE_total={st['mean']:6.2f} std={st['std']:.2f}")
|
||||
print()
|
||||
|
||||
# 8. Pattern clustering by heading variance
|
||||
print("=== 8. PATTERN CLUSTERING: heading variance vs predictor accuracy ===")
|
||||
# recompute per-row heading variance and p1.07 MAE as representative mid-power
|
||||
p_rep = 1.07
|
||||
bullet_speed_rep = 20 - 3 * p_rep
|
||||
buckets = {"stable": [], "moderate": [], "chaotic": []}
|
||||
for r in rows:
|
||||
headings = [math.atan2(fv(r, fi, "heading_sin"), fv(r, fi, "heading_cos")) for fi in range(10)]
|
||||
s = sum(math.sin(h) for h in headings) / 10
|
||||
c = sum(math.cos(h) for h in headings) / 10
|
||||
R = math.sqrt(s**2 + c**2)
|
||||
hv = 1 - R
|
||||
|
||||
dist = fv(r, 0, "distance")
|
||||
ticks = dist / bullet_speed_rep
|
||||
vx = fv(r, 0, "enemy_x") - fv(r, 1, "enemy_x")
|
||||
vy = fv(r, 0, "enemy_y") - fv(r, 1, "enemy_y")
|
||||
pred_x = fv(r, 0, "enemy_x") + vx * ticks
|
||||
pred_y = fv(r, 0, "enemy_y") + vy * ticks
|
||||
actual_x = pv(r, p_rep, "enemy_x")
|
||||
actual_y = pv(r, p_rep, "enemy_y")
|
||||
err = math.sqrt((pred_x - actual_x)**2 + (pred_y - actual_y)**2)
|
||||
|
||||
if hv < 0.1:
|
||||
buckets["stable"].append((hv, err))
|
||||
elif hv < 0.3:
|
||||
buckets["moderate"].append((hv, err))
|
||||
else:
|
||||
buckets["chaotic"].append((hv, err))
|
||||
|
||||
for name, items in buckets.items():
|
||||
if not items:
|
||||
print(f" {name}: no rows")
|
||||
continue
|
||||
errs = [e for _, e in items]
|
||||
hvs = [h for h, _ in items]
|
||||
se = stats(errs)
|
||||
sh = stats(hvs)
|
||||
print(f" {name:10s} ({len(items):3d} rows): heading_var={sh['mean']:.4f} MAE_total={se['mean']:6.2f} std={se['std']:.2f}")
|
||||
|
||||
# correlation between heading_variance and error
|
||||
all_hv = []
|
||||
all_err = []
|
||||
for r in rows:
|
||||
headings = [math.atan2(fv(r, fi, "heading_sin"), fv(r, fi, "heading_cos")) for fi in range(10)]
|
||||
s = sum(math.sin(h) for h in headings) / 10
|
||||
c = sum(math.cos(h) for h in headings) / 10
|
||||
R = math.sqrt(s**2 + c**2)
|
||||
all_hv.append(1 - R)
|
||||
|
||||
dist = fv(r, 0, "distance")
|
||||
ticks = dist / bullet_speed_rep
|
||||
vx = fv(r, 0, "enemy_x") - fv(r, 1, "enemy_x")
|
||||
vy = fv(r, 0, "enemy_y") - fv(r, 1, "enemy_y")
|
||||
pred_x = fv(r, 0, "enemy_x") + vx * ticks
|
||||
pred_y = fv(r, 0, "enemy_y") + vy * ticks
|
||||
actual_x = pv(r, p_rep, "enemy_x")
|
||||
actual_y = pv(r, p_rep, "enemy_y")
|
||||
all_err.append(math.sqrt((pred_x - actual_x)**2 + (pred_y - actual_y)**2))
|
||||
|
||||
print(f" corr(heading_variance, prediction_error) = {corr(all_hv, all_err):+.3f}")
|
||||
print()
|
||||
|
||||
# Extra: distance vs MAE (does distance matter?)
|
||||
print("=== EXTRA: DISTANCE vs PREDICTION ERROR (p=1.07) ===")
|
||||
dists = [fv(r, 0, "distance") for r in rows]
|
||||
print(f" corr(distance, MAE_total) = {corr(dists, all_err):+.3f}")
|
||||
dist_s = stats(dists)
|
||||
print(f" distance: mean={dist_s['mean']:.1f} std={dist_s['std']:.1f} min={dist_s['mn']:.1f} max={dist_s['mx']:.1f}")
|
||||
print()
|
||||
|
||||
# Extra: what is the velocity field vs computed velocity?
|
||||
print("=== EXTRA: REPORTED VELOCITY vs COMPUTED VELOCITY ===")
|
||||
rep_vel = [fv(r, 0, "velocity") for r in rows]
|
||||
comp_vel = [math.sqrt((fv(r, 0, "enemy_x") - fv(r, 1, "enemy_x"))**2 +
|
||||
(fv(r, 0, "enemy_y") - fv(r, 1, "enemy_y"))**2) for r in rows]
|
||||
print(f" corr(reported_vel, computed_speed) = {corr(rep_vel, comp_vel):+.3f}")
|
||||
sv = stats(rep_vel)
|
||||
sc = stats(comp_vel)
|
||||
print(f" reported_vel: mean={sv['mean']:.2f} std={sv['std']:.2f}")
|
||||
print(f" computed_speed: mean={sc['mean']:.2f} std={sc['std']:.2f}")
|
||||
print()
|
||||
|
||||
print("=" * 60)
|
||||
print("CONCLUSIONS")
|
||||
print("=" * 60)
|
||||
print("""
|
||||
1. STRONGEST INPUT->OUTPUT CORRELATION:
|
||||
- Enemy velocity (f0_velocity) and positional delta between f0/f1
|
||||
directly predict displacement to the hit point. Correlation
|
||||
between computed velocity direction and displacement is the
|
||||
strongest single signal. Distance determines TIME-TO-HIT, which
|
||||
scales the displacement magnitude: corr(ticks_estimated, |disp|)
|
||||
is consistently high across all power levels.
|
||||
- The heading field is stable most of the time (majority of rows
|
||||
have circular variance < 0.1), meaning the enemy's direction of
|
||||
travel barely changes — linear extrapolation exploits this directly.
|
||||
|
||||
2. HOW WELL DOES LINEAR EXTRAPOLATION WORK?
|
||||
- At low power (fast bullet, short ticks): MAE is small (~10-30 units).
|
||||
- At high power (slow bullet, many ticks): MAE grows because small
|
||||
heading errors compound. But even at power=3.00, MAE is in the
|
||||
tens of units on a 1000x1000 arena — roughly 2-5% positional error.
|
||||
- Heading-stable rows have significantly lower MAE than chaotic ones.
|
||||
- Verdict: linear extrapolation is the dominant predictor and is
|
||||
"good enough" as a baseline.
|
||||
|
||||
3. WHAT LEARNING RULE CAN EXPLOIT THIS WITHOUT BACKPROPAGATION?
|
||||
- Hebbian / correlation learning on residuals: after firing, compute
|
||||
the miss vector (actual_hit - predicted_hit). The residual is the
|
||||
signal. A simple anti-Hebbian rule can suppress the weight patterns
|
||||
that produced the worst predictions:
|
||||
w += lr * (residual_x * input_feature) for each correlated input.
|
||||
- Nearest-neighbor / kernel memory: store (input_state, hit_offset)
|
||||
pairs. At inference, retrieve the k nearest past states (by velocity
|
||||
+ heading + distance) and average their residuals to correct the
|
||||
linear estimate. No gradient needed — just cosine similarity lookups.
|
||||
- Competitive/winner-takes-all on discretized heading buckets: divide
|
||||
heading into ~8 sectors, maintain per-sector velocity statistics.
|
||||
At runtime, use the sector mean as the prediction. Update is a
|
||||
running average — O(1), no backprop.
|
||||
|
||||
4. RECOMMENDED APPROACH:
|
||||
Step 1 (baseline): linear extrapolation using f0 position + velocity
|
||||
computed from f0-f1 delta, scaled by distance/bullet_speed ticks.
|
||||
Step 2 (Hebbian correction): maintain a small weight vector per
|
||||
heading sector that stores the mean residual error from past shots.
|
||||
After each resolved wave, update the relevant sector with the miss.
|
||||
At fire time, bias the predicted position by that sector's residual.
|
||||
This two-layer approach (physics model + Hebbian residual table) needs
|
||||
no backpropagation, is fully online, and targets the dominant source
|
||||
of error: systematic per-heading prediction bias from wall bouncing
|
||||
and acceleration patterns that repeat within a game.
|
||||
""")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,390 @@
|
||||
# Biology Domain Report: Learning Mechanisms for BNNBot
|
||||
|
||||
**Context**: Binary neural network (690-bit input, online learning, no gradient descent, reward from wave-hit miss distance, ~1ms/tick budget).
|
||||
|
||||
---
|
||||
|
||||
## 1. Three-Factor Learning Rules (Neuromodulation)
|
||||
|
||||
### How it works biologically
|
||||
In cortex, synaptic plasticity depends on three signals simultaneously: pre-synaptic activity, post-synaptic activity, and a neuromodulator (dopamine for reward, acetylcholine for attention, norepinephrine for arousal). The local Hebbian correlation (pre × post) creates an **eligibility trace** — a molecular tag that marks a synapse as "recently active." The neuromodulator gates whether that trace converts to actual weight change. This solves the temporal credit assignment problem: the trace persists for seconds, so a delayed reward can still modulate the right synapses.
|
||||
|
||||
### Core algorithmic principle
|
||||
```
|
||||
eligibility[w] += pre_activity * post_activity * decay
|
||||
Δw = eligibility[w] * reward_signal(t)
|
||||
```
|
||||
The trace bridges the gap between action (synapse fires) and evaluation (reward arrives). Different layers can have different decay constants, giving the reward signal variable reach depth.
|
||||
|
||||
### Mapping to our system
|
||||
- Wave hit system fires a reward signal at a delay (bullet travel time). This is exactly the temporal gap eligibility traces are built for.
|
||||
- Each binary synapse (XOR input, threshold sum) computes pre × post locally at no extra cost — the product is 1 only if both sides were active.
|
||||
- The reward scalar (miss distance inverted) becomes the neuromodulator: `Δw ∝ eligibility * (1 / miss_distance)`.
|
||||
- Deeper layers get a weaker or differently-shaped neuromodulatory signal — natural depth-aware credit assignment without backprop.
|
||||
|
||||
### Update rule sketch
|
||||
```
|
||||
# Per synapse, per tick:
|
||||
e[i,j] += pre[i] * post[j]
|
||||
e[i,j] *= decay # e.g. 0.95/tick
|
||||
|
||||
# On wave hit:
|
||||
reward = 1.0 - (miss_px / arena_width)
|
||||
for each (i,j) in layer:
|
||||
w[i,j] += lr * e[i,j] * reward
|
||||
e[i,j] = 0 # consume trace
|
||||
```
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Handles delayed reward natively (critical for our wave system).
|
||||
+ Works with binary activations — pre=0/1, post=0/1, product is cheap.
|
||||
+ Scales well: O(weights), no global error computation needed.
|
||||
+ Different layers can use different lr or different eligibility decay → implicit layer-wise credit assignment.
|
||||
- Variance is high with sparse binary activations (most products are 0). Need enough co-activations to get signal.
|
||||
- Reward signal is scalar; it's not instructive (doesn't say which direction to move). Works best when combined with exploration.
|
||||
|
||||
---
|
||||
|
||||
## 2. Cerebellar Learning (Supervised via Error Signal + Timing)
|
||||
|
||||
### How it works biologically
|
||||
The cerebellum is the brain's timing engine. Granule cells provide a massive population code of context (parallel fibers). Purkinje cells are the output neurons. Climbing fibers from the inferior olive deliver a precise error signal ("something went wrong") that triggers long-term depression (LTD) at the active parallel fiber → Purkinje cell synapses. The critical detail: **only the synapses that were active just before the error are depressed** — this is temporal specificity without backpropagation.
|
||||
|
||||
Recent (2024) work shows granule cells ramp at different rates toward a reward moment, and the climbing fiber spike at reward time selectively strengthens the synapses whose ramp was timed correctly. This is literally: learn to predict when the bullet arrives.
|
||||
|
||||
### Core algorithmic principle
|
||||
```
|
||||
# Climbing fiber = error event at time T
|
||||
# Depress all parallel fiber synapses that were active in window [T-Δ, T]
|
||||
for synapse active in recent_window:
|
||||
w -= lr * (was_active AND error_occurred)
|
||||
```
|
||||
It's a delayed anti-Hebbian rule gated by an error signal. No error = no change. Error = punish recently-active pathways.
|
||||
|
||||
### Mapping to our system
|
||||
The wave system is essentially a climbing fiber: it fires an error/reward signal at a defined time (when the wave reaches the enemy). Our predictor was active with specific binary patterns when the shot was committed. We can depress the synapses that fired and caused a miss, or potentiate those that fired and caused a near-hit.
|
||||
|
||||
The granule cell population code idea maps directly to our 690-bit sparse input — we already have a rich, diverse temporal representation that can encode "which part of the trajectory context was active."
|
||||
|
||||
### Update rule sketch
|
||||
```
|
||||
# Store recent binary activations per layer (ring buffer, ~50 ticks)
|
||||
on wave_hit(miss_distance, ticks_ago):
|
||||
reward = clip(1.0 - miss_distance/threshold, -1, 1)
|
||||
pattern = activation_history[ticks_ago]
|
||||
for each active synapse in pattern:
|
||||
w += lr * reward # LTP on near-hit, LTD on miss
|
||||
```
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Elegant credit assignment without any backward pass: just "what was active before the error?"
|
||||
+ Temporal specificity is free — ring buffer of activations is cheap.
|
||||
+ Directly analogous to our wave timing structure.
|
||||
+ The granule cell / parallel fiber idea suggests we want MANY diverse binary features upstream — our 690-bit encoding already does this.
|
||||
- Classic cerebellar model is essentially supervised (climbing fiber knows the correct output). Our reward is scalar, not a correction vector. We get "wrong" but not "which direction is right."
|
||||
- Works better with many output cells (Purkinje cells) each tuned to a sub-task. With a single X/Y output we lose diversity.
|
||||
|
||||
---
|
||||
|
||||
## 3. Immune Clonal Selection + Somatic Hypermutation
|
||||
|
||||
### How it works biologically
|
||||
When a pathogen appears, B-cells with partial affinity are selected and cloned. Clones undergo somatic hypermutation — rapid, local random changes to antibody genes (not genome-wide). Clones with better affinity bind more antigen and survive; others die. The result is rapid local optimization starting from a working seed. No central controller, no gradient — just: copy, mutate locally, select, repeat.
|
||||
|
||||
### Core algorithmic principle
|
||||
```
|
||||
population = [copy(best) for _ in range(n_clones)]
|
||||
for clone in population:
|
||||
mutate locally with rate ∝ 1/affinity # better clones mutate less
|
||||
affinity = evaluate(clone)
|
||||
keep top k
|
||||
```
|
||||
This is a hill-climber with adaptive mutation radius and population diversity. The key insight: **mutation rate inversely proportional to current performance** — near-optimal solutions mutate less, preventing regression.
|
||||
|
||||
### Mapping to our system
|
||||
We can maintain a small population (e.g., 4–8) of weight vectors for the readout layer. Every N ticks, clone the best-performing weight vector, apply random bit-flips to the binary weights with probability ∝ miss_distance (worse performance = more aggressive mutation). Test clones against incoming wave hits. Keep survivors.
|
||||
|
||||
This sidesteps gradient computation entirely: evaluation is the reward signal itself.
|
||||
|
||||
### Update rule sketch
|
||||
```
|
||||
# Every 20 ticks:
|
||||
clones = [flip_bits(best_weights, rate=miss_ema) for _ in range(4)]
|
||||
# Over next 20 ticks, score each clone on wave hits
|
||||
best_weights = clone with lowest average miss distance
|
||||
```
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Zero gradient computation. Works on discrete/binary weights directly.
|
||||
+ Adaptive mutation rate naturally does simulated annealing.
|
||||
+ Population diversity prevents local minima.
|
||||
+ Compatible with any loss landscape shape.
|
||||
- Requires parallel evaluation — need to run multiple weight hypotheses simultaneously and compare. Adds memory.
|
||||
- Convergence is slower than gradient methods for smooth losses (but our loss is NOT smooth — binary weights make gradient methods useless here anyway).
|
||||
- Population size ≥ 2 costs memory; with binary weights and ~100 readout weights this is negligible.
|
||||
|
||||
**This is underexplored for binary networks where gradients are meaningless. Strongest candidate here.**
|
||||
|
||||
---
|
||||
|
||||
## 4. Kauffman Boolean Networks / Edge-of-Chaos Self-Organization
|
||||
|
||||
### How it works biologically
|
||||
Kauffman's NK Boolean networks model gene regulatory networks. Each gene node has K inputs from other nodes and a random Boolean function. With K=2, networks sit at a phase transition: ordered (frozen, no computation) vs. chaotic (noise floods signal). At K≈2 (the "edge of chaos"), networks show maximal information transmission, long transients before attractors, and sensitivity to initial conditions without instability.
|
||||
|
||||
Living cells appear to self-tune toward this critical point. Perturbations propagate far but don't explode exponentially.
|
||||
|
||||
### Core algorithmic principle
|
||||
The edge-of-chaos is an architectural prior: design connectivity so each node has ≈ 2 inputs. This maximizes the repertoire of distinguishable states the network can encode, making the network a rich feature extractor with minimal parameters.
|
||||
|
||||
For learning: networks can be guided toward the edge by rewarding connectivity patterns that show intermediate sensitivity (not frozen, not chaotic), using damage spreading tests.
|
||||
|
||||
### Mapping to our system
|
||||
Our XOR+popcount+threshold neurons already have arbitrary fan-in. If we constrain each neuron to K≈2 inputs (or K≈4 for richer functions), we could build a Boolean reservoir that sits at the edge of chaos and provides a rich nonlinear projection of the 690-bit input. The readout layer then does the learning.
|
||||
|
||||
This is essentially "design the hidden layer using Kauffman's criticality principle."
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Principled architecture design without training hidden layers.
|
||||
+ Maximizes representational capacity of fixed random layer.
|
||||
+ Binary everywhere — exact fit.
|
||||
- It's an architectural heuristic, not a learning algorithm. Still needs a supervised/RL readout.
|
||||
- Self-tuning criticality during online battle is complex; better as initialization strategy.
|
||||
- K=2 limits each neuron's discriminability; our current threshold neurons with high fan-in may already be better.
|
||||
|
||||
---
|
||||
|
||||
## 5. Octopus: Hierarchical Autonomy with Peripheral Pre-processing
|
||||
|
||||
### How it works biologically
|
||||
The octopus has ~500M neurons, but only 36% are in the central brain. Each arm has its own mini-brain that executes local motor programs (grasp, explore, retract) without waiting for central commands. The central brain issues high-level goals ("reach there"); the arm negotiates locally with its environment. Crucially: **each peripheral layer learns what it needs for its task**, decoupled from the other layers.
|
||||
|
||||
### Core algorithmic principle
|
||||
Hierarchical decomposition where each processing stage has its own local learning objective, not a globally supervised one. The central system trains on outcomes; the periphery trains on local sensory prediction (self-supervised). This creates natural credit assignment boundaries: you don't need to propagate error through the arm's local controller to train the central goal selector.
|
||||
|
||||
### Mapping to our system
|
||||
This suggests a **two-stage architecture**:
|
||||
- Stage 1 (peripheral, fixed or self-supervised): encode the 690-bit input into a compressed, locally predictive representation. Train to predict next frame from current frame (self-supervised). No reward needed here.
|
||||
- Stage 2 (central, RL-trained): use the stage-1 representation as input. This layer receives the wave hit reward and trains with Hebbian/three-factor rules.
|
||||
|
||||
Stage 1 insulates stage 2 from input noise and does feature extraction. Stage 2 does the goal-directed aiming.
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Clean credit assignment: stage 2 trains on reward, stage 1 trains on local prediction error.
|
||||
+ Self-supervised stage 1 can learn from every tick (no reward needed), converges faster.
|
||||
+ Modular: can replace either stage independently.
|
||||
- Two-stage adds complexity. For our problem (movement is 97.8% constant-velocity), stage 1 may not be worth the cost.
|
||||
- Self-supervised prediction of next frame is essentially "predict the enemy continues straight" — which linear extrapolation already does perfectly.
|
||||
|
||||
---
|
||||
|
||||
## 6. Slime Mold (Physarum polycephalum): Flow-Reinforced Network Topology
|
||||
|
||||
### How it works biologically
|
||||
*Physarum* is a single-celled organism (no neurons) that solves shortest-path problems. Its body is a network of cytoplasmic tubes. Food sources cause oscillatory contractions that push fluid through tubes. Tubes that carry more flow grow thicker (lower resistance → more flow → more growth). Tubes that carry less flow shrink and disappear. The result: the network self-organizes to the minimum Steiner tree connecting food sources.
|
||||
|
||||
This is **Hebbian learning on a physical network**: use it more → strengthen it. The "signal" is flow (pressure differential), the "synapse" is tube cross-section.
|
||||
|
||||
### Core algorithmic principle
|
||||
```
|
||||
# For each edge (i,j) with flow Q[i,j]:
|
||||
D[i,j] += alpha * (Q[i,j] - beta * D[i,j]) # grow with flow, decay otherwise
|
||||
```
|
||||
Where D is tube diameter (conductance). This is a local, flow-proportional reinforcement rule with decay. No central controller.
|
||||
|
||||
### Mapping to our system
|
||||
Map "flow" to activation frequency: a binary weight that fires more often under successful predictions gets stronger. This is a frequency-weighted Hebbian rule:
|
||||
```
|
||||
Δw[i,j] += alpha * activation_freq[i,j] * reward_ema - beta * w[i,j]
|
||||
```
|
||||
The decay term (-beta * w) prevents runaway potentiation (Physarum tubes that aren't used shrink). This gives us **structural plasticity**: unused pathways die, active+rewarded pathways survive.
|
||||
|
||||
This is subtly different from standard Hebbian learning: the reinforcement is on **path flow** (consistent activation patterns over time), not just single-trial coincidence. It's an exponential moving average of "did this synapse contribute to successes?"
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Extremely simple update rule. Naturally implements Occam's razor: unused connections prune themselves.
|
||||
+ Decay term prevents runaway weights and provides implicit regularization.
|
||||
+ The flow-reinforcement principle is perfect for our wave system: each wave hit tells us which connections were "on the path" to the prediction.
|
||||
- Physarum solves shortest-path, which is a topological problem. Our problem is regression (predict X, Y). The flow metaphor requires careful translation.
|
||||
- Pruning live connections during battle could cause instability if exploration is needed.
|
||||
|
||||
---
|
||||
|
||||
## 7. Predictive Processing / Free Energy Minimization
|
||||
|
||||
### How it works biologically
|
||||
Karl Friston's free energy principle proposes the brain minimizes "surprise" by constantly predicting its sensory inputs and updating internal models when predictions fail. Prediction errors flow upward (bottom-up), predictions flow downward (top-down). Each layer only sees the prediction error from the layer below, not the raw input. Learning minimizes the sum of prediction errors across all layers simultaneously — this turns out to be mathematically equivalent to variational inference, and approximately equivalent to backpropagation under certain conditions.
|
||||
|
||||
### Core algorithmic principle
|
||||
Each layer maintains a prediction of the layer below's state and updates based on the error:
|
||||
```
|
||||
error[l] = actual[l] - prediction[l]
|
||||
prediction[l] = W[l+1] * activity[l+1] # top-down
|
||||
Δw[l] = lr * error[l] * activity[l+1] # Hebbian on error
|
||||
```
|
||||
No global error required — each layer minimizes its local prediction error. This achieves approximate credit assignment through depth.
|
||||
|
||||
### Mapping to our system
|
||||
Train the lower layers to predict the next input frame (self-supervised, every tick). Train the top layer to minimize aiming error (RL, every wave hit). The lower layers develop representations that are useful for prediction, which in turn aids the top layer.
|
||||
|
||||
For binary networks: the "prediction" is a reconstructed binary pattern, and the "error" is the XOR (bitwise difference) between predicted and actual pattern.
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Every tick provides a learning signal for lower layers (no need to wait for wave hits).
|
||||
+ Layer-local updates — no need to propagate anything through the full depth.
|
||||
+ Mathematically principled; proven to approximate backprop in continuous case.
|
||||
- In binary networks, the "prediction error" (XOR) is not differentiable and doesn't provide a directional update signal — just "wrong" or "right" per bit.
|
||||
- The top-down prediction path requires an explicit generative model (decoder weights), doubling parameter count.
|
||||
- For our near-linear enemy motion, prediction error will be near-zero almost always, starving the learning signal.
|
||||
|
||||
---
|
||||
|
||||
## 8. Reward-Modulated STDP (R-STDP) with Eligibility Traces
|
||||
|
||||
### How it works biologically
|
||||
Spike-timing-dependent plasticity (STDP): if pre fires before post within ~20ms, potentiate; if post fires before pre, depress. R-STDP adds a third factor: the dopaminergic reward signal gates the eligibility trace that STDP creates. The eligibility trace is a slow-decaying shadow of the Hebbian correlation; only when reward arrives does it convert to permanent weight change.
|
||||
|
||||
### Core algorithmic principle (adapted for rate-coded binary neurons)
|
||||
```
|
||||
# At each tick:
|
||||
e[i,j] = pre[i] * post[j] - (1-pre[i]) * post[j] * depression_factor
|
||||
e[i,j] *= trace_decay
|
||||
|
||||
# At wave hit:
|
||||
Δw[i,j] = lr * e[i,j] * reward
|
||||
```
|
||||
The anti-Hebbian term (inactive pre, active post) prevents post-synaptic neurons from firing without cause — this is the "STDP asymmetry" that drives selectivity.
|
||||
|
||||
### Mapping to our system
|
||||
Direct application: run R-STDP on the readout layer with wave-hit reward as the neuromodulator. For binary neurons, "pre fires before post" translates to "this input bit was 1 when this output bit became 1." The eligibility trace naturally bridges the bullet travel delay.
|
||||
|
||||
This is a well-studied, published combination: R-STDP + binary/SNN networks + reward-based learning.
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Well-studied, proven to train binary/spiking networks on classification tasks.
|
||||
+ Eligibility trace handles delayed reward explicitly.
|
||||
+ Anti-Hebbian depression term improves specificity over pure Hebbian.
|
||||
- Standard R-STDP trains only the readout layer well; deep credit assignment remains hard.
|
||||
- In rate-coded binary (not spike-timing) settings, the "timing" aspect is lost — reduces to three-factor Hebbian.
|
||||
|
||||
---
|
||||
|
||||
## 9. Lateral Inhibition / Winner-Take-All for Representation Learning (LESS KNOWN angle)
|
||||
|
||||
### How it works biologically
|
||||
In cortex, excitatory neurons compete via inhibitory interneurons. Only the most-activated cell "wins" and suppresses its neighbors. This WTA dynamic creates **sparse, non-overlapping representations** where each input pattern activates only a few neurons. Used in the olfactory bulb, hippocampus (sparse place cells), and visual cortex.
|
||||
|
||||
The key learning rule is **SoftHebb**: Hebbian updates gated by the WTA competition. The winner potentiates its input weights; losers depress theirs. No labels, no reward — purely competitive.
|
||||
|
||||
### Core algorithmic principle
|
||||
```
|
||||
winner = argmax(activation_vector)
|
||||
Δw[winner, :] = lr * (input - w[winner, :]) # move toward input
|
||||
Δw[losers, :] = -small_lr * input # move away
|
||||
```
|
||||
This is online k-means / vector quantization, but implemented as neural competition.
|
||||
|
||||
### Mapping to our system
|
||||
Use a WTA hidden layer between input (690 bits) and readout. The WTA layer creates a sparse binary code from the input — essentially a hash into a learned codebook of "enemy movement contexts." The readout then maps each context-hash to an (x, y) correction.
|
||||
|
||||
This extends our current Hebbian residual table (8 heading sectors × 3 distance bands = 24 cells) to a LEARNED partitioning with hundreds of cells, found automatically from data rather than hand-coded.
|
||||
|
||||
### Update rule sketch
|
||||
```
|
||||
# Hidden layer: WTA competition
|
||||
scores = W_hidden @ input_bits # shape: [n_hidden]
|
||||
k_active = top_k_indices(scores, k=5) # k-sparse activation
|
||||
binary_hidden = sparse_binary(k_active, n_hidden)
|
||||
|
||||
# Hebbian update on hidden layer weights (unsupervised, every tick):
|
||||
for i in k_active:
|
||||
W_hidden[i] += lr_unsup * (input_bits - W_hidden[i])
|
||||
|
||||
# Readout update (on wave hit):
|
||||
Δw_readout = lr_rl * binary_hidden * reward
|
||||
```
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Replaces hand-coded sector table with a learned, data-driven partitioning.
|
||||
+ Unsupervised layer learns from every tick; RL layer learns from wave hits. Two timescales.
|
||||
+ Sparse binary hidden code is efficient and interpretable.
|
||||
+ Scales naturally to hundreds of "cells" vs. our current 24.
|
||||
+ SoftHebb (2022) showed this achieves competitive image classification without backprop.
|
||||
- The hidden layer learns the input distribution, not the reward structure — may learn irrelevant features.
|
||||
- k-sparse WTA is sensitive to the choice of k and n_hidden. Needs tuning.
|
||||
|
||||
---
|
||||
|
||||
## 10. Plant Root Tropism: Gradient-Free Local Search with Memory (VERY UNDEREXPLORED)
|
||||
|
||||
### How it works biologically
|
||||
Plant roots grow toward nutrients (chemotropism), water (hydrotropism), and away from toxins. Each root tip integrates local chemical gradients over its surface and biases growth direction. No central nervous system, no backprop. The mechanism: differential auxin concentration across the root tip causes asymmetric elongation. The root "bends" toward the side with less auxin (more elongation).
|
||||
|
||||
Crucially: **the root remembers where it came from** (gravitropism provides a reference frame), and successful growth (reaching nutrient) is consolidated by lateral root branching — the successful path is reinforced structurally.
|
||||
|
||||
### Core algorithmic principle
|
||||
```
|
||||
# Local gradient sensing:
|
||||
direction_bias = integrate(local_signal, window=tip_width)
|
||||
grow(direction_bias)
|
||||
|
||||
# Reinforcement on success:
|
||||
if nutrient_found:
|
||||
branch here # spawn lateral root from successful path
|
||||
consolidate path weights # auxin redistribution
|
||||
```
|
||||
This is a stochastic local search with: (a) local gradient estimation from small perturbations, (b) structural reinforcement of successful paths, (c) no global controller.
|
||||
|
||||
### Mapping to our system
|
||||
The "root tip" is the current weight vector. "Growing" is perturbing weights. "Nutrient gradient" is the miss distance improvement over recent ticks. The plant root insight is: **estimate gradient locally by trying slightly perturbed directions and measuring which direction improves reward** — this is exactly node/weight perturbation learning.
|
||||
|
||||
The "lateral branching on success" maps to: when performance improves significantly, save the current weight vector as a new candidate in a small ensemble.
|
||||
|
||||
### Strengths / weaknesses
|
||||
+ Gradient-free by construction — works on any loss landscape.
|
||||
+ "Branch on success" idea gives a cheap ensemble without parallel evaluation.
|
||||
+ Local perturbation + reward correlation = unbiased gradient estimate (weight perturbation theorem).
|
||||
- Perturbation-based gradient estimates have high variance with many weights.
|
||||
- For binary weights, even a single bit flip is a discrete jump, not an infinitesimal perturbation. Must flip multiple bits to get meaningful reward signal difference.
|
||||
|
||||
---
|
||||
|
||||
## Cross-Cutting Synthesis
|
||||
|
||||
### The Four Most Promising Mechanisms for BNNBot
|
||||
|
||||
**Tier 1 (implement now):**
|
||||
|
||||
1. **Three-factor Hebbian + Eligibility Traces** — maps directly onto existing Hebbian residual table. Add eligibility trace to bridge the bullet travel delay. Extends the current architecture minimally.
|
||||
|
||||
2. **Clonal Selection (Immune)** — for binary weight vectors, gradient descent is meaningless. Maintain 2–4 clones of the readout weights, mutate with rate ∝ miss_distance, keep winner. This is the correct optimizer for discrete weight spaces. ~10 lines of code.
|
||||
|
||||
**Tier 2 (worth exploring):**
|
||||
|
||||
3. **WTA + SoftHebb hidden layer** — replaces the hand-coded 8×3 sector table with a learned ~256-cell partitioning. Every tick provides an unsupervised update; every wave hit provides a reward update. Two decoupled learning loops.
|
||||
|
||||
4. **Physarum flow-reinforcement (structural pruning)** — add a decay term to the current weight update. Connections that fire often under reward survive; others die. Implicit regularization.
|
||||
|
||||
**Tier 3 (architectural ideas, not ready for implementation):**
|
||||
|
||||
5. **Kauffman edge-of-chaos** — use as an initialization principle for any fixed random hidden layer: set K≈2 per neuron for maximal computational richness.
|
||||
|
||||
6. **Cerebellar granule cell ramp** — train binary hidden cells to ramp (increase activation rate) toward the expected bullet arrival time. Those that are active at hit time get potentiated. Requires temporal structure the current encoding lacks.
|
||||
|
||||
### Key Insight from Biology
|
||||
|
||||
Every mechanism above shares one property: **local information + delayed global signal = credit assignment**. The brain never backpropagates a gradient; it stores a **trace** of what was active, then modulates that trace when a reward arrives. The three-factor rule is the minimal mathematical expression of this principle. Everything else (cerebellar timing, immune cloning, Physarum flow) is a specialization of it to a particular domain.
|
||||
|
||||
For our problem: the wave system already provides the delayed global signal. The missing piece is the **trace** — recording what the network did when it committed to a prediction, then crediting or debiting those activations when the wave hit occurs.
|
||||
|
||||
---
|
||||
|
||||
## Appendix: Less-Known Mechanisms (Brief)
|
||||
|
||||
**Bacterial chemotaxis (run-and-tumble):** E. coli compares current receptor occupancy to a memory of receptor occupancy ~1 second ago. If occupancy improved, bias toward running; if worsened, tumble (random new direction). No neurons, no gradient. Pure temporal comparison. Maps to: compare current miss_distance to miss_distance 20 ticks ago; if improved, continue current weight direction; if worsened, randomize. The "memory" is a single exponential moving average.
|
||||
|
||||
**Voltage-gated calcium channels as eligibility trace substrate:** In real neurons, calcium transients triggered by coincident pre-post firing persist for hundreds of milliseconds and activate CaM-KII, which phosphorylates AMPA receptors. This is the molecular implementation of the eligibility trace. For us: any variable that accumulates during active periods and decays when inactive is a valid trace substrate. A simple integer counter per weight, incremented on pre×post=1 and multiplied by 0.95 each tick, is the computational equivalent.
|
||||
|
||||
**Neurogenesis under stress (hippocampus):** The hippocampus generates new neurons under novelty/stress. New neurons have lower activation thresholds and are more plastic. They either get incorporated (if they contribute) or die within weeks. For us: "spawn" new binary neurons (random weight vectors) when miss distance spikes (enemy starts dodging). Test them for 50 ticks. Keep those that improve prediction; discard others. This is a second form of clonal selection operating at the architectural level.
|
||||
|
||||
**Octopus chromatophore pattern learning:** Octopuses can learn to flash specific chromatophore patterns to match backgrounds they've never seen, using reinforcement from camouflage success. Each skin patch (papilla) has local autonomy but is coordinated by central pattern generators. The learning is: local patches learn to respond to local visual input; global coordination emerges from shared output constraints. Maps to: local hidden neurons learn from local input sub-regions; global readout imposes output coordination.
|
||||
@@ -0,0 +1,560 @@
|
||||
# Electronics & Hardware Domain Analysis
|
||||
## BNNBot Research — Learning Without Gradient Descent
|
||||
|
||||
**Context:** Binary network predicting enemy position in Robocode Tank Royale.
|
||||
Constraints: no gradient descent, online learning only, ~1ms/tick, binary-friendly,
|
||||
reward signal from wave-hit system (miss distance known per shot).
|
||||
|
||||
---
|
||||
|
||||
## 1. Memristive Systems
|
||||
|
||||
### How it works in hardware
|
||||
A memristor's resistance is a function of its charge history. Pass current one direction:
|
||||
resistance drops (LRS, low-resistance state = "1"). Reverse: resistance rises (HRS = "0").
|
||||
In a crossbar array, each crosspoint is one synapse. Reading = multiply (V × G = I),
|
||||
summing wires implement dot product in Ohm's law. Writing = apply voltage pulse.
|
||||
|
||||
Binary memristors (two-state, SET/RESET) switch between exactly LRS and HRS — no analog
|
||||
level needed. Programming is by voltage threshold: exceed it → switch state.
|
||||
|
||||
### Core algorithmic principle
|
||||
The natural learning rule is **STDP (Spike-Timing Dependent Plasticity)** — a Hebbian
|
||||
variant gated by spike timing. With three-factor extensions, a third neuromodulatory
|
||||
signal (reward / dopamine analog) gates the synaptic update:
|
||||
|
||||
```
|
||||
ΔW = eligibility_trace × reward_signal
|
||||
```
|
||||
|
||||
The eligibility trace is a leaky counter: it captures recent pre/post coincidence and
|
||||
decays. When reward arrives (delayed), it multiplies the trace. This lets delayed rewards
|
||||
credit the right synapses — the hardware equivalent of credit assignment without backprop.
|
||||
|
||||
For binary memristors specifically:
|
||||
- Hebbian: if pre AND post both fired recently → SET (LRS)
|
||||
- Anti-Hebbian: if pre fired but post did not (or vice versa) → RESET (HRS)
|
||||
- Three-factor: gate SET/RESET on reward sign
|
||||
|
||||
### Mapping to BNNBot
|
||||
- Our neuron is: `popcount(XOR(weights, input)) > threshold` — an n-input binary gate
|
||||
- Weights are bits; SET/RESET maps to w[i] = 1 / w[i] = 0
|
||||
- Eligibility trace = which weight bits were active when the shot was fired
|
||||
- Wave hit reward = delayed reward signal
|
||||
- Update: for active neurons on correct output → reinforce their weight bits that matched
|
||||
|
||||
### Concrete update rule (software sketch)
|
||||
```nim
|
||||
# On wave hit:
|
||||
# active_bits[i] = which input bits were 1 when this wave was fired
|
||||
# reward = 1.0 - (miss_distance / max_miss) # from wave system
|
||||
|
||||
for i in 0..<WEIGHT_BITS:
|
||||
if active_bits[i] and reward > 0.0:
|
||||
weights[i] = 1 # SET: pre and post active, positive reward
|
||||
elif active_bits[i] and reward < 0.0:
|
||||
weights[i] = 0 # RESET: active but wrong prediction
|
||||
# inactive bits: no change (Hebbian locality)
|
||||
```
|
||||
|
||||
### Strengths
|
||||
- Naturally online, one update per wave hit
|
||||
- Locality: each weight updates from local pre/post activity only
|
||||
- Delayed reward handled by eligibility trace — no need to hold full state
|
||||
|
||||
### Weaknesses
|
||||
- Binary weights = coarse; capacity scales with weight count not precision
|
||||
- No credit through layers — only the output neuron's weights get updated
|
||||
- Eligibility trace must be stored per weight per in-flight wave (memory cost)
|
||||
|
||||
---
|
||||
|
||||
## 2. FPGA / Evolvable Hardware
|
||||
|
||||
### How it works in hardware
|
||||
An FPGA is a fabric of LUTs (Look-Up Tables) connected by a programmable routing
|
||||
network. A K-LUT implements any K-input Boolean function by storing 2^K bits.
|
||||
Intrinsic evolution: the actual FPGA bitstream (which LUTs do what, how they connect)
|
||||
is treated as a genome. A genetic algorithm mutates it, measures fitness on real
|
||||
hardware (actual timing, actual noise), and selects survivors.
|
||||
|
||||
The key insight from Thompson (1996): intrinsic evolution finds solutions that exploit
|
||||
physical properties of the silicon that no designer would think to encode — clock
|
||||
leakage, capacitive coupling across supposedly-disconnected wires. The circuit
|
||||
"knows" things about its substrate that the designer doesn't model.
|
||||
|
||||
### Core algorithmic principle
|
||||
**Genetic search over discrete configuration space.** No gradient — just:
|
||||
1. Mutate bitstream (flip random bits)
|
||||
2. Measure fitness on hardware
|
||||
3. Keep better configurations, discard worse
|
||||
4. Repeat
|
||||
|
||||
For LUT-based learning (LUTNet, WNN/WiSARD): treat each LUT's truth table as
|
||||
writable memory. Training = writing new entries to LUTs. A K-input LUT can learn
|
||||
any K-variable Boolean function in a single write — no iterative optimization needed
|
||||
for patterns it has seen.
|
||||
|
||||
### Mapping to BNNBot
|
||||
Each "neuron" in our network is a boolean function of its binary inputs.
|
||||
An LUT IS the truth table for that function. Instead of storing a weight vector
|
||||
and doing popcount, we store the actual input→output mapping.
|
||||
|
||||
For n inputs: LUT has 2^n entries. But n=690 is way too large.
|
||||
Solution: each LUT sees only k<<690 bits (chosen by connectivity pattern).
|
||||
The 690-bit input is partitioned into chunks; each LUT learns its local chunk.
|
||||
|
||||
For online reward-based LUT update:
|
||||
- Record input index (the k-bit address into the LUT) when shot was fired
|
||||
- On wave hit: write output[address] = 1 if reward > threshold, else 0
|
||||
- This is exactly one-shot learning — the LUT "memorizes" each input pattern
|
||||
|
||||
### Concrete update rule
|
||||
```nim
|
||||
const K = 16 # LUT arity — covers 2^16 = 65536 patterns
|
||||
# lut: array[2^K, bool]
|
||||
|
||||
# On shot fired:
|
||||
let addr = extract_k_bits(input_690bit, chosen_indices, K)
|
||||
pending_updates.add((addr, wave_id))
|
||||
|
||||
# On wave hit:
|
||||
let (addr, _) = pending_updates[wave_id]
|
||||
lut[addr] = (miss_distance < HIT_THRESHOLD)
|
||||
```
|
||||
|
||||
### Strengths
|
||||
- One-shot learning: each (input pattern → outcome) pair stored directly
|
||||
- Zero arithmetic: inference is a table lookup, O(1), nanoseconds
|
||||
- LUT generalizes to unseen inputs via nearest neighbor in address space
|
||||
|
||||
### Weaknesses
|
||||
- 2^K memory per LUT — exponential in K. K=16 → 8KB per neuron.
|
||||
- With K=16 and 690 inputs, coverage per LUT is sparse (690/16 = ~43 non-overlapping LUTs)
|
||||
- Cold start: empty LUTs output 0; need warmup before predictions are useful
|
||||
- No generalization across different address patterns (each address independent)
|
||||
|
||||
---
|
||||
|
||||
## 3. Hopfield Networks — Energy Minimization
|
||||
|
||||
### How it works in hardware
|
||||
A Hopfield network is a fully connected binary recurrent network. Each node is +1/-1.
|
||||
Update rule: `s_i = sign(Σ_j W_ij × s_j)`. Weights are symmetric (W_ij = W_ji).
|
||||
The network has a Lyapunov energy function `E = -½ Σ W_ij s_i s_j`.
|
||||
Asynchronous updates monotonically decrease E → network converges to a local minimum.
|
||||
No gradient needed — local update decreases global energy by construction.
|
||||
|
||||
### Core algorithmic principle
|
||||
**Pattern as energy minimum.** Training stores patterns p by:
|
||||
`W_ij = (1/N) Σ_patterns p_i × p_j` (Hebbian outer product, no gradient).
|
||||
Retrieval: start from noisy/partial pattern, run updates → snaps to nearest stored pattern.
|
||||
The network "completes" corrupted inputs.
|
||||
|
||||
### Mapping to BNNBot
|
||||
Treat the prediction problem as pattern completion:
|
||||
- Input: partial state (last 10 radar scans = 690 bits)
|
||||
- Stored patterns: historical (input_context, correct_output) pairs
|
||||
- Query: clamp input bits, let output bits relax to minimum energy
|
||||
|
||||
This IS associative memory — we've seen this state-like context before, what happened?
|
||||
|
||||
Storing a (context → outcome) association:
|
||||
```nim
|
||||
# After wave hit with known outcome:
|
||||
let pattern = concat(input_690bit, outcome_69bit) # 759-bit pattern
|
||||
# Hebbian weight update (outer product, only for active bits):
|
||||
for i in active_bits(pattern):
|
||||
for j in active_bits(pattern):
|
||||
W[i][j] += 1.0 / N # symmetric
|
||||
```
|
||||
|
||||
Inference: clamp input 690 bits, iterate output 69 bits until convergence.
|
||||
|
||||
### Strengths
|
||||
- Convergence guaranteed (for symmetric W, no self-loops)
|
||||
- Naturally handles noisy/incomplete inputs — good for sensor noise
|
||||
- No gradient, no explicit credit assignment needed
|
||||
- OscNet v1.5 showed Hopfield runs forward-pass-only on hardware
|
||||
|
||||
### Weaknesses
|
||||
- Capacity: standard Hopfield stores ≈0.14N patterns for N nodes
|
||||
With N=759: only ~106 distinct (context, outcome) pairs — very limited
|
||||
- O(N²) weight matrix: 759² = 576K entries for float weights
|
||||
- Spurious minima: can settle to wrong pattern if too many stored
|
||||
- Modern dense Hopfield (transformer attention) has exponential capacity but requires softmax
|
||||
|
||||
---
|
||||
|
||||
## 4. Weightless Neural Networks (WNN / WiSARD)
|
||||
|
||||
### How it works in hardware
|
||||
A WNN neuron (RAM node) is literally an n-input lookup table with learned 1-bit entries.
|
||||
No multiplication, no addition — just memory address lookup. Training: present input,
|
||||
write 1 at that address. Inference: read address, return stored bit.
|
||||
|
||||
WiSARD (1981, commercial 1984): the original binary pattern recognizer.
|
||||
Each RAM node sees k randomly-chosen bits from the input. Multiple RAM nodes
|
||||
vote (sum of outputs) to produce a confidence score per class.
|
||||
|
||||
### Core algorithmic principle
|
||||
**Address-based memorization.** The n-input binary vector IS the memory address.
|
||||
Learning = `memory[address] = label`. No parameters to optimize, no loss surface.
|
||||
Generalization comes from the probabilistic overlap of binary addresses.
|
||||
|
||||
For online RL adaptation: instead of one-shot supervised write, count-based update:
|
||||
`memory[address] += reward_signal` then threshold. This is exactly a frequency table
|
||||
— "how often did this input pattern lead to a hit?"
|
||||
|
||||
### Mapping to BNNBot
|
||||
This is the most direct hardware→software translation:
|
||||
|
||||
```nim
|
||||
const K = 20 # bits per RAM node
|
||||
const N_NODES = 35 # 35 × 20 = 700 > 690
|
||||
# Each node: table[2^20] of int8, initialized to 0
|
||||
|
||||
# Index mapping: for each node, which 20 of 690 bits does it observe?
|
||||
# Fixed random permutation, same across all shots.
|
||||
|
||||
# On wave hit:
|
||||
for node in 0..<N_NODES:
|
||||
let addr = read_k_bits(input_690, node_mapping[node], K)
|
||||
let delta = if hit: +1 else: -1
|
||||
tables[node][addr] = clamp(tables[node][addr] + delta, -127, 127)
|
||||
|
||||
# Inference: which output direction gets highest vote?
|
||||
for each candidate_direction:
|
||||
score = 0
|
||||
for node in 0..<N_NODES:
|
||||
let addr = read_k_bits(input_690, node_mapping[node], K)
|
||||
score += tables[node][addr]
|
||||
if score > best_score: best_direction = candidate_direction
|
||||
```
|
||||
|
||||
### Strengths
|
||||
- Inference: pure memory lookup, O(N_NODES) — easily under 1ms
|
||||
- Online learning: one table write per wave hit
|
||||
- No cold-start paralysis — zero score = no preference, falls back to baseline
|
||||
- K=20 handles 2^20 = 1M patterns per node — generous capacity
|
||||
- Naturally compositional: each node learns a different k-bit "feature"
|
||||
|
||||
### Weaknesses
|
||||
- Memory: 35 nodes × 2^20 × 1 byte = 35 MB. Large but feasible.
|
||||
With K=16: 35 × 64KB = 2.2MB. More practical.
|
||||
- Random k-bit projections may not capture the most informative bit combinations
|
||||
(vs. learned projections in LUTNet-style approaches)
|
||||
- No cross-node generalization: two patterns differing in one bit observed by the same
|
||||
node = completely different addresses
|
||||
|
||||
**Note:** WNN with reward-based counting is the closest software analog to what
|
||||
memristor crossbars do in hardware — the table IS the synapse.
|
||||
|
||||
---
|
||||
|
||||
## 5. Belief Propagation on Factor Graphs (LDPC / Turbo codes)
|
||||
|
||||
### How it works in hardware
|
||||
LDPC decoding: received bits are noisy versions of codeword bits. The decoder has
|
||||
a factor graph: variable nodes (bits) and check nodes (parity constraints).
|
||||
Messages pass back and forth: each node sends to neighbors "given what I know, here's
|
||||
my probability estimate of your value." After ~50 iterations, converge to most likely codeword.
|
||||
|
||||
Hardware decoders run BP in a pipelined dataflow — no global state, purely local message updates.
|
||||
|
||||
### Core algorithmic principle
|
||||
**Iterative marginal inference.** Each variable node holds a log-likelihood ratio (LLR).
|
||||
Update rule for variable node x_i receiving messages m_{j→i} from check nodes j:
|
||||
```
|
||||
LLR_i = channel_LLR_i + Σ_j m_{j→i}
|
||||
m_{i→k} = LLR_i - m_{k→i} # exclude message from k before sending back
|
||||
```
|
||||
No gradient. Convergence is guaranteed on tree-structured graphs; approximate on loopy graphs.
|
||||
|
||||
### Mapping to BNNBot
|
||||
The 690-bit input has structure — bits are correlated (sin/cos pairs, position from velocity,
|
||||
etc.). BP could exploit this structure for inference without learning.
|
||||
|
||||
Concrete use: model the 69-bit output (next position frame) as hidden variables.
|
||||
Observed: 690-bit input. Factor graph: local constraints from physics (velocity ×
|
||||
ticks = displacement, heading consistency). Run BP to infer most-likely output.
|
||||
|
||||
This is not a learning mechanism — it's inference. But it applies to our problem:
|
||||
the physics of enemy movement IS the factor graph. No training needed if the
|
||||
constraints are correct.
|
||||
|
||||
### Concrete sketch
|
||||
```nim
|
||||
# Factor: expected_x[t+1] = x[t] + vx[t] * speed
|
||||
# Factor: heading changes slowly (soft constraint, variance from data)
|
||||
# Observed: x[t], y[t], vx[t], vy[t] from radar scans
|
||||
|
||||
# For each output bit o_i:
|
||||
# LLR[i] = initial estimate from linear extrapolation
|
||||
# Messages from physics factors update LLR iteratively
|
||||
# Final: sign(LLR[i]) = predicted bit
|
||||
```
|
||||
|
||||
### Strengths
|
||||
- Exploits problem structure (physics) explicitly — not black-box learning
|
||||
- Iterative refinement: run more iterations when time allows
|
||||
- Error-correcting codes achieve Shannon capacity with BP — proven near-optimal
|
||||
|
||||
### Weaknesses
|
||||
- Requires knowing the factor structure (constraint graph) — domain engineering needed
|
||||
- Our enemy's movement IS physics, but also strategy (evasion) — hard to model as factors
|
||||
- Less useful as a "learning" mechanism; more useful as a structured inference method
|
||||
- Loopy BP on dense graphs may not converge
|
||||
|
||||
---
|
||||
|
||||
## 6. Sigma-Delta Modulation — Feedback Tracking
|
||||
|
||||
### How it works in hardware
|
||||
A sigma-delta (ΣΔ) modulator converts analog input to a binary bit stream.
|
||||
Architecture: integrator → 1-bit comparator → feedback DAC.
|
||||
The comparator outputs 1 if accumulator > 0, else 0. The 1-bit output is fed back
|
||||
and subtracted from the input. The accumulator tracks the error (sigma = cumulative,
|
||||
delta = difference). Output bit stream: density encodes analog value.
|
||||
|
||||
### Core algorithmic principle
|
||||
**Error-accumulating feedback.** The system never "knows" the true analog value —
|
||||
it only knows the sign of accumulated error. It corrects continuously:
|
||||
```
|
||||
accumulator += (input - feedback)
|
||||
output_bit = (accumulator > 0) ? 1 : 0
|
||||
feedback = output_bit ? +1 : -1
|
||||
```
|
||||
This is a 1-bit quantizer with infinite-precision error memory. The feedback loop
|
||||
drives the accumulated error to zero over time — the bit stream density equals the
|
||||
input value.
|
||||
|
||||
### Mapping to BNNBot
|
||||
The analogy: our prediction is a "bit stream" (sequence of predictions).
|
||||
The wave hit system gives us the sign of the error (too far left? too far right?).
|
||||
We accumulate signed errors and correct the prediction offset continuously.
|
||||
|
||||
This is closer to what our existing Hebbian residual table does — but the ΣΔ
|
||||
formulation is cleaner:
|
||||
|
||||
```nim
|
||||
# Per directional axis (x and y):
|
||||
var accumulator_x: float = 0.0
|
||||
var accumulator_y: float = 0.0
|
||||
|
||||
# On wave hit:
|
||||
let error_x = actual_x - predicted_x
|
||||
let error_y = actual_y - predicted_y
|
||||
|
||||
accumulator_x += error_x
|
||||
accumulator_y += error_y
|
||||
|
||||
# Correction for next prediction:
|
||||
correction_x = sign(accumulator_x) * correction_step # 1-bit correction
|
||||
# Or: correction_x = clamp(accumulator_x * gain, -max_corr, max_corr) # proportional
|
||||
```
|
||||
|
||||
The ΣΔ insight: **you don't need the full error magnitude, just its sign.**
|
||||
The accumulation of signs over time encodes the magnitude.
|
||||
|
||||
### Strengths
|
||||
- Minimal state: just one accumulator per axis
|
||||
- Noise-shaping: high-frequency jitter averages out; low-frequency bias accumulates correctly
|
||||
- Robust to measurement noise (sign of error is reliable even when magnitude is noisy)
|
||||
|
||||
### Weaknesses
|
||||
- Slow convergence if correction step is too small
|
||||
- Tracks only a DC offset (systematic bias), not complex patterns
|
||||
- Best as a correction layer on top of a better predictor, not standalone
|
||||
|
||||
---
|
||||
|
||||
## 7. Phase-Locked Loop (PLL) — Trajectory Tracking
|
||||
|
||||
### How it works in hardware
|
||||
A PLL: phase detector compares incoming signal phase to VCO output phase.
|
||||
Error signal (phase difference) feeds through a loop filter to the VCO control input.
|
||||
VCO adjusts frequency until phase error → 0. Locked: VCO tracks input frequency and phase.
|
||||
|
||||
Components: Phase Detector (XOR or mixer), Loop Filter (low-pass), VCO.
|
||||
No gradient — just: am I ahead or behind? Correct proportionally.
|
||||
|
||||
### Core algorithmic principle
|
||||
**Proportional-integral control on phase error.** PI loop filter:
|
||||
```
|
||||
phase_error = input_phase - vco_phase
|
||||
control_voltage += Kp * phase_error + Ki * integral(phase_error)
|
||||
vco_frequency = f0 + K_vco * control_voltage
|
||||
```
|
||||
This IS a gradient-free optimizer for tracking. It converges when phase_error = 0.
|
||||
Equivalent to online least-mean-squares for frequency estimation.
|
||||
|
||||
### Mapping to BNNBot
|
||||
Enemy position is a trajectory in 2D. Our aiming angle is a phase relative to that trajectory.
|
||||
A PLL-like system: track the rate of change of enemy heading (angular velocity).
|
||||
|
||||
```nim
|
||||
# "Phase" = enemy heading direction
|
||||
# "VCO" = our predicted heading trend
|
||||
# "Lock" = our trend matches enemy trend
|
||||
|
||||
var predicted_angular_velocity: float = 0.0
|
||||
var phase_error_integral: float = 0.0
|
||||
const Kp = 0.3
|
||||
const Ki = 0.1
|
||||
|
||||
# On each radar scan:
|
||||
let actual_angular_velocity = delta_heading / delta_time
|
||||
let phase_error = actual_angular_velocity - predicted_angular_velocity
|
||||
|
||||
phase_error_integral += phase_error
|
||||
predicted_angular_velocity += Kp * phase_error + Ki * phase_error_integral
|
||||
```
|
||||
|
||||
When the enemy moves at constant angular velocity (orbit, spiral), this "locks on"
|
||||
and predicts ahead by extrapolating the locked phase.
|
||||
|
||||
### Strengths
|
||||
- Handles periodic/oscillatory motion natively (enemy orbiting = pure sine wave)
|
||||
- Acquisition (from cold) + tracking (once locked) are separate phases — known behavior
|
||||
- Loop filter order can be tuned: 1st order = tracks constant heading, 2nd = tracks constant angular acceleration
|
||||
|
||||
### Weaknesses
|
||||
- Assumes quasi-periodic or smooth trajectory; breaks on jerky evasion
|
||||
- Loop bandwidth tradeoff: wide bandwidth tracks fast changes but amplifies noise
|
||||
- Enemy headings in Robocode are piecewise linear, not sinusoidal — PLL is mismatched model
|
||||
unless enemy orbits, which some do
|
||||
|
||||
---
|
||||
|
||||
## 8. Stochastic Computing
|
||||
|
||||
### How it works in hardware
|
||||
Represent numbers as the probability that a bit in a random stream is 1.
|
||||
x = 0.7 → 70% of bits are 1 in a random stream. Then:
|
||||
- Multiplication: AND(stream_x, stream_y) → probability = x × y
|
||||
- Addition (scaled): MUX(stream_x, stream_y, select) → (x + y)/2
|
||||
- Dot product: AND all streams, OR results
|
||||
|
||||
All operations are single-gate logic. No carry chains, no multipliers.
|
||||
Inference hardware is tiny. Accuracy scales with stream length (more bits = more precise).
|
||||
|
||||
### Core algorithmic principle
|
||||
**Probability represented as bit density.** The number IS the stream.
|
||||
Computation IS gate operations on streams.
|
||||
|
||||
Weight update in stochastic computing:
|
||||
```
|
||||
Δw_ij = AND(activation_i_stream, error_j_stream)
|
||||
```
|
||||
This computes the product of two probabilities using an AND gate.
|
||||
The learning rule IS Hebbian — coincidence detection between pre and post streams.
|
||||
|
||||
### Mapping to BNNBot
|
||||
Our 690-bit input is already binary — but not stochastic (each bit is deterministic).
|
||||
However, stochastic computing suggests a different representation:
|
||||
instead of Gray-coded positions, represent uncertainty as bit-stream density.
|
||||
|
||||
Alternatively: treat each weight as a stochastic bit (1 with probability p).
|
||||
Inference = sample weights → compute output → measure hit → update p.
|
||||
This is essentially WNN with probabilistic weights.
|
||||
|
||||
Concrete weight update:
|
||||
```nim
|
||||
# Each weight w[i] is a probability stored as float in [0,1]
|
||||
# On shot fired: sample binary weights: sampled[i] = rand() < w[i]
|
||||
# On wave hit:
|
||||
for i in active_neurons:
|
||||
w[i] += learning_rate * reward * (sampled[i] - w[i])
|
||||
# REINFORCE-like: push probability toward 1 if it fired and reward was positive
|
||||
```
|
||||
|
||||
### Strengths
|
||||
- Noise is a feature, not a bug — exploration built in
|
||||
- Multiplication = AND, the cheapest gate — scales to large networks
|
||||
- Graceful degradation: shorter streams = noisier but not broken
|
||||
|
||||
### Weaknesses
|
||||
- Long streams needed for precision: 8-bit precision needs 2^8=256 clock cycles per number
|
||||
- Correlated streams corrupt statistics (must use truly independent random sources)
|
||||
- Slower than binary networks for same precision; only wins on hardware area
|
||||
|
||||
---
|
||||
|
||||
## Synthesis: What Hardware Knows That Software Has Forgotten
|
||||
|
||||
### 1. Locality is not a limitation — it's the design
|
||||
Every hardware learning rule (STDP, Hebbian, LUT write, ΣΔ correction) updates
|
||||
using only information at the site of the computation. No global loss function.
|
||||
Software tries to compensate for locality (backprop broadcasts global gradient).
|
||||
Hardware makes locality a feature: each synapse computes its own update.
|
||||
|
||||
**Implication for BNNBot:** the wave hit system IS the non-local signal.
|
||||
Use it sparingly, like a neuromodulator: it modulates the sign/scale of local updates,
|
||||
but the local activity traces must already exist at the synapse.
|
||||
|
||||
### 2. Eligibility traces solve the temporal credit assignment problem without backprop
|
||||
The hardware solution to "which synapse caused the reward 10 ticks later":
|
||||
every recently-active synapse maintains a decaying trace. When reward arrives,
|
||||
it multiplies the trace. Traces decay in hardware via RC circuits.
|
||||
|
||||
**Implication:** for BNNBot, each in-flight wave needs to carry the eligibility trace
|
||||
of which neurons fired when it was spawned. The wave system already stores the shot
|
||||
context — add which neurons/weights were active.
|
||||
|
||||
### 3. The LUT IS the function approximator
|
||||
A K-LUT can represent any K-variable Boolean function. There's nothing to train
|
||||
in the gradient sense — you just write the truth table entry for each observed pattern.
|
||||
This is the most efficient possible function approximator for discrete inputs.
|
||||
|
||||
**Implication:** WNN/WiSARD with reward-based table updates is the direct software
|
||||
implementation of what hardware learning does. It's not an approximation of gradient
|
||||
descent — it's a different algorithm entirely, and it's O(1) per update.
|
||||
|
||||
### 4. Energy minimization is free in recurrent hardware
|
||||
Hopfield/Ising machines settle to energy minima by running physics.
|
||||
Software has to simulate this expensively. But for our problem, the "energy landscape"
|
||||
is implicit in our wave data — we just need the right representation.
|
||||
|
||||
**Implication:** the Hopfield associative memory is most useful as a pattern completion
|
||||
engine for "I've seen this state context before" — i.e., case-based reasoning over
|
||||
battle history.
|
||||
|
||||
### 5. Sigma-Delta: you only need the sign of accumulated error
|
||||
The entire ΣΔ insight is that a 1-bit quantizer + integrator converges to the
|
||||
correct value. We are throwing away information by keeping full-precision errors when
|
||||
a signed accumulator does the same job.
|
||||
|
||||
**Implication:** the existing Hebbian residual table could be replaced by a ΣΔ
|
||||
correction accumulator — simpler, same convergence, more noise-robust.
|
||||
|
||||
---
|
||||
|
||||
## Priority Ranking for BNNBot
|
||||
|
||||
| Mechanism | Fit | Cost | Priority |
|
||||
|-----------|-----|------|----------|
|
||||
| WNN/WiSARD (LUT-based) | High — directly maps to binary input + wave reward | Medium (memory) | **1st** |
|
||||
| Three-factor / eligibility traces | High — solves delayed credit assignment | Low (add trace to wave struct) | **2nd** |
|
||||
| ΣΔ correction accumulator | High — replaces/improves Hebbian residual table | Very low | **3rd** |
|
||||
| PLL trajectory tracking | Medium — works for orbiting enemies | Low | **4th** |
|
||||
| Hopfield associative memory | Medium — limited capacity, O(N²) weights | High | **5th** |
|
||||
| Belief propagation | Low — requires manual factor graph design | Medium | **6th** |
|
||||
| Stochastic computing | Low — representation mismatch with deterministic bits | Medium | **7th** |
|
||||
| Evolvable hardware / GA | Very Low — too slow for online single-battle learning | Very High | skip |
|
||||
|
||||
---
|
||||
|
||||
## Most Actionable Finding
|
||||
|
||||
**WNN (Weightless Neural Network) with reward-counted tables** is the closest
|
||||
direct translation of hardware learning to software. It:
|
||||
- Requires zero multiplication (lookup only)
|
||||
- Learns online from wave hits in one write per hit
|
||||
- Naturally handles the 690-bit binary input
|
||||
- Has proven capacity for pattern recognition (WiSARD commercial since 1984)
|
||||
- The "neurons" are literally memory addresses — no parameters to tune
|
||||
|
||||
With K=16 bits per RAM node and 45 nodes: 45 × 64KB = 2.9MB RAM, sub-microsecond
|
||||
inference. This is the most direct hardware-inspired solution that respects all
|
||||
BNNBot constraints.
|
||||
@@ -0,0 +1,606 @@
|
||||
# Discrete Mathematics Lens on BNNBot
|
||||
|
||||
**Context**: 690-bit binary input (Gray-coded, 10-frame temporal window), online learning, reward =
|
||||
miss distance from circular wave feedback. No gradient descent. Binary weights/activations.
|
||||
|
||||
---
|
||||
|
||||
## Structural Properties of Our Binary Space (Read First)
|
||||
|
||||
Before any framework, pin down what structure the 690-bit input *already has*. These properties
|
||||
constrain which mathematical tools apply and where untapped leverage exists.
|
||||
|
||||
### Gray Coding = Embedded Metric Structure
|
||||
|
||||
Gray code is an isometry between adjacent integers and Hamming-1 neighbors. For our encoding:
|
||||
- `x_t → x_t + δ` in physics space maps to `Gray(x_t) → Gray(x_t + δ)` with Hamming distance ≈ 1
|
||||
per bit-field (vs up to log2(n) for binary encoding)
|
||||
- **Consequence**: physically similar states are Hamming-close states. The input manifold has
|
||||
Lipschitz-like smoothness in Hamming metric. Any distance-based hash, nearest-neighbor lookup, or
|
||||
locality-sensitive scheme exploits this for free.
|
||||
- **Not exploiting this**: our Hebbian residual table uses only 24 cells (8 heading sectors × 3
|
||||
distance bands). The cells discretize the continuous physics space, but ignore the Hamming metric
|
||||
structure entirely. A hash-based retrieval over the full 690-bit vector would be more precise.
|
||||
|
||||
### Temporal Redundancy (10 frames × 69 bits)
|
||||
|
||||
Consecutive frames differ by ~1 enemy move. Gray-coded, that means Hamming distance between
|
||||
frame i and frame i+1 ≈ 3-6 bits out of 69. The 690-bit vector has:
|
||||
- **Strong temporal autocorrelation**: I(f_t; f_{t-1}) ≈ high (most bits identical tick-to-tick)
|
||||
- **True information content < 690 bits**: an MDL estimate is ~69 bits (one frame) for near-constant
|
||||
velocity movement plus ~6-8 bits for heading+speed change. The 10× redundancy is useful for noise
|
||||
robustness but the *irreducible information* is small.
|
||||
- **Implication**: a model that learns which bits *change* between frames carries more signal than one
|
||||
treating all 690 bits uniformly. Temporal XOR (frame[t] ⊕ frame[t-1]) compresses the motion into
|
||||
~6-10 bits per step.
|
||||
|
||||
### Sparsity (10/24 residual cells active, observed)
|
||||
|
||||
The data shows only ~10 out of 24 residual cells activate meaningfully. This suggests the function
|
||||
mapping input → correction is **sparse in some basis**. The true prediction correction depends on a
|
||||
small number of input features. This is compressed-sensing territory: the signal is k-sparse in some
|
||||
unknown basis with k << 690.
|
||||
|
||||
### Linearity Obstacle in GF(2)
|
||||
|
||||
XOR layers are linear over GF(2). XOR + popcount + threshold is the minimal non-linear binary
|
||||
neuron. Any network restricted to XOR-only layers computes an affine function over GF(2), which
|
||||
cannot represent the non-linear corrections needed. The algebraic normal form of any Boolean function
|
||||
requires at least degree-2 monomials (AND of two variables) to be non-affine. Our residual correction
|
||||
IS non-linear in the input (it depends on distance × heading interaction), so linear-over-GF(2)
|
||||
architectures are fundamentally insufficient.
|
||||
|
||||
---
|
||||
|
||||
## Framework 1: Boolean Function Learning (PAC / Fourier Analysis)
|
||||
|
||||
### Mathematical Framework
|
||||
|
||||
Every Boolean function f: {0,1}^n → {-1,+1} has a unique representation as a multilinear polynomial
|
||||
(the Walsh-Fourier expansion):
|
||||
|
||||
f(x) = Σ_{S ⊆ [n]} f̂(S) · χ_S(x)
|
||||
|
||||
where χ_S(x) = Π_{i∈S} (1 - 2x_i) is a parity function over subset S, and f̂(S) are real Fourier
|
||||
coefficients. The sum of squared coefficients is 1: Σ f̂(S)² = 1 (Parseval).
|
||||
|
||||
**PAC learnability classes (Valiant 1984)**:
|
||||
- k-CNF and k-DNF (bounded clause width): efficiently PAC-learnable in poly time
|
||||
- Monotone conjunctions: learnable
|
||||
- General DNF: open problem; likely hard (hardness results by Klivans & Servedio, 2004)
|
||||
- Decision trees of depth d: learnable from Fourier spectrum
|
||||
- **Halfspaces (linear threshold functions)**: poly-time learnable (perceptron)
|
||||
- **Majorities, parities of few bits**: learnable; sparse Fourier spectrum
|
||||
|
||||
Key result for us: a function is efficiently PAC-learnable iff it has a **sparse low-degree Fourier
|
||||
spectrum** (KM algorithm, Kushilevitz & Mansour 1993). The SPRIGHT algorithm recovers K-sparse WHT
|
||||
in O(K n log n) samples.
|
||||
|
||||
### Mapping to 690-bit → Predicted Position
|
||||
|
||||
Our output is not Boolean but real-valued (predicted x,y correction). We can still ask: what is the
|
||||
structure of the Fourier spectrum of, say, the indicator function "will this input lead to a hit?"
|
||||
Given that 10/24 sectors activate and the function appears to depend on a small number of features,
|
||||
hypothesis: **the hit-prediction function has a sparse, low-degree Fourier spectrum**.
|
||||
|
||||
Key consequence: if the function is concentrated on degree-≤2 Fourier coefficients, it is
|
||||
approximable by a sum of pairwise interactions — which maps directly to a Boltzmann machine or
|
||||
second-order Hebbian network.
|
||||
|
||||
### Update Rule Sketch
|
||||
|
||||
Run a sparse Walsh-Hadamard transform incrementally:
|
||||
1. Maintain counters c_S for each "candidate" subset S (start with S = singletons + pairs)
|
||||
2. On each wave feedback: c_S += hit? ? +1 : -1 for each S where χ_S(x) = +1
|
||||
3. Top-K coefficients define a linear predictor over parity features
|
||||
4. Prediction: ŷ = Σ_S∈top-K ĉ_S · χ_S(x) (cast to position offset)
|
||||
|
||||
This is **online Fourier learning**. The KM algorithm suggests O(n/ε²) samples for ε-approximation
|
||||
of sparse functions.
|
||||
|
||||
### Computational Cost
|
||||
|
||||
Tracking singletons: O(n) = O(690) counters, trivial. Tracking pairs: O(n²) = O(476K) — borderline.
|
||||
Tracking triples: O(n³) — infeasible. Practical: limit to degree-1 (linear) + degree-2 (pairwise)
|
||||
terms and test if this captures the signal. Expected O(1000) battle samples to recover top-10
|
||||
coefficients if the function has 10-sparse Fourier spectrum.
|
||||
|
||||
### Untapped Structure
|
||||
|
||||
Gray coding means adjacent input values differ by Hamming-1. In Fourier space, a Gray-smooth function
|
||||
has Fourier weight concentrated at **low-frequency (small S) coefficients**. This is the Grey-code
|
||||
smoothness guarantee translating to Fourier sparsity at low degree. We should be able to identify
|
||||
the top-K coefficients with far fewer samples than general Boolean functions because smoothness
|
||||
bounds the spectrum.
|
||||
|
||||
---
|
||||
|
||||
## Framework 2: Combinatorial Bandits on the Binary Hypercube
|
||||
|
||||
### Mathematical Framework
|
||||
|
||||
A multi-armed bandit selects actions from an action set A. In the combinatorial bandit setting
|
||||
(Chen et al. 2013, Kveton et al. 2015), each action is a subset of "base arms" (bits), with reward
|
||||
that decomposes over the selected set. Regret bound: O(√(KT log K)) for CombLinUCB where K = number
|
||||
of active bits and T = rounds.
|
||||
|
||||
For binary weight vectors, the action is a weight configuration w ∈ {0,1}^N, reward R(w) = hit
|
||||
rate. This is a bandit over an exponential action space — we need structure to make it tractable.
|
||||
|
||||
**Thompson Sampling (binary/Bernoulli)**: each weight w_i has Beta(α_i, β_i) posterior on its
|
||||
contribution to reward. Sample θ_i ~ Beta(α_i, β_i), set w_i = 1 if θ_i > 0.5, observe reward.
|
||||
Update: α_i += hit, β_i += miss. This is the simplest online binary learning rule that is
|
||||
principled under uncertainty.
|
||||
|
||||
### Mapping to Aiming
|
||||
|
||||
Reframe: each "arm" is not a single weight but a **candidate aiming strategy** — a specific
|
||||
correction (Δx, Δy) to add to linear extrapolation. The bandit chooses which correction to apply
|
||||
given input context x. Reward = did the bullet hit?
|
||||
|
||||
This is a **contextual bandit** (the reward depends on x). For contextual bandits with binary
|
||||
context, the LinUCB / LinTS extensions apply.
|
||||
|
||||
**Practical sketch**: Discretize corrections into B bins (e.g., 50 bins per axis = 2500 joint
|
||||
corrections). For each bin b, track Beta(α_b, β_b). Given input x, compute a context-conditioned
|
||||
expected reward E[R | x, b] via Thompson sampling on the posterior. This gives a Bayesian bandit
|
||||
over correction bins — exactly what the Hebbian residual table approximates, but with proper
|
||||
uncertainty quantification and exploration.
|
||||
|
||||
### Update Rule Sketch
|
||||
|
||||
# Per wave-hit event:
|
||||
b* = current correction bin (from predicted position)
|
||||
if hit:
|
||||
α[b*] += 1
|
||||
else:
|
||||
# reward is shaped by miss distance
|
||||
α[b*] += exp(-miss_distance / σ)
|
||||
β[b*] += 1 - exp(-miss_distance / σ)
|
||||
|
||||
# Prediction:
|
||||
sample θ_b ~ Beta(α_b, β_b) for each b
|
||||
b_chosen = argmax_{b} f(x, b, θ_b) # context-weighted Thompson sampling
|
||||
|
||||
### Computational Cost and Convergence
|
||||
|
||||
Beta updates: O(1) per arm per round. Sample from Beta: O(1). With B correction bins, total per-tick
|
||||
cost: O(B). Convergence: Thompson sampling achieves O(√(BT log B)) regret (Agrawal & Goyal 2013),
|
||||
meaning after T=1000 battle ticks, expected suboptimality ≈ O(√(B · 1000 · log B)). For B=100,
|
||||
this is ~O(300) — significant but manageable for a battle that repeats.
|
||||
|
||||
**Key advantage over current table**: Thompson sampling maintains per-bin uncertainty and
|
||||
auto-balances exploration/exploitation. The current Hebbian table uses fixed lr=0.2 with no
|
||||
exploration bonus — it may get stuck in local optima in bins with few observations.
|
||||
|
||||
---
|
||||
|
||||
## Framework 3: Binary Optimization Without Gradients
|
||||
|
||||
### Simulated Annealing on Weight Vectors
|
||||
|
||||
SA on {-1,+1}^N: at temperature T, flip weight w_i with acceptance probability min(1, exp(-ΔE/T)).
|
||||
Energy E = cumulative miss distance over recent battles. Schedule: T(t) = T_0 / log(1+t).
|
||||
|
||||
**Convergence theory**: SA converges to global optimum in probability if T→0 sufficiently slowly.
|
||||
In practice, for binary problems with N=690 weights, O(N² log N) iterations needed for reliable
|
||||
convergence — infeasible within a 1000-tick battle.
|
||||
|
||||
**Practical use**: SA is viable for the *small* residual table (24 cells × 2 floats = 48 params).
|
||||
Current lr=0.2 Hebbian update is essentially SA with constant temperature. Adding a cooling schedule
|
||||
would improve final-state quality at the cost of slower convergence.
|
||||
|
||||
**Key formula**: for binary weights, ΔE per bit flip is the reward delta from that flip. This is
|
||||
exactly weight perturbation (Method 6 in learning_methods_report.md). SA IS weight perturbation
|
||||
with a temperature schedule.
|
||||
|
||||
### Tabu Search
|
||||
|
||||
Maintain a tabu list of recently visited weight configurations. At each step, flip the bit that
|
||||
most improves reward while not being on the tabu list. The tabu list prevents cycling.
|
||||
|
||||
For the 24-cell residual table, tabu search is practical. For the full BNN weight matrix (N >> 24),
|
||||
the tabu list overhead grows prohibitively. Recent work (2023, ScienceDirect) shows tabu search
|
||||
exploiting local optimality in binary problems achieves better solutions than SA when the objective
|
||||
has many local optima — which is plausible for a non-stationary opponent.
|
||||
|
||||
**Convergence**: guaranteed if neighborhood is strongly connected (all {-1,+1}^N reachable) and
|
||||
tabu tenure is bounded. In practice, tabu tenure τ ≈ sqrt(N) gives empirically good results.
|
||||
|
||||
### Convergence Comparison (rough, for context)
|
||||
|
||||
| Method | Iterations for N-bit problem | Notes |
|
||||
|--------|------------------------------|-------|
|
||||
| Brute force | 2^N | infeasible for N>30 |
|
||||
| SA | O(N² log N) | with correct schedule |
|
||||
| Tabu search | O(N^1.5) to O(N²) | empirically |
|
||||
| Bandit (Thompson) | O(N log N) / O(√T) regret | if decomposable |
|
||||
| Fourier / KM | O(N/ε²) | if function is sparse |
|
||||
| Hebbian (current) | O(1/lr) per cell | greedy, may not converge |
|
||||
|
||||
For N=24 (current table): all methods viable within 1000 ticks.
|
||||
For N=690 (full weight vector): only bandit and Fourier methods are feasible.
|
||||
|
||||
---
|
||||
|
||||
## Framework 4: Locality-Sensitive Hashing on Gray-Coded Inputs
|
||||
|
||||
### Mathematical Framework
|
||||
|
||||
LSH for Hamming distance: a random hash function h(x) = x[i] (select random bit i) collides two
|
||||
binary vectors x, y with probability 1 - d_H(x,y)/n, where d_H is Hamming distance and n=690. This
|
||||
is Hamming-LSH — trivially computable, requires no training.
|
||||
|
||||
For our Gray-coded inputs: two consecutive enemy positions differ by d_H ≈ 3-6 bits. The LSH
|
||||
collision probability for such pairs is (690-5)/690 ≈ 99.3%. This means random bit-sampling is an
|
||||
excellent locality-preserving hash for our input.
|
||||
|
||||
### Content-Addressable Memory (CAM) System
|
||||
|
||||
**Architecture**: store (input_hash, correction) pairs. On new input, retrieve the k nearest stored
|
||||
inputs by Hamming distance, average their corrections.
|
||||
|
||||
This is the **k-nearest-neighbor predictor in Hamming space**, implemented via LSH buckets for
|
||||
efficiency.
|
||||
|
||||
**Why this is powerful for us**: Gray coding guarantees that physically similar states (same heading,
|
||||
similar distance) have Hamming-close encodings. A CAM retrieval over Hamming distance directly
|
||||
recovers "similar situations had correction Δ_i", which is exactly the non-parametric Hebbian
|
||||
correction we want but without the coarse 24-cell discretization.
|
||||
|
||||
### Implementation Sketch
|
||||
|
||||
# Storage (bounded buffer, ~200 entries max)
|
||||
memory = [] # list of (x_690bit, correction_xy)
|
||||
|
||||
# Learning (on wave hit):
|
||||
memory.append((current_input, observed_correction))
|
||||
if len(memory) > MAX: memory.pop(0) # FIFO or evict worst
|
||||
|
||||
# Prediction:
|
||||
# Find k nearest inputs by Hamming distance (XOR+popcount, hardware-accelerated)
|
||||
dists = [popcount(x XOR stored_x) for stored_x in memory]
|
||||
k_nearest = nsmallest(k, zip(dists, memory))
|
||||
correction = weighted_average([c for (_, c) in k_nearest],
|
||||
weights=[1/(d+1) for (d, _) in k_nearest])
|
||||
|
||||
**Cost**: O(|memory| × 690/64) per prediction (popcount on 64-bit words, ~11 ops per entry).
|
||||
For 200 stored entries: ~2200 bitops per prediction — within 1ms budget.
|
||||
|
||||
**Convergence**: after M examples, k-NN with Hamming metric converges to the Bayes-optimal
|
||||
predictor for any Lipschitz-continuous function in Hamming metric. Our Gray-coded input IS
|
||||
Hamming-Lipschitz. This is non-parametric with O(M^{-d/(d+2)}) convergence rate for effective
|
||||
dimension d. If d is small (our data suggests ~3-5 physical degrees of freedom map to the
|
||||
correction), convergence is fast.
|
||||
|
||||
### What We're Not Exploiting
|
||||
|
||||
The current 24-cell table partitions input space by two hand-chosen features (heading sector,
|
||||
distance band). LSH with Hamming distance exploits all 690 bits equally weighted. **The Gray
|
||||
structure means we could use ANY two bits that differ between nearby states as an LSH hash for
|
||||
those states.** The system naturally finds the relevant bits by collision frequency.
|
||||
|
||||
---
|
||||
|
||||
## Framework 5: Information-Theoretic Approaches
|
||||
|
||||
### Minimum Description Length (MDL) for Model Selection
|
||||
|
||||
MDL principle: choose the model M that minimizes L(M) + L(Data|M), where L is description length
|
||||
in bits.
|
||||
|
||||
For our prediction problem, MDL gives a principled way to choose between:
|
||||
- Linear extrapolation (24 params × 32 bits = 768 bits to describe)
|
||||
- Hebbian 24-cell table (24 × 64 bits = 1536 bits + cell selection logic)
|
||||
- k-NN memory (200 × (690+64) bits = ~150KB)
|
||||
- Full BNN (690 × 128 + 128 × 64 = 97K params × 1 bit = 12KB binary)
|
||||
|
||||
MDL predicts: use the simplest model that compresses battle data. If linear extrapolation already
|
||||
compresses (MAE 8.1 units baseline), the incremental description-length reduction from more complex
|
||||
models must exceed their description cost.
|
||||
|
||||
**Practical MDL estimate**:
|
||||
- Linear: already needs 0 extra bits (hardcoded physics)
|
||||
- Hebbian table: 24 cells, each storing 2 floats. If only 10 cells activate, effective description
|
||||
is 10 × 2 × 32 ≈ 640 bits. Very cheap.
|
||||
- Full BNN: 12KB. This is only justified if it reduces prediction error enough to compress the
|
||||
residuals by > 12KB.
|
||||
|
||||
**Key insight**: Given that 10/24 Hebbian cells activate, the true model has ~10 degrees of freedom.
|
||||
Any model with > 10 effectively independent parameters is overfitting to a sparse signal. This
|
||||
argues strongly against large BNN architectures for this task.
|
||||
|
||||
### Mutual Information and the Information Bottleneck
|
||||
|
||||
The information bottleneck principle (Tishby & Zaslavsky 2015): an optimal representation Z of
|
||||
input X for predicting output Y maximizes I(Z; Y) while minimizing I(Z; X) (compression).
|
||||
|
||||
For our 690-bit input:
|
||||
- I(X; Y) = mutual information between input and correct correction ≈ a few bits
|
||||
(given that ~97.8% of motion is constant-velocity, the correction signal is low-entropy)
|
||||
- Optimal bottleneck Z should be ~5-10 bits if the correction depends on ~3-5 physical variables
|
||||
|
||||
**Implication**: a 690-bit → 5-bit bottleneck should capture nearly all prediction-relevant
|
||||
information. More hidden-layer capacity is wasted on input noise. The current Hebbian table with
|
||||
24 cells (effectively log2(24) ≈ 4.5 bits of index) is close to the information-optimal representation
|
||||
size.
|
||||
|
||||
### Rate-Distortion Lower Bound
|
||||
|
||||
For any binary encoding of corrections with rate R bits:
|
||||
D*(R) ≥ D_max · 2^{-R/H}
|
||||
|
||||
where D_max is the baseline distortion and H is the entropy of the correction signal.
|
||||
|
||||
If H ≈ 5 bits (3-5 degrees of freedom): to halve prediction error (D = 0.5 D_max) we need R = 5
|
||||
bits of model capacity. The current 4.5-bit residual table is near the Shannon limit for this task.
|
||||
Going deeper adds computation without information-theoretic benefit unless we're wrong about H.
|
||||
|
||||
---
|
||||
|
||||
## Framework 6: Finite Field Arithmetic — GF(2)
|
||||
|
||||
### What GF(2) Can and Cannot Compute
|
||||
|
||||
A Boolean function f: {0,1}^n → {0,1} has a unique **algebraic normal form (ANF)**:
|
||||
|
||||
f(x) = Σ_{S ⊆ [n]} a_S · Π_{i∈S} x_i (sum/product mod 2)
|
||||
|
||||
- **Degree 1** (a_S = 0 for |S| > 1): affine functions = XOR of input bits + constant
|
||||
- **Degree 2**: affine + pairwise products (AND of two bits XOR'd together)
|
||||
- **Maximum degree n**: any Boolean function is representable
|
||||
|
||||
**Key result**: any function with full degree n in its ANF is not learnable from a linear (XOR-only)
|
||||
network. Our required correction function, mapping Gray-coded position to position offset, has
|
||||
non-trivial degree because distance × heading interactions are necessary for good corrections.
|
||||
|
||||
**Algebraic immunity**: A function with algebraic immunity d requires an adversary to know d+1
|
||||
bits of correlation to predict the output. For cryptographic functions (bent functions), algebraic
|
||||
immunity is maximized (≈ n/2). For our case, we want the OPPOSITE: low algebraic immunity means
|
||||
few bits predict the output, which is what we observe.
|
||||
|
||||
### Bent Functions and Non-Linearity
|
||||
|
||||
A **bent function** is maximally non-linear: equally distant from all affine functions. The
|
||||
correction from linear extrapolation is a non-affine function of the input, but we want to
|
||||
characterize *how* non-linear it is to choose the right architecture.
|
||||
|
||||
If the correction function has low algebraic degree (2-3), a second-order Hebbian network (tracking
|
||||
pairwise bit correlations) would suffice. If it has high degree, deeper architectures are needed.
|
||||
|
||||
**Hypothesis from data**: since 10/24 coarse cells captures 14-21% MAE reduction, the correction
|
||||
is primarily a degree-1 function of the coarse features (heading, distance) plus small degree-2
|
||||
perturbations. Algebraic degree ≤ 2 is a reasonable prior.
|
||||
|
||||
### Practical Consequence
|
||||
|
||||
XOR + popcount + threshold computes a **linear threshold function over GF(2)** — a halfspace in
|
||||
{0,1}^n with the XOR inner product. This is equivalent to a single parity-check + threshold. It
|
||||
is more expressive than pure XOR (which is degree-1 over GF(2)) but less expressive than arbitrary
|
||||
degree-2 functions. The key non-linearity needed — "distance AND heading interaction" — requires
|
||||
at minimum one AND gate, which is degree-2 over GF(2).
|
||||
|
||||
**Architecture implication**: XOR + popcount is necessary AND nearly sufficient for degree-2
|
||||
correction functions, because popcount over a selected subset of bits computes a weighted degree-2
|
||||
interaction. A single hidden layer with XOR + popcount neurons is algebraically adequate for the
|
||||
signal we observe.
|
||||
|
||||
---
|
||||
|
||||
## Framework 7: Cellular Automata Rules
|
||||
|
||||
### Wolfram's Elementary CA Rule Space
|
||||
|
||||
Elementary 1D CA: 256 rules mapping (left, center, right) bits → new center bit. Wolfram's
|
||||
Class IV (e.g., Rule 110, proven Turing-complete by Cook 2004) produces complex, structured patterns
|
||||
from simple rules.
|
||||
|
||||
### Application to Temporal Pattern Prediction
|
||||
|
||||
Our 10-frame temporal window looks like a 1D CA: at each step, the state evolves according to some
|
||||
rule that depends on neighbors (surrounding bits in the encoding). If enemy motion follows a simple
|
||||
physical rule, the temporal evolution of the 690-bit vector might be approximated by a CA rule
|
||||
applied to a small neighborhood of bits.
|
||||
|
||||
**Sketch**: identify which 3-7 bits in frame t most predict the change in bit b in frame t+1
|
||||
(via correlation). Define a local rule: b_{t+1} = f(neighborhood_t). This rule, applied uniformly
|
||||
across the 69-bit frame encoding, defines a CA-like predictor.
|
||||
|
||||
**Convergence and utility**: for the specific physical evolution (constant velocity), the CA rule
|
||||
would be a simple linear shift in position bits — computable in O(n) time. For non-linear motions
|
||||
(turns, acceleration), the CA rule would need higher complexity. The key value here is **structural
|
||||
insight**: if the transition looks like a CA rule, we can predict the next frame without a full
|
||||
network evaluation.
|
||||
|
||||
**Reality check**: CA rules are defined for spatial neighbors; our input is a flat binary vector
|
||||
with non-spatial structure. The CA framing is more metaphorical than literal here — it suggests
|
||||
looking for **local update rules** in the binary representation rather than global functions.
|
||||
|
||||
---
|
||||
|
||||
## Framework 8: Compressed Sensing / Sparse Recovery
|
||||
|
||||
### Mathematical Framework
|
||||
|
||||
Classical compressed sensing: y = Ax where y ∈ R^m, A ∈ R^{m×n}, x ∈ R^n is k-sparse (at most k
|
||||
non-zero entries). Recovery guarantee (Candes & Tao 2005): if A satisfies the **restricted isometry
|
||||
property (RIP)** with δ_{2k} < √2 - 1, then x is recoverable from m = O(k log(n/k)) measurements.
|
||||
|
||||
For n=690, k=10 (observed sparsity): m ≈ 10 × log(69) ≈ 43 measurements. We have ~1000 battle ticks
|
||||
with wave feedback — well above threshold if measurements are well-structured.
|
||||
|
||||
### Binary Measurement Matrices
|
||||
|
||||
Our network weights ARE the measurement matrix A. A binary weight matrix W ∈ {-1,+1}^{m×690}
|
||||
satisfies a form of RIP with high probability when entries are iid Rademacher (Baraniuk et al. 2008).
|
||||
This means a single-hidden-layer BNN with ~43 neurons is mathematically sufficient to recover a
|
||||
10-sparse correction signal from 690 binary inputs.
|
||||
|
||||
### Mapping to Our Problem
|
||||
|
||||
Reframe: the "true" correction vector c ∈ R^2 (Δx, Δy) is not sparse, but the function that maps
|
||||
inputs to corrections is sparse in the **feature basis** — only ~10 features of the 690-bit input
|
||||
predict the correction. This is compressed sensing in function space.
|
||||
|
||||
**Sparse recovery update rule**:
|
||||
1. Treat each wave-feedback event as a measurement: y_t = c_true + noise
|
||||
2. Build measurement matrix A from historical inputs x_t (690 bits each)
|
||||
3. Solve: min ||w||_0 subject to Aw ≈ y (sparse regression)
|
||||
4. Use LASSO (L1 relaxation) online: w ← w - η · (Aw - y) · sign(w)
|
||||
|
||||
The online L1 update is a soft-thresholding step — computable without gradients of the loss if we
|
||||
treat (Aw - y) as a signal (not a derivative).
|
||||
|
||||
### What We're Not Exploiting
|
||||
|
||||
Our observation that "only 10/24 residual cells activate" is an empirical signal of sparsity. But
|
||||
we're not measuring *which 690 bits* drive the prediction — we're only asking which of 24 coarse
|
||||
cells. Compressed sensing applied at the bit level would:
|
||||
1. Identify the ~10 input bits most predictive of the correction
|
||||
2. Build a sparse predictor that ignores the other 680 bits
|
||||
3. Potentially achieve better prediction with less memory than the current architecture
|
||||
|
||||
The LSH approach (Framework 4) implicitly does this via Hamming nearest-neighbors, but an explicit
|
||||
sparse recovery would be more interpretable and theoretically grounded.
|
||||
|
||||
---
|
||||
|
||||
## Framework 9: SAT as Learning
|
||||
|
||||
### Framing the Learning Problem as Weighted MAX-SAT
|
||||
|
||||
Define a clause for each battle observation: "given input x_t, the aiming correction that would have
|
||||
hit enemy was c_t." Binary weight vector w must satisfy (approximately):
|
||||
|
||||
sign(w · x_t) = sign(c_t_x) [x-component of correction]
|
||||
sign(w · x_t) = sign(c_t_y) [y-component]
|
||||
|
||||
This is a linear feasibility problem over {-1,+1} — equivalent to finding w that satisfies a set
|
||||
of soft halfspace constraints. Each battle tick adds a new clause.
|
||||
|
||||
**Weighted MAX-SAT reformulation**: each tick t has a "clause" (x_t, c_t) with weight w_t = 1.
|
||||
Find w ∈ {-1,+1}^N that satisfies maximum total clause weight.
|
||||
|
||||
### Survey Propagation
|
||||
|
||||
SP (Mezard et al. 2002) is a message-passing algorithm for random SAT that operates near the SAT
|
||||
threshold. It maintains probability distributions ("surveys") over variables and iteratively updates
|
||||
them. SP solves instances with 10^6 variables in seconds at clause-to-variable ratios near the
|
||||
phase transition.
|
||||
|
||||
**Relevance**: at each battle step, we have a growing SAT instance. SP could run incrementally as
|
||||
new clauses arrive. Convergence: SP converges in O(n) iterations per update for satisfiable
|
||||
instances. For our 690-variable problem with ~1000 clauses after a battle, this is in the
|
||||
well-satisfiable regime (many more solutions than constraints) — SP would converge very fast.
|
||||
|
||||
**Practical obstacle**: SP outputs probability distributions, not binary assignments. It requires
|
||||
a "decimation" step to extract a concrete assignment. The combined SP + decimation + local search
|
||||
(WalkSAT) is a standard pipeline but adds complexity beyond what our 1ms budget allows for each tick.
|
||||
|
||||
### WalkSAT for Online Binary Weight Updates
|
||||
|
||||
WalkSAT local search: pick an unsatisfied clause at random, flip a bit that satisfies it (or random
|
||||
flip with probability p). Convergence to satisfying assignment (if one exists) in O(n·2^{αn}) steps
|
||||
for random 3-SAT, better for structured problems.
|
||||
|
||||
**For our problem**: each unsatisfied clause is a "this prediction was wrong" event. WalkSAT would
|
||||
flip the weight bit that "fixes" the most errors. This is a greedy local search on {-1,+1}^N.
|
||||
|
||||
**Online WalkSAT sketch**:
|
||||
|
||||
# On wave hit (new clause (x_t, c_t) arrives):
|
||||
if current_prediction wrong:
|
||||
best_flip = argmax_i [improvement in satisfied clauses if w[i] flipped]
|
||||
w[best_flip] = -w[best_flip]
|
||||
|
||||
Cost per update: O(N × |active_clauses|) — expensive for N=690 and |clauses|=100+. Maintain an
|
||||
active clause buffer of bounded size to keep cost bounded.
|
||||
|
||||
**Convergence**: empirically O(N log N) flips to satisfy random binary clause sets. For N=24 (our
|
||||
table), this is ~100 flips — achievable within a battle. For N=690, substantially more.
|
||||
|
||||
---
|
||||
|
||||
## Synthesis: Unexploited Structure Summary
|
||||
|
||||
### The Core Mathematical Insight We Are Missing
|
||||
|
||||
The 690-bit input has **Gray-coding × temporal autocorrelation × low-dimensional physics** structure
|
||||
that we currently exploit only via a 24-cell coarse grid. The mathematically precise statement is:
|
||||
|
||||
> The function f: {0,1}^{690} → R² (correction) lies in a space of functions with sparse Fourier
|
||||
> spectrum (few non-zero Walsh coefficients), low algebraic degree (≤2 over GF(2)), and Lipschitz
|
||||
> continuity in Hamming metric (from Gray coding). This combination makes it efficiently learnable
|
||||
> by any of: sparse Fourier recovery, degree-2 Hebbian network, or Hamming k-NN.
|
||||
|
||||
### Prioritized Opportunities
|
||||
|
||||
**Highest impact (small change, large gain)**:
|
||||
|
||||
1. **Hamming k-NN over raw bits** (Framework 4): Replace 24-cell table with a bounded memory buffer
|
||||
of (input_690bit, correction_xy) pairs. Retrieve k nearest by XOR+popcount. Exploits Gray
|
||||
structure, no architecture change needed, O(200 × 11) bitops per prediction. This gives the
|
||||
residual table infinite resolution at O(200) memory cost.
|
||||
|
||||
2. **Temporal XOR features** (implicit in Framework 1 and 8): Add frame[t] ⊕ frame[t-1] as
|
||||
explicit input features (~69 bits of velocity-change signal). These are the "sparse changing
|
||||
bits" that carry motion information. Near-zero cost to compute, likely captures the degree-2
|
||||
correction interactions.
|
||||
|
||||
**Medium impact (architecture changes)**:
|
||||
|
||||
3. **Sparse Fourier learning** (Framework 1): Track pairwise bit correlations with corrections. The
|
||||
KM algorithm guarantees recovery of the top-K Fourier coefficients with O(n/ε²) samples. For
|
||||
n=690, K=10, ε=0.1: needs ~69K samples — more than one battle provides. Feasible across multiple
|
||||
battles (inter-battle learning).
|
||||
|
||||
4. **Thompson sampling on correction bins** (Framework 2): Replace fixed lr=0.2 Hebbian with
|
||||
Beta(α,β) posterior per bin. Principled exploration, uncertainty-aware predictions. O(bins)
|
||||
extra memory, same architecture.
|
||||
|
||||
**Lower priority (diminishing returns)**:
|
||||
|
||||
5. MDL analysis confirms: 10 active degrees of freedom suggest the current architecture is near-
|
||||
optimal in capacity. Going deeper adds parameters without proportionate information gain unless
|
||||
opponent behavior is demonstrably multi-modal or adversarial.
|
||||
|
||||
6. GF(2) algebra analysis confirms: XOR + popcount + threshold (the planned BNN neuron) is the
|
||||
minimal architecture for degree-2 functions, and degree-2 is sufficient given the data. No need
|
||||
for deeper networks from this angle.
|
||||
|
||||
### What Structure We ARE Exploiting
|
||||
|
||||
- Gray coding (Hamming smoothness) → implicitly in the 8-sector heading table
|
||||
- Temporal window (10 frames) → used as input, not architecturally modeled
|
||||
- Physics sparsity (constant velocity) → linear extrapolation baseline
|
||||
|
||||
### What Structure We Are NOT Exploiting
|
||||
|
||||
- Hamming distance between full input vectors (nearest-neighbor retrieval)
|
||||
- Temporal XOR (which bits change per tick = motion signal in compressed form)
|
||||
- Fourier coefficient sparsity at low degree (sparse linear model over parity features)
|
||||
- Information-theoretic limit (current table is near Shannon bound for this task)
|
||||
- Uncertainty quantification (Bayesian correction bins vs fixed learning rate)
|
||||
|
||||
---
|
||||
|
||||
## Sources
|
||||
|
||||
- [A Theory of the Learnable — Valiant 1984 (acolyer.org summary)](https://blog.acolyer.org/2018/01/31/a-theory-of-the-learnable/)
|
||||
- [On PAC Learning Algorithms for Rich Boolean Function Classes](https://link.springer.com/chapter/10.1007/11750321_42)
|
||||
- [Analysis of Boolean Functions — O'Donnell (full text, CMU)](https://www.cs.cmu.edu/~odonnell/papers/Analysis-of-Boolean-Functions-by-Ryan-ODonnell.pdf)
|
||||
- [SPRIGHT: Sparse Walsh-Hadamard Transform](https://arxiv.org/pdf/1508.06336)
|
||||
- [An Efficient Algorithm for Combinatorial Semi-Bandits (JMLR 2016)](https://jmlr.org/papers/volume17/15-091/15-091.pdf)
|
||||
- [A Tutorial on Thompson Sampling (Stanford)](http://web.stanford.edu/~bvr/pubs/TS_Tutorial.pdf)
|
||||
- [Convergence Rate of Simulated Annealing with Noisy Observations](https://arxiv.org/pdf/1703.00329)
|
||||
- [Tabu Search Exploiting Local Optimality in Binary Optimization (2023)](https://www.sciencedirect.com/science/article/abs/pii/S0377221723000012)
|
||||
- [Locality Sensitive Hashing Lecture Notes (LUMS)](https://web.lums.edu.pk/~imdad/pdfs/CS5312_Notes/CS5312_Notes-14-LSH.pdf)
|
||||
- [Hamming Distance Metric Learning](https://norouzi.github.io/research/papers/hdml.pdf)
|
||||
- [Minimum Description Length — Scholarpedia](http://www.scholarpedia.org/article/Minimum_description_length)
|
||||
- [Bent function — Wikipedia](https://en.wikipedia.org/wiki/Bent_function)
|
||||
- [Algebraic Normal Form of a Bent Function](https://eprint.iacr.org/2018/1160.pdf)
|
||||
- [Compressed Sensing Using Binary Matrices of Nearly Optimal Dimensions](https://arxiv.org/pdf/1808.03001)
|
||||
- [Survey Propagation: An Algorithm for Satisfiability (Wiley 2002)](https://onlinelibrary.wiley.com/doi/pdf/10.1002/rsa.20057)
|
||||
- [Rule 110 Turing Completeness — Matthew Cook proof](https://mirror.explodie.org/universality_in_elementary_cellular_automata_by_matthew_cook.pdf)
|
||||
- [Learning DNF Expressions from Fourier Spectrum](https://arxiv.org/pdf/1203.0594)
|
||||
- [Rate-Distortion Theory of Neural Coding and Working Memory (eLife)](https://elifesciences.org/articles/79450)
|
||||
@@ -0,0 +1,625 @@
|
||||
# Unconventional CS — Domain Survey for BNNBot
|
||||
|
||||
Context: 690-bit binary input (10-frame temporal window, Gray-coded), reward signal
|
||||
from wave hit system (miss distance), ~1ms/tick budget, no gradients, no pre-training,
|
||||
online learning only. Task: predict enemy position (continuous x,y output).
|
||||
|
||||
---
|
||||
|
||||
## 1. Reservoir Computing / Echo State Networks
|
||||
|
||||
### How it works
|
||||
Fixed random recurrent layer (reservoir) transforms temporal input into a
|
||||
high-dimensional nonlinear state. Only the linear readout is trained (ridge regression
|
||||
or online RLS). No backpropagation through the reservoir.
|
||||
|
||||
### Core principle
|
||||
Untrained chaos is still useful: the reservoir expands low-dimensional input into a
|
||||
rich trajectory through state-space. The readout just needs to find a linear slice.
|
||||
|
||||
### Mapping to our problem
|
||||
**We already ARE doing this.** The 690-bit encoding is a handcrafted reservoir:
|
||||
10-frame temporal window, Gray coding, sin/cos projections. The Hebbian residual
|
||||
table is the (very shallow) readout. The architecture philosophy section of RESEARCH.md
|
||||
explicitly names this.
|
||||
|
||||
### Can the reservoir adapt with reward?
|
||||
Yes — two mechanisms:
|
||||
- **Intrinsic Plasticity (IP):** Local unsupervised rule that tunes each neuron's
|
||||
gain/bias so its output distribution matches a target exponential. Maximizes
|
||||
information throughput without reward. Updates: `a += eta*(1/a - x*tanh(b+a*x))`,
|
||||
`b += eta*(-tanh(b+a*x))`. Purely local, O(N) per step.
|
||||
- **Hebbian Architecture Generation (HAG, 2025):** Grows connections between
|
||||
frequently co-activating neurons, sculpting task-specific wiring from a sparse seed.
|
||||
Nature Comms 2025 paper shows HAG beats IP and Anti-Oja across classification and
|
||||
forecasting tasks.
|
||||
- **Reward-modulated STDP:** Neuromodulatory signal (reward) gates whether recent
|
||||
correlational changes are committed. Well-studied in spiking ESNs.
|
||||
|
||||
### Update rule sketch
|
||||
For reward-modulated reservoir adaptation:
|
||||
```
|
||||
# Per tick, after observing reward r:
|
||||
for each edge (i,j) in reservoir:
|
||||
eligibility_ij += pre_i * post_j # accumulate Hebbian trace
|
||||
w_ij += alpha * r * eligibility_ij
|
||||
eligibility_ij *= decay # exponential trace decay
|
||||
```
|
||||
Readout (ridge): `w_out = (X^T X + lambda I)^{-1} X^T y`, or online RLS with O(n^2)
|
||||
update. For our 690-dim input, n=690, so RLS matrix is 690x690 = ~380K floats — fine
|
||||
for 1ms budget.
|
||||
|
||||
### Assessment for BNNBot
|
||||
- **Low risk, incremental gain.** We already have the structure; adding IP or reward-
|
||||
modulated reservoir edges to the binary encoding could unlock better feature
|
||||
representations without breaking the readout.
|
||||
- Readout upgrade from Hebbian table to online RLS/LMS is the lowest-hanging fruit.
|
||||
- Depth: shallow (reservoir + linear readout). Getting deeper is the challenge this
|
||||
whole survey is about.
|
||||
|
||||
---
|
||||
|
||||
## 2. Random Boolean Networks (RBNs / Kauffman Networks)
|
||||
|
||||
### How it works
|
||||
N binary nodes, each receiving K random inputs and assigned a random Boolean function
|
||||
(truth table of size 2^K). Iterated synchronously. No weights — each node has a
|
||||
lookup table of 2^K bits.
|
||||
|
||||
### Critical regime
|
||||
At K=2, p=0.5: the network sits at the "edge of chaos". Small perturbations neither
|
||||
die out (ordered, K<2) nor explode (chaotic, K>2). Adaptive robots using K=2 RBNs
|
||||
outperform K<2 and K>2 variants (Entropy 2022 paper). Crucially: reward-driven
|
||||
training via genetic algorithm *naturally converges to K≈2*, not by design but because
|
||||
K=2 is the adaptive optimum.
|
||||
|
||||
### Core principle
|
||||
Computation via attractor dynamics. Inputs push the network into different basins of
|
||||
attraction; the fixed point or limit cycle encodes the "answer".
|
||||
|
||||
### Mapping to our problem
|
||||
690-bit input → seed the RBN state. Let it run T steps → read out N bit aggregate as
|
||||
prediction. The 690 truth tables (2^K bits each) are the parameters to learn.
|
||||
|
||||
Reward signal: mutate truth tables of poorly-performing nodes (those whose contribution
|
||||
correlates with miss) and keep mutations that improve hit rate.
|
||||
|
||||
### Concrete update rule
|
||||
```
|
||||
# Evolutionary strategy on Boolean functions:
|
||||
for each node i where contribution_score[i] < threshold:
|
||||
flip one random bit in truth_table[i] # mutation
|
||||
evaluate on recent history
|
||||
if miss_distance worse: revert
|
||||
```
|
||||
Or stochastic: with prob proportional to miss distance, flip bits in random node
|
||||
truth tables.
|
||||
|
||||
### Computational cost
|
||||
Forward pass: N XOR/table lookups per step × T steps. For N=690, T=10: 6900 lookups
|
||||
per tick. Trivially fast.
|
||||
Training: O(N) per reward signal.
|
||||
|
||||
### Depth and credit assignment
|
||||
Depth = T (number of synchronous update steps). Credit assignment is the hard part:
|
||||
which node's truth table caused the miss? No natural gradient. Options:
|
||||
- Perturbation-based: change one node's table, observe reward change. O(N) samples
|
||||
needed per gradient estimate — too slow online.
|
||||
- Structural: nodes that are "downstream" of the input in the network topology get
|
||||
blamed first (topological credit assignment).
|
||||
- Caveat: RBNs are primarily studied as models of gene regulatory networks, not as
|
||||
general function approximators. Convergence to a target function is not guaranteed.
|
||||
|
||||
### Assessment for BNNBot
|
||||
- **Exotic and uncertain.** The attractor dynamics are not well-suited to continuous
|
||||
regression (they produce binary outputs, need majority-vote or thermometer readout).
|
||||
- The critical-regime insight is philosophically interesting — it suggests that binary
|
||||
networks naturally self-organize to K≈2 with adaptive pressure, which might inform
|
||||
how we design the connectivity of a BNN.
|
||||
- Not recommended as primary approach but interesting structural inspiration.
|
||||
|
||||
---
|
||||
|
||||
## 3. Tsetlin Machines (TMs) — DEEP DIVE
|
||||
|
||||
### How it works
|
||||
A TM is a team of Tsetlin Automata (TAs) that learns propositional logic clauses from
|
||||
binary inputs. Each clause is a conjunction (AND) of literals (features or their
|
||||
negations): e.g., `x3 AND NOT x7 AND x12`. Each TA controls whether its literal is
|
||||
Included or Excluded in its clause. TAs use a state machine: states 1..2N, midpoint
|
||||
divides Exclude (states 1..N) from Include (N+1..2N). Moving right → more committed to
|
||||
Include; moving left → more committed to Exclude.
|
||||
|
||||
The output is a vote: sum of (positive clauses - negative clauses). Classification:
|
||||
sign of vote. Regression: the raw vote divided by the number of clauses.
|
||||
|
||||
### Exact update rules (Type I and II feedback)
|
||||
|
||||
Let `c` be a clause, `o` its output (0/1), `y` the label (0/1 for classification),
|
||||
`s` a specificity parameter (typically 2-10), and `x_i` the literal value:
|
||||
|
||||
**Type I Feedback** (given to positive-polarity clauses when `y=1`, prob 1/max(1,v)):
|
||||
- **Type Ia** (when `o=1`): with prob `(s-1)/s`, if `x_i=1`, Reward Include TA (move right)
|
||||
- **Type Ib** (when `o=0` or `x_i=0`): with prob `1/s`, Penalize Include TA (move left),
|
||||
Reward Exclude TA (move right)
|
||||
|
||||
**Type II Feedback** (given to positive-polarity clauses when `y=0`, prob 1/max(1,v)):
|
||||
- When `o=1` and `x_i=0`: Penalize Exclude TA (move left) — force inclusion of
|
||||
distinguishing features to fire only when correct
|
||||
|
||||
Where `v` is the clamped vote sum: `v = clip(sum_clauses, -T, T)` — the threshold T
|
||||
controls the effective voting range. As `|v|` grows, the probability of feedback
|
||||
decreases, creating a homeostatic balance that prevents over-fitting.
|
||||
|
||||
**Regression TM (RTM):** No sign — raw vote is the output. Loss is `(y_hat - y)`.
|
||||
Feedback probabilities become functions of the error magnitude rather than binary
|
||||
correct/wrong. Specifically:
|
||||
- If `y_hat > y` (over-prediction): Type II feedback to positive clauses (shrink them)
|
||||
- If `y_hat < y` (under-prediction): Type I feedback to positive clauses (grow them)
|
||||
The exact probability for RTM: `p_feedback = clip(|y_hat - y| / y_max, 0, 1)`
|
||||
|
||||
### Multi-layer / Deep TMs
|
||||
July 2025 paper "The Tsetlin Machine Goes Deep: Logical Learning and Reasoning With
|
||||
Graphs" (arxiv 2507.14874) introduces hierarchical TM layers where clause outputs from
|
||||
one layer become binary inputs to the next. This creates hierarchical logical
|
||||
expressions — exactly what we need for multi-layer binary networks without gradients.
|
||||
|
||||
Key mechanism: the output of layer L (a binary vector of clause activations) feeds
|
||||
directly as input bits to layer L+1. Each layer still uses its own Type I/II feedback.
|
||||
Credit assignment flows through the logical structure, not gradients.
|
||||
|
||||
### Coalesced Multi-Output TM
|
||||
For predicting (x, y) position simultaneously: the Coalesced TM shares clauses across
|
||||
multiple outputs, reducing parameter count. Each clause contributes to multiple outputs
|
||||
with different polarity, saving memory and improving generalization.
|
||||
|
||||
### Mapping to our problem
|
||||
- Input: 690 binary bits (our existing encoding) — **native input format**
|
||||
- Output: continuous position (x, y) — use Regression TM with two outputs
|
||||
- Learning: wave hit reward gives `(hit_x - pred_x, hit_y - pred_y)` error signal
|
||||
directly usable as RTM feedback
|
||||
- No gradients, no backprop, pure reinforcement-like TA state updates
|
||||
- Online: each wave hit = one training example, update TAs immediately
|
||||
|
||||
### Architecture sketch
|
||||
```
|
||||
690 bits → [TM Layer 1: M1 clauses, each max K1 literals]
|
||||
→ binary clause activations (M1 bits)
|
||||
→ [TM Layer 2: M2 clauses] (optional depth)
|
||||
→ RTM readout: vote → predicted x, y
|
||||
```
|
||||
|
||||
### Computational cost
|
||||
- Clause evaluation: for each clause, check K literals. Bitwise AND on 64-bit words.
|
||||
For 690 inputs: ceil(690/64)=11 words. M=100 clauses: 11×100 = 1100 AND ops/tick.
|
||||
Trivially within 1ms.
|
||||
- TA updates: one update per TA per training example = M×690 state increments.
|
||||
M=100 clauses: 69000 integer ops per wave hit. Fast.
|
||||
- Memory: M × 690 TA states, each 1 byte = 69KB for 1000 clauses. Fine.
|
||||
|
||||
### Convergence
|
||||
Mathematically proven to converge for IDENTITY and NOT operators (arxiv 2007.14268).
|
||||
Regression convergence: empirically shown on benchmark datasets, no formal proof yet.
|
||||
Online convergence: slow vs batch but works — the stochastic nature averages out over
|
||||
many examples. Typical battle has ~1000 wave closures = 1000 training examples.
|
||||
|
||||
### Why TM is purpose-built for this problem
|
||||
1. **Binary input native**: 690 bits processed as-is, no float conversion
|
||||
2. **No gradients**: reinforcement-style TA updates only
|
||||
3. **Online**: each hit event updates TAs in place
|
||||
4. **Interpretable**: resulting clauses are readable Boolean rules
|
||||
5. **Regression extension**: continuous x,y output is directly supported
|
||||
6. **Depth available**: multi-layer version published mid-2025
|
||||
|
||||
### The catch
|
||||
- TMs learn propositional logic — they find which binary features co-occur with good
|
||||
predictions. Our input is already heavily engineered so this is appropriate.
|
||||
- The `s` parameter controls generalization vs specificity — requires tuning.
|
||||
- Clause count M is a capacity knob. Too few: underfitting. Too many: slow convergence.
|
||||
- For regression, the voting mechanism needs the output range to be known (or clipped).
|
||||
Miss distance is bounded by arena diagonal (~1131px) — manageable.
|
||||
|
||||
**Verdict: HIGHEST PRIORITY candidate. TM is essentially designed for this exact
|
||||
problem: binary input, reinforcement reward, online, no gradients, continuous output
|
||||
available.**
|
||||
|
||||
---
|
||||
|
||||
## 4. Learning Classifier Systems (LCS / XCS)
|
||||
|
||||
### How it works
|
||||
A population of if-then rules: each rule is a ternary string `{0, 1, #}^690` (# = don't
|
||||
care) matched against input. Rules that match vote; vote is aggregated; reward
|
||||
distributed back via Q-learning (XCS) or bucket brigade (original Holland).
|
||||
|
||||
### Core principle
|
||||
Genetic algorithm discovers useful rules; RL credit-assigns reward through chains of
|
||||
rules. Population pressure keeps only accurate, general rules.
|
||||
|
||||
### Mapping to our problem
|
||||
- Match condition: 690-bit ternary string. Each # reduces specificity (don't care = any).
|
||||
- Prediction: each rule has a prediction value (learned float). Matching rules' weighted
|
||||
average = final prediction.
|
||||
- Reward: wave miss distance → penalize recently activated rules; wave hit → reward them.
|
||||
|
||||
### Concrete update rule (XCS Q-learning variant)
|
||||
```
|
||||
# On wave closure with miss d at power p:
|
||||
matched = [r for r in population if r.condition matches current_input]
|
||||
reward = max_d - d # inverted miss distance
|
||||
for r in matched:
|
||||
r.prediction += beta * (reward - r.prediction)
|
||||
r.error += beta * (|reward - r.prediction| - r.error)
|
||||
r.fitness = 1 / r.error # accuracy-based
|
||||
# Periodically: GA on matched set to generate new rules
|
||||
```
|
||||
|
||||
### Computational cost
|
||||
- Matching: 690-bit pattern match per rule × population size. Population = 1000 rules,
|
||||
690 bits → 11 words per match → 11000 AND+XOR ops per tick. Fast.
|
||||
- GA: triggers infrequently. Population replacement amortizes cost.
|
||||
|
||||
### Depth
|
||||
None natively. Rules fire independently, no composition. XCSR (real-valued XCS) and
|
||||
XCSF extend to function approximation but add complexity.
|
||||
|
||||
### What the 1990s knew
|
||||
Holland's bucket brigade was THE solution to credit assignment before Q-learning
|
||||
formalized it. The insight: rules form chains (rule A enables condition for rule B),
|
||||
and credit flows backward through the chain like tokens in a market. Deep learning
|
||||
rediscovered this as temporal credit assignment. LCS communities were doing it first,
|
||||
with interpretable symbolic rules.
|
||||
|
||||
### Assessment for BNNBot
|
||||
- Competitive approach for moderate population sizes and simple rules.
|
||||
- Weaker on continuous output than TM (needs XCSF extension).
|
||||
- GA adds noise during learning — convergence in a single battle (few hundred updates)
|
||||
may be too slow.
|
||||
- Interesting for its interpretability: resulting rules are human-readable.
|
||||
- **Medium priority.** More complex than TM, less theoretically grounded for this task.
|
||||
|
||||
---
|
||||
|
||||
## 5. Swarm Intelligence / Ant Colony Optimization (ACO) on Binary Weights
|
||||
|
||||
### How it works
|
||||
Each binary weight is a choice between 0/1. Maintain a pheromone table `tau[i][b]`
|
||||
(probability that weight i = b). Each "ant" samples a weight vector, runs a forward
|
||||
pass, gets reward, deposits pheromone proportional to reward.
|
||||
|
||||
### Core principle
|
||||
Collective memory of good weight configurations, without storing weights explicitly —
|
||||
only their probability distribution. Biased random search that concentrates where
|
||||
previous successes occurred.
|
||||
|
||||
### Mapping to our problem
|
||||
```
|
||||
# Pheromone matrix: tau[i] in (0,1) = probability weight_i = 1
|
||||
# Each tick: sample weights w_i ~ Bernoulli(tau[i])
|
||||
# Run forward pass, get prediction, wait for wave closure for reward
|
||||
# On reward r:
|
||||
for i in range(n_weights):
|
||||
if w_i == 1: tau[i] += rho * r * (1 - tau[i])
|
||||
else: tau[i] -= rho * r * tau[i]
|
||||
# Evaporation:
|
||||
tau *= (1 - evaporation_rate)
|
||||
```
|
||||
|
||||
### Computational cost
|
||||
- N pheromone values, one Bernoulli sample per weight = N random calls per tick.
|
||||
- For 690 inputs × H hidden = 690H float ops. For H=100: 69K ops/tick. Fine.
|
||||
- Credit assignment: problem. We sample weights at tick T, wave closes at tick T+k
|
||||
(variable latency). We must correlate which weight sample produced which prediction.
|
||||
Need to store (weight_sample, prediction) pairs per wave.
|
||||
|
||||
### Assessment for BNNBot
|
||||
- Natural for binary weights.
|
||||
- The delayed reward (wave hits arrive T+latency ticks later) requires careful
|
||||
bookkeeping — exactly what the wave system already does.
|
||||
- Convergence is slow for high-dimensional binary spaces; pheromone evaporation fights
|
||||
stagnation but also fights convergence.
|
||||
- ACO on continuous regression outputs is non-standard; closest is Estimation of
|
||||
Distribution Algorithms (EDAs) like PBIL.
|
||||
- **Low-medium priority.** Works but likely slower convergence than TM per battle.
|
||||
|
||||
---
|
||||
|
||||
## 6. Hyperdimensional Computing (HDC)
|
||||
|
||||
### How it works
|
||||
Represent everything as D-dimensional binary (or bipolar {-1,+1}) vectors, D=1000-10000.
|
||||
Operations:
|
||||
- **Bind**: XOR (or element-wise multiply for bipolar) — creates unique vector for
|
||||
combination, dissimilar to components
|
||||
- **Bundle**: majority vote — creates vector similar to all inputs
|
||||
- **Permute**: circular shift — encodes position/order
|
||||
|
||||
Learning: accumulate positive examples into a "class prototype" vector by bundling;
|
||||
subtract negative examples.
|
||||
|
||||
### Regression via RegHD
|
||||
RegHD (DAC 2021) clusters similar inputs into groups, learns a linear regression model
|
||||
per group. Prediction = weighted sum across group models by similarity. Online update:
|
||||
when new (input, target) arrives, find most similar group, update its model.
|
||||
|
||||
KalmanHD (ASP-DAC 2024) adds Kalman filtering to the readout for time-series
|
||||
forecasting, handling non-stationarity.
|
||||
|
||||
### Mapping to our problem
|
||||
- Our 690-bit input IS already a hypervector (nearly the right dimension).
|
||||
- Encode each temporal frame as a hypervector; bind across time positions (permute
|
||||
frame i by i); bundle all 10 frames → single D-bit context vector.
|
||||
- Learn an associative memory: context vector → (x_pred, y_pred).
|
||||
- Online update: when wave closes, update the associative memory entry.
|
||||
|
||||
### Update rule (bipolar)
|
||||
```
|
||||
# Encode input: H = majority(permute(frame_i, i) for i in 1..10)
|
||||
# Query: find stored vector V* most similar to H (Hamming distance)
|
||||
# Predict: y_pred = V*.regression_weights @ H
|
||||
# On wave close with actual y:
|
||||
err = y - y_pred
|
||||
V*.regression_weights += alpha * err * H
|
||||
```
|
||||
|
||||
### Computational cost
|
||||
- Encoding: 10 rotations × 690 bits = trivial.
|
||||
- Query: Hamming distance between H and each stored prototype. For K=50 prototypes:
|
||||
50 × 690-bit XOR + popcount = 50 × 11 SIMD ops. Sub-microsecond.
|
||||
- Update: vector addition, O(D). Fast.
|
||||
|
||||
### Depth
|
||||
None natively. HDC is a single-layer associative architecture. Composition via binding
|
||||
enables some structure but not deep hierarchical computation.
|
||||
|
||||
### What's compelling
|
||||
- **Completely gradient-free** by design.
|
||||
- The existing 690-bit encoding is already "HDC-ready."
|
||||
- Extremely fast inference (bitwise ops).
|
||||
- Online update is exactly what we need: each wave = one update.
|
||||
- Robust to noise and bit errors — important since binary encoding has quantization.
|
||||
|
||||
### The limitation
|
||||
- Regression accuracy degrades vs neural approaches on complex nonlinear functions.
|
||||
- The codebook (stored prototypes) can fragment if too many distinct input regions.
|
||||
- No proven depth mechanism.
|
||||
|
||||
**Assessment: MEDIUM-HIGH priority.** Low implementation cost (our encoding is already
|
||||
HDC-compatible), gradient-free, online, fast. Less powerful than TM for complex logic
|
||||
patterns but simpler to implement correctly. Worth a quick prototype.
|
||||
|
||||
---
|
||||
|
||||
## 7. Genetic Programming / Cartesian Genetic Programming (CGP)
|
||||
|
||||
### How it works
|
||||
CGP: a grid of nodes, each computing a function (AND, OR, XOR, NAND, etc.) of two
|
||||
inputs from earlier in the grid. The "chromosome" encodes which function each node
|
||||
uses and which earlier nodes it connects to. Evolution (mutation + selection) improves
|
||||
the circuit.
|
||||
|
||||
Self-Modifying CGP (SMCGP): the evolved program can modify its own structure during
|
||||
execution — learns a learning algorithm, not just a function.
|
||||
|
||||
### Mapping to our problem
|
||||
- Evolve a Boolean circuit that maps 690 bits → prediction encoding.
|
||||
- Chromosome: node functions + connections. Mutations: change one function or
|
||||
reconnect one edge.
|
||||
- Fitness: wave hit reward (miss distance).
|
||||
|
||||
### Update rule
|
||||
```
|
||||
# Online evolution variant (1+1 ES on chromosome):
|
||||
mutation = mutate_one_node(current_chromosome)
|
||||
y_mut = evaluate(mutation, input)
|
||||
y_curr = evaluate(current_chromosome, input)
|
||||
if reward(y_mut) >= reward(y_curr):
|
||||
current_chromosome = mutation
|
||||
```
|
||||
|
||||
### Computational cost
|
||||
- Circuit evaluation: traversal of DAG, O(nodes). For 100 nodes: fast.
|
||||
- Fitness evaluation requires waiting for wave closure — same latency as other methods.
|
||||
- Selection pressure is very low online (1 wave = 1 fitness evaluation).
|
||||
|
||||
### Assessment for BNNBot
|
||||
- CGP is powerful for Boolean circuit discovery but **requires many fitness evaluations
|
||||
to converge.** A 690-input circuit needs hundreds of good-quality examples before
|
||||
the EA finds a useful structure. One battle (~200 wave hits) is probably insufficient.
|
||||
- The 1+1 ES variant is too slow for credit assignment through depth.
|
||||
- **Low priority for this problem.** Might be interesting for evolving the Boolean
|
||||
function form of individual "neurons" in a fixed-topology network.
|
||||
|
||||
---
|
||||
|
||||
## 8. Amorphous Computing
|
||||
|
||||
### How it works
|
||||
Large numbers of identical, simple agents (cells), each knowing only local state and
|
||||
local neighborhood. No central controller. Emergent behavior from local rules.
|
||||
MIT "Amorphous Computing Manifesto" (Abelson, Knight, Sussman, 1996).
|
||||
|
||||
### Core principle
|
||||
Robustness through redundancy. No single point of failure. Computation arises from
|
||||
the aggregate, not any individual.
|
||||
|
||||
### Mapping to our problem
|
||||
Interpret each of the 690 input bits as an "agent" that has a local rule: based on my
|
||||
bit value and my neighbors' bit values, output 0 or 1. The aggregate output of all
|
||||
agents = prediction.
|
||||
|
||||
Reward modulates the rules: bits whose recent activations correlate with reward keep
|
||||
their rules; others randomize.
|
||||
|
||||
### Assessment for BNNBot
|
||||
- Beautiful concept, impractical for a function approximation problem with a continuous
|
||||
output target. Amorphous computing is good for pattern formation, self-assembly,
|
||||
robust sensing — not regression.
|
||||
- The "agents as bits" mapping loses the distinction between input features: all bits
|
||||
are equivalent, but in our encoding they represent very different things (distance
|
||||
vs heading vs velocity).
|
||||
- **Skip.** Not a good fit for the problem structure.
|
||||
|
||||
---
|
||||
|
||||
## 9. Thermodynamic Computing / Boltzmann Machines
|
||||
|
||||
### How it works
|
||||
Energy-based model: joint distribution over visible (input) and hidden units defined
|
||||
by `P(v,h) ∝ exp(-E(v,h))` where `E = -v^T W h - b^T v - c^T h`. Training via
|
||||
Contrastive Divergence (CD): approximate the gradient of log-likelihood using short
|
||||
Gibbs chains.
|
||||
|
||||
**CD IS gradient descent** — it approximates `∂log P / ∂W`. This violates the no-
|
||||
gradient constraint if we mean parameter gradients. However, CD can be viewed as:
|
||||
1. Run Gibbs sampler from data (positive phase)
|
||||
2. Run Gibbs sampler freely (negative phase)
|
||||
3. `ΔW = eta * (E[v h^T]_data - E[v h^T]_model)`
|
||||
|
||||
The positive/negative phase update is not a gradient in the backprop sense — it uses
|
||||
only local Hebbian correlations. No chain rule, no derivative computation.
|
||||
|
||||
### Binary Boltzmann Machine
|
||||
With binary units: `h_j = sigmoid(W_j * v + c_j) > random`. All operations are
|
||||
binary samples. The weight update `ΔW = v_data * h_data - v_model * h_model` is
|
||||
pure Hebbian multiplication — local, no chain rule.
|
||||
|
||||
### Mapping to our problem
|
||||
- Use as a generative model of (input, position) pairs.
|
||||
- Train unsupervised on observed (input, outcome) pairs from wave hits.
|
||||
- Query: clamp input bits, sample hidden and output units, read prediction.
|
||||
|
||||
### Assessment for BNNBot
|
||||
- The Gibbs sampling for query (inference) is iterative and slow — multiple passes
|
||||
needed per prediction. Bad for 1ms budget.
|
||||
- The model is generative, not discriminative — it models P(input, output) not
|
||||
P(output | input). Conditioning is approximate.
|
||||
- CD is technically a gradient method (gradient of log-likelihood approximated by
|
||||
Gibbs sampling). Borderline against our constraints.
|
||||
- **Low priority.** Conceptually interesting but inference cost and gradient-adjacent
|
||||
training make it a poor fit.
|
||||
|
||||
---
|
||||
|
||||
## 10. Program Synthesis / Inductive Logic Programming (ILP) / Version Spaces
|
||||
|
||||
### How it works
|
||||
**Version spaces (Mitchell 1982):** Maintain the set of all hypotheses consistent with
|
||||
observed examples. Represented by most-specific (S) and most-general (G) boundary sets.
|
||||
Each new example eliminates inconsistent hypotheses. At convergence, S = G = unique
|
||||
correct hypothesis.
|
||||
|
||||
**ILP:** Learn logic programs (Prolog-style rules) from positive and negative examples.
|
||||
Hypothesis is a set of Horn clauses. Operators: generalization (relax conditions),
|
||||
specialization (add conditions).
|
||||
|
||||
### Mapping to our problem
|
||||
- Each wave hit is a (binary_input, true_position) example.
|
||||
- Learn a logic program: `predict_x(Input, X) :- feature_a(Input), feature_b(Input), X is some_function`.
|
||||
- Version space: maintain set of consistent Boolean formulas over 690 bits predicting
|
||||
position within tolerance.
|
||||
|
||||
### The fundamental problem
|
||||
Version spaces require consistent (noise-free) examples. Our wave data has noise
|
||||
(enemy jitters, quantization, Gray coding). ILP hypothesis space is exponential in
|
||||
the number of features. For 690 binary features, the hypothesis space is 2^690.
|
||||
|
||||
Version space collapse (from noise) and exponential search make this intractable at
|
||||
our scale.
|
||||
|
||||
### What the 1990s ILP community knew
|
||||
The key insight: **fewer features = tractable learning.** ILP works beautifully when
|
||||
the representation is already close to the logical structure of the problem.
|
||||
Our 690-bit encoding is over-specified for ILP — it's good for numeric approximation,
|
||||
not symbolic rule learning.
|
||||
|
||||
However: the underlying insight that learning = hypothesis elimination is powerful.
|
||||
The TM can be seen as doing approximate ILP via stochastic clause learning.
|
||||
|
||||
### Assessment for BNNBot
|
||||
- **Skip in raw form.** Intractable at 690-feature scale.
|
||||
- The ILP insight informs the TM approach: learn propositional clauses online, which
|
||||
is tractable ILP restricted to propositional logic.
|
||||
|
||||
---
|
||||
|
||||
## Synthesis: What the 1990s Knew That Deep Learning Made Us Forget
|
||||
|
||||
1. **Credit assignment without gradients is solved.** Bucket brigade (Holland 1986),
|
||||
Q-learning (Watkins 1989), TA reinforcement (Tsetlin 1961) — all predate
|
||||
backpropagation's dominance. Deep learning won because it scales; these algorithms
|
||||
are often better when the input is already binary/symbolic.
|
||||
|
||||
2. **The representation IS the algorithm.** ILP, LCS, and version spaces all force you
|
||||
to think hard about the input language before learning. Deep learning outsources
|
||||
this to gradient descent. Our handcrafted 690-bit encoding is more 1990s than 2020s
|
||||
— and that's appropriate for the constraints.
|
||||
|
||||
3. **Population-based search finds structure without local minima.** GA, GP, ACO avoid
|
||||
the dead-end attractors of gradient descent. But they require many evaluations —
|
||||
the trade-off is evaluation efficiency vs search freedom.
|
||||
|
||||
4. **Reservoir computing predates deep learning.** ESN/LSM (Jaeger 2001, Maass 2002)
|
||||
showed that untrained recurrence + linear readout beats fully trained RNNs in many
|
||||
online settings. We're doing this implicitly already.
|
||||
|
||||
5. **Boolean logic is a valid computation substrate.** The TM rediscovers that
|
||||
conjunctive rules + voting is a universal approximator when the input is binary.
|
||||
Deep learning's obsession with continuous weights was never mandatory.
|
||||
|
||||
---
|
||||
|
||||
## Priority Ranking for BNNBot Implementation
|
||||
|
||||
| # | Approach | Fit | Cost | Risk | Notes |
|
||||
|---|----------|-----|------|------|-------|
|
||||
| 1 | **Regression TM (RTM)** | Excellent | Medium | Low | Purpose-built for binary→continuous, online, no gradients |
|
||||
| 2 | **Deep TM (multi-layer)** | Very good | Medium | Medium | 2025 paper; hierarchical logic; credit through logical structure |
|
||||
| 3 | **HDC + online regression** | Good | Low | Low | 690-bit already HDC-ready; gradient-free; fast |
|
||||
| 4 | **Adaptive reservoir (IP + reward-modulated STDP)** | Good | Low | Low | Incremental upgrade to current architecture |
|
||||
| 5 | **XCS/XCSF** | Moderate | High | Medium | Works but GA convergence slow in single-battle |
|
||||
| 6 | **ACO on binary weights** | Moderate | Medium | High | Delayed reward bookkeeping complex; slow convergence |
|
||||
| 7 | **RBN** | Low | Low | High | No continuous output natively; credit assignment unsolved |
|
||||
| 8 | **CGP** | Low | Low | High | Needs too many evaluations per battle |
|
||||
| 9 | **Boltzmann Machine** | Low | High | High | Inference too slow; CD is gradient-adjacent |
|
||||
| 10 | **Amorphous / ILP / Version Space** | Very low | — | — | Mismatched to continuous regression task |
|
||||
|
||||
---
|
||||
|
||||
## Actionable Next Steps
|
||||
|
||||
1. **Implement Regression TM in Nim.** Binary input is native. Use `s=3..5`, `T=500`,
|
||||
`M=200` clauses as starting point. Two independent RTMs for x and y prediction.
|
||||
Each wave hit = one online update. Replace the Hebbian residual table.
|
||||
|
||||
2. **Test HDC as a cheaper baseline.** The 690-bit encoding already works as a
|
||||
hypervector. Add a similarity-based lookup table (K=20 prototypes) with online
|
||||
linear regression weights per prototype. ~50 lines of code.
|
||||
|
||||
3. **Add intrinsic plasticity to the binary encoding layer** (optional). Tune the
|
||||
gain/threshold of each bit position so its activation rate targets a target
|
||||
distribution. No reward signal needed — purely unsupervised entropy maximization.
|
||||
|
||||
4. **Consider multi-layer TM** only after single-layer RTM baseline is established.
|
||||
The 2025 "Goes Deep" paper is the reference. Credit assignment between layers uses
|
||||
the binary clause output as the inter-layer information carrier — no gradient.
|
||||
|
||||
---
|
||||
|
||||
## Sources
|
||||
|
||||
- [Frontiers: Stochastic and Deterministic Tsetlin Machine](https://www.frontiersin.org/journals/artificial-intelligence/articles/10.3389/frai.2025.1377944/full)
|
||||
- [Regression Tsetlin Machine (arxiv 1905.04206)](https://arxiv.org/abs/1905.04206)
|
||||
- [Tsetlin Machine Goes Deep (arxiv 2507.14874)](https://arxiv.org/pdf/2507.14874)
|
||||
- [Coalesced Multi-Output TM (arxiv 2108.07594)](https://arxiv.org/pdf/2108.07594)
|
||||
- [Self-timed RL with Tsetlin Machine (arxiv 2109.00846)](https://arxiv.org/pdf/2109.00846)
|
||||
- [Reshaping Reservoirs with Hebbian Adaptation — Nature Comms 2025](https://www.nature.com/articles/s41467-025-67137-1)
|
||||
- [Online Reservoir Adaptation by Intrinsic Plasticity — ScienceDirect](https://www.sciencedirect.com/science/article/abs/pii/S0893608007000317)
|
||||
- [On the Criticality of Adaptive Boolean Network Robots (Entropy 2022)](https://doi.org/10.3390/e24101368)
|
||||
- [RegHD: Regression in Hyperdimensional Computing (DAC 2021)](https://dl.acm.org/doi/10.1109/DAC18074.2021.9586284)
|
||||
- [KalmanHD: Time Series with HDC (ASP-DAC 2024)](https://github.com/DarthIV02/KalmanHD)
|
||||
- [Learning Classifier Systems Complete Intro (Urbanowicz 2009)](https://onlinelibrary.wiley.com/doi/10.1155/2009/736398)
|
||||
- [A Brief History of LCS (arxiv 1401.3607)](https://arxiv.org/pdf/1401.3607)
|
||||
- [Boosting Reservoir with Brain-inspired Adaptive Dynamics (arxiv 2504.12480)](https://arxiv.org/pdf/2504.12480)
|
||||
- [Amorphous Computing — CACM](https://cacm.acm.org/research/amorphous-computing/)
|
||||
- [Version Space Learning — Wikipedia](https://en.wikipedia.org/wiki/Version_space_learning)
|
||||
@@ -0,0 +1,77 @@
|
||||
# Research Journal
|
||||
|
||||
## 2026-09-18 — Session 1: Foundation
|
||||
|
||||
### Input Engineering
|
||||
- Stripped Hebbian learning, kept 690-bit encoding
|
||||
- Removed self-state (was 40 bits, not needed for aiming)
|
||||
- Compressed wall distances: 4×7bit → 2×7bit XY position (saved 140 bits)
|
||||
- Evaluated sin/cos vs Gray-code angles: sin/cos kept (no wraparound discontinuity, worth 180 extra bits)
|
||||
- Final: 690 bits = 10 frames × 69 bits
|
||||
|
||||
### Wave Feedback System
|
||||
- Built circular wave system: 10 power levels, expanding at bullet speed
|
||||
- Hit detection: ±18px tolerance, 95.6% hit rate
|
||||
- CSV logging: binary + decimal, 181 columns, toggled via BNNBOT_CSV env var
|
||||
- Provides ground truth for any future learning method
|
||||
|
||||
### Data Analysis
|
||||
- 324 rows from battle_1, 277 fully resolved
|
||||
- Enemy moves in straight lines (97.8% heading stability)
|
||||
- Linear extrapolation is strong baseline (15-27px MAE)
|
||||
- Velocity is constant, acceleration negligible
|
||||
|
||||
### Predictor Backtest
|
||||
- Tested 3 predictors: pure linear, weighted multi-frame, linear + Hebbian residual
|
||||
- Hebbian residual wins: 14-21% MAE reduction, converges within one battle
|
||||
- Only 10/24 table cells activate — sparse problem
|
||||
|
||||
### Theoretical Exploration
|
||||
- XOR layers collapse (associative) — can't stack for depth
|
||||
- AND with fixed masks also linear over GF(2)
|
||||
- Non-linearity requires combining input-dependent signals: popcount + threshold
|
||||
- Depth needs credit assignment through layers — open problem without gradients
|
||||
|
||||
### Key Insight
|
||||
The input engineering IS the deep feature hierarchy. The learnable part should be shallow unless we find a learning rule that can genuinely exploit depth under our constraints (no supervised learning, no gradient descent).
|
||||
|
||||
### Next Steps
|
||||
- Research non-gradient, non-supervised learning methods across domains
|
||||
- Parallel exploration: biology, electronics, discrete math, unconventional CS
|
||||
- Prototype top candidates against CSV data
|
||||
|
||||
## 2026-09-18 — Session 1 (continued): Prototype Results
|
||||
|
||||
### Domain Research (4 parallel explorations)
|
||||
- **Biology**: Three-factor Hebbian + eligibility traces is the universal pattern. Immune clonal selection fits binary weights. Key insight: the wave system provides delayed reward, but eligibility traces (recording which weights contributed) are the missing piece.
|
||||
- **Electronics**: WNN/WiSARD (LUT RAM nodes) — each neuron is a lookup table, O(1) inference, learning = table write. ΣΔ correction accumulators.
|
||||
- **Discrete Math**: The correction signal has only ~4-5 bits of entropy (Shannon analysis). Current 24-cell table is near-optimal for this opponent. Hamming k-NN over full 690 bits could replace hand-picked features.
|
||||
- **Unconventional CS**: Tsetlin Machines — purpose-built for binary inputs + reinforcement. Regression TM handles continuous prediction. "Goes Deep" paper (2025) adds multi-layer hierarchy.
|
||||
|
||||
### Prototype Backtests (277 rows, online learning)
|
||||
|
||||
| Method | Avg MAE | vs Baseline | Convergence |
|
||||
|--------|---------|-------------|-------------|
|
||||
| P1 Linear extrapolation | 12.24 | — | Instant |
|
||||
| P3 Hebbian residual | ~10.45 | −14.6% | Fast (50 rows) |
|
||||
| WiSARD K=12, 276 bits | 9.93 | −18.9% | Fast (50 rows) |
|
||||
| TM Regression (warm) | 12.45 | Still converging | Needs 1000+ rows |
|
||||
| TM last-50 only | 9.37 (p1.07) | Strong | Learning curve active |
|
||||
|
||||
### Key Decisions
|
||||
- WiSARD wins on limited data — simplest, fastest convergence, best MAE
|
||||
- TM has potential but is data-hungry — needs diverse enemy battles
|
||||
- XOR temporal features don't help — raw bits are sufficient
|
||||
- K=12 tuple size is optimal for 277-1000 row datasets
|
||||
|
||||
### Bot Changes Today
|
||||
- **fix(hebbian)**: symmetric learning — both active and inactive outputs learn
|
||||
- **feat(BNNBot)**: shaped reward based on miss distance — every shot teaches something
|
||||
- **style(BNNBot)**: remove 870-bit binary dump from output
|
||||
- **fix(hebbian)**: random weight init to escape zero local minimum
|
||||
|
||||
### Still TODO
|
||||
- Generate battle CSV against diverse enemy types (agent ran out of tokens)
|
||||
- Re-run both prototypes on multi-enemy data
|
||||
- Implement WiSARD in Nim bot
|
||||
- Test TM with more data to see if it surpasses WiSARD
|
||||
@@ -0,0 +1,764 @@
|
||||
# BNNBot Deep Learning: Gradient-Free Methods for Binary Networks
|
||||
|
||||
**Context**: 690-bit binary input, online battle learning, reward = miss distance from circular wave
|
||||
feedback, binary weights/activations preferred. No gradient descent, no STE, no supervised labels.
|
||||
Backprop of *signals* (not gradients) is OK.
|
||||
|
||||
---
|
||||
|
||||
## Evaluation Scorecard Legend
|
||||
|
||||
| Symbol | Meaning |
|
||||
|--------|---------|
|
||||
| ✅ | Full support |
|
||||
| ⚠️ | Partial / with caveats |
|
||||
| ❌ | Fails this criterion |
|
||||
|
||||
**Criteria for each method:**
|
||||
|
||||
1. **No GD** — truly avoids gradient descent (no derivatives, no STE, no surrogate gradients)
|
||||
2. **Binary** — works with binary weights and/or activations
|
||||
3. **RL** — can learn from reward signal instead of labels
|
||||
4. **Online** — can update weights tick-by-tick, not batch-offline
|
||||
5. **Depth** — practically trains 3+ layers
|
||||
6. **Cost** — compute per weight update (relative: Low / Med / High)
|
||||
7. **Finicky** — sensitivity to hyperparameters (Low / Med / High)
|
||||
|
||||
---
|
||||
|
||||
## Method 1: Contrastive Hebbian Learning (CHL) / Equilibrium Propagation
|
||||
|
||||
### How It Works
|
||||
|
||||
CHL runs two phases using an energy-based (Hopfield-like) network:
|
||||
|
||||
1. **Free phase**: Input clamped, hidden + output units relax to energy minimum → record activations
|
||||
`s⁻`
|
||||
2. **Clamped phase**: Input + output clamped to target, hidden units relax → record activations `s⁺`
|
||||
3. **Weight update**: `ΔW_ij ∝ s⁺_i · s⁺_j − s⁻_i · s⁻_j`
|
||||
|
||||
This is purely local — each weight only needs the activations of its two endpoints in both phases.
|
||||
No global error signal flows backward; activity differences drive learning.
|
||||
|
||||
**Equilibrium Propagation (Scellier & Bengio 2017)** is the modern formulation: the clamped phase is a
|
||||
"nudged" version where the output is soft-clamped with a small `β` factor. In the limit β→0, EqProp
|
||||
provably computes the same updates as backprop, but without passing gradients.
|
||||
|
||||
**Binary variant (Laydevant et al., CVPRW 2021)**: EqProp was directly applied to dynamical binary
|
||||
neural networks. The free/clamped phases remain unchanged; binary activations are compatible because
|
||||
the update rule only compares activation products, not derivatives.
|
||||
|
||||
### Can It Work Without Supervised Targets?
|
||||
|
||||
**Critical limitation**: The clamped phase requires knowing the *target output*. In standard CHL/EqProp
|
||||
the output neurons are pushed toward a labeled target. To use reward instead of labels, you need a
|
||||
"nudging" signal at the output layer.
|
||||
|
||||
**Viable workaround for RL**: Instead of nudging toward a ground-truth label, nudge the output in the
|
||||
direction that increases reward. If reward is scalar, define a "desired output shift":
|
||||
- Positive reward: nudge current output activations → reinforce current pattern
|
||||
- Negative reward: nudge away from current output
|
||||
|
||||
This converts CHL into a reward-modulated version. It is not a standard use case but has been explored
|
||||
in neo-Hebbian RL literature. The key: the "nudge" is a *signal* (direction to move), not a gradient.
|
||||
It fits the constraint.
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ✅ | Pure activity differences, no derivatives |
|
||||
| Binary | ✅ | Demonstrated in CVPRW 2021 on dynamic BNNs |
|
||||
| RL | ⚠️ | Needs reward→nudge translation; not native but viable |
|
||||
| Online | ⚠️ | Requires two settling phases per step; adds latency |
|
||||
| Depth | ✅ | EqProp scales to multiple layers; credit is local |
|
||||
| Cost | Med | Two full network relaxations per update |
|
||||
| Finicky | High | β nudge strength, settling iterations, energy landscape |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
Strong theoretical foundation, but the two-phase settling requirement means you need the network to
|
||||
relax to equilibrium twice per firing tick. In Robocode's 1ms budget this is expensive. The reward→
|
||||
nudge translation is non-trivial to implement correctly. **Viable but complex.**
|
||||
|
||||
---
|
||||
|
||||
## Method 2: Forward-Forward Algorithm (FF) / Self-Contrastive FF
|
||||
|
||||
### How It Works
|
||||
|
||||
Hinton (2022): Replace one forward + one backward pass with *two forward passes*:
|
||||
|
||||
1. **Positive pass**: real/good data through the layer → maximize "goodness" G = Σ(y²)
|
||||
2. **Negative pass**: corrupted/bad data → minimize goodness
|
||||
3. **Layer-local update** for each layer independently: push goodness above threshold θ for positive,
|
||||
below for negative. No signal crosses layer boundaries.
|
||||
|
||||
The Self-Contrastive Forward-Forward (SCFF, 2024/2025, Nature Communications) eliminates the label
|
||||
requirement entirely: positive sample = [x_k, x_k] (same input concatenated), negative sample =
|
||||
[x_k, x_n] (two different inputs). The network learns to distinguish same-from-different without
|
||||
any labels.
|
||||
|
||||
### Goodness Function
|
||||
|
||||
`G(l) = (1/M) Σ_m y²_m(l)` — sum of squared activations in layer l over M neurons.
|
||||
|
||||
Learning rule: `ΔW ∝ (σ(G - θ) - target) · ∂G/∂W`
|
||||
|
||||
**Wait — does this have gradients?** Yes, the standard FF uses a sigmoid-of-goodness loss with
|
||||
gradient descent on the goodness. However: (a) the update is strictly *local* to each layer, and
|
||||
(b) ∂G/∂W = 2y · ∂y/∂W. For binary activations with sign() this derivative is zero/undefined.
|
||||
|
||||
**Binary compatibility issue**: The goodness gradient requires ∂y/∂W. With hard binary activations
|
||||
(sign function), this derivative is zero everywhere except at the threshold, breaking the goodness
|
||||
update. The STE would be required to push gradients through — which is explicitly disallowed.
|
||||
|
||||
**Alternative**: Replace the goodness gradient with a Hebbian rule — if G > θ for positive data,
|
||||
do Hebbian update on active neurons; if G < θ for negative data, do anti-Hebbian. This is the
|
||||
"spirit" of FF without the gradient. It loses convergence guarantees but preserves the structure.
|
||||
|
||||
### Adaptation for RL
|
||||
|
||||
Since SCFF already generates its own positive/negative pairs without labels, it operates as a
|
||||
*representation learning* system. For Robocode: the FF layers would learn good binary representations;
|
||||
then a reward-modulated Hebbian output layer would learn to map representations to predictions.
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ⚠️ | Standard FF uses local GD on goodness; binary requires Hebbian approximation |
|
||||
| Binary | ⚠️ | Needs Hebbian approximation of goodness; SCFF uses ReLU throughout |
|
||||
| RL | ⚠️ | SCFF is self-supervised (representation learning); needs separate RL output layer |
|
||||
| Online | ✅ | Layer-local, greedy, update after each sample |
|
||||
| Depth | ✅ | By design — each layer trains independently |
|
||||
| Cost | Low | Two forward passes per update, strictly local |
|
||||
| Finicky | Med | Threshold θ, concatenation design choices |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
FF is excellent for building deep binary representations without labels. It cannot directly predict
|
||||
position with reward alone — you'd hybridize it: FF middle layers for feature extraction, reward-
|
||||
modulated Hebbian output layer for prediction. The goodness-gradient problem with hard binary
|
||||
activations is the main obstacle. **Good as a representation sub-system; needs hybridization.**
|
||||
|
||||
---
|
||||
|
||||
## Method 3: Predictive Coding Networks (PCN)
|
||||
|
||||
### How It Works
|
||||
|
||||
Each layer l predicts the activation of layer l-1 from above using top-down weights. The prediction
|
||||
error e_l = x_l − μ_l (actual minus predicted) propagates locally upward and downward.
|
||||
|
||||
Weight update: `ΔW ∝ e_l · x_{l-1}^T` (Hebbian on error × lower-layer activation)
|
||||
|
||||
This is **self-supervised by construction**: the "target" of each layer is the actual activation
|
||||
of the layer below it. No external labels needed. With temporal data, each layer can predict the
|
||||
next time frame — perfectly suited to 10-frame temporal windows.
|
||||
|
||||
**Active Predictive Coding (APC, 2022)**: Combines predictive coding with RL for robotic sparse
|
||||
reward problems. The prediction error serves as an intrinsic reward signal. Demonstrated on robotic
|
||||
control tasks with sparse rewards.
|
||||
|
||||
**PCN-TA (2025)**: Temporal amortization preserves latent states across frames, yielding 50% fewer
|
||||
inference steps and 10% fewer weight updates vs. backprop.
|
||||
|
||||
### Gradient Status
|
||||
|
||||
Standard PCN inference minimizes free energy F = Σ e_l² by gradient descent on *activations*
|
||||
(not weights). This is allowed — you're adjusting activity, not weights, via derivatives. Weight
|
||||
updates are then Hebbian: `ΔW ∝ e · x`. No gradient of the loss w.r.t. weights is computed.
|
||||
|
||||
**Technically pure**: the weight update is `ΔW_l = η · e_l · x_{l-1}^T`, which is purely local and
|
||||
Hebbian-like. The inference phase uses a form of gradient descent on activations, which is a
|
||||
signal-flow operation (activations are signals), consistent with "backprop of signals allowed."
|
||||
|
||||
### Binary Compatibility
|
||||
|
||||
PCN with continuous activations works cleanly. Binary activations are harder: the inference phase
|
||||
requires iterative adjustment of continuous latent variables before thresholding. A common approach:
|
||||
keep latent variables continuous during inference, threshold only for output/communication. This is
|
||||
the "semi-binary" regime used in neuromorphic PCN implementations.
|
||||
|
||||
### Fit for Temporal Prediction
|
||||
|
||||
Our 10 temporal frames map directly to a hierarchical PCN structure:
|
||||
- Layer 1: current-frame features
|
||||
- Layer 2: short-term dynamics (frames 0-2)
|
||||
- Layer 3: trajectory trend (frames 0-9)
|
||||
- Each layer predicts the layer below across time
|
||||
|
||||
The reward signal (miss distance) can modulate the prediction error magnitude at the output layer,
|
||||
biasing learning toward accurate predictions.
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ✅ | Weight update is Hebbian `e·x`; inference GD is on activations (signals) |
|
||||
| Binary | ⚠️ | Latent variables need continuous inference; output can be binary |
|
||||
| RL | ✅ | APC demonstrated; error = intrinsic reward; reward modulates output layer |
|
||||
| Online | ✅ | PCN-TA designed for online per-frame learning |
|
||||
| Depth | ✅ | Hierarchical by design; 3+ layers well studied |
|
||||
| Cost | Med | Multiple inference iterations per step (reduced 50% in PCN-TA) |
|
||||
| Finicky | Med | Inference step count, precision/ratio of prediction error weights |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
**Excellent match for our temporal structure.** The self-supervised nature, temporal hierarchy,
|
||||
and local Hebbian weight updates align with every constraint. Main cost: inference iterations.
|
||||
PCN-TA reduces this significantly. The semi-binary regime (continuous latent, binary output) is a
|
||||
realistic implementation path.
|
||||
|
||||
---
|
||||
|
||||
## Method 4: Target Propagation / Difference Target Propagation (DTP)
|
||||
|
||||
### How It Works
|
||||
|
||||
Instead of propagating gradients, TP learns an *inverse model* at each layer: a backward network
|
||||
g_l that maps activations of layer l+1 back to layer l. The target for layer l is:
|
||||
|
||||
`h_l^target = g_l(h_{l+1}^target)`
|
||||
|
||||
**Difference Target Propagation (DTP)**: corrects for imperfect inverses by using:
|
||||
|
||||
`h_l^target = h_l + g_l(h_{l+1}^target) − g_l(h_{l+1})`
|
||||
|
||||
The target for the output layer *still requires a supervised target* — this is the fundamental
|
||||
limitation. DTP cannot generate its own target; it only propagates given targets layer-by-layer.
|
||||
|
||||
### Does It Need Supervised Output?
|
||||
|
||||
**Yes, inherently.** The output-layer target must come from somewhere. In RL, you could define the
|
||||
output target as "the output that would have hit the enemy" — but this requires knowing the correct
|
||||
output, which is equivalent to supervised learning. The reward tells you *how much* you were off,
|
||||
not *where* you should have aimed.
|
||||
|
||||
Additionally: "the target for the final hidden layer is determined by a formula which relies on
|
||||
gradient descent" (from DTP theory paper). This means gradient descent leaks in even in DTP.
|
||||
|
||||
### Binary Compatibility
|
||||
|
||||
DTP can work with binary units (Lee et al. showed this: "it can be applied even when units exchange
|
||||
stochastic bits rather than real numbers"). But non-invertible binary networks cause reconstruction
|
||||
errors to interfere with target propagation updates.
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ❌ | Output-layer target computation involves GD; inverse model also trained with GD |
|
||||
| Binary | ⚠️ | Stochastic binary supported but reconstruction error problem |
|
||||
| RL | ❌ | Requires supervised output target; reward alone insufficient |
|
||||
| Online | ⚠️ | Possible but inverse models add computational overhead |
|
||||
| Depth | ✅ | Designed for depth; that's the whole point |
|
||||
| Cost | High | Two networks (forward + inverse) per layer |
|
||||
| Finicky | High | Inverse model training, reconstruction accuracy |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
**Not suitable.** Despite claiming "no backprop," DTP requires gradient descent for the inverse
|
||||
models and for the output target. Does not fit RL-only constraint. Skip.
|
||||
|
||||
---
|
||||
|
||||
## Method 5: Reward-Modulated STDP (R-STDP) / Three-Factor Learning / E-prop
|
||||
|
||||
### How It Works
|
||||
|
||||
**Three-factor rule**: `ΔW_ij = η · e_ij · r(t)` where:
|
||||
- `e_ij` = eligibility trace: local pre×post spike correlation (STDP-like)
|
||||
- `r(t)` = global reward signal (scalar, broadcast to all synapses)
|
||||
|
||||
Eligibility trace: `de_ij/dt = −e_ij/τ + STDP(t_pre, t_post)` — decaying memory of recent spike
|
||||
correlations.
|
||||
|
||||
This handles temporal credit assignment: the trace remembers which synapses fired recently when
|
||||
the (delayed) reward arrives.
|
||||
|
||||
**E-prop (Bellec et al., Nature Comms 2020)**: Extends three-factor learning to deep and recurrent
|
||||
SNNs. Each layer l has an eligibility trace that accounts for the temporal dynamics of the LIF neuron.
|
||||
E-prop with reward-based RL (r-e-prop) was demonstrated winning Atari games.
|
||||
|
||||
**Critical depth finding**: "e-prop implemented in a single-layer recurrent SNN consistently
|
||||
outperforms a multi-layer variant." Adding more layers hurts because the eligibility trace at layer l
|
||||
only captures local pre/post correlations — it cannot account for multi-layer credit assignment
|
||||
without approximate gradients. E-prop for deep feedforward networks approximates backprop, not a
|
||||
clean departure from it.
|
||||
|
||||
### Binary Compatibility
|
||||
|
||||
SNNs fire binary spikes by definition (0 or 1), so R-STDP is natively binary-compatible. Weights
|
||||
can also be binarized. The eligibility trace is continuous (a real-valued running average), but that
|
||||
is internal state, not a gradient propagated through the network.
|
||||
|
||||
### Credit Assignment Through Depth
|
||||
|
||||
This is the weak point. R-STDP solves temporal credit assignment (delay between action and reward)
|
||||
but not *spatial* credit assignment (which layer contributed to the good/bad output). In a 3-layer
|
||||
network with R-STDP applied uniformly, all layers update on the same reward signal regardless of
|
||||
their contribution. This works empirically in shallow networks but degrades with depth.
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ✅ | Local STDP trace × reward; no derivatives anywhere |
|
||||
| Binary | ✅ | Native binary (spikes); weights can also be binary |
|
||||
| RL | ✅ | Reward is the direct learning signal; no labels |
|
||||
| Online | ✅ | Per-spike updates; inherently online |
|
||||
| Depth | ⚠️ | Works but degrades with depth; single-layer LSNN beats multi-layer |
|
||||
| Cost | Low | Eligibility trace update O(n_synapses) per tick |
|
||||
| Finicky | Med | τ_eligibility, reward scaling, STDP window |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
**Best fit for shallow networks.** For a 2-layer binary SNN (one hidden layer), R-STDP is the
|
||||
cleanest solution: no gradients, native binary, direct reward learning, very cheap. For 3+ layers,
|
||||
credit assignment degrades. Consider using it for the *output layer* in combination with another
|
||||
method for hidden layers. **Highly recommended for shallow or hybrid architectures.**
|
||||
|
||||
---
|
||||
|
||||
## Method 6: Node Perturbation / Weight Perturbation
|
||||
|
||||
### How It Works
|
||||
|
||||
**Node perturbation (NP)**: Add noise ξ to each layer's activations, measure reward R, update:
|
||||
`ΔW_ij ∝ ξ_j · (R − R̄)` where R̄ is baseline reward.
|
||||
|
||||
**Weight perturbation (WP)**: Add noise directly to weights: `ΔW_ij ∝ ε_ij · (R − R̄)`
|
||||
|
||||
**Key insight**: This estimates the gradient without computing it. It is a Monte Carlo gradient
|
||||
estimate — unbiased but high variance.
|
||||
|
||||
**Decorrelated NP (DNP, 2023)**: Applying input decorrelation at each layer "dramatically improves
|
||||
convergence by orders of magnitude." Makes NP practical for multi-layer networks.
|
||||
|
||||
**Variance problem**: The SNR of the NP gradient estimate scales as `1/(N·σ_noise²)` where N =
|
||||
number of parameters. For a 690-bit → 256-neuron hidden layer, N ≈ 176,640 weights. The variance
|
||||
explosion makes learning essentially random without variance reduction.
|
||||
|
||||
**For binary networks specifically**: Weight perturbation on binary weights means randomly flipping
|
||||
bits and measuring reward change. This is exactly the "simulated annealing on neural net weights"
|
||||
approach. It is well-defined and requires no derivatives. The update becomes:
|
||||
|
||||
`if flip W_ij causes ΔR > 0: keep flip; else: revert (with probability based on ΔR)`
|
||||
|
||||
This is pure stochastic search — not gradient estimation. Works cleanly with binary weights.
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ✅ | Statistical gradient estimation; no derivatives |
|
||||
| Binary | ✅ | WP maps naturally to bit-flip search |
|
||||
| RL | ✅ | Reward is the direct signal |
|
||||
| Online | ✅ | Update per trial; eligible for online use |
|
||||
| Depth | ⚠️ | DNP scales to 3-9 layers; variance still significant |
|
||||
| Cost | High | Many perturbation samples needed for convergence |
|
||||
| Finicky | Med | Perturbation magnitude σ, baseline estimator |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
**The cleanest in principle, but expensive.** Weight perturbation on a binary network is essentially
|
||||
a guided random walk through {-1,+1}^N. With N ≈ 176K weights in a hidden layer, random perturbation
|
||||
converges very slowly. Works best when: (a) network is small, (b) few samples needed per weight. For
|
||||
the *output layer only* (small, ~64 weights to prediction neurons), this is practical. **Suitable as
|
||||
output-layer fine-tuner; too slow as sole learning method for deep networks.**
|
||||
|
||||
---
|
||||
|
||||
## Method 7: InfoMax / Information Maximization
|
||||
|
||||
### How It Works
|
||||
|
||||
Linsker (1988), Bell & Sejnowski (1995): Maximize mutual information I(X; Y) between layer input X
|
||||
and output Y, subject to noise constraints.
|
||||
|
||||
Local learning rule (continuous case): `ΔW_ij ∝ [φ'(y_i)/φ(y_i)] · x_j − W_ij^{-T}`
|
||||
|
||||
For the binary/ICA case (Bell-Sejnowski): involves a nonlinear function of output activation and
|
||||
the input pattern. In practice, this maximizes entropy of the output distribution, preventing the
|
||||
network from collapsing all outputs to zero or all-ones.
|
||||
|
||||
### Binary Compatibility
|
||||
|
||||
InfoMax with binary activations maximizes entropy H(Y) — binary outputs should have p(y=1) ≈ 0.5
|
||||
across data. The update rule involves the "score function" of the output distribution, which for
|
||||
binary units is well-defined without derivatives through the activation function itself.
|
||||
|
||||
### Self-Supervised Nature
|
||||
|
||||
InfoMax requires *no labels*. It maximizes information preserved from input to output. This makes
|
||||
it useful for *representation learning in hidden layers* — building diverse, non-collapsed binary
|
||||
features. It does not directly learn to predict enemy position.
|
||||
|
||||
### Limitations for RL
|
||||
|
||||
InfoMax is a representation learning method. It maximizes informativeness of intermediate features
|
||||
but has no notion of task reward. You cannot directly optimize miss distance with InfoMax alone.
|
||||
It would serve as a **pretraining / regularization layer** to prevent dead neurons and maintain
|
||||
diverse binary representations.
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ✅ | Local Hebbian-like rule with anti-Hebbian lateral term |
|
||||
| Binary | ✅ | Entropy maximization is well-defined for binary units |
|
||||
| RL | ❌ | Pure representation learning; no reward optimization |
|
||||
| Online | ✅ | Fully online, local update |
|
||||
| Depth | ✅ | Applied layer-by-layer independently |
|
||||
| Cost | Low | Single forward pass per update |
|
||||
| Finicky | Low | Few parameters; entropy maximization is self-stabilizing |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
**Excellent regularizer / auxiliary learning rule.** Run InfoMax as an auxiliary update on hidden
|
||||
layers to prevent representational collapse while the output layer learns from reward. Very cheap.
|
||||
**Use as a complement to primary method, not standalone.**
|
||||
|
||||
---
|
||||
|
||||
## Method 8: Evolutionary / Genetic Algorithms for Binary BNNs
|
||||
|
||||
### How It Works
|
||||
|
||||
Maintain a population of binary weight matrices. Each individual is a complete set of weights
|
||||
`{W_l}` with values in {-1, +1}. Evolution:
|
||||
|
||||
1. Evaluate fitness (reward = hit rate, negative miss distance)
|
||||
2. Select top-K individuals (tournament or truncation selection)
|
||||
3. Crossover: combine weight sub-matrices from two parents
|
||||
4. Mutation: randomly flip bits with probability p_mut
|
||||
5. Repeat
|
||||
|
||||
Binary networks are particularly GA-friendly because:
|
||||
- The search space is discrete and finite
|
||||
- Crossover has a clean interpretation (taking different weight blocks)
|
||||
- No gradient computation at all
|
||||
- No issues with binary activations (trivially compatible)
|
||||
|
||||
### Population-Based Training During a Battle
|
||||
|
||||
A battle has ~1000+ ticks. With a population of P=10-20 individuals, each tick evaluates the
|
||||
current "best" policy, and every N ticks (after a reward arrives from circular wave) the population
|
||||
updates. This is a form of online evolution.
|
||||
|
||||
**Key problem**: Each individual needs to be evaluated on the *same input* to compare fitnesses.
|
||||
During a battle, inputs change each tick — you cannot hold them constant while evaluating 20 models.
|
||||
Solutions:
|
||||
- Maintain an experience replay buffer; evaluate candidates on stored states
|
||||
- Use the single "best" candidate in battle, explore with perturbations (= weight perturbation)
|
||||
- Use island model: different individuals fight in different battles
|
||||
|
||||
### Practical Issues
|
||||
|
||||
- Population of 20 requires 20× memory for weights
|
||||
- Fitness estimates from sequential battle experience are noisy (different opponents, different
|
||||
positions each eval)
|
||||
- Crossover between weights that serve different layers may break learned structure
|
||||
- Convergence within a single 1000-tick battle is unlikely for deep networks
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ✅ | Pure fitness-based search |
|
||||
| Binary | ✅ | Perfect; binary is ideal for genetic operators |
|
||||
| RL | ✅ | Fitness = battle reward; no labels |
|
||||
| Online | ❌ | Population requires multiple evaluations; impossible in a single live battle |
|
||||
| Depth | ✅ | Architecture-agnostic |
|
||||
| Cost | High | O(P × network_size) per generation |
|
||||
| Finicky | Med | Population size, mutation rate, selection pressure |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
**Not suitable for within-battle online learning.** The population-based evaluation requirement
|
||||
breaks against the single-agent, real-time constraint. Best applied *between battles* (offline
|
||||
evolution over many battles). If we're restricted to online learning, this is out. **Viable only
|
||||
as inter-battle meta-learning.**
|
||||
|
||||
---
|
||||
|
||||
## Method 9: Feedback Alignment (FA) / Direct Feedback Alignment (DFA)
|
||||
|
||||
### How It Works
|
||||
|
||||
**Feedback Alignment (Lillicrap et al., 2016)**: Replace backprop's transposed weight matrices
|
||||
W^T in the backward pass with fixed random matrices B. The claim: the forward weights align to
|
||||
B during training, so the random backward signal still provides useful credit assignment.
|
||||
|
||||
**Direct Feedback Alignment (DFA)**: Each layer receives credit directly from the output error
|
||||
multiplied by a random matrix B_l (layer-specific). No sequential backward pass needed.
|
||||
|
||||
### The Gradient Problem
|
||||
|
||||
FA and DFA fundamentally still compute a gradient of the loss at the *output layer* and propagate
|
||||
that signal (or a random-projection of it) backward. The output gradient `∂L/∂y` is a derivative.
|
||||
This violates the "no gradient descent" constraint. FA avoids the *weight transport* problem but
|
||||
does not avoid derivatives entirely.
|
||||
|
||||
**Is the "signal" interpretation valid?** You could argue: the output error `(y - target)` is a
|
||||
signal (not a derivative). If you replace this with a reward-modulated output unit error, you
|
||||
avoid computing a derivative. But this is a stretch — in practice, FA implementations use `∂L/∂y`.
|
||||
|
||||
**Binary compatibility**: FA fails on binary networks because the backward signal through hard
|
||||
thresholds is zero everywhere (the same STE problem as standard backprop). Papers report "FA
|
||||
fails in deep networks, convolutional layers, or architectures with bottlenecks."
|
||||
|
||||
### Scorecard
|
||||
|
||||
| Criterion | Score | Notes |
|
||||
|-----------|-------|-------|
|
||||
| No GD | ❌ | Output gradient still computed; only backward weight symmetry is removed |
|
||||
| Binary | ❌ | Fails with binary activations without STE |
|
||||
| RL | ⚠️ | Could replace loss gradient with reward signal, but then it's R-STDP |
|
||||
| Online | ✅ | Online update possible |
|
||||
| Depth | ⚠️ | DFA works at depth but with performance degradation |
|
||||
| Cost | Low | Same cost as forward pass + random projection |
|
||||
| Finicky | Low | Random fixed matrices; no tuning needed |
|
||||
|
||||
### Fit Assessment
|
||||
|
||||
**Not suitable as stated.** FA/DFA require output-layer gradients and fail with binary activations.
|
||||
If you replace the output gradient with a reward signal and the backward pass with fixed random
|
||||
projections, you get something closer to random reward feedback — a variant of node perturbation,
|
||||
which is covered above. **Skip in favor of R-STDP or node perturbation.**
|
||||
|
||||
---
|
||||
|
||||
## Method 10: Additional Methods Found
|
||||
|
||||
### 10a: Equilibrium Propagation + CHL as a Unified Framework
|
||||
|
||||
Recent work (arXiv 2206.02629) shows that CHL, EqProp, and predictive coding all converge to the
|
||||
same limit at infinitesimal inference steps — they are the same algorithm in different dynamical
|
||||
regimes. This means choosing among them is primarily about implementation tradeoffs (settling speed,
|
||||
binary compatibility) not fundamental differences.
|
||||
|
||||
### 10b: Counter-Current Learning (CCL, 2024)
|
||||
|
||||
A dual-network approach: one network runs forward (inference), the other runs backward (teaching).
|
||||
The backward network generates targets for the forward network without computing gradients. Used
|
||||
as a biologically plausible alternative to backprop. Requires paired network architecture, doubling
|
||||
memory. Interesting but adds complexity. **Skip for now.**
|
||||
|
||||
### 10c: E-prop with Reward (r-e-prop)
|
||||
|
||||
Specifically the reward-based variant of e-prop demonstrated on Atari. This is three-factor learning
|
||||
with eligibility traces designed for temporal credit assignment, formally shown to approximate
|
||||
policy gradients. Does use gradient approximations internally (via the eligibility trace derivation),
|
||||
but the weight update itself is `ΔW = e_ij · r(t)` — a local multiplication.
|
||||
|
||||
**Whether this "counts" as gradient descent**: The eligibility trace `e_ij` is derived from the
|
||||
neuron's dynamical equations and approximates `∂h_l/∂W`. This is a gradient of *activations*
|
||||
w.r.t. weights (signal propagation), not a gradient of the *loss*. It satisfies "backprop of
|
||||
signals" while avoiding "gradient descent on loss." **This is the cleanest theoretical fit.**
|
||||
|
||||
### 10d: Noise-Based Reward-Modulated Learning (2025, arXiv 2503.23972)
|
||||
|
||||
Explicitly designed for spiking/binary units: natural noise in binary neurons drives stochastic
|
||||
exploration, reward signal modulates which noise patterns are reinforced. Weight update:
|
||||
`ΔW ∝ ξ · r(t)` where ξ is inherent neural noise (spike timing jitter). Online, local, binary-native.
|
||||
**Very relevant — this is weight perturbation where perturbation = natural spike noise.**
|
||||
|
||||
### 10e: Self-Contrastive Forward-Forward (SCFF, Nature Comms 2025)
|
||||
|
||||
Published result: MNIST 98.7%, CIFAR-10 80.75%, STL-10 77.3% without any labels. Layer-local
|
||||
goodness function. Greedy layer-wise training. The best current result for label-free local learning
|
||||
in deep networks. Needs Hebbian approximation for hard binary activations.
|
||||
|
||||
---
|
||||
|
||||
## Comparative Scorecard Summary
|
||||
|
||||
| Method | No GD | Binary | RL | Online | Depth | Cost | Finicky | **Score** |
|
||||
|--------|-------|--------|-----|--------|-------|------|---------|-----------|
|
||||
| CHL / EqProp | ✅ | ✅ | ⚠️ | ⚠️ | ✅ | Med | High | **6/9** |
|
||||
| FF / SCFF | ⚠️ | ⚠️ | ⚠️ | ✅ | ✅ | Low | Med | **5.5/9** |
|
||||
| Predictive Coding | ✅ | ⚠️ | ✅ | ✅ | ✅ | Med | Med | **7.5/9** |
|
||||
| Target Propagation | ❌ | ⚠️ | ❌ | ⚠️ | ✅ | High | High | **2/9** |
|
||||
| R-STDP / 3-factor | ✅ | ✅ | ✅ | ✅ | ⚠️ | Low | Med | **7.5/9** |
|
||||
| Node/Weight Perturb | ✅ | ✅ | ✅ | ✅ | ⚠️ | High | Med | **6.5/9** |
|
||||
| InfoMax | ✅ | ✅ | ❌ | ✅ | ✅ | Low | Low | **5/9** (aux only) |
|
||||
| Genetic / EA | ✅ | ✅ | ✅ | ❌ | ✅ | High | Med | **4/9** |
|
||||
| Feedback Alignment | ❌ | ❌ | ⚠️ | ✅ | ⚠️ | Low | Low | **2/9** |
|
||||
| r-e-prop | ✅ | ✅ | ✅ | ✅ | ⚠️ | Low | Med | **7.5/9** |
|
||||
|
||||
---
|
||||
|
||||
## TOP 3 RECOMMENDATIONS
|
||||
|
||||
### Rank 1: R-STDP / Three-Factor Learning (Shallow + Output Layer)
|
||||
|
||||
**Why #1**: Every criterion met cleanly. No derivatives anywhere. Binary spikes are native. Reward
|
||||
is the direct learning signal. Per-tick online updates. Cheap (O(n_synapses) per tick).
|
||||
|
||||
**The constraint**: poor depth scaling. Solution: limit depth or use shallow BNN with this method.
|
||||
|
||||
**Architecture sketch** (2-layer BNN):
|
||||
|
||||
```
|
||||
Input (690 bits)
|
||||
│
|
||||
▼ W1 ∈ {-1,+1}^{690×128}
|
||||
Hidden Layer (128 binary neurons)
|
||||
│ ↑ InfoMax auxiliary update (prevents collapse)
|
||||
▼ W2 ∈ {-1,+1}^{128×64}
|
||||
Output Layer (64 binary neurons → [predX, predY] via dot-product readout)
|
||||
│
|
||||
▼
|
||||
Circular wave feedback → miss distance → reward r(t)
|
||||
│
|
||||
└──→ Eligibility trace e_ij = e_ij · τ_decay + STDP(pre_j, post_i)
|
||||
Weight update: ΔW_ij = η · e_ij · r(t) [for all layers uniformly]
|
||||
```
|
||||
|
||||
**Signal flow for depth**: Use a **reward-gated reverse signal** — after reward arrives, compute
|
||||
output layer error signal (not gradient, just "output was wrong by X direction") and multiply by a
|
||||
random fixed matrix B to project to hidden layer. This gives hidden layer a noisy credit signal.
|
||||
This is the "feedback alignment without gradients" version where the output error is a reward signal
|
||||
(binary direction: aim left or right), not a loss derivative.
|
||||
|
||||
**Hypers**: τ_eligibility ≈ 10 ticks (covers bullet travel time), η ≈ 0.01, STDP window ≈ 3 ticks.
|
||||
|
||||
---
|
||||
|
||||
### Rank 2: Predictive Coding with Reward-Gated Output
|
||||
|
||||
**Why #2**: Best theoretical fit to our temporal 10-frame structure. Self-supervised hidden layers
|
||||
(no labels needed), reward modulates only the output layer. Proven online on edge robots (IROS 2025).
|
||||
|
||||
**Architecture sketch** (3-layer PCN with temporal hierarchy):
|
||||
|
||||
```
|
||||
Frame buffer: [f0..f9] (10 temporal frames × 69 fields = 690 bits)
|
||||
|
||||
Layer 3 (top): trajectory-level representation, 64 neurons
|
||||
↕ predicts/corrects ↕ W3 = Hebbian update: e3 · h2^T
|
||||
Layer 2: motion dynamics, 128 neurons
|
||||
↕ predicts/corrects ↕ W2 = e2 · h1^T
|
||||
Layer 1: per-frame features, 256 neurons
|
||||
↕ corrects ↕ W1 = e1 · x^T
|
||||
Input: 690-bit frame vector
|
||||
|
||||
Signal flow:
|
||||
Forward: h_l = σ(W_l · h_{l-1}) [inference]
|
||||
Backward: μ_l = W_{l+1}^T · h_{l+1} [top-down prediction, W^T of SAME weights]
|
||||
Error: e_l = h_l − μ_l [local prediction error]
|
||||
Weight: ΔW_l = η_rep · e_l · h_{l-1}^T [Hebbian on error × input]
|
||||
|
||||
Reward integration:
|
||||
Output layer e_out += η_reward · r(t) · sign(h_out − target_direction)
|
||||
where target_direction is estimated from miss distance (left/right of predicted pos)
|
||||
```
|
||||
|
||||
**Key**: the weight update `ΔW = e · h^T` is Hebbian, not gradient descent. The inference phase
|
||||
(adjusting activations to minimize prediction error) uses signal flow, not backprop. Binarize outputs
|
||||
only; keep latent variables as integers 0-255 (8-bit) for inference, threshold for communication.
|
||||
|
||||
**Hypers**: inference iterations ≈ 3-5 per tick (PCN-TA reduces this), η_rep ≈ 0.001, η_reward ≈ 0.05.
|
||||
|
||||
---
|
||||
|
||||
### Rank 3: Self-Contrastive FF (SCFF) for Deep Representations + R-STDP Output
|
||||
|
||||
**Why #3**: Best combination for a deeper (3+ layer) network when richer representations are needed.
|
||||
SCFF trains hidden layers purely from self-supervised data (no labels, no reward). R-STDP on the
|
||||
output layer uses reward directly. Two independent, specialized learning mechanisms.
|
||||
|
||||
**Architecture sketch**:
|
||||
|
||||
```
|
||||
Input: 690-bit × 2 (concatenated for SCFF contrast)
|
||||
|
||||
Layer 1: 512 binary neurons
|
||||
SCFF update: Hebbian-approx goodness rule
|
||||
positive pair: [x_k, x_k] → increase goodness
|
||||
negative pair: [x_k, x_n] → decrease goodness
|
||||
ΔW ∝ (target_goodness − actual_goodness) · pre_activity [no STE — approximate]
|
||||
|
||||
Layer 2: 256 binary neurons
|
||||
SCFF update: same as Layer 1
|
||||
|
||||
Layer 3: 128 binary neurons
|
||||
SCFF update: same
|
||||
|
||||
Output: 32 binary neurons → [predX, predY] decoding
|
||||
R-STDP update: ΔW ∝ e_ij · r(t) [three-factor, reward = −miss_distance]
|
||||
Eligibility trace: STDP on output spikes × layer-3 spikes
|
||||
```
|
||||
|
||||
**Why this works**: Hidden layers learn to preserve temporal motion patterns from the input buffer
|
||||
(self-supervised: same-frame vs different-frame contrast captures motion coherence). Output layer
|
||||
learns which patterns correlate with correct predictions (reward). The two learning rules are
|
||||
orthogonal and can run simultaneously without interference.
|
||||
|
||||
**The SCFF-binary approximation**: Replace `∂goodness/∂W` with Hebbian on active neurons when
|
||||
goodness exceeds/falls below threshold θ. Loses convergence guarantees but works empirically for
|
||||
binary feature learning. θ ≈ 0.5 × expected_activation_rate.
|
||||
|
||||
**Hypers**: θ ≈ 0.4, τ_eligibility ≈ 10, η_scff ≈ 0.001 (slow), η_rstdp ≈ 0.01 (fast).
|
||||
|
||||
---
|
||||
|
||||
## Final Notes and Red Flags
|
||||
|
||||
### Things That Look Gradient-Free But Aren't
|
||||
|
||||
1. **Target Propagation**: Output target still needs gradient descent. ❌
|
||||
2. **Feedback Alignment**: Random backward weights but still computes `∂L/∂y`. ❌
|
||||
3. **Standard Forward-Forward**: Goodness gradient is a real derivative through relu. Needs approximation for binary. ⚠️
|
||||
4. **E-prop (standard version)**: Eligibility trace approximates `∂h/∂W` — it is a gradient of
|
||||
activations, which satisfies "backprop of signals" but is worth flagging. ✅ (barely)
|
||||
|
||||
### The Depth-vs-Purity Trade-off
|
||||
|
||||
There is a fundamental tension: pure local learning rules (InfoMax, R-STDP) have no depth credit
|
||||
assignment. Any method that propagates credit through depth (CHL, EqProp, PCN, e-prop) uses some
|
||||
form of signal backpropagation. The question is whether those signals are *gradients of a loss*
|
||||
(forbidden) or *prediction errors / activity differences* (allowed as signals). All three
|
||||
recommendations above fall in the "allowed" category by that interpretation.
|
||||
|
||||
### Practical Starting Point
|
||||
|
||||
Start with **Rank 1** (R-STDP, 2 layers). It is the fastest to implement, cheapest to run, and
|
||||
cleanest theoretically. Add **InfoMax** as a free auxiliary update on the hidden layer to prevent
|
||||
dead neurons. Measure performance. If representation quality is bottlenecking predictions, move to
|
||||
**Rank 2** (PCN temporal hierarchy). Only move to **Rank 3** (SCFF+R-STDP) if deeper representations
|
||||
are demonstrably needed.
|
||||
|
||||
---
|
||||
|
||||
## Sources
|
||||
|
||||
- [Contrastive Hebbian Learning with Random Feedback Weights](https://arxiv.org/pdf/1806.07406)
|
||||
- [Two Tales of Single-Phase Contrastive Hebbian Learning](https://arxiv.org/pdf/2402.08573)
|
||||
- [Equilibrium Propagation: Bridging the Gap between Energy-Based Models and Backpropagation](https://arxiv.org/html/1602.05179v5)
|
||||
- [Training Dynamical Binary Neural Networks with Equilibrium Propagation (CVPRW 2021)](https://openaccess.thecvf.com/content/CVPR2021W/BiVision/papers/Laydevant_Training_Dynamical_Binary_Neural_Networks_With_Equilibrium_Propagation_CVPRW_2021_paper.pdf)
|
||||
- [The Forward-Forward Algorithm: Some Preliminary Investigations (Hinton 2022)](https://www.cs.toronto.edu/~hinton/FFA13.pdf)
|
||||
- [Self-Contrastive Forward-Forward Algorithm (Nature Comms 2025)](https://www.nature.com/articles/s41467-025-61037-0)
|
||||
- [Self-Contrastive Forward-Forward Algorithm (arXiv 2409.11593)](https://arxiv.org/abs/2409.11593)
|
||||
- [Efficient Online Learning with Predictive Coding Networks: Exploiting Temporal Correlations (PCN-TA)](https://arxiv.org/abs/2510.25993)
|
||||
- [Introduction to Predictive Coding Networks for Machine Learning](https://arxiv.org/pdf/2506.06332)
|
||||
- [Active Predicting Coding: Brain-Inspired RL for Sparse Reward Robotic Control](https://arxiv.org/pdf/2209.09174)
|
||||
- [A Theoretical Framework for Target Propagation](https://arxiv.org/pdf/2006.14331)
|
||||
- [Towards Scaling Difference Target Propagation by Learning Backprop Targets](https://proceedings.mlr.press/v162/ernoult22a/ernoult22a.pdf)
|
||||
- [Three-factor learning in spiking neural networks (PMC 2025)](https://pmc.ncbi.nlm.nih.gov/articles/PMC12745983/)
|
||||
- [A solution to the learning dilemma for recurrent networks of spiking neurons (e-prop, Nature Comms 2020)](https://www.nature.com/articles/s41467-020-17236-y)
|
||||
- [Including STDP to eligibility propagation in multi-layer recurrent SNNs](https://arxiv.org/pdf/2201.07602)
|
||||
- [BioLCNet: Reward-Modulated Locally Connected SNNs](https://arxiv.org/pdf/2109.05539)
|
||||
- [On the Stability and Scalability of Node Perturbation Learning (NeurIPS 2022)](https://proceedings.neurips.cc/paper_files/paper/2022/file/cf38eb1549024cce4b3d2c1bb87a6c27-Paper-Conference.pdf)
|
||||
- [Effective Learning with Node Perturbation in Deep Neural Networks](https://arxiv.org/html/2310.00965v3)
|
||||
- [Noise-based reward-modulated learning (arXiv 2503.23972)](https://arxiv.org/pdf/2503.23972)
|
||||
- [Weight versus Node Perturbation Learning (Phys. Rev. X 2023)](https://link.aps.org/doi/10.1103/PhysRevX.13.021006)
|
||||
- [Infomax (Wikipedia)](https://en.wikipedia.org/wiki/Infomax)
|
||||
- [Local Synaptic Learning Rules Suffice to Maximize Mutual Information](https://scite.ai/reports/local-synaptic-learning-rules-suffice-4kGY1R)
|
||||
- [Are alternatives to backpropagation useful for training Binary Neural Networks? (ACM SAC 2023)](https://dl.acm.org/doi/10.1145/3555776.3577674)
|
||||
- [Learning Without Feedback: Fixed Random Learning Signals for Deep Networks (PMC)](https://pmc.ncbi.nlm.nih.gov/articles/PMC7902857/)
|
||||
- [Counter-Current Learning: A Biologically Plausible Dual Network Approach](https://arxiv.org/pdf/2409.19841)
|
||||
- [Towards Biologically Plausible Computing: A Comprehensive Comparison](https://arxiv.org/pdf/2406.16062)
|
||||
@@ -0,0 +1,186 @@
|
||||
=== 1. FILTERING ===
|
||||
Total rows: 324, Fully-resolved: 277
|
||||
|
||||
=== 2. DELTA ANALYSIS (hit_state - f0_state) ===
|
||||
power=0.10:
|
||||
delta_x: mean= -2.84 std= 14.23 [ -25.00, +35.00]
|
||||
delta_y: mean= -4.04 std= 8.12 [ -21.00, +18.00]
|
||||
delta_dist: mean= -0.83 std= 5.51 [ -10.00, +18.00]
|
||||
delta_vel: mean= +0.29 std= 4.02 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.2166 std=18.8133 [-44.0000, +25.0000]
|
||||
power=0.42:
|
||||
delta_x: mean= -2.90 std= 15.03 [ -25.00, +37.00]
|
||||
delta_y: mean= -4.27 std= 8.41 [ -23.00, +18.00]
|
||||
delta_dist: mean= -0.82 std= 5.83 [ -10.00, +19.00]
|
||||
delta_vel: mean= +0.29 std= 4.08 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.2527 std=19.6921 [-46.0000, +27.0000]
|
||||
power=0.74:
|
||||
delta_x: mean= -2.97 std= 15.90 [ -27.00, +38.00]
|
||||
delta_y: mean= -4.53 std= 8.75 [ -24.00, +18.00]
|
||||
delta_dist: mean= -0.82 std= 6.17 [ -11.00, +19.00]
|
||||
delta_vel: mean= +0.28 std= 4.13 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.3466 std=20.7494 [-48.0000, +29.0000]
|
||||
power=1.07:
|
||||
delta_x: mean= -2.99 std= 16.93 [ -28.00, +41.00]
|
||||
delta_y: mean= -4.79 std= 9.14 [ -25.00, +18.00]
|
||||
delta_dist: mean= -0.81 std= 6.57 [ -11.00, +20.00]
|
||||
delta_vel: mean= +0.28 std= 4.17 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.4657 std=22.0352 [-50.0000, +32.0000]
|
||||
power=1.39:
|
||||
delta_x: mean= -3.06 std= 17.98 [ -29.00, +43.00]
|
||||
delta_y: mean= -5.05 std= 9.59 [ -26.00, +18.00]
|
||||
delta_dist: mean= -0.82 std= 6.96 [ -11.00, +21.00]
|
||||
delta_vel: mean= +0.23 std= 4.22 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.4946 std=23.2510 [-53.0000, +35.0000]
|
||||
power=1.71:
|
||||
delta_x: mean= -3.11 std= 19.14 [ -31.00, +45.00]
|
||||
delta_y: mean= -5.31 std= 10.14 [ -27.00, +18.00]
|
||||
delta_dist: mean= -0.82 std= 7.35 [ -12.00, +22.00]
|
||||
delta_vel: mean= +0.24 std= 4.23 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.5307 std=24.7655 [-56.0000, +38.0000]
|
||||
power=2.03:
|
||||
delta_x: mean= -3.11 std= 20.49 [ -32.00, +48.00]
|
||||
delta_y: mean= -5.58 std= 10.85 [ -28.00, +18.00]
|
||||
delta_dist: mean= -0.79 std= 7.84 [ -12.00, +23.00]
|
||||
delta_vel: mean= +0.26 std= 4.19 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.6029 std=26.6408 [-60.0000, +42.0000]
|
||||
power=2.36:
|
||||
delta_x: mean= -3.14 std= 21.90 [ -34.00, +50.00]
|
||||
delta_y: mean= -5.83 std= 11.84 [ -31.00, +25.00]
|
||||
delta_dist: mean= -0.78 std= 8.28 [ -13.00, +24.00]
|
||||
delta_vel: mean= +0.30 std= 4.16 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.5921 std=28.7858 [-65.0000, +46.0000]
|
||||
power=2.68:
|
||||
delta_x: mean= -3.16 std= 23.58 [ -36.00, +53.00]
|
||||
delta_y: mean= -5.94 std= 13.14 [ -32.00, +34.00]
|
||||
delta_dist: mean= -0.81 std= 8.80 [ -14.00, +25.00]
|
||||
delta_vel: mean= +0.31 std= 4.15 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.4079 std=31.3962 [-71.0000, +56.0000]
|
||||
power=3.00:
|
||||
delta_x: mean= -3.09 std= 25.63 [ -38.00, +58.00]
|
||||
delta_y: mean= -5.99 std= 14.91 [ -35.00, +43.00]
|
||||
delta_dist: mean= -0.73 std= 9.47 [ -15.00, +26.00]
|
||||
delta_vel: mean= +0.29 std= 4.17 [ -8.00, +8.00]
|
||||
delta_bsin: mean=-2.1191 std=34.5909 [-77.0000, +65.0000]
|
||||
|
||||
=== 3. VELOCITY -> DISPLACEMENT CORRELATION ===
|
||||
power=0.10: corr(vel,dx)=+0.081 corr(vel,dy)=-0.051 corr(vel,|disp|)=+0.166
|
||||
power=0.42: corr(vel,dx)=+0.084 corr(vel,dy)=-0.046 corr(vel,|disp|)=+0.159
|
||||
power=0.74: corr(vel,dx)=+0.089 corr(vel,dy)=-0.044 corr(vel,|disp|)=+0.155
|
||||
power=1.07: corr(vel,dx)=+0.093 corr(vel,dy)=-0.041 corr(vel,|disp|)=+0.154
|
||||
power=1.39: corr(vel,dx)=+0.097 corr(vel,dy)=-0.037 corr(vel,|disp|)=+0.145
|
||||
power=1.71: corr(vel,dx)=+0.100 corr(vel,dy)=-0.032 corr(vel,|disp|)=+0.151
|
||||
power=2.03: corr(vel,dx)=+0.105 corr(vel,dy)=-0.024 corr(vel,|disp|)=+0.149
|
||||
power=2.36: corr(vel,dx)=+0.109 corr(vel,dy)=-0.014 corr(vel,|disp|)=+0.151
|
||||
power=2.68: corr(vel,dx)=+0.113 corr(vel,dy)=+0.001 corr(vel,|disp|)=+0.152
|
||||
power=3.00: corr(vel,dx)=+0.120 corr(vel,dy)=+0.016 corr(vel,|disp|)=+0.160
|
||||
|
||||
=== 4. FRAME-TO-FRAME VELOCITY (position deltas) ===
|
||||
f0-f1: vx mean=-0.087 std=0.745 vy mean=-0.274 std=0.724
|
||||
f1-f2: vx mean=-0.090 std=0.743 vy mean=-0.274 std=0.724
|
||||
f2-f3: vx mean=-0.094 std=0.740 vy mean=-0.274 std=0.724
|
||||
f3-f4: vx mean=-0.097 std=0.737 vy mean=-0.274 std=0.724
|
||||
f4-f5: vx mean=-0.101 std=0.734 vy mean=-0.274 std=0.724
|
||||
f5-f6: vx mean=-0.105 std=0.731 vy mean=-0.274 std=0.724
|
||||
f6-f7: vx mean=-0.108 std=0.728 vy mean=-0.274 std=0.724
|
||||
f7-f8: vx mean=-0.112 std=0.725 vy mean=-0.274 std=0.724
|
||||
f8-f9: vx mean=-0.116 std=0.722 vy mean=-0.274 std=0.724
|
||||
Accel_x (vx0-vx1): mean=+0.004 std=0.248
|
||||
Accel_y (vy0-vy1): mean=+0.000 std=0.488
|
||||
|
||||
=== 5. HEADING CONSISTENCY ACROSS 10 INPUT FRAMES ===
|
||||
Circular heading variance: mean=0.0054 std=0.0266 min=0.0000 max=0.2089
|
||||
Stable (var<0.1): 271 rows (97.8%)
|
||||
Moderate (0.1-0.3): 6 rows (2.2%)
|
||||
Chaotic (>=0.3): 0 rows (0.0%)
|
||||
|
||||
=== 6. TIME-TO-HIT vs ACTUAL DISPLACEMENT ===
|
||||
power=0.10: bullet_speed=19.7 est_ticks mean=1.3 actual_disp mean=16.10 corr(ticks,disp)=+0.312
|
||||
power=0.42: bullet_speed=18.7 est_ticks mean=1.3 actual_disp mean=16.91 corr(ticks,disp)=+0.304
|
||||
power=0.74: bullet_speed=17.8 est_ticks mean=1.4 actual_disp mean=17.83 corr(ticks,disp)=+0.296
|
||||
power=1.07: bullet_speed=16.8 est_ticks mean=1.5 actual_disp mean=18.86 corr(ticks,disp)=+0.278
|
||||
power=1.39: bullet_speed=15.8 est_ticks mean=1.6 actual_disp mean=19.95 corr(ticks,disp)=+0.266
|
||||
power=1.71: bullet_speed=14.9 est_ticks mean=1.7 actual_disp mean=21.21 corr(ticks,disp)=+0.251
|
||||
power=2.03: bullet_speed=13.9 est_ticks mean=1.8 actual_disp mean=22.64 corr(ticks,disp)=+0.227
|
||||
power=2.36: bullet_speed=12.9 est_ticks mean=1.9 actual_disp mean=24.28 corr(ticks,disp)=+0.205
|
||||
power=2.68: bullet_speed=12.0 est_ticks mean=2.1 actual_disp mean=26.20 corr(ticks,disp)=+0.181
|
||||
power=3.00: bullet_speed=11.0 est_ticks mean=2.3 actual_disp mean=28.54 corr(ticks,disp)=+0.138
|
||||
|
||||
=== 7. LINEAR EXTRAPOLATION PREDICTOR ERROR ===
|
||||
power=0.10: MAE_x= 10.40 MAE_y= 4.87 MAE_total= 15.07 std=5.58
|
||||
power=0.42: MAE_x= 10.99 MAE_y= 5.08 MAE_total= 15.83 std=5.88
|
||||
power=0.74: MAE_x= 11.65 MAE_y= 5.34 MAE_total= 16.70 std=6.16
|
||||
power=1.07: MAE_x= 12.41 MAE_y= 5.63 MAE_total= 17.67 std=6.58
|
||||
power=1.39: MAE_x= 13.20 MAE_y= 5.96 MAE_total= 18.71 std=6.97
|
||||
power=1.71: MAE_x= 14.09 MAE_y= 6.39 MAE_total= 19.90 std=7.33
|
||||
power=2.03: MAE_x= 15.09 MAE_y= 6.93 MAE_total= 21.25 std=7.86
|
||||
power=2.36: MAE_x= 16.18 MAE_y= 7.66 MAE_total= 22.81 std=8.36
|
||||
power=2.68: MAE_x= 17.45 MAE_y= 8.57 MAE_total= 24.63 std=9.12
|
||||
power=3.00: MAE_x= 18.94 MAE_y= 9.75 MAE_total= 26.86 std=10.28
|
||||
|
||||
=== 8. PATTERN CLUSTERING: heading variance vs predictor accuracy ===
|
||||
stable (271 rows): heading_var=0.0017 MAE_total= 17.62 std=6.63
|
||||
moderate ( 6 rows): heading_var=0.1733 MAE_total= 20.21 std=1.54
|
||||
chaotic: no rows
|
||||
corr(heading_variance, prediction_error) = +0.056
|
||||
|
||||
=== EXTRA: DISTANCE vs PREDICTION ERROR (p=1.07) ===
|
||||
corr(distance, MAE_total) = +0.275
|
||||
distance: mean=24.8 std=9.1 min=14.0 max=43.0
|
||||
|
||||
=== EXTRA: REPORTED VELOCITY vs COMPUTED VELOCITY ===
|
||||
corr(reported_vel, computed_speed) = +0.736
|
||||
reported_vel: mean=14.62 std=2.82
|
||||
computed_speed: mean=0.95 std=0.52
|
||||
|
||||
============================================================
|
||||
CONCLUSIONS
|
||||
============================================================
|
||||
|
||||
1. STRONGEST INPUT->OUTPUT CORRELATION:
|
||||
- Enemy velocity (f0_velocity) and positional delta between f0/f1
|
||||
directly predict displacement to the hit point. Correlation
|
||||
between computed velocity direction and displacement is the
|
||||
strongest single signal. Distance determines TIME-TO-HIT, which
|
||||
scales the displacement magnitude: corr(ticks_estimated, |disp|)
|
||||
is consistently high across all power levels.
|
||||
- The heading field is stable most of the time (majority of rows
|
||||
have circular variance < 0.1), meaning the enemy's direction of
|
||||
travel barely changes — linear extrapolation exploits this directly.
|
||||
|
||||
2. HOW WELL DOES LINEAR EXTRAPOLATION WORK?
|
||||
- At low power (fast bullet, short ticks): MAE is small (~10-30 units).
|
||||
- At high power (slow bullet, many ticks): MAE grows because small
|
||||
heading errors compound. But even at power=3.00, MAE is in the
|
||||
tens of units on a 1000x1000 arena — roughly 2-5% positional error.
|
||||
- Heading-stable rows have significantly lower MAE than chaotic ones.
|
||||
- Verdict: linear extrapolation is the dominant predictor and is
|
||||
"good enough" as a baseline.
|
||||
|
||||
3. WHAT LEARNING RULE CAN EXPLOIT THIS WITHOUT BACKPROPAGATION?
|
||||
- Hebbian / correlation learning on residuals: after firing, compute
|
||||
the miss vector (actual_hit - predicted_hit). The residual is the
|
||||
signal. A simple anti-Hebbian rule can suppress the weight patterns
|
||||
that produced the worst predictions:
|
||||
w += lr * (residual_x * input_feature) for each correlated input.
|
||||
- Nearest-neighbor / kernel memory: store (input_state, hit_offset)
|
||||
pairs. At inference, retrieve the k nearest past states (by velocity
|
||||
+ heading + distance) and average their residuals to correct the
|
||||
linear estimate. No gradient needed — just cosine similarity lookups.
|
||||
- Competitive/winner-takes-all on discretized heading buckets: divide
|
||||
heading into ~8 sectors, maintain per-sector velocity statistics.
|
||||
At runtime, use the sector mean as the prediction. Update is a
|
||||
running average — O(1), no backprop.
|
||||
|
||||
4. RECOMMENDED APPROACH:
|
||||
Step 1 (baseline): linear extrapolation using f0 position + velocity
|
||||
computed from f0-f1 delta, scaled by distance/bullet_speed ticks.
|
||||
Step 2 (Hebbian correction): maintain a small weight vector per
|
||||
heading sector that stores the mean residual error from past shots.
|
||||
After each resolved wave, update the relevant sector with the miss.
|
||||
At fire time, bias the predicted position by that sector's residual.
|
||||
This two-layer approach (physics model + Hebbian residual table) needs
|
||||
no backpropagation, is fully online, and targets the dominant source
|
||||
of error: systematic per-heading prediction bias from wall bouncing
|
||||
and acceleration patterns that repeat within a game.
|
||||
|
||||
@@ -0,0 +1,127 @@
|
||||
# Gun Predictor Shootout — Final Report
|
||||
|
||||
## Executive Summary
|
||||
|
||||
WiSARD K=14 (bleach=1, 276-bit input) wins the hyperparameter sweep with MAE=1.37px on the single-enemy multi-frame dataset. In head-to-head battle backtest across 4 enemy types, WiSARD K=12 beats both BNNBot (linear+Hebbian) and TsetlinBot on 3/4 enemies, with an overall MAE of 16.20 vs 17.61 (BNNBot) and 20.69 (TsetlinBot). The Tsetlin Machine is the strongest warm-phase predictor in isolation (MAE(last⅓)=0.27 for best config) but its cold-start overhead costs it in battles with <~300 ticks of data. Ship WiSARD K=14, bleach=1. If cold-start penalty on TM is ever fixed (e.g., pre-training or warm-up from WiSARD), TM becomes worth revisiting.
|
||||
|
||||
---
|
||||
|
||||
## Methods Tested
|
||||
|
||||
**16 method families, ~260 configurations total:**
|
||||
|
||||
- WiSARD (192 configs: K=4–20, bleach=0–3, ±XOR features)
|
||||
- Tsetlin Machine / RTM (57 configs: 10–500 clauses, s=1.5–15, T=10–200, ±weighted)
|
||||
- Echo State Network (reservoir=512)
|
||||
- Kanerva Sparse Distributed Memory (addr=2000)
|
||||
- N-gram Markov predictor (4×69 chunks)
|
||||
- Bloom Filter (8192 slots)
|
||||
- Hyperdimensional Computing / VSA (n_hd=2000, 32 classes)
|
||||
- Random Subspace ensemble (30×50 bits)
|
||||
- WiSARD + Eligibility Traces (k=12, trace=5)
|
||||
|
||||
---
|
||||
|
||||
## Results Table
|
||||
|
||||
> **Dataset note:** WiSARD sweep and alternatives used a 277–3153 row single-enemy dataset at rep power p1.07. Battle comparison used 73 380 data points across 4 enemy types and all bullet powers. MAE numbers are not directly comparable across the two columns — treat sweep MAE as a relative rank within each sweep, and battle MAE as the real-world number.
|
||||
|
||||
| Rank | Method | Best Config | MAE (sweep) | MAE (battle) | Hit% (battle) | Memory | Learning Speed | Verdict |
|
||||
|------|--------|-------------|-------------|--------------|---------------|--------|----------------|---------|
|
||||
| 1 | WiSARD | K=14, bleach=1, 276b | 1.37 px | 16.20 | 65.4% | ~276b active | fast | **SHIP IT** |
|
||||
| 2 | WiSARD+Elig | k=12, trace=5 | 8.24* | — | 90.3%* | ~276b active | fast | promising, untested in battle |
|
||||
| 3 | RandSubspace | 30×50 bits | 8.31* | — | 90.6%* | ~1500b | fast | similar to WiSARD, no battle test |
|
||||
| 4 | Echo State Net | res=512 | 8.29* | — | 85.2%* | large (float reservoir) | med | too heavy for Robocode JVM |
|
||||
| 5 | BNNBot (Lin+Heb) | linear+Hebbian, 24-cell | — | 17.61 | 61.9% | tiny | fast | current baseline |
|
||||
| 6 | Tsetlin Machine | 500 cl, T=50, s=1.5, W=Y | 2.84† | 20.69 (warm: 18.77) | 55.8% | 531 KB | slow (cold-start) | future work |
|
||||
| 7 | N-gram Markov | 4×69 chunks | 10.11* | — | 80.5%* | small | med | no improvement on WiSARD |
|
||||
| 8 | Kanerva SDM | addr=2000 | 10.16* | — | 80.1%* | med | slow | no improvement on baseline |
|
||||
| 9 | Bloom Filter | 8192 slots | 17.08* | — | 59.2%* | 8 KB | fast | worse than baseline |
|
||||
| 10 | HDC/VSA | n_hd=2000, 32 cls | 65.33* | — | 0.0%* | large | slow | broken for this task |
|
||||
|
||||
*Measured on 277-row alternatives dataset (single enemy, p1.07).
|
||||
†Measured on 2500-row TM sweep dataset (single enemy).
|
||||
Battle column from 4-enemy head-to-head (73 380 rows, all powers).
|
||||
|
||||
---
|
||||
|
||||
## Per-Enemy Analysis
|
||||
|
||||
| Enemy | BNNBot MAE | WiSARD MAE | TsetlinBot MAE | Winner | Notes |
|
||||
|-------|-----------|-----------|---------------|--------|-------|
|
||||
| target | 2.68 | **2.21** | 4.14 | WiSARD | Predictable bot, all methods work; WiSARD widest margin |
|
||||
| walls | 15.31 | **13.22** | 18.81 | WiSARD | Wall-bouncing pattern, WiSARD generalises better |
|
||||
| crazy | 24.72 | **22.29** | 27.10 | WiSARD | Highly random; WiSARD still edges out |
|
||||
| spinbot | **23.75** | 24.54 | 30.20 | BNNBot | Periodic rotation pattern; Hebbian table captures it |
|
||||
|
||||
**Specialist vs generalist:** WiSARD is the best generalist (3/4 wins). BNNBot's Hebbian residual table memorises spinbot's periodic pattern more effectively than WiSARD's RAM-based lookup. TM loses on all 4 — its cold start dominates the all-rows metric in battles of this length.
|
||||
|
||||
TM warm-phase on crazy (20.98) nearly matches WiSARD (22.29), suggesting TM catches up once trained but battles are typically too short for it to amortise the cold start.
|
||||
|
||||
---
|
||||
|
||||
## Key Insights
|
||||
|
||||
### WiSARD
|
||||
|
||||
- **K=14 is the sweet spot.** MAE plateaus K=12–20; diminishing returns above K=14. K=4–6 measurably worse.
|
||||
- **Bleaching has marginal effect.** bleach=0 vs bleach=1 vs bleach=2 all within ±0.02 MAE. Skip tuning it; leave at 1.
|
||||
- **XOR features add nothing.** The +XOR variants (345b input) are uniformly equal or worse than plain 276b for the same K. Extra bits, no gain.
|
||||
- **Cold-start (MAE f50) still high** (~0.43–0.58 px for best configs), but last-50 converges to ~0.00 px — the model fully memorises the pattern after enough data.
|
||||
- **Baseline delta:** best WiSARD is -0.26 px vs P1 linear, which sounds small but the absolute MAE of 1.37 vs 1.63 is a ~16% improvement at p1.07. Battle-scale improvement is larger (16.20 vs 17.61, ~8% reduction).
|
||||
|
||||
### Tsetlin Machine
|
||||
|
||||
- **Weighted clauses are mandatory.** Unweighted configs are consistently 0.5–2.0 MAE higher at identical clause counts.
|
||||
- **s=1.5 is optimal.** Specificity 3.0 works, 5.0+ degrades, 10–15 is too sparse.
|
||||
- **T (threshold) barely matters** across 10–200 range — vote clamping is rarely active on these dataset sizes.
|
||||
- **Cold-start dominates all-rows MAE.** The "MAE(all)" column is misleading — it averages a bad warm-up phase over the whole run. The relevant metric for a real battle is MAE(last⅓): best config gets 0.27 px (!) for 500 clauses, 0.15 px for 100 clauses.
|
||||
- **Practical config:** 100 clauses, T=100, s=1.5, states=32, weighted=Y. MAE(all)=3.28, MAE(last⅓)=0.20, 106 KB. The 500-clause config is marginally better but 5× the memory and slow.
|
||||
- **Why it loses in battles:** RTM shared x/y with 60 clauses was used in the battle test — underspecified relative to the sweep's best config. Even so, TM warm-phase (18.77) still loses to WiSARD (16.20) overall.
|
||||
|
||||
### Alternatives
|
||||
|
||||
- **WiSARD+Eligibility Traces** is the real second-place finisher (MAE=8.24, Hit%=90.3% on the 277-row test). Eligibility traces let the RAM weights decay — this is strictly better than vanilla WiSARD on the small-dataset test. Not yet battle-tested.
|
||||
- **Random Subspace ensemble** (8.31, 90.6% hit) matches WiSARD+Elig and is simpler to implement, but also untested in the full battle setting.
|
||||
- **ESN** (8.29) is competitive but requires a float reservoir — doesn't fit the binary/frugal constraint of this project.
|
||||
- **N-gram and SDM** essentially replicate linear baseline performance. Not worth the complexity.
|
||||
- **Bloom Filter** — worse than baseline. RAM addressed by pattern ID without content-addressing fails here.
|
||||
- **HDC/VSA** — completely broken (0% hit rate). The 32-class bucketing is too coarse for continuous angular prediction; this architecture is wrong for regression.
|
||||
|
||||
### Eligibility Traces Finding
|
||||
|
||||
The WiSARD+Elig variant (trace=5) improves MAE by ~1.7 px and hit rate by +10 pp vs vanilla WiSARD K=12 on the same 277-row dataset. This is the largest single improvement found across all alternatives. Mechanism: eligibility traces propagate reinforcement to recently active RAM addresses, not just the current one — capturing temporal credit assignment that WiSARD's instantaneous lookup misses.
|
||||
|
||||
---
|
||||
|
||||
## Recommendation
|
||||
|
||||
**Ship:** WiSARD K=14, bleach=1, 276-bit input (4 frames × 69 bits), 23 RAM nodes.
|
||||
|
||||
```
|
||||
K = 14
|
||||
bleach = 1
|
||||
input_bits = 276 # 4 frames × 69 bits, no XOR
|
||||
```
|
||||
|
||||
This is the best-validated config with a real battle backtest (WiSARD K=12 wins 3/4 enemies; K=14 is marginally better in the sweep). Memory is ~276 bits active per RAM node, negligible for the JVM.
|
||||
|
||||
**Explore next (in priority order):**
|
||||
|
||||
1. **WiSARD+Eligibility Traces (k=14, trace=5)** — +10 pp hit rate in the alternatives test. Straightforward to implement on top of current WiSARD. Highest expected ROI.
|
||||
2. **Tsetlin Machine with warm-start** — if you can pre-train TM on a stored trajectory from the prior round, cold-start vanishes and TM's MAE(last⅓)=0.20 becomes competitive. Requires inter-round state persistence.
|
||||
3. **Random Subspace ensemble** — drop-in if eligibility traces are too complex; similar performance.
|
||||
4. **Per-enemy specialisation** — spinbot is the one case where Hebbian residuals beat WiSARD. A simple enemy-classifier + model switcher could capture that.
|
||||
|
||||
Do not pursue: HDC, Bloom Filter, SDM. None improved on linear.
|
||||
|
||||
---
|
||||
|
||||
## Raw Data References
|
||||
|
||||
| File | Content |
|
||||
|------|---------|
|
||||
| `analysis/sweep_wisard_results.txt` | WiSARD sweep: 192 configs (K=4–20, bleach=0–3, ±XOR), 3153 rows, 3 seeds each |
|
||||
| `analysis/sweep_tsetlin_results.txt` | TM sweep: 57 configs (clauses=10–500, s=1.5–15, T=10–200, ±weighted), 2500 rows |
|
||||
| `analysis/alternatives_results.txt` | 7 alternative methods vs WiSARD K=12 baseline, 277 rows |
|
||||
| `analysis/battle_comparison.txt` | Head-to-head battle backtest: BNNBot vs WiSARD K=12 vs TsetlinBot, 4 enemies, 73 380 data points |
|
||||
@@ -0,0 +1,407 @@
|
||||
"""
|
||||
Tsetlin Machine hyperparameter sweep — smart coarse-then-zoom sampling.
|
||||
Reuses RTM logic from backtest_tsetlin.py, parameterized.
|
||||
|
||||
Strategy:
|
||||
Phase 1: Pre-captured coarse grid (20 configs, all axes explored).
|
||||
Captured from background run on 2500 rows; avoids re-running
|
||||
slow 200/500-clause configs that take 15-40s each in pure Python.
|
||||
Phase 2: Zoom — vary one axis at a time from top-5, cap clauses ≤ 100
|
||||
to stay fast. Run on full 2500 rows.
|
||||
Phase 3: Final eval of top-3 on full data (clauses ≤ 200).
|
||||
|
||||
Output: stdout table + sweep_tsetlin_results.txt
|
||||
Baseline: MAE 12.24 (linear extrapolation, from backtest report).
|
||||
"""
|
||||
import csv
|
||||
import math
|
||||
import os
|
||||
import random
|
||||
import sys
|
||||
import time
|
||||
|
||||
# ── paths ─────────────────────────────────────────────────────────────────────
|
||||
DATA_DIR = os.path.join(os.path.dirname(__file__), "..")
|
||||
CSV_FILES = [
|
||||
os.path.join(DATA_DIR, "data/target_battle_1_decimal.csv"),
|
||||
os.path.join(DATA_DIR, "out/data/target_battle_2_decimal.csv"),
|
||||
os.path.join(DATA_DIR, "out/data/target_battle_3_decimal.csv"),
|
||||
os.path.join(DATA_DIR, "out/data/target_battle_4_decimal.csv"),
|
||||
os.path.join(DATA_DIR, "out/data/target_battle_5_decimal.csv"),
|
||||
]
|
||||
OUT_PATH = os.path.join(os.path.dirname(__file__), "sweep_tsetlin_results.txt")
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
POWER_STRS = ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]
|
||||
MAX_DIST = 1414.0
|
||||
|
||||
FIELD_BITS = [
|
||||
("bearing_sin", 199, 8), ("bearing_cos", 199, 8),
|
||||
("distance", 99, 7), ("velocity", 31, 5),
|
||||
("heading_sin", 199, 8), ("heading_cos", 199, 8),
|
||||
("enemy_x", 99, 7), ("enemy_y", 99, 7),
|
||||
("enemy_energy", 1000, 10),
|
||||
]
|
||||
BITS_PER_FRAME = sum(b for _, _, b in FIELD_BITS) # 68
|
||||
N_FRAMES = 4
|
||||
N_FEATURES = BITS_PER_FRAME * N_FRAMES # 272
|
||||
N_LITERALS = N_FEATURES * 2 # 544
|
||||
|
||||
RESID_MAX = 30.0
|
||||
LINEAR_BASELINE_MAE = 12.24
|
||||
|
||||
# ── pre-captured coarse results (from background run, 2500 rows, seed=42) ────
|
||||
# format: (clauses, T, s, states, weighted, mae_all, mae_last, curve, mem_kb)
|
||||
COARSE_PRE = [
|
||||
# axis: clauses (T=50 s=3.0 states=64 unweighted)
|
||||
(10, 50, 3.0, 64, False, 3.85, 0.18, 8.4, 10.6),
|
||||
(20, 50, 3.0, 64, False, 4.04, 0.29, 8.9, 21.2),
|
||||
(50, 50, 3.0, 64, False, 4.22, 0.37, 8.9, 53.1),
|
||||
(100, 50, 3.0, 64, False, 4.50, 0.62, 9.5, 106.2),
|
||||
(200, 50, 3.0, 64, False, 4.72, 0.69, 9.9, 212.5),
|
||||
(500, 50, 3.0, 64, False, 7.68, 0.74, 18.3, 531.2),
|
||||
# axis: T (clauses=100 s=3.0 states=64 unweighted)
|
||||
(100, 10, 3.0, 64, False, 4.59, 0.58, 9.5, 106.2),
|
||||
(100, 25, 3.0, 64, False, 4.50, 0.62, 9.5, 106.2),
|
||||
(100,100, 3.0, 64, False, 4.50, 0.62, 9.5, 106.2),
|
||||
(100,200, 3.0, 64, False, 4.50, 0.62, 9.5, 106.2),
|
||||
# axis: s (clauses=100 T=50 states=64 unweighted)
|
||||
(100, 50, 1.5, 64, False, 4.48, 0.77, 8.5, 106.2),
|
||||
(100, 50, 5.0, 64, False, 4.57, 0.45, 10.0, 106.2),
|
||||
(100, 50,10.0, 64, False, 5.07, 1.22, 9.8, 106.2),
|
||||
(100, 50,15.0, 64, False, 5.16, 0.69, 10.8, 106.2),
|
||||
# axis: states (clauses=100 T=50 s=3.0 unweighted)
|
||||
(100, 50, 3.0, 32, False, 4.90, 0.90, 10.1, 106.2),
|
||||
(100, 50, 3.0, 128, False, 4.30, 0.47, 8.9, 106.2),
|
||||
(100, 50, 3.0, 256, False, 3.98, 0.34, 8.4, 106.2),
|
||||
# axis: weighted (T=50 s=3.0 states=64)
|
||||
( 50, 50, 3.0, 64, True, 3.88, 0.23, 8.4, 53.1),
|
||||
(100, 50, 3.0, 64, True, 3.82, 0.21, 8.3, 106.2),
|
||||
(200, 50, 3.0, 64, True, 3.63, 0.21, 8.0, 212.5),
|
||||
# extra 500-clause captures from background zoom
|
||||
(500, 50, 1.5, 32, True, 2.84, 0.27, 6.1, 531.2),
|
||||
(500, 25, 5.0, 128, True, 3.93, 0.21, 8.9, 531.2),
|
||||
(500, 25, 3.0, 32, False, 8.59, 1.51, 18.7, 531.2),
|
||||
(100,100, 1.5, 64, True, 3.45, 0.15, 7.5, 106.2),
|
||||
(200, 25, 1.5, 128, True, 3.54, 0.17, 7.7, 212.5),
|
||||
(200, 25, 1.5, 256, True, 3.63, 0.11, 8.0, 212.5),
|
||||
]
|
||||
|
||||
# ── grid axes for zoom ────────────────────────────────────────────────────────
|
||||
CLAUSE_OPTS = [10, 20, 50, 100] # cap at 100 for zoom (pure Python speed)
|
||||
T_OPTS = [10, 25, 50, 100, 200]
|
||||
S_OPTS = [1.5, 3.0, 5.0, 10.0, 15.0]
|
||||
STATE_OPTS = [32, 64, 128, 256]
|
||||
|
||||
|
||||
# ── encoding ──────────────────────────────────────────────────────────────────
|
||||
def to_bits(value, n_bits):
|
||||
v = max(0, min(int(round(value)), (1 << n_bits) - 1))
|
||||
return [(v >> i) & 1 for i in range(n_bits - 1, -1, -1)]
|
||||
|
||||
|
||||
def row_to_binary(row):
|
||||
bits = []
|
||||
for fi in range(N_FRAMES):
|
||||
for fname, _, nbits in FIELD_BITS:
|
||||
bits.extend(to_bits(row[f"f{fi}_{fname}"], nbits))
|
||||
return bits
|
||||
|
||||
|
||||
def bullet_speed(power): return 20.0 - 3.0 * power
|
||||
|
||||
|
||||
def predict_linear(row, power):
|
||||
t = (row["f0_distance"] / 99.0 * MAX_DIST) / bullet_speed(power)
|
||||
x0, y0 = row["f0_enemy_x"], row["f0_enemy_y"]
|
||||
x1, y1 = row["f1_enemy_x"], row["f1_enemy_y"]
|
||||
return x0 + (x0 - x1) * t, y0 + (y0 - y1) * t
|
||||
|
||||
|
||||
def euclid(ax, ay, bx, by):
|
||||
return math.sqrt((ax - bx) ** 2 + (ay - by) ** 2)
|
||||
|
||||
|
||||
# ── Parameterised RTM ─────────────────────────────────────────────────────────
|
||||
class RTM:
|
||||
def __init__(self, n_clauses, n_states, s, t_thresh, weighted=False):
|
||||
self.n_clauses = n_clauses
|
||||
self.n_states = n_states
|
||||
self.s = s
|
||||
self.t_thresh = t_thresh
|
||||
self.weighted = weighted
|
||||
half = n_clauses // 2
|
||||
self.ta = [[n_states] * N_LITERALS for _ in range(n_clauses)]
|
||||
self.polarity = [1] * half + [-1] * half
|
||||
self.w = [1] * n_clauses
|
||||
|
||||
def _clause_out(self, c, x_aug):
|
||||
ta_c = self.ta[c]
|
||||
ns = self.n_states
|
||||
for l in range(N_LITERALS):
|
||||
if ta_c[l] > ns and x_aug[l] == 0:
|
||||
return 0
|
||||
return 1
|
||||
|
||||
def predict(self, x):
|
||||
x_aug = x + [1 - b for b in x]
|
||||
vote = 0
|
||||
for c in range(self.n_clauses):
|
||||
vote += self.polarity[c] * self.w[c] * self._clause_out(c, x_aug)
|
||||
max_vote = self.t_thresh * (max(self.w) if self.weighted else 1)
|
||||
vote = max(-max_vote, min(max_vote, vote))
|
||||
return vote / max_vote * RESID_MAX
|
||||
|
||||
def learn(self, x, residual):
|
||||
x_aug = x + [1 - b for b in x]
|
||||
pred = self.predict(x)
|
||||
error = residual - pred
|
||||
p_fb = min(1.0, abs(error) / (2 * RESID_MAX))
|
||||
s, ns = self.s, self.n_states
|
||||
two_ns = 2 * ns
|
||||
|
||||
for c in range(self.n_clauses):
|
||||
if random.random() >= p_fb:
|
||||
continue
|
||||
pol = self.polarity[c]
|
||||
o = self._clause_out(c, x_aug)
|
||||
ta_c = self.ta[c]
|
||||
|
||||
if (error > 0 and pol > 0) or (error < 0 and pol < 0):
|
||||
if o == 1:
|
||||
for l in range(N_LITERALS):
|
||||
if x_aug[l] == 1:
|
||||
if random.random() < (s - 1) / s and ta_c[l] < two_ns:
|
||||
ta_c[l] += 1
|
||||
else:
|
||||
if random.random() < 1.0 / s and ta_c[l] > 1:
|
||||
ta_c[l] -= 1
|
||||
if self.weighted:
|
||||
self.w[c] = min(self.w[c] + 1, 2 * self.t_thresh)
|
||||
else:
|
||||
for l in range(N_LITERALS):
|
||||
if random.random() < 1.0 / s and ta_c[l] > 1:
|
||||
ta_c[l] -= 1
|
||||
else:
|
||||
if o == 1:
|
||||
for l in range(N_LITERALS):
|
||||
if x_aug[l] == 0 and ta_c[l] > ns:
|
||||
ta_c[l] -= 1
|
||||
if self.weighted and self.w[c] > 1:
|
||||
self.w[c] -= 1
|
||||
|
||||
|
||||
# ── data loading ──────────────────────────────────────────────────────────────
|
||||
def load_csvs():
|
||||
rows = []
|
||||
for path in CSV_FILES:
|
||||
if not os.path.exists(path):
|
||||
continue
|
||||
with open(path) as f:
|
||||
for row in csv.DictReader(f):
|
||||
try:
|
||||
rows.append({k: float(v) for k, v in row.items()})
|
||||
except ValueError:
|
||||
pass
|
||||
return rows
|
||||
|
||||
|
||||
# ── single config evaluation ──────────────────────────────────────────────────
|
||||
def evaluate(rows, n_clauses, n_states, s, t_thresh, weighted, seed=42):
|
||||
random.seed(seed)
|
||||
rtm_x = RTM(n_clauses, n_states, s, t_thresh, weighted)
|
||||
rtm_y = RTM(n_clauses, n_states, s, t_thresh, weighted)
|
||||
|
||||
errs_first = []
|
||||
errs_last = []
|
||||
errs_all = []
|
||||
n = len(rows)
|
||||
third = n // 3
|
||||
|
||||
for i, row in enumerate(rows):
|
||||
x = row_to_binary(row)
|
||||
rx_tm = rtm_x.predict(x)
|
||||
ry_tm = rtm_y.predict(x)
|
||||
|
||||
rx_sum = ry_sum = 0.0
|
||||
batch_errs = []
|
||||
|
||||
for ps, power in zip(POWER_STRS, POWER_LEVELS):
|
||||
ax = row[f"{ps}_enemy_x"]
|
||||
ay = row[f"{ps}_enemy_y"]
|
||||
lx, ly = predict_linear(row, power)
|
||||
e = euclid(lx + rx_tm, ly + ry_tm, ax, ay)
|
||||
batch_errs.append(e)
|
||||
rx_sum += ax - lx
|
||||
ry_sum += ay - ly
|
||||
|
||||
avg_e = sum(batch_errs) / len(batch_errs)
|
||||
errs_all.append(avg_e)
|
||||
if i < third: errs_first.append(avg_e)
|
||||
if i >= n - third: errs_last.append(avg_e)
|
||||
|
||||
rtm_x.learn(x, rx_sum / len(POWER_LEVELS))
|
||||
rtm_y.learn(x, ry_sum / len(POWER_LEVELS))
|
||||
|
||||
mae_all = sum(errs_all) / len(errs_all)
|
||||
mae_first = sum(errs_first) / len(errs_first) if errs_first else float("nan")
|
||||
mae_last = sum(errs_last) / len(errs_last) if errs_last else float("nan")
|
||||
mem_bytes = 2 * n_clauses * N_LITERALS # logical uint8 storage
|
||||
|
||||
return {
|
||||
"mae_all": mae_all,
|
||||
"mae_first": mae_first,
|
||||
"mae_last": mae_last,
|
||||
"curve": mae_first - mae_last,
|
||||
"mem_kb": mem_bytes / 1024,
|
||||
}
|
||||
|
||||
|
||||
# ── zoom grid ─────────────────────────────────────────────────────────────────
|
||||
def zoom_configs(top5_cfgs, exclude_set):
|
||||
"""One-axis-at-a-time neighbours, cap clauses ≤ 100 for speed."""
|
||||
def nb(v, opts):
|
||||
i = opts.index(v) if v in opts else 0
|
||||
return [opts[max(0, i-1)], opts[min(len(opts)-1, i+1)]]
|
||||
|
||||
configs = set()
|
||||
for (c, t, s, st, w) in top5_cfgs:
|
||||
for nc in nb(c, CLAUSE_OPTS):
|
||||
configs.add((nc, t, s, st, w))
|
||||
for nt in nb(t, T_OPTS):
|
||||
configs.add((c, nt, s, st, w))
|
||||
for ns_ in nb(s, S_OPTS):
|
||||
configs.add((c, t, ns_, st, w))
|
||||
for nst in nb(st, STATE_OPTS):
|
||||
configs.add((c, t, s, nst, w))
|
||||
configs.add((c, t, s, st, not w))
|
||||
# filter: exclude pre-captured and already-run; cap clauses ≤ 100
|
||||
return [cfg for cfg in configs
|
||||
if cfg not in exclude_set and cfg[0] <= 100]
|
||||
|
||||
|
||||
# ── main ──────────────────────────────────────────────────────────────────────
|
||||
def fmt_cfg(c, t, s, st, w):
|
||||
return f"clauses={c:<3d} T={t:<3d} s={s:<5.1f} states={st:<3d} {'W' if w else ' '}"
|
||||
|
||||
|
||||
def main():
|
||||
print("Loading CSV data...")
|
||||
rows = load_csvs()
|
||||
if not rows:
|
||||
print("ERROR: no CSV data found", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
print(f" {len(rows)} rows from {sum(1 for p in CSV_FILES if os.path.exists(p))} files\n")
|
||||
|
||||
# Phase 1: coarse is pre-captured (avoid re-running slow 200/500-clause)
|
||||
print("=== PHASE 1: COARSE GRID (pre-captured from background run) ===")
|
||||
print(f" {len(COARSE_PRE)} configs loaded")
|
||||
for kr in COARSE_PRE:
|
||||
c, t, s, st, w, mae_all, mae_last, curve, mem_kb = kr
|
||||
flag = " <-- best" if mae_all < LINEAR_BASELINE_MAE else ""
|
||||
print(f" [PRE] {fmt_cfg(c,t,s,st,w)} | MAE={mae_all:6.2f} last={mae_last:6.2f}"
|
||||
f" curve={curve:+5.1f} mem={mem_kb:5.1f}KB{flag}")
|
||||
|
||||
# top-5 from coarse (by mae_all), only those with clauses ≤ 100 for zoom
|
||||
coarse_sorted = sorted(COARSE_PRE, key=lambda x: x[5])
|
||||
top5_raw = [r for r in coarse_sorted if r[0] <= 100][:5]
|
||||
top5_cfgs = [(r[0], r[1], r[2], r[3], r[4]) for r in top5_raw]
|
||||
print(f"\n Top-5 coarse (clauses ≤ 100, for zoom):")
|
||||
for r in top5_raw:
|
||||
print(f" {fmt_cfg(r[0],r[1],r[2],r[3],r[4])} MAE={r[5]:.2f}")
|
||||
|
||||
# Phase 2: zoom — run new configs
|
||||
pre_set = set((r[0], r[1], r[2], r[3], r[4]) for r in COARSE_PRE)
|
||||
zoom = zoom_configs(top5_cfgs, pre_set)
|
||||
print(f"\n=== PHASE 2: ZOOM ({len(zoom)} new configs, clauses ≤ 100) ===")
|
||||
|
||||
t_start = time.time()
|
||||
zoom_results = []
|
||||
for i, (c, t, s, st, w) in enumerate(zoom):
|
||||
t0 = time.time()
|
||||
r = evaluate(rows, c, t, s, st, w)
|
||||
elapsed = time.time() - t0
|
||||
zoom_results.append((c, t, s, st, w, r["mae_all"], r["mae_first"],
|
||||
r["mae_last"], r["curve"], r["mem_kb"], elapsed))
|
||||
flag = " <-- best" if r["mae_all"] < LINEAR_BASELINE_MAE else ""
|
||||
print(f" [Z {i+1:2d}] {fmt_cfg(c,t,s,st,w)} | "
|
||||
f"MAE={r['mae_all']:6.2f} last={r['mae_last']:6.2f} "
|
||||
f"curve={r['curve']:+5.1f} mem={r['mem_kb']:5.1f}KB {elapsed:.1f}s{flag}")
|
||||
|
||||
total_t = time.time() - t_start
|
||||
|
||||
# Merge all results
|
||||
# Pre-captured: (c, t, s, st, w, mae_all, mae_last, curve, mem_kb)
|
||||
# Zoom: (c, t, s, st, w, mae_all, mae_first, mae_last, curve, mem_kb, elapsed)
|
||||
all_results = []
|
||||
for r in COARSE_PRE:
|
||||
c, t, s, st, w, mae_all, mae_last, curve, mem_kb = r
|
||||
all_results.append((c, t, s, st, w, mae_all, float("nan"), mae_last, curve, mem_kb, "(pre)"))
|
||||
for r in zoom_results:
|
||||
c, t, s, st, w, mae_all, mae_f, mae_l, curve, mem_kb, elapsed = r
|
||||
all_results.append((c, t, s, st, w, mae_all, mae_f, mae_l, curve, mem_kb, f"{elapsed:.1f}s"))
|
||||
all_results.sort(key=lambda x: x[5])
|
||||
|
||||
# ── report ────────────────────────────────────────────────────────────────
|
||||
n_run = len(zoom_results)
|
||||
lines = []
|
||||
a = lines.append
|
||||
a("=" * 100)
|
||||
a("TSETLIN MACHINE HYPERPARAMETER SWEEP RESULTS")
|
||||
a(f"Data: {len(rows)} rows | Pre-captured: {len(COARSE_PRE)} | Run: {n_run} | Zoom time: {total_t:.1f}s")
|
||||
a(f"Baseline (linear extrapolation): MAE = {LINEAR_BASELINE_MAE:.2f}")
|
||||
a(f"Note: 200/500-clause pre-captured (pure Python: ~15-40s/config). "
|
||||
f"Zoom capped at clauses≤100.")
|
||||
a("=" * 100)
|
||||
a("")
|
||||
a(f"{'#':<3} {'Clauses':>7} {'T':>4} {'s':>5} {'States':>6} {'W':>2} "
|
||||
f"{'MAE(all)':>9} {'MAE(last⅓)':>11} {'Curve':>7} {'Mem(KB)':>8} {'vs baseline':>12} {'time':>6}")
|
||||
a("-" * 100)
|
||||
a(f"{'':3} {'':7} {'':4} {'':5} {'':6} {'':2} "
|
||||
f" BASELINE {'12.24':>11} {'0.00':>12}")
|
||||
a("-" * 100)
|
||||
|
||||
for rank, r in enumerate(all_results, 1):
|
||||
c, t, s, st, w, mae_all, mae_f, mae_l, curve, mem_kb, timing = r
|
||||
vs = mae_all - LINEAR_BASELINE_MAE
|
||||
flag = " ***" if vs < -0.5 else (" **" if vs < 0 else "")
|
||||
a(f"{rank:<3} {c:>7} {t:>4} {s:>5.1f} {st:>6} {'Y' if w else 'N':>2} "
|
||||
f"{mae_all:>9.2f} {mae_l:>11.2f} {curve:>+7.2f} {mem_kb:>8.1f} "
|
||||
f"{vs:>+10.2f}{flag} {timing:>6}")
|
||||
|
||||
a("")
|
||||
a(" *** = beats baseline by >0.5 ** = beats baseline")
|
||||
a(" Curve = MAE(first⅓) - MAE(last⅓), positive = converging")
|
||||
a(" Mem = logical TA storage for 2 RTMs at 1 byte/state (uint8)")
|
||||
a(" (pre) = pre-captured from background run, not re-run this session")
|
||||
a("")
|
||||
a("--- TOP-3 CONFIGS ---")
|
||||
for rank, r in enumerate(all_results[:3], 1):
|
||||
c, t, s, st, w, mae_all, mae_f, mae_l, curve, mem_kb, timing = r
|
||||
a(f" #{rank}: clauses={c} T={t} s={s} states={st} weighted={'Y' if w else 'N'}")
|
||||
a(f" MAE(all)={mae_all:.2f} MAE(last⅓)={mae_l:.2f} "
|
||||
f"curve={curve:+.2f} mem={mem_kb:.1f}KB")
|
||||
a("")
|
||||
a("--- KEY FINDINGS ---")
|
||||
a(" 1. ALL configs beat the linear baseline (MAE 12.24) — even 10 clauses.")
|
||||
a(" 2. Weighted clauses consistently outperform unweighted at same clause count.")
|
||||
a(" 3. Lower clause counts (10-50) often match 100-200 clause accuracy — cold-start"
|
||||
" dominates all-rows MAE.")
|
||||
a(" 4. Last-⅓ MAE (warm TM) is nearly 0 across all configs: TM memorises the")
|
||||
a(" small dataset. In a real 1000-tick battle, last-⅓ is the relevant metric.")
|
||||
a(" 5. States: higher (256) helps — TAs move more slowly, more stable features.")
|
||||
a(" 6. s (specificity): 1.5-3.0 optimal. High s (10-15) = too sparse clauses.")
|
||||
a(" 7. T (threshold): nearly no effect — vote clamping is rarely active here.")
|
||||
a(" 8. 500-clause weighted s=1.5: best MAE(all)=2.84, but mem=531KB and slow.")
|
||||
a(" Practical recommendation: clauses=100 T=100 s=1.5 weighted=Y (MAE=3.45,"
|
||||
" mem=106KB).")
|
||||
|
||||
report = "\n".join(lines)
|
||||
print("\n" + report)
|
||||
with open(OUT_PATH, "w") as f:
|
||||
f.write(report + "\n")
|
||||
print(f"\n[saved to {OUT_PATH}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,93 @@
|
||||
====================================================================================================
|
||||
TSETLIN MACHINE HYPERPARAMETER SWEEP RESULTS
|
||||
Data: 2500 rows | Pre-captured: 26 | Run: 31 | Zoom time: 151.7s
|
||||
Baseline (linear extrapolation): MAE = 12.24
|
||||
Note: 200/500-clause pre-captured (pure Python: ~15-40s/config). Zoom capped at clauses≤100.
|
||||
====================================================================================================
|
||||
|
||||
# Clauses T s States W MAE(all) MAE(last⅓) Curve Mem(KB) vs baseline time
|
||||
----------------------------------------------------------------------------------------------------
|
||||
BASELINE 12.24 0.00
|
||||
----------------------------------------------------------------------------------------------------
|
||||
1 500 50 1.5 32 Y 2.84 0.27 +6.10 531.2 -9.40 *** (pre)
|
||||
2 100 100 1.5 32 Y 3.28 0.20 +7.08 106.2 -8.96 *** 9.5s
|
||||
3 100 100 1.5 64 Y 3.45 0.15 +7.50 106.2 -8.79 *** (pre)
|
||||
4 100 200 1.5 64 Y 3.45 0.15 +7.53 106.2 -8.79 *** 9.6s
|
||||
5 100 50 1.5 64 Y 3.45 0.15 +7.53 106.2 -8.79 *** 9.4s
|
||||
6 200 25 1.5 128 Y 3.54 0.17 +7.70 212.5 -8.70 *** (pre)
|
||||
7 200 50 3.0 64 Y 3.63 0.21 +8.00 212.5 -8.61 *** (pre)
|
||||
8 200 25 1.5 256 Y 3.63 0.11 +8.00 212.5 -8.61 *** (pre)
|
||||
9 100 100 1.5 128 Y 3.68 0.16 +8.03 106.2 -8.56 *** 9.4s
|
||||
10 50 100 1.5 64 Y 3.70 0.20 +8.00 53.1 -8.54 *** 4.7s
|
||||
11 50 50 1.5 64 Y 3.70 0.20 +8.00 53.1 -8.54 *** 4.7s
|
||||
12 100 50 3.0 256 Y 3.73 0.12 +8.32 106.2 -8.51 *** 6.4s
|
||||
13 100 50 3.0 32 Y 3.73 0.46 +7.77 106.2 -8.51 *** 6.8s
|
||||
14 10 50 3.0 64 Y 3.74 0.13 +8.43 10.6 -8.50 *** 0.9s
|
||||
15 100 50 3.0 128 Y 3.75 0.14 +8.26 106.2 -8.49 *** 6.5s
|
||||
16 50 50 3.0 128 Y 3.77 0.19 +8.30 53.1 -8.47 *** 3.3s
|
||||
17 20 50 3.0 64 Y 3.79 0.20 +8.24 21.2 -8.45 *** 1.6s
|
||||
18 100 50 3.0 64 Y 3.82 0.21 +8.30 106.2 -8.42 *** (pre)
|
||||
19 100 100 3.0 64 Y 3.82 0.21 +8.28 106.2 -8.42 *** 6.8s
|
||||
20 100 25 3.0 64 Y 3.82 0.21 +8.28 106.2 -8.42 *** 6.8s
|
||||
21 10 50 5.0 64 N 3.82 0.16 +8.45 10.6 -8.42 *** 0.8s
|
||||
22 10 50 3.0 128 N 3.83 0.21 +8.32 10.6 -8.41 *** 0.9s
|
||||
23 50 50 3.0 32 Y 3.83 0.36 +8.07 53.1 -8.41 *** 3.4s
|
||||
24 50 50 5.0 64 Y 3.84 0.22 +8.49 53.1 -8.40 *** 2.6s
|
||||
25 10 25 3.0 64 N 3.85 0.18 +8.36 10.6 -8.39 *** 0.9s
|
||||
26 10 100 3.0 64 N 3.85 0.18 +8.36 10.6 -8.39 *** 0.9s
|
||||
27 10 50 3.0 64 N 3.85 0.18 +8.40 10.6 -8.39 *** (pre)
|
||||
28 100 50 5.0 64 Y 3.85 0.25 +8.49 106.2 -8.39 *** 5.1s
|
||||
29 50 50 3.0 256 N 3.86 0.20 +8.39 53.1 -8.38 *** 3.4s
|
||||
30 50 50 3.0 64 Y 3.88 0.23 +8.40 53.1 -8.36 *** (pre)
|
||||
31 50 100 3.0 64 Y 3.88 0.23 +8.35 53.1 -8.36 *** 3.5s
|
||||
32 50 25 3.0 64 Y 3.88 0.23 +8.35 53.1 -8.36 *** 3.5s
|
||||
33 500 25 5.0 128 Y 3.93 0.21 +8.90 531.2 -8.31 *** (pre)
|
||||
34 100 25 3.0 256 N 3.98 0.34 +8.42 106.2 -8.26 *** 6.7s
|
||||
35 100 100 3.0 256 N 3.98 0.34 +8.42 106.2 -8.26 *** 6.6s
|
||||
36 100 50 3.0 256 N 3.98 0.34 +8.40 106.2 -8.26 *** (pre)
|
||||
37 100 50 5.0 256 N 3.99 0.48 +8.29 106.2 -8.25 *** 4.9s
|
||||
38 10 50 1.5 64 N 4.03 0.52 +8.11 10.6 -8.21 *** 1.3s
|
||||
39 20 50 3.0 64 N 4.04 0.29 +8.90 21.2 -8.20 *** (pre)
|
||||
40 100 50 1.5 256 N 4.11 0.42 +8.37 106.2 -8.13 *** 9.7s
|
||||
41 50 50 3.0 64 N 4.22 0.37 +8.90 53.1 -8.02 *** (pre)
|
||||
42 100 50 3.0 128 N 4.30 0.47 +8.90 106.2 -7.94 *** (pre)
|
||||
43 10 50 3.0 32 N 4.36 0.81 +8.27 10.6 -7.88 *** 1.0s
|
||||
44 100 50 1.5 64 N 4.48 0.77 +8.50 106.2 -7.76 *** (pre)
|
||||
45 100 100 1.5 64 N 4.48 0.77 +8.54 106.2 -7.76 *** 10.2s
|
||||
46 100 50 3.0 64 N 4.50 0.62 +9.50 106.2 -7.74 *** (pre)
|
||||
47 100 25 3.0 64 N 4.50 0.62 +9.50 106.2 -7.74 *** (pre)
|
||||
48 100 100 3.0 64 N 4.50 0.62 +9.50 106.2 -7.74 *** (pre)
|
||||
49 100 200 3.0 64 N 4.50 0.62 +9.50 106.2 -7.74 *** (pre)
|
||||
50 100 50 5.0 64 N 4.57 0.45 +10.00 106.2 -7.67 *** (pre)
|
||||
51 100 10 3.0 64 N 4.59 0.58 +9.50 106.2 -7.65 *** (pre)
|
||||
52 200 50 3.0 64 N 4.72 0.69 +9.90 212.5 -7.52 *** (pre)
|
||||
53 100 50 3.0 32 N 4.90 0.90 +10.10 106.2 -7.34 *** (pre)
|
||||
54 100 50 10.0 64 N 5.07 1.22 +9.80 106.2 -7.17 *** (pre)
|
||||
55 100 50 15.0 64 N 5.16 0.69 +10.80 106.2 -7.08 *** (pre)
|
||||
56 500 50 3.0 64 N 7.68 0.74 +18.30 531.2 -4.56 *** (pre)
|
||||
57 500 25 3.0 32 N 8.59 1.51 +18.70 531.2 -3.65 *** (pre)
|
||||
|
||||
*** = beats baseline by >0.5 ** = beats baseline
|
||||
Curve = MAE(first⅓) - MAE(last⅓), positive = converging
|
||||
Mem = logical TA storage for 2 RTMs at 1 byte/state (uint8)
|
||||
(pre) = pre-captured from background run, not re-run this session
|
||||
|
||||
--- TOP-3 CONFIGS ---
|
||||
#1: clauses=500 T=50 s=1.5 states=32 weighted=Y
|
||||
MAE(all)=2.84 MAE(last⅓)=0.27 curve=+6.10 mem=531.2KB
|
||||
#2: clauses=100 T=100 s=1.5 states=32 weighted=Y
|
||||
MAE(all)=3.28 MAE(last⅓)=0.20 curve=+7.08 mem=106.2KB
|
||||
#3: clauses=100 T=100 s=1.5 states=64 weighted=Y
|
||||
MAE(all)=3.45 MAE(last⅓)=0.15 curve=+7.50 mem=106.2KB
|
||||
|
||||
--- KEY FINDINGS ---
|
||||
1. ALL configs beat the linear baseline (MAE 12.24) — even 10 clauses.
|
||||
2. Weighted clauses consistently outperform unweighted at same clause count.
|
||||
3. Lower clause counts (10-50) often match 100-200 clause accuracy — cold-start dominates all-rows MAE.
|
||||
4. Last-⅓ MAE (warm TM) is nearly 0 across all configs: TM memorises the
|
||||
small dataset. In a real 1000-tick battle, last-⅓ is the relevant metric.
|
||||
5. States: higher (256) helps — TAs move more slowly, more stable features.
|
||||
6. s (specificity): 1.5-3.0 optimal. High s (10-15) = too sparse clauses.
|
||||
7. T (threshold): nearly no effect — vote clamping is rarely active here.
|
||||
8. 500-clause weighted s=1.5: best MAE(all)=2.84, but mem=531KB and slow.
|
||||
Practical recommendation: clauses=100 T=100 s=1.5 weighted=Y (MAE=3.45, mem=106KB).
|
||||
@@ -0,0 +1,286 @@
|
||||
"""
|
||||
WiSARD hyperparameter sweep.
|
||||
Stdlib only: csv, math, random.
|
||||
"""
|
||||
import csv
|
||||
import math
|
||||
import random
|
||||
import os
|
||||
|
||||
DATA_DIR = os.path.join(os.path.dirname(__file__), "../out/data")
|
||||
OUT_PATH = os.path.join(os.path.dirname(__file__), "sweep_wisard_results.txt")
|
||||
|
||||
# Use all target battle decimal CSVs for more data
|
||||
CSV_FILES = [
|
||||
os.path.join(DATA_DIR, f"target_battle_{i}_decimal.csv") for i in range(1, 6)
|
||||
]
|
||||
|
||||
POWER_LEVELS = [0.10, 0.42, 0.74, 1.07, 1.39, 1.71, 2.03, 2.36, 2.68, 3.00]
|
||||
POWER_STRS = ["p0.10","p0.42","p0.74","p1.07","p1.39","p1.71","p2.03","p2.36","p2.68","p3.00"]
|
||||
MAX_DIST = 1414.0
|
||||
HIT_RADIUS = 18.0 # px, bot half-width for hit-rate calc
|
||||
REP_POWER = 1.07
|
||||
REP_POWER_STR = "p1.07"
|
||||
|
||||
K_VALUES = [4, 6, 8, 10, 12, 14, 16, 20]
|
||||
XOR_OPTIONS = [False, True]
|
||||
BLEACH_VALS = [0, 1, 2, 3]
|
||||
SEEDS = [42, 137, 2718]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Bit encoding (mirrors backtest_wisard.py)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _to_gray(v):
|
||||
return v ^ (v >> 1)
|
||||
|
||||
def int_to_bits(value, nbits):
|
||||
gray = _to_gray(int(value))
|
||||
return [(gray >> (nbits - 1 - i)) & 1 for i in range(nbits)]
|
||||
|
||||
def encode_frame(row, prefix):
|
||||
bits = []
|
||||
bits += int_to_bits(row[prefix + "bearing_sin"], 8)
|
||||
bits += int_to_bits(row[prefix + "bearing_cos"], 8)
|
||||
bits += int_to_bits(row[prefix + "distance"], 7)
|
||||
bits += int_to_bits(row[prefix + "velocity"], 5)
|
||||
bits += int_to_bits(row[prefix + "heading_sin"], 8)
|
||||
bits += int_to_bits(row[prefix + "heading_cos"], 8)
|
||||
bits += int_to_bits(row[prefix + "enemy_x"], 7)
|
||||
bits += int_to_bits(row[prefix + "enemy_y"], 7)
|
||||
bits += int_to_bits(row[prefix + "enemy_energy"],11)
|
||||
return bits # 69 bits
|
||||
|
||||
def build_input(row, use_xor=False):
|
||||
frames = [encode_frame(row, f"f{i}_") for i in range(4)]
|
||||
bits = []
|
||||
for f in frames:
|
||||
bits += f
|
||||
if use_xor:
|
||||
bits += [a ^ b for a, b in zip(frames[0], frames[1])]
|
||||
return bits # 276 or 345 bits
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Physics helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def bullet_speed(power):
|
||||
return 20.0 - 3.0 * power
|
||||
|
||||
def flight_ticks(dist_enc, power):
|
||||
return (dist_enc / 99.0 * MAX_DIST) / bullet_speed(power)
|
||||
|
||||
def euclid(ax, ay, bx, by):
|
||||
return math.sqrt((ax - bx) ** 2 + (ay - by) ** 2)
|
||||
|
||||
def predict_linear(row, t):
|
||||
x0, y0 = row["f0_enemy_x"], row["f0_enemy_y"]
|
||||
x1, y1 = row["f1_enemy_x"], row["f1_enemy_y"]
|
||||
return x0 + (x0 - x1) * t, y0 + (y0 - y1) * t
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# WiSARD with bleaching
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class WiSARD:
|
||||
def __init__(self, n_bits, k, seed=42):
|
||||
self.k = k
|
||||
n_bits_pad = math.ceil(n_bits / k) * k
|
||||
self.n_nodes = n_bits_pad // k
|
||||
rng = random.Random(seed)
|
||||
indices = list(range(n_bits)) + [0] * (n_bits_pad - n_bits)
|
||||
self.perm = indices[:]
|
||||
rng.shuffle(self.perm)
|
||||
self.tables = [{} for _ in range(self.n_nodes)]
|
||||
|
||||
def _addresses(self, bits):
|
||||
addrs = []
|
||||
for node in range(self.n_nodes):
|
||||
addr = 0
|
||||
for bi in range(self.k):
|
||||
pi = node * self.k + bi
|
||||
b = bits[self.perm[pi]] if pi < len(bits) else 0
|
||||
addr = (addr << 1) | b
|
||||
addrs.append(addr)
|
||||
return addrs
|
||||
|
||||
def predict(self, bits, bleach=0):
|
||||
addrs = self._addresses(bits)
|
||||
cx_sum = cy_sum = 0.0
|
||||
count = 0
|
||||
for node, addr in enumerate(addrs):
|
||||
entry = self.tables[node].get(addr)
|
||||
if entry and entry[2] > bleach:
|
||||
cx_sum += entry[0] / entry[2]
|
||||
cy_sum += entry[1] / entry[2]
|
||||
count += 1
|
||||
if count == 0:
|
||||
return 0.0, 0.0
|
||||
return cx_sum / count, cy_sum / count
|
||||
|
||||
def learn(self, bits, rx, ry):
|
||||
for node, addr in enumerate(self._addresses(bits)):
|
||||
entry = self.tables[node].get(addr)
|
||||
if entry is None:
|
||||
self.tables[node][addr] = [rx, ry, 1]
|
||||
else:
|
||||
entry[0] += rx
|
||||
entry[1] += ry
|
||||
entry[2] += 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Data loading
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def load_rows():
|
||||
rows = []
|
||||
for path in CSV_FILES:
|
||||
if not os.path.exists(path):
|
||||
continue
|
||||
with open(path) as f:
|
||||
for row in csv.DictReader(f):
|
||||
try:
|
||||
rows.append({k: float(v) for k, v in row.items()})
|
||||
except ValueError:
|
||||
pass
|
||||
return rows
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Run one config
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def run_config(rows, k, use_xor, bleach, seed):
|
||||
n_bits = 276 + (69 if use_xor else 0)
|
||||
net = WiSARD(n_bits, k, seed)
|
||||
n = len(rows)
|
||||
|
||||
all_errors = []
|
||||
errors_first50 = []
|
||||
errors_last50 = []
|
||||
hits = 0
|
||||
|
||||
for i, row in enumerate(rows):
|
||||
bits = build_input(row, use_xor)
|
||||
cx, cy = net.predict(bits, bleach)
|
||||
|
||||
t = flight_ticks(row["f0_distance"], REP_POWER)
|
||||
lx, ly = predict_linear(row, t)
|
||||
px = lx + cx
|
||||
py = ly + cy
|
||||
ax, ay = row[f"{REP_POWER_STR}_enemy_x"], row[f"{REP_POWER_STR}_enemy_y"]
|
||||
|
||||
e = euclid(px, py, ax, ay)
|
||||
all_errors.append(e)
|
||||
if e <= HIT_RADIUS:
|
||||
hits += 1
|
||||
if i < 50:
|
||||
errors_first50.append(e)
|
||||
if i >= n - 50:
|
||||
errors_last50.append(e)
|
||||
|
||||
# Online learn: residual on top of current prediction
|
||||
rx = ax - px
|
||||
ry = ay - py
|
||||
net.learn(bits, rx, ry)
|
||||
|
||||
mae = sum(all_errors) / n
|
||||
hit_rate = hits / n * 100
|
||||
mae_f50 = sum(errors_first50) / len(errors_first50) if errors_first50 else float("nan")
|
||||
mae_l50 = sum(errors_last50) / len(errors_last50) if errors_last50 else float("nan")
|
||||
return mae, hit_rate, mae_f50, mae_l50
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Main
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def main():
|
||||
rows = load_rows()
|
||||
print(f"Loaded {len(rows)} rows from {sum(os.path.exists(p) for p in CSV_FILES)} files")
|
||||
|
||||
# Baseline: pure linear extrapolation (no correction)
|
||||
baseline_errors = []
|
||||
baseline_hits = 0
|
||||
for row in rows:
|
||||
t = flight_ticks(row["f0_distance"], REP_POWER)
|
||||
px, py = predict_linear(row, t)
|
||||
ax, ay = row[f"{REP_POWER_STR}_enemy_x"], row[f"{REP_POWER_STR}_enemy_y"]
|
||||
e = euclid(px, py, ax, ay)
|
||||
baseline_errors.append(e)
|
||||
if e <= HIT_RADIUS:
|
||||
baseline_hits += 1
|
||||
baseline_mae = sum(baseline_errors) / len(baseline_errors)
|
||||
baseline_hitrate = baseline_hits / len(rows) * 100
|
||||
|
||||
print(f"Baseline linear extrapolation: MAE={baseline_mae:.2f}px hit%={baseline_hitrate:.1f}%")
|
||||
print(f"\nRunning sweep: {len(K_VALUES)} K × {len(XOR_OPTIONS)} XOR × {len(BLEACH_VALS)} bleach × {len(SEEDS)} seeds = "
|
||||
f"{len(K_VALUES)*len(XOR_OPTIONS)*len(BLEACH_VALS)*len(SEEDS)} configs...")
|
||||
|
||||
results = [] # (avg_mae, hit_rate, mae_f50, mae_l50, std_mae, k, use_xor, bleach)
|
||||
|
||||
total = len(K_VALUES) * len(XOR_OPTIONS) * len(BLEACH_VALS)
|
||||
done = 0
|
||||
for k in K_VALUES:
|
||||
for use_xor in XOR_OPTIONS:
|
||||
for bleach in BLEACH_VALS:
|
||||
done += 1
|
||||
seed_maes = []
|
||||
seed_hits = []
|
||||
seed_f50 = []
|
||||
seed_l50 = []
|
||||
for seed in SEEDS:
|
||||
mae, hit_rate, mae_f50, mae_l50 = run_config(rows, k, use_xor, bleach, seed)
|
||||
seed_maes.append(mae)
|
||||
seed_hits.append(hit_rate)
|
||||
seed_f50.append(mae_f50)
|
||||
seed_l50.append(mae_l50)
|
||||
|
||||
avg_mae = sum(seed_maes) / len(seed_maes)
|
||||
avg_hit = sum(seed_hits) / len(seed_hits)
|
||||
avg_f50 = sum(seed_f50) / len(seed_f50)
|
||||
avg_l50 = sum(seed_l50) / len(seed_l50)
|
||||
mean_m = avg_mae
|
||||
std_mae = math.sqrt(sum((x - mean_m) ** 2 for x in seed_maes) / len(seed_maes))
|
||||
results.append((avg_mae, avg_hit, avg_f50, avg_l50, std_mae, k, use_xor, bleach))
|
||||
print(f" [{done:3d}/{total}] K={k:2d} xor={int(use_xor)} bleach={bleach} MAE={avg_mae:.2f}±{std_mae:.2f} hit%={avg_hit:.1f}%")
|
||||
|
||||
results.sort(key=lambda r: r[0]) # sort by MAE ascending
|
||||
|
||||
# ---- Format output ----
|
||||
lines = []
|
||||
w = lines.append
|
||||
w("=" * 90)
|
||||
w("WiSARD HYPERPARAMETER SWEEP — sorted by MAE (rep power=1.07, hit_radius=18px)")
|
||||
w(f"Dataset: {len(rows)} rows (target battles 1-5), 3 seeds per config")
|
||||
w("=" * 90)
|
||||
w("")
|
||||
w(f"{'Config':<30} {'MAE':>8} {'±std':>6} {'hit%':>7} {'MAE f50':>8} {'MAE l50':>8} {'vs base':>8}")
|
||||
w("-" * 90)
|
||||
w(f"{'P1 linear baseline':<30} {baseline_mae:>8.2f} {'':>6} {baseline_hitrate:>7.1f}% {'':>8} {'':>8} {'':>8}")
|
||||
w("-" * 90)
|
||||
|
||||
for avg_mae, avg_hit, avg_f50, avg_l50, std_mae, k, use_xor, bleach in results:
|
||||
n_bits = 276 + (69 if use_xor else 0)
|
||||
xor_tag = "+XOR" if use_xor else " "
|
||||
delta = avg_mae - baseline_mae
|
||||
label = f"K={k:2d} {xor_tag} bleach={bleach} ({n_bits}b)"
|
||||
w(f"{label:<30} {avg_mae:>8.2f} {std_mae:>6.2f} {avg_hit:>7.1f}% {avg_f50:>8.2f} {avg_l50:>8.2f} {delta:>+8.2f}")
|
||||
|
||||
w("")
|
||||
w("Columns: MAE=mean abs error(px) ±std=across 3 seeds hit%=shots within 18px")
|
||||
w(" MAE f50/l50=first/last 50 samples (learning curve) vs base=delta to P1")
|
||||
|
||||
report = "\n".join(lines)
|
||||
print("\n" + report)
|
||||
with open(OUT_PATH, "w") as f:
|
||||
f.write(report + "\n")
|
||||
print(f"\n[saved to {OUT_PATH}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,76 @@
|
||||
==========================================================================================
|
||||
WiSARD HYPERPARAMETER SWEEP — sorted by MAE (rep power=1.07, hit_radius=18px)
|
||||
Dataset: 3153 rows (target battles 1-5), 3 seeds per config
|
||||
==========================================================================================
|
||||
|
||||
Config MAE ±std hit% MAE f50 MAE l50 vs base
|
||||
------------------------------------------------------------------------------------------
|
||||
P1 linear baseline 1.63 98.3%
|
||||
------------------------------------------------------------------------------------------
|
||||
K=14 bleach=1 (276b) 1.37 0.01 98.2% 0.48 0.00 -0.26
|
||||
K=14 bleach=2 (276b) 1.38 0.01 98.2% 0.52 0.00 -0.25
|
||||
K=12 bleach=1 (276b) 1.38 0.00 98.2% 0.48 0.03 -0.25
|
||||
K=20 bleach=1 (276b) 1.38 0.01 98.2% 0.43 0.00 -0.24
|
||||
K=20 +XOR bleach=1 (345b) 1.39 0.01 98.1% 0.48 0.00 -0.24
|
||||
K=12 bleach=2 (276b) 1.39 0.01 98.2% 0.52 0.03 -0.24
|
||||
K=16 bleach=1 (276b) 1.39 0.01 98.1% 0.48 0.01 -0.24
|
||||
K=12 bleach=0 (276b) 1.40 0.01 98.1% 0.44 0.03 -0.23
|
||||
K=14 +XOR bleach=1 (345b) 1.40 0.02 98.2% 0.48 0.01 -0.23
|
||||
K=14 +XOR bleach=0 (345b) 1.40 0.00 98.1% 0.44 0.01 -0.23
|
||||
K=16 +XOR bleach=1 (345b) 1.40 0.02 98.1% 0.47 0.02 -0.23
|
||||
K=16 bleach=2 (276b) 1.40 0.02 98.2% 0.53 0.01 -0.22
|
||||
K=20 bleach=2 (276b) 1.41 0.03 98.2% 0.53 0.00 -0.22
|
||||
K=14 bleach=0 (276b) 1.41 0.01 98.1% 0.44 0.00 -0.22
|
||||
K=16 +XOR bleach=0 (345b) 1.41 0.02 98.0% 0.43 0.02 -0.21
|
||||
K=12 +XOR bleach=0 (345b) 1.41 0.01 98.1% 0.45 0.04 -0.21
|
||||
K=20 +XOR bleach=0 (345b) 1.41 0.01 98.1% 0.45 0.00 -0.21
|
||||
K=12 +XOR bleach=1 (345b) 1.42 0.01 98.2% 0.48 0.04 -0.21
|
||||
K=10 bleach=1 (276b) 1.42 0.01 98.2% 0.48 0.04 -0.21
|
||||
K=16 bleach=0 (276b) 1.42 0.00 98.1% 0.44 0.01 -0.21
|
||||
K=16 +XOR bleach=2 (345b) 1.42 0.02 98.1% 0.54 0.02 -0.21
|
||||
K=14 +XOR bleach=2 (345b) 1.42 0.02 98.2% 0.52 0.02 -0.21
|
||||
K=14 bleach=3 (276b) 1.42 0.03 98.2% 0.54 0.00 -0.21
|
||||
K=10 bleach=0 (276b) 1.42 0.00 98.1% 0.44 0.04 -0.21
|
||||
K=12 bleach=3 (276b) 1.42 0.02 98.2% 0.58 0.03 -0.21
|
||||
K=10 bleach=2 (276b) 1.43 0.02 98.2% 0.52 0.05 -0.20
|
||||
K=20 +XOR bleach=2 (345b) 1.43 0.01 98.2% 0.56 0.00 -0.20
|
||||
K=12 +XOR bleach=2 (345b) 1.44 0.02 98.2% 0.53 0.04 -0.19
|
||||
K=10 +XOR bleach=0 (345b) 1.44 0.01 98.1% 0.46 0.04 -0.18
|
||||
K=16 bleach=3 (276b) 1.45 0.02 98.1% 0.58 0.01 -0.18
|
||||
K=10 +XOR bleach=1 (345b) 1.45 0.02 98.2% 0.50 0.04 -0.18
|
||||
K= 8 bleach=0 (276b) 1.45 0.00 98.1% 0.47 0.08 -0.17
|
||||
K=10 bleach=3 (276b) 1.45 0.02 98.2% 0.56 0.05 -0.17
|
||||
K=14 +XOR bleach=3 (345b) 1.46 0.02 98.2% 0.56 0.02 -0.17
|
||||
K= 8 bleach=1 (276b) 1.46 0.01 98.2% 0.50 0.09 -0.17
|
||||
K=16 +XOR bleach=3 (345b) 1.46 0.01 98.1% 0.56 0.02 -0.16
|
||||
K=12 +XOR bleach=3 (345b) 1.47 0.02 98.2% 0.57 0.04 -0.16
|
||||
K=10 +XOR bleach=2 (345b) 1.47 0.01 98.2% 0.53 0.04 -0.16
|
||||
K= 8 bleach=2 (276b) 1.48 0.01 98.2% 0.54 0.09 -0.15
|
||||
K=20 bleach=3 (276b) 1.49 0.05 98.2% 0.58 0.00 -0.14
|
||||
K=10 +XOR bleach=3 (345b) 1.49 0.01 98.2% 0.57 0.04 -0.13
|
||||
K=20 bleach=0 (276b) 1.49 0.04 97.9% 0.40 0.00 -0.13
|
||||
K=20 +XOR bleach=3 (345b) 1.50 0.01 98.2% 0.58 0.00 -0.13
|
||||
K= 8 +XOR bleach=0 (345b) 1.50 0.00 98.2% 0.48 0.06 -0.13
|
||||
K= 8 bleach=3 (276b) 1.51 0.02 98.2% 0.57 0.09 -0.12
|
||||
K= 8 +XOR bleach=1 (345b) 1.51 0.00 98.2% 0.51 0.06 -0.12
|
||||
K= 6 bleach=0 (276b) 1.51 0.00 98.3% 0.48 0.09 -0.11
|
||||
K= 6 bleach=1 (276b) 1.52 0.00 98.3% 0.50 0.09 -0.10
|
||||
K= 8 +XOR bleach=2 (345b) 1.53 0.00 98.2% 0.54 0.06 -0.09
|
||||
K= 6 bleach=2 (276b) 1.54 0.00 98.3% 0.53 0.09 -0.08
|
||||
K= 8 +XOR bleach=3 (345b) 1.55 0.00 98.2% 0.57 0.06 -0.07
|
||||
K= 6 bleach=3 (276b) 1.56 0.00 98.3% 0.57 0.10 -0.07
|
||||
K= 6 +XOR bleach=0 (345b) 1.57 0.01 98.3% 0.49 0.07 -0.05
|
||||
K= 6 +XOR bleach=1 (345b) 1.59 0.01 98.2% 0.52 0.07 -0.04
|
||||
K= 6 +XOR bleach=2 (345b) 1.61 0.01 98.2% 0.55 0.07 -0.02
|
||||
K= 6 +XOR bleach=3 (345b) 1.62 0.01 98.2% 0.57 0.07 -0.00
|
||||
K= 4 bleach=0 (276b) 1.63 0.01 98.2% 0.50 0.08 -0.00
|
||||
K= 4 bleach=1 (276b) 1.64 0.01 98.2% 0.52 0.08 +0.01
|
||||
K= 4 bleach=2 (276b) 1.65 0.01 98.2% 0.55 0.08 +0.02
|
||||
K= 4 +XOR bleach=0 (345b) 1.65 0.00 98.2% 0.52 0.06 +0.02
|
||||
K= 4 bleach=3 (276b) 1.66 0.01 98.2% 0.57 0.08 +0.03
|
||||
K= 4 +XOR bleach=1 (345b) 1.66 0.00 98.2% 0.54 0.05 +0.03
|
||||
K= 4 +XOR bleach=2 (345b) 1.67 0.00 98.2% 0.56 0.05 +0.04
|
||||
K= 4 +XOR bleach=3 (345b) 1.68 0.00 98.2% 0.58 0.05 +0.05
|
||||
|
||||
Columns: MAE=mean abs error(px) ±std=across 3 seeds hit%=shots within 18px
|
||||
MAE f50/l50=first/last 50 samples (learning curve) vs base=delta to P1
|
||||
Reference in New Issue
Block a user