zhanwenchen's picture
GUI-agent evaluation rig: code, per-episode records, media and findings
60bbfe6
Raw History Blame Contribute Delete
13 kB
# /// script
# requires-python = '>=3.12'
# dependencies = ['numpy', 'pillow', 'pyserial']
# ///
'''Relative aiming for Task A: move the gun, not a cursor.
Everything actuated so far has been absolute pointing — park the cursor, then
jump to a screen pixel. That is right for menus and unusable in a battle: there
is no cursor, and the mouse steers the gun by relative movement. So aiming is a
control problem rather than a click, and it needs three things this file
provides.
1. A way to measure how far the view actually moved, from the captured frames
alone. Phase correlation gives that without any game-side information.
2. A gain: how many pixels the view turns per unit of mouse movement. This is
a property of the game's sensitivity setting, so it has to be measured on
the rig rather than assumed, and re-measured whenever that setting changes.
3. A closed loop: move, look, correct. One open-loop jump will not land,
because the gain is only approximate and the turret has inertia.
uv run aim.py --self-test # verify the estimator, no hardware
uv run aim.py --calibrate # measure the gain (needs the game up)
The self-test is the part that can be checked without the rig, and it is worth
running after any change here: an aiming loop built on a shift estimator that
is silently wrong would look like a model that cannot aim.
'''
from __future__ import annotations
import time
from argparse import ArgumentParser
from dataclasses import dataclass
from io import BytesIO
from typing import Callable
import numpy as np
from PIL import Image
Grab = Callable[[], bytes] # returns JPEG bytes of the current frame
def _luma(jpeg: bytes, downscale: int = 2) -> np.ndarray:
im = Image.open(BytesIO(jpeg)).convert('L')
if downscale > 1:
im = im.resize((im.width // downscale, im.height // downscale))
return np.asarray(im, dtype=np.float32)
def estimate_shift(a: np.ndarray, b: np.ndarray) -> tuple[float, float]:
'''How far b is displaced from a, in pixels, by phase correlation.
Returns (dx, dy): positive dx means the content moved right. A Hann window
is applied first because the frames are not periodic and the edges would
otherwise dominate the correlation.
'''
if a.shape != b.shape:
raise ValueError(f'frame size changed: {a.shape} vs {b.shape}')
h, w = a.shape
win = np.outer(np.hanning(h), np.hanning(w))
fa = np.fft.rfft2((a - a.mean()) * win)
fb = np.fft.rfft2((b - b.mean()) * win)
# conj(a)*b, not a*conj(b): the reversed order returns the exact
# negative of the displacement, which an earlier version of this
# file shipped while its self-test quietly negated the result and
# reported a pass (FINDINGS F44).
cross = np.conj(fa) * fb
mag = np.abs(cross)
mag[mag == 0] = 1e-12
corr = np.fft.irfft2(cross / mag, s=a.shape)
peak = np.unravel_index(int(np.argmax(corr)), corr.shape)
dy, dx = float(peak[0]), float(peak[1])
# wrap: a peak past the halfway point is a negative displacement
if dy > h / 2:
dy -= h
if dx > w / 2:
dx -= w
return dx, dy
@dataclass(frozen=True)
class Gain:
'''Pixels of view movement per unit of mouse movement, WITH sign.
The sign records which way the view travels for a positive mouse movement.
It is not cosmetic: aim_at is a proportional controller, and one fed a
flipped sign does not converge slowly, it diverges.
'''
px_per_count_x: float
px_per_count_y: float
downscale: int
samples: int
sign_stable: bool = True
def counts_for(self, dx_px: float, dy_px: float) -> tuple[int, int]:
gx = self.px_per_count_x or 1e-9
gy = self.px_per_count_y or 1e-9
return int(round(dx_px / gx)), int(round(dy_px / gy))
def calibrate_gain(hid, grab: Grab, counts: int = 200, samples: int = 3,
settle_s: float = 0.35, downscale: int = 2) -> Gain:
'''Measure pixels-per-count by moving a known amount and watching the view.
Each sample moves out and back so the aim ends where it started, which
matters because this runs on a live game. The horizontal and vertical gains
are measured separately: they differ whenever the game applies a different
sensitivity per axis.
'''
xs: list[float] = []
ys: list[float] = []
for _ in range(samples):
before = _luma(grab(), downscale)
hid.move_rel(counts, 0)
time.sleep(settle_s)
after = _luma(grab(), downscale)
dx, _ = estimate_shift(before, after)
hid.move_rel(-counts, 0)
time.sleep(settle_s)
xs.append(dx * downscale / counts) # signed, deliberately
before = _luma(grab(), downscale)
hid.move_rel(0, counts)
time.sleep(settle_s)
after = _luma(grab(), downscale)
_, dy = estimate_shift(before, after)
hid.move_rel(0, -counts)
time.sleep(settle_s)
ys.append(dy * downscale / counts) # signed, deliberately
# If the measured direction flips between samples the gain is not
# trustworthy at all: something other than our input is moving the view.
stable = (len({x > 0 for x in xs}) == 1 and len({y > 0 for y in ys}) == 1)
return Gain(float(np.median(xs)), float(np.median(ys)),
downscale, samples, stable)
def aim_at(hid, grab: Grab, offset_fn: Callable[[bytes], tuple[float, float] | None],
gain: Gain, tol_px: float = 12.0, max_steps: int = 6,
settle_s: float = 0.25, damping: float = 0.8) -> dict:
'''Bring the gun onto a target by moving, looking and correcting.
offset_fn is given the current frame and returns how far the target sits
from the aiming point in pixels, or None if it cannot find it. Steps are
damped because overshooting and oscillating is the usual failure of a loop
like this, and each correction is measured rather than assumed.
'''
trace: list[dict] = []
for step in range(max_steps):
frame = grab()
off = offset_fn(frame)
if off is None:
trace.append({'step': step, 'status': 'target not found'})
return {'hit': False, 'reason': 'target not found', 'trace': trace}
dx_px, dy_px = off
err = float(np.hypot(dx_px, dy_px))
trace.append({'step': step, 'dx_px': dx_px, 'dy_px': dy_px, 'err_px': err})
if err <= tol_px:
return {'hit': True, 'steps': step, 'err_px': err, 'trace': trace}
cx, cy = gain.counts_for(dx_px * damping, dy_px * damping)
if cx == 0 and cy == 0: # below one count of resolution
return {'hit': False, 'reason': 'below movement resolution',
'err_px': err, 'trace': trace}
hid.move_rel(cx, cy)
time.sleep(settle_s)
return {'hit': False, 'reason': 'did not converge', 'trace': trace}
def _self_test() -> int:
'''Check the estimator against known shifts, with no hardware involved.'''
rng = np.random.default_rng(0)
base = rng.random((360, 640)).astype(np.float32)
# smooth it so it resembles a scene rather than white noise
for _ in range(3):
base = (base + np.roll(base, 1, 0) + np.roll(base, 1, 1)) / 3.0
worst = 0.0
print(f'{"true dx":>8s} {"true dy":>8s} {"est dx":>8s} {"est dy":>8s}')
# The last four exceed half the frame on one or both axes, which is
# what exercises the wrap-around branch below (half-width 320,
# half-height 180 on this 360x640 test image).
for tdx, tdy in ((10, 0), (-14, 0), (0, 9), (0, -21), (17, -13),
(-30, 25), (200, 0), (-260, 0), (0, 150),
(240, -140)):
shifted = np.roll(np.roll(base, tdy, axis=0), tdx, axis=1)
edx, edy = estimate_shift(base, shifted)
print(f'{tdx:8d} {tdy:8d} {edx:8.1f} {edy:8.1f}')
worst = max(worst, abs(edx - tdx), abs(edy - tdy))
ok = worst <= 1.0
print(f'\nworst error {worst:.2f} px — {"PASS" if ok else "FAIL"}')
return 0 if ok else 1
def _direction_test() -> int:
"""Run the real calibrate_gain against a mock rig with a known direction.
The estimator's self-test only exercises estimate_shift. This exercises the
whole path — device, capture, gain — and checks the one property nothing
else checks: that a positive mouse movement produces a gain whose SIGN says
which way the view actually went. Two bugs shipped for want of this test
(FINDINGS F44): the estimator returned the negative of its contract, and
the gain discarded the sign with abs() so nothing downstream could notice.
"""
from io import BytesIO as _B
rng = np.random.default_rng(1)
world = rng.random((720, 1280)).astype(np.float32)
for _ in range(3):
world = (world + np.roll(world, 1, 0) + np.roll(world, 1, 1)) / 3.0
class MockRig:
"""A device whose movement really does displace the captured view."""
def __init__(self, px_per_count_x: float, px_per_count_y: float):
self.gx, self.gy = px_per_count_x, px_per_count_y
self.ox = self.oy = 0.0
def move_rel(self, dx: int, dy: int) -> None:
self.ox += dx * self.gx
self.oy += dy * self.gy
def grab(self) -> bytes:
view = np.roll(np.roll(world, int(round(self.oy)), 0),
int(round(self.ox)), 1)
buf = _B()
Image.fromarray(view.clip(0, 1).__mul__(255).astype('uint8')).save(
buf, format='JPEG', quality=92)
return buf.getvalue()
ok = True
print(f'{"true gain x":>12s} {"true gain y":>12s} '
f'{"measured x":>11s} {"measured y":>11s} verdict')
for tgx, tgy in ((0.40, 0.35), (-0.40, 0.35), (0.55, -0.48), (-0.30, -0.30)):
rig = MockRig(tgx, tgy)
g = calibrate_gain(rig, rig.grab, counts=100, samples=2,
settle_s=0.0, downscale=2)
sign_ok = (np.sign(g.px_per_count_x) == np.sign(tgx)
and np.sign(g.px_per_count_y) == np.sign(tgy))
mag_ok = (abs(abs(g.px_per_count_x) - abs(tgx)) < 0.05
and abs(abs(g.px_per_count_y) - abs(tgy)) < 0.05)
good = sign_ok and mag_ok and g.sign_stable
ok &= good
print(f'{tgx:12.2f} {tgy:12.2f} {g.px_per_count_x:11.3f} '
f'{g.px_per_count_y:11.3f} '
f'{"ok" if good else ("SIGN WRONG" if not sign_ok else "magnitude off")}')
# A controller given a flipped gain must diverge, not merely converge
# slowly. Confirm that, so the sign check above is known to matter.
class Turret:
def __init__(self, dx, gx): self.dx, self.gx = dx, gx
def move_rel(self, cx, cy): self.dx -= cx * self.gx
def offset(self, _): return (self.dx, 0.0)
right = Turret(300.0, 0.40)
aim_at(right, lambda: b'', right.offset,
Gain(0.40, 0.40, 2, 2), tol_px=12, max_steps=6, settle_s=0.0)
flipped = Turret(300.0, 0.40)
aim_at(flipped, lambda: b'', flipped.offset,
Gain(-0.40, -0.40, 2, 2), tol_px=12, max_steps=6, settle_s=0.0)
diverged = abs(flipped.dx) > 300.0
print(f'\ncorrect sign converges to {abs(right.dx):8.1f} px')
print(f'flipped sign ends at {abs(flipped.dx):8.1f} px '
f'({"diverges as expected" if diverged else "DID NOT DIVERGE"})')
ok &= diverged
print(f'\n{"PASS" if ok else "FAIL"}')
return 0 if ok else 1
def main() -> int:
ap = ArgumentParser(description='Relative aiming for Task A.')
ap.add_argument('--self-test', action='store_true')
ap.add_argument('--direction-test', action='store_true',
help='run the real gain measurement against a mock rig')
ap.add_argument('--calibrate', action='store_true')
ap.add_argument('--counts', type=int, default=200)
ap.add_argument('--device', default='/dev/video0')
ap.add_argument('--port',
default='/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0')
args = ap.parse_args()
if args.self_test:
return _self_test()
if args.direction_test:
return _direction_test()
if args.calibrate:
from gua_eval.capture import ElgatoSource # noqa: PLC0415
from hid_kmbox import KMBox # noqa: PLC0415
cap = ElgatoSource(args.device)
frames = cap.frames()
def grab() -> bytes:
return next(frames)[0]
with KMBox(args.port) as hid:
hid.open()
hid.set_relative()
gain = calibrate_gain(hid, grab, counts=args.counts)
print(f'horizontal {gain.px_per_count_x:.4f} px/count')
print(f'vertical {gain.px_per_count_y:.4f} px/count')
print(f' a 300 px correction needs '
f'{gain.counts_for(300, 0)[0]} counts horizontally')
return 0
ap.print_help()
return 0
if __name__ == '__main__':
raise SystemExit(main())