TM gun round 2: base was never behind; RADIAL target beats Linear on bmPoint
=== TASK 1: MY PREMISE WAS REFUTED ===
I instructed the job to "fix the baseline" because an earlier measurement said the
TM gun's base did not iterate flight time like `LinearGun`. MEASURED: the new gun's
base is BYTE-FOR-BYTE `LinearGun` - 18/18 runs tie exactly, p=1.000, every per-run
row byte-identical. The "non-iterating baseline" belonged to the OLD `tsetlin.nim`,
not this gun. So no fix was needed, and the earlier inference should not have been
generalised to the new gun. (It did still align the zero-correction clamp to
LinearGun's exact [0, arena] range, and reports the old BotRadius-inset base was a
wash/marginally better at 34.2%/24.7%.)
=== TASK 2: THE RADIAL TARGET - A CONTROL-VALIDATED WIN, BUT ONLY ON bmPoint ===
Instead of the lateral (GF-bucket) component - which the linear lead already
captures - the TM now predicts the RADIAL component: will the enemy be nearer or
farther than the base prediction when our bullet arrives? A 5-class radial head
sharing the same 40-bit context and TM core; the readout advances/retards the aim
distance along the base bearing.
under bmPath (the SHIPPED metric): STRUCTURAL NO-OP
synthetic 8/8 exact ties, p=1.0; real 33.9%/24.1% vs Linear 34.0%/24.3%
under bmPoint: A WIN, control-validated
TMRadial 9.4% (6013/63785) / 5.8% (42079/726652)
Linear 7.2% / 4.7% overall 17/1, p=0.0001
Tsetlin 7.0% / 4.8% overall 15/3, p=0.0075
shuffled 7.0% / 3.6% early 17/1 p=0.0001; overall 18/0, p<0.0001
radial head online accuracy 48.8% vs 19.9% shuffled chance and 36.7% majority
-> it is CONDITIONAL learning, not a constant short-range bias.
Best config: TM_RADIAL_RANGE=60, TM_RAD_MARGIN=0.25, 5 classes.
CAVEAT THAT MATTERS: a win on `bmPoint` is NOT yet evidence of a real win. `bmPath`
is the shipped SELECTION metric precisely because it beat `bmPoint` on real hit
rate (7.43% vs 4.70%). But that A/B was about which gun to PICK, not about gun
QUALITY - a gun can be better in reality while scoring worse on the selection
metric. So this needs a LIVE test, and it is the decisive one.
=== TASK 3: REVERSAL TARGET - CLEAN NEGATIVE ===
The label positive rate is only 9.7% (rev=[24772,2673]) and the head's 86.8%
accuracy is BELOW the 90.3% majority baseline: it does not learn the positive
class at all. Hit-rate effect neutral (bmPath 19.5%/18.4% vs shuffled 19.1%/17.8%,
p=0.24/0.82). Dropped.
=== OVERALL ===
Not competitive on the shipped bmPath metric (gated GF 28.3%/22.2% vs Linear
34.0%/24.3%, p=0.0075). Better than Linear on bmPoint via TMRadial (+2.2pp early,
+1.1pp overall). Per-enemy reset exists; a fresh gun per round; NO cross-battle
persistence (the user's non-negotiable).
MEASURED LIMITATION: radial mode has a high labelMiss because aiming short
resolves BEFORE the base arrival tick, biasing training toward resolvable samples.
The metric win is label-independent. A deferred-label fix is the next refinement.
INFERRED: the mechanism is surfers being NEARER than the base prediction
(range-holding); a constant-short-offset ablation would separate a learned
short-range bias from genuine per-tick conditional prediction.
This commit is contained in:
+164
-29
@@ -71,8 +71,30 @@ const
|
||||
TM_TRACE_SLOTS = 1024
|
||||
POS_RING = 512
|
||||
DebugTMPattern* = false
|
||||
## ── radial head (Task 2) ────────────────────────────────────────────────
|
||||
## Radial label = (enemy radius at the BASE arrival tick) - (base fire
|
||||
## distance), bucketed over +/-TM_RADIAL_RANGE px. Readout advances/retards
|
||||
## the aim distance along the base bearing.
|
||||
TM_RADIAL_RANGE_DEF {.strdefine.} = "60.0"
|
||||
TM_RADIAL_RANGE* = parseFloat(TM_RADIAL_RANGE_DEF)
|
||||
TM_RAD_MARGIN_DEF {.strdefine.} = "0.25"
|
||||
TM_RAD_MARGIN* = parseFloat(TM_RAD_MARGIN_DEF)
|
||||
## ── reversal head (Task 3) ──────────────────────────────────────────────
|
||||
## Binary: did the enemy's heading turn direction over the flight oppose the
|
||||
## direction it was turning at fire time?
|
||||
TM_REV_TURN_DEG_DEF {.strdefine.} = "10.0"
|
||||
TM_REV_TURN_DEG* = parseFloat(TM_REV_TURN_DEG_DEF)
|
||||
TM_REV_MARGIN_DEF {.strdefine.} = "0.0"
|
||||
TM_REV_MARGIN* = parseFloat(TM_REV_MARGIN_DEF)
|
||||
TM_REV_GAIN_DEF {.strdefine.} = "1.0"
|
||||
TM_REV_GAIN* = parseFloat(TM_REV_GAIN_DEF)
|
||||
|
||||
type
|
||||
TmTargetMode* = enum
|
||||
tmGF ## round-1: lateral guess-factor bucket
|
||||
tmRadial ## Task 2: radial displacement bucket (aim-distance correction)
|
||||
tmReversal ## Task 3: binary turn reversal; flips the GF correction sign
|
||||
|
||||
TmBits* = array[TM_NLITS, uint8]
|
||||
|
||||
TmPatternTrace = object
|
||||
@@ -81,20 +103,33 @@ type
|
||||
arrivalTick: int
|
||||
baseBearing: float
|
||||
fireX, fireY: float
|
||||
fireHeading: float
|
||||
fireTurn: int
|
||||
fireDist: float
|
||||
lits: TmBits
|
||||
votes: array[TM_CLASSES, float]
|
||||
cache: array[TM_CLASSES, array[TM_NCLAUSES, uint8]]
|
||||
chosen: int
|
||||
radVotes: array[TM_CLASSES, float]
|
||||
radCache: array[TM_CLASSES, array[TM_NCLAUSES, uint8]]
|
||||
radChosen: int
|
||||
revVotes: array[2, float]
|
||||
revCache: array[2, array[TM_NCLAUSES, uint8]]
|
||||
revChosen: int
|
||||
warm: bool
|
||||
alive: bool
|
||||
|
||||
PosSample = object
|
||||
tick: int
|
||||
x, y: float
|
||||
heading: float
|
||||
valid: bool
|
||||
|
||||
TmPatternGun* = object
|
||||
teams: array[TM_CLASSES, seq[int16]]
|
||||
radTeams: array[TM_CLASSES, seq[int16]]
|
||||
revTeams: array[2, seq[int16]]
|
||||
targetMode*: TmTargetMode
|
||||
traces: array[TM_TRACE_SLOTS, TmPatternTrace]
|
||||
# ── history ──
|
||||
posRing: array[POS_RING, PosSample]
|
||||
@@ -117,10 +152,17 @@ type
|
||||
labelMisses*: int
|
||||
chosenHist*: array[TM_CLASSES, int]
|
||||
labelHist*: array[TM_CLASSES, int]
|
||||
radChosenHist*: array[TM_CLASSES, int]
|
||||
radLabelHist*: array[TM_CLASSES, int]
|
||||
revChosenHist*: array[2, int]
|
||||
revLabelHist*: array[2, int]
|
||||
radCorrect*, radTotal*: int
|
||||
revCorrect*, revTotal*: int
|
||||
classCorrect*: int ## warm predictions whose class matched the eventual label
|
||||
classTotal*: int ## warm predictions with a resolvable label
|
||||
lastChosen*: int
|
||||
shuffleLabels*: bool ## control: replace the computed GF label with a random class
|
||||
forceBase*: bool ## measurement: ignore the TM, emit the pure LinearGun base
|
||||
debugGraphics*: bool
|
||||
|
||||
# ── TM core (Granmo Table 2/3, corrected resource allocation) ────────────────
|
||||
@@ -199,6 +241,14 @@ proc bucketToGF(c: int): float {.inline.} =
|
||||
if TM_CLASSES <= 1: 0.0
|
||||
else: float(c) / float(TM_CLASSES - 1) * 2.0 - 1.0
|
||||
|
||||
proc radToBucket(delta: float): int {.inline.} =
|
||||
let u = clamp(delta / TM_RADIAL_RANGE, -1.0, 1.0)
|
||||
clamp(int(round((u + 1.0) * 0.5 * float(TM_CLASSES - 1))), 0, TM_CLASSES - 1)
|
||||
|
||||
proc bucketToRadial(c: int): float {.inline.} =
|
||||
if TM_CLASSES <= 1: 0.0
|
||||
else: (float(c) / float(TM_CLASSES - 1) * 2.0 - 1.0) * TM_RADIAL_RANGE
|
||||
|
||||
proc normDeg(d: float): float {.inline.} =
|
||||
result = d
|
||||
while result > 180.0: result -= 360.0
|
||||
@@ -208,6 +258,9 @@ proc normDeg(d: float): float {.inline.} =
|
||||
|
||||
proc initTmPatternGun*(): TmPatternGun =
|
||||
for c in 0..<TM_CLASSES: result.teams[c] = tmNewTeam()
|
||||
for c in 0..<TM_CLASSES: result.radTeams[c] = tmNewTeam()
|
||||
for c in 0..<2: result.revTeams[c] = tmNewTeam()
|
||||
result.targetMode = tmGF
|
||||
result.lastTick = -1
|
||||
result.prevTick = -1
|
||||
result.currentTarget = -1
|
||||
@@ -221,6 +274,8 @@ proc resetLearning*(g: var TmPatternGun) =
|
||||
## Fresh concept: wipe every clause team and the motion history. Called when
|
||||
## the target id changes so a new opponent starts from a cold net.
|
||||
for c in 0..<TM_CLASSES: g.teams[c] = tmNewTeam()
|
||||
for c in 0..<TM_CLASSES: g.radTeams[c] = tmNewTeam()
|
||||
for c in 0..<2: g.revTeams[c] = tmNewTeam()
|
||||
g.totalObs = 0
|
||||
g.hasPrev = false
|
||||
for i in 0..<3:
|
||||
@@ -235,7 +290,7 @@ proc tmUpdateHistory(g: var TmPatternGun, state: WorldState) =
|
||||
g.lastTick = state.tick
|
||||
let slot = ((state.tick mod POS_RING) + POS_RING) mod POS_RING
|
||||
g.posRing[slot] = PosSample(tick: state.tick, x: state.enemyX, y: state.enemyY,
|
||||
valid: true)
|
||||
heading: state.enemyHeading, valid: true)
|
||||
if g.hasPrev and state.tick > g.prevTick:
|
||||
let dx = state.enemyX - g.prevX
|
||||
let dy = state.enemyY - g.prevY
|
||||
@@ -368,25 +423,25 @@ proc tmSoftGF(votes: array[TM_CLASSES, float]): float =
|
||||
for c in 0..<TM_CLASSES:
|
||||
result += (w[c] / sum) * bucketToGF(c)
|
||||
|
||||
proc tmChooseClass(g: var TmPatternGun, votes: array[TM_CLASSES, float]): int =
|
||||
## Cold gun or a flat vote vector -> straight ahead (GF = 0). Otherwise the
|
||||
## argmax class, but ONLY when it beats the centre class by TM_CONF_MARGIN
|
||||
## (fraction of TM_T); otherwise stay at the centre. This is what keeps the
|
||||
## gun from degrading to arbitrary buckets when the TM has no real evidence.
|
||||
let centre = (TM_CLASSES - 1) div 2
|
||||
if g.totalObs < TM_MIN_OBS:
|
||||
proc tmChooseAt(votes: openArray[float], centre: int, margin: float,
|
||||
nObs: int): int =
|
||||
## Cold gun or no class beating the centre by `margin` (fraction of TM_T)
|
||||
## -> the centre. Shared by the GF, radial and reversal heads.
|
||||
if nObs < TM_MIN_OBS:
|
||||
return centre
|
||||
var best = 0
|
||||
var bestV = -Inf
|
||||
for c in 0..<TM_CLASSES:
|
||||
for c in 0..<votes.len:
|
||||
if votes[c] > bestV: bestV = votes[c]; best = c
|
||||
if best == centre:
|
||||
return centre
|
||||
let margin = (votes[best] - votes[centre]) / TM_T
|
||||
if margin < TM_CONF_MARGIN:
|
||||
if (votes[best] - votes[centre]) / TM_T < margin:
|
||||
return centre
|
||||
result = best
|
||||
|
||||
proc tmChooseClass(g: var TmPatternGun, votes: array[TM_CLASSES, float]): int =
|
||||
tmChooseAt(votes, (TM_CLASSES - 1) div 2, TM_CONF_MARGIN, g.totalObs)
|
||||
|
||||
proc predict*(g: var TmPatternGun, state: WorldState, bulletSpeed: float):
|
||||
GunPrediction =
|
||||
inc g.predictCalls
|
||||
@@ -413,21 +468,52 @@ proc predict*(g: var TmPatternGun, state: WorldState, bulletSpeed: float):
|
||||
var caches: array[TM_CLASSES, array[TM_NCLAUSES, uint8]]
|
||||
for c in 0..<TM_CLASSES:
|
||||
votes[c] = tmForward(g.teams[c], lits, caches[c])
|
||||
var radVotes: array[TM_CLASSES, float]
|
||||
var radCaches: array[TM_CLASSES, array[TM_NCLAUSES, uint8]]
|
||||
for c in 0..<TM_CLASSES:
|
||||
radVotes[c] = tmForward(g.radTeams[c], lits, radCaches[c])
|
||||
var revVotes: array[2, float]
|
||||
var revCaches: array[2, array[TM_NCLAUSES, uint8]]
|
||||
for c in 0..<2:
|
||||
revVotes[c] = tmForward(g.revTeams[c], lits, revCaches[c])
|
||||
|
||||
let chosen = g.tmChooseClass(votes)
|
||||
let radChosen = tmChooseAt(radVotes, (TM_CLASSES - 1) div 2, TM_RAD_MARGIN,
|
||||
g.totalObs)
|
||||
let revChosen = tmChooseAt(revVotes, 0, TM_REV_MARGIN, g.totalObs)
|
||||
g.lastChosen = chosen
|
||||
inc g.chosenHist[chosen]
|
||||
inc g.radChosenHist[radChosen]
|
||||
inc g.revChosenHist[revChosen]
|
||||
|
||||
var gf: float
|
||||
if g.totalObs < TM_MIN_OBS:
|
||||
gf = 0.0
|
||||
elif TM_GF_MODE == "soft":
|
||||
gf = TM_SHRINK * tmSoftGF(votes)
|
||||
var gf = 0.0
|
||||
var radOffset = 0.0
|
||||
if not (g.forceBase or g.totalObs < TM_MIN_OBS):
|
||||
case g.targetMode
|
||||
of tmGF:
|
||||
if TM_GF_MODE == "soft": gf = TM_SHRINK * tmSoftGF(votes)
|
||||
else: gf = TM_SHRINK * bucketToGF(chosen)
|
||||
of tmRadial:
|
||||
radOffset = bucketToRadial(radChosen)
|
||||
of tmReversal:
|
||||
if TM_GF_MODE == "soft": gf = TM_SHRINK * tmSoftGF(votes)
|
||||
else: gf = TM_SHRINK * bucketToGF(chosen)
|
||||
if revChosen == 1:
|
||||
gf = -TM_REV_GAIN * gf
|
||||
|
||||
# An all-zero correction must reproduce `LinearGun` BYTE-FOR-BYTE, so use its
|
||||
# exact aim point and its exact [0, arena] clamp rather than the
|
||||
# BotRadius-inset clamp the corrective excursions use.
|
||||
let usedBase = (gf == 0.0 and radOffset == 0.0)
|
||||
var px, py: float
|
||||
if usedBase:
|
||||
px = f.x
|
||||
py = f.y
|
||||
else:
|
||||
gf = TM_SHRINK * bucketToGF(chosen)
|
||||
let aimAngle = f.bearing + gf * mea
|
||||
let px = state.selfX + cos(aimAngle) * f.dist
|
||||
let py = state.selfY + sin(aimAngle) * f.dist
|
||||
let aimAngle = f.bearing + gf * mea
|
||||
let aimDist = f.dist + radOffset
|
||||
px = state.selfX + cos(aimAngle) * aimDist
|
||||
py = state.selfY + sin(aimAngle) * aimDist
|
||||
|
||||
let binIdx = tmBinForSpeed(bulletSpeed)
|
||||
if binIdx >= 0:
|
||||
@@ -440,16 +526,23 @@ proc predict*(g: var TmPatternGun, state: WorldState, bulletSpeed: float):
|
||||
arrivalTick: state.tick + arrOff,
|
||||
baseBearing: f.bearing,
|
||||
fireX: state.selfX, fireY: state.selfY,
|
||||
lits: lits, votes: votes, cache: caches,
|
||||
chosen: chosen, warm: (g.totalObs >= TM_MIN_OBS), alive: true)
|
||||
fireHeading: state.enemyHeading, fireTurn: g.turnSignHist[0],
|
||||
fireDist: f.dist,
|
||||
lits: lits, votes: votes, cache: caches, chosen: chosen,
|
||||
radVotes: radVotes, radCache: radCaches, radChosen: radChosen,
|
||||
revVotes: revVotes, revCache: revCaches, revChosen: revChosen,
|
||||
warm: (g.totalObs >= TM_MIN_OBS), alive: true)
|
||||
|
||||
when DebugTMPattern:
|
||||
echo "tmp tick=", state.tick, " bin=", binIdx, " chosen=", chosen,
|
||||
" gf=", gf, " obs=", g.totalObs, " votes=", votes
|
||||
" radChosen=", radChosen, " revChosen=", revChosen,
|
||||
" gf=", gf, " roff=", radOffset, " obs=", g.totalObs, " votes=", votes
|
||||
|
||||
GunPrediction(
|
||||
x: clamp(px, BotRadius, state.arenaWidth - BotRadius),
|
||||
y: clamp(py, BotRadius, state.arenaHeight - BotRadius),
|
||||
x: if usedBase: clamp(px, 0.0, state.arenaWidth)
|
||||
else: clamp(px, BotRadius, state.arenaWidth - BotRadius),
|
||||
y: if usedBase: clamp(py, 0.0, state.arenaHeight)
|
||||
else: clamp(py, BotRadius, state.arenaHeight - BotRadius),
|
||||
)
|
||||
|
||||
proc onResult*(g: var TmPatternGun, e: FeedbackEvent) =
|
||||
@@ -479,15 +572,57 @@ proc onResult*(g: var TmPatternGun, e: FeedbackEvent) =
|
||||
while delta > PI: delta -= 2.0 * PI
|
||||
while delta < -PI: delta += 2.0 * PI
|
||||
let gf = if mea > 1e-10: clamp(delta / mea, -1.0, 1.0) else: 0.0
|
||||
let winner = if g.shuffleLabels: rand(TM_CLASSES - 1) else: gfToBucket(gf)
|
||||
|
||||
# The shuffled control randomises ONLY the head the current mode is claiming.
|
||||
let shuffleGF = g.shuffleLabels and g.targetMode == tmGF
|
||||
let shuffleRad = g.shuffleLabels and g.targetMode == tmRadial
|
||||
let shuffleRev = g.shuffleLabels and g.targetMode == tmReversal
|
||||
|
||||
let winner = if shuffleGF: rand(TM_CLASSES - 1) else: gfToBucket(gf)
|
||||
inc g.labelHist[winner]
|
||||
if t.warm:
|
||||
inc g.classTotal
|
||||
if winner == t.chosen: inc g.classCorrect
|
||||
|
||||
for c in 0..<TM_CLASSES:
|
||||
let d = if c == winner: 1.0 else: -1.0
|
||||
g.teams[c].tmLearnDir(t.lits, t.cache[c], t.votes[c], d)
|
||||
# Radial label: enemy radius at the base arrival tick minus the base fire
|
||||
# distance. Independent of our own aim, so it is a clean target.
|
||||
let actualRadius = hypot(g.posRing[s].x - t.fireX, g.posRing[s].y - t.fireY)
|
||||
let radDelta = actualRadius - t.fireDist
|
||||
let radWinner = if shuffleRad: rand(TM_CLASSES - 1) else: radToBucket(radDelta)
|
||||
inc g.radLabelHist[radWinner]
|
||||
if t.warm:
|
||||
inc g.radTotal
|
||||
if radWinner == t.radChosen: inc g.radCorrect
|
||||
|
||||
# Reversal label: net heading turn over the flight, opposite to the direction
|
||||
# the enemy was turning at fire time.
|
||||
let dh = normDeg(g.posRing[s].heading - t.fireHeading)
|
||||
let netTurn = if dh > TM_REV_TURN_DEG: 1 elif dh < -TM_REV_TURN_DEG: -1 else: 0
|
||||
let revWinner =
|
||||
if shuffleRev: rand(1)
|
||||
elif t.fireTurn != 0 and netTurn != 0 and netTurn != t.fireTurn: 1
|
||||
else: 0
|
||||
inc g.revLabelHist[revWinner]
|
||||
if t.warm:
|
||||
inc g.revTotal
|
||||
if revWinner == t.revChosen: inc g.revCorrect
|
||||
|
||||
case g.targetMode
|
||||
of tmGF:
|
||||
for c in 0..<TM_CLASSES:
|
||||
let d = if c == winner: 1.0 else: -1.0
|
||||
g.teams[c].tmLearnDir(t.lits, t.cache[c], t.votes[c], d)
|
||||
of tmRadial:
|
||||
for c in 0..<TM_CLASSES:
|
||||
let d = if c == radWinner: 1.0 else: -1.0
|
||||
g.radTeams[c].tmLearnDir(t.lits, t.radCache[c], t.radVotes[c], d)
|
||||
of tmReversal:
|
||||
for c in 0..<TM_CLASSES:
|
||||
let d = if c == winner: 1.0 else: -1.0
|
||||
g.teams[c].tmLearnDir(t.lits, t.cache[c], t.votes[c], d)
|
||||
for c in 0..<2:
|
||||
let d = if c == revWinner: 1.0 else: -1.0
|
||||
g.revTeams[c].tmLearnDir(t.lits, t.revCache[c], t.revVotes[c], d)
|
||||
inc g.totalObs
|
||||
inc g.trainCalls
|
||||
t.alive = false
|
||||
|
||||
Reference in New Issue
Block a user