tests/test.sh exit code (0 → resolved); the classification below is post-hoc and cannot change it.Explore app structure
ls -la && echo "---SUBMISSION---" && ls -la submission/ && echo "---DATA---" && ls -la data/ && echo "---RUNCHECKS head---" && head -50 run_checks.py
total 117
drwxr-xr-x 4 user user 4096 Jun 30 22:11 .
drwxr-xr-x 21 root root 4096 Jun 30 22:11 ..
-rw-r--r-- 1 user user 15364 Jun 30 22:11 PROMPT.txt
-rw-r--r-- 1 user user 5 Jun 30 22:11 agent.pid
-rw-r--r-- 1 user user 0 Jun 30 22:11 agent.stderr
-rw-r--r-- 1 user user 4596 Jun 30 22:11 agent_trajectory.jsonl
drwxr-xr-x 2 user user 60 Jun 30 22:11 data
-rw-r--r-- 1 user user 0 Jun 30 22:11 run.log
-rwxr-xr-x 1 user user 76773 Jun 30 10:02 run_checks.py
drwxr-xr-x 2 user user 128 Jun 30 22:11 submission
-rwxr-xr-x 1 user user 804 Jun 30 10:02 test.sh
-rwxr-xr-x 1 user user 629 Jun 30 10:02 timer.sh
---SUBMISSION---
total 112
drwxr-xr-x 2 user user 128 Jun 30 22:11 .
drwxr-xr-x 4 user user 4096 Jun 30 22:11 ..
-rw-r--r-- 1 user user 50472 Jun 30 10:02 autograd.py
-rw-r--r-- 1 user user 1661 Jun 30 10:02 data.py
-rw-r--r-- 1 user user 33295 Jun 30 10:02 nn.py
-rw-r--r-- 1 user user 11509 Jun 30 10:02 optim.py
-rw-r--r-- 1 user user 2827 Jun 30 10:02 train.py
---DATA---
total 1900
drwxr-xr-x 2 user user 60 Jun 30 22:11 .
drwxr-xr-x 4 user user 4096 Jun 30 22:11 ..
-rw-r--r-- 1 user user 1940490 Jun 30 10:02 train.npz
---RUNCHECKS head---
#!/usr/bin/env python3
"""PUBLIC component check runner for the from-scratch numpy QAT framework.
Run this AS OFTEN AS YOU LIKE while you implement, to get a per-check progress signal:
python3 /app/run_checks.py # check the framework in /app/submission
python3 /app
…[truncated 2703 chars]/app/submission/autograd.py
1 """Reverse-mode automatic differentiation over numpy arrays. 2 3 YOU MUST IMPLEMENT EVERYTHING MARKED ``# TODO`` / ``raise NotImplementedError`` using numpy 4 ONLY. No torch/jax/tensorflow/autograd/etc. The grader's conformance suite (a) differentiates the 5 differentiable ops below with central finite differences and compares against YOUR analytic 6 backward, and (b) checks the LSQ ``fake_quant`` STE + scale gradient against the reference 7 definition, so every backward must be correct (a single wrong reduction / STE / Jacobian fails 8 the gradient checks and zeroes the reward). 9 10 A ``Tensor`` wraps one ``numpy.ndarray`` (stored as ``float64`` in ``self.data``) and records the 11 op that produced it so ``.backward()`` can accumulate ``.grad`` into every leaf. 12 13 CONTRACT (the grader builds its own reference against this exact API): 14 * ``Tensor(data, requires_grad=False)`` -- ``self.data`` is ``float64``; ``self.grad`` is None 15 until backward, then a same-shape ``float64`` array. requires_grad leaves accumulate grad. 16 * Every op returns a NEW Tensor whose ``requires_grad`` is the OR of its differentiable inputs, 17 and whose ``_backward`` closure does ``input._accum(local_grad)`` (so multiple paths add up). 18 * ``t.backward(grad=None)`` -- seeds ``grad`` (all-ones for a scalar) and walks the graph in 19 reverse topological order, calling each node's ``_backward``. Repeated backward accumulates. 20 * BROADCASTING: binary ops broadcast like numpy; the ba …[truncated 54775 chars]
/app/submission/nn.py
1 """QAT layers + a small INT2 CNN, built on YOUR autograd engine.
2
3 Implement every ``# TODO`` forward (the parameters + ``named_params``/``buffers`` naming are
4 already wired for you; you compose the autograd ops). The grader checks each layer's forward
5 against its OWN reference AND finite-difference-checks the gradients that flow through your
6 autograd, so the composition must be exactly right.
7
8 CHECKPOINT NAMING CONTRACT (the grader loads YOUR ``qat_model.npz`` into its own reference
9 QuantCNN by these exact keys/shapes -- do not rename):
10 stem.conv.weight (W0,3,3,3) | stem.conv.wq.scale (1,) | stem.bn.gamma/.beta (W0,) | stem.aq.scale (1,)
11 blocks.{i}.conv.weight (Cout,Cin,3,3) | blocks.{i}.conv.wq.scale (1,)
12 blocks.{i}.bn.gamma/.beta (Cout,) | blocks.{i}.aq.scale (1,)
13 head.weight (Cfeat,n_classes) | head.wq.scale (1,) | head.bias (n_classes,)
14 BN running stats are BUFFERS (saved alongside params, NOT trained by the optimizer, NOT audited):
15 stem.bn.running_mean/.running_var (W0,) | blocks.{i}.bn.running_mean/.running_var (Cout,)
16
17 Quantization: every conv/head WEIGHT is LSQ-quantized to a signed 2-bit grid {-2,-1,0,1} via a
18 per-tensor learnable step before use; every block activation (post-relu) is LSQ-quantized to an
19 unsigned 2-bit grid {0,1,2,3}. Conv = 3x3 same-padding cross-correlation. Linear head = x@weight+bias.
20 """
21 from __future__ import annotations
22
23 from typing import Dict, List
24
25 import numpy as n
…[truncated 35167 chars]/app/submission/optim.py
1 """Optimizers over autograd ``Tensor`` parameters.
2
3 Implement the ``# TODO`` update math. Both optimizers update ``param.data`` IN PLACE using
4 ``param.grad``. The grader runs one (and several) steps and compares your updated params against
5 its reference within a tight tolerance, so the math must be exact.
6
7 SGD (with momentum ``mu`` and coupled weight decay ``wd``):
8 g = grad + wd * param; v = mu * v + g; param -= lr * v
9
10 AdamW (DECOUPLED weight decay -- the decay is applied to the PARAM, not folded into the moments):
11 m = b1*m + (1-b1)*g; v = b2*v + (1-b2)*g^2
12 mhat = m / (1 - b1^t); vhat = v / (1 - b2^t) # t = 1-based step count
13 param -= lr * ( mhat / (sqrt(vhat) + eps) + wd * param )
14
15 PARAM GROUPS: both optimizers must accept EITHER a flat param list OR a list of
16 ``{"params": [...], "weight_decay": wd}`` dicts, so weight decay can be applied to SOME params
17 and not others. This matters for low-bit LSQ QAT: the per-tensor quantizer ``scale`` params,
18 BatchNorm gamma/beta, and biases must be EXCLUDED from weight decay. ``_normalize_groups`` and
19 ``split_decay_params`` are provided; honour the per-group weight decay in ``step``.
20 """
21 from __future__ import annotations
22
23 import math
24
25 from typing import Dict, List
26
27 import numpy as np
28
29 from autograd import Tensor
30
31
32 def split_decay_params(model) -> Dict[str, List[Tensor]]:
33 """Partition a model's named params into weight
…[truncated 11129 chars]/app/submission/data.py
1 """Image data loading + normalization + batching.
2
3 The dataset is a procedurally-generated CIFAR-style set: ``X`` is ``uint8`` (N,3,S,S) in [0,255],
4 ``y`` is the integer class label in [0, n_classes). The shipped training split is at
5 ``/app/data/train.npz``; the SEALED held-out split is regenerated by the verifier (never shipped).
6
7 Implement the ``# TODO`` bodies (numpy only). The verifier normalizes the held-out split with the
8 SAME transform, so match it exactly.
9
10 Contract:
11 load_npz(path) -> (X uint8 (N,3,S,S), y int64 (N,)) [provided]
12 normalize(X) -> float64: x = (X/255 - 0.5) / 0.25 [per-channel, the grader's transform]
13 iter_minibatches(Xn, y, batch_size, rng, shuffle=True) -> yields (xb, yb)
14 """
15 from __future__ import annotations
16
17 from typing import Tuple
18
19 import numpy as np
20
21 NORM_MEAN = 0.5
22 NORM_STD = 0.25
23
24
25 def load_npz(path: str) -> Tuple[np.ndarray, np.ndarray]:
26 d = np.load(path)
27 X = np.asarray(d["X"]).astype(np.uint8)
28 y = np.asarray(d["y"]).astype(np.int64).reshape(-1)
29 return X, y
30
31
32 def normalize(X: np.ndarray) -> np.ndarray:
33 """uint8 (N,3,S,S) -> float64, x = (X/255 - NORM_MEAN) / NORM_STD."""
34 # TODO: cast to float, scale to [0,1], subtract NORM_MEAN, divide by NORM_STD.
35 raise NotImplementedError("normalize")
36
37
38 def iter_minibatches(Xn: np.ndarray, y: np.ndarray, batch_size: int,
39 rng: np.rando
…[truncated 281 chars]/app/submission/train.py
1 """Training entry point. Implement the QAT loop, train your INT2 CNN on /app/data/train.npz, and 2 SAVE the checkpoint to /app/submission/qat_model.npz (numpy .npz of the model state_dict: every 3 param + every BN running buffer, by the nn.QuantCNN naming contract). 4 5 The grader (verify.py) will: 6 (1) run the conformance suite over your autograd/nn/optim, 7 (2) BIT-AUDIT every conv/head weight tensor in your checkpoint to <= 4 distinct float values, 8 (3) load your weights into its OWN QuantCNN and score held-out top-1 on a SEALED split. 9 10 So at SAVE time you must BAKE the quantized weights back into each ``weight`` tensor (replace it 11 with round(clip(w/s, -W_NEG, W_POS)) * s using the learned wq.scale) so the saved weights already 12 lie on the 2-bit grid and pass the audit. Reaching the top-1 floor at INT-2 needs a real recipe: 13 sensible LSQ STEP-SIZE INITIALIZATION (a default scale of 1.0 quantizes the small init weights to 14 all-zeros -> a dead network at chance), per-tensor learnable scales, weight decay EXCLUDED from the 15 scale/BN/bias params, gradient clipping, a decaying LR, and enough epochs. Naive post-training 16 rounding or under-training lands at chance. 17 18 This file is a skeleton; the loop body is yours to write. 19 """ 20 from __future__ import annotations 21 22 import argparse 23 import os 24 import sys 25 26 import numpy as np 27 28 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) 29 sys.path.insert(0, "/app") 30 3 …[truncated 1513 chars]
Scan run_checks for relevant references
grep -n "def \|grad_scale\|fake_quant\|scale_grad\|n_levels\|Qn\|Qp\|round\|class " /app/run_checks.py | head -120
22: * quant_grads : the LSQ fake_quant STE indicator + scale-gradient CLIP RULES (the exact 26: fake_quant lands on the integer grid, the full models run + shapes). 64:def _load_module(name, path, inject=None): 84:def load_framework(root): 93:def _num_grad_input(forward, x, eps=EPS): 108:def _max_abs(a, b): 112:def _bsum(it): 119:def _imax(a, b): 124:def check_autograd_grads(fw, sb): 130: def case(name, build, shape, seed, upstream=None): 135: def wrapped(t): 193: def two_path(): 204: def loss_grad(name, lossfn, shape, seed, inttgt): 218: def norm_param(name, which, seed): 237: def conv_grad(name, which, seed): 265: def pool_grad(name, op, seed, jitter=False): 281: def bn_grad(name, dim, which, seed): 316: def layer_grad(name, make, in_shape, seed): 335: def quant_model_backprop(name, build, make_X, seed): 382: def gn_x(): 395: def gn_param(name, which, seed): 413: def cell_grad(name, make, in_shape, hid, seed, two_state=False): 424: def fwd(xv): 438: def cell_param_grad(name, make, in_shape, hid, pkey, seed, two_state=False): 450: def fwd(pv): 455: def fwd(pv): 479: def hub_grad(name, seed, scale_in, delta): 493: def kl_grad_pub(): 505: def emb_grad_pub(): 517: def conv_gen_grad_pub(name, which, seed, stride, pad, dilation, groups, Cin, cig, Cout, hw): 538: def convT_grad_pub(name, which, seed, stride, pad): 558: def pool_s_grad_pub(name, o …[truncated 4240 chars]
/app/run_checks.py
584 def check_quant_grads(fw, sb):
585 ag = fw["autograd"]
586 results = []
587
588 def grads(v0, s0, Qn, Qp, up):
589 vt = ag.Tensor(v0.copy(), requires_grad=True)
590 st = ag.Tensor(np.array([s0]), requires_grad=True)
591 out = ag.fake_quant(vt, st, Qn, Qp)
592 out.backward(up.copy())
593 return np.asarray(vt.grad, np.float64), np.asarray(st.grad, np.float64), out.data.copy()
594
595 def ste_indicator(name, seed, Qn, Qp, s0):
596 try:
597 rng = np.random.default_rng(sb + seed)
598 v0 = rng.standard_normal((5, 5)) * 2.0
599 up = rng.standard_normal((5, 5))
600 gv, _, _ = grads(v0, s0, Qn, Qp, up)
601 r = v0 / s0
602 middle = (r >= -Qn) & (r <= Qp)
603 expected = up * middle
604 ok = _max_abs(gv, expected) < 1e-9 and np.all(gv[~middle] == 0.0)
605 results.append((f"quant/{name}", ok, f"err={_max_abs(gv, expected):.1e}"))
606 except Exception as e: # noqa: BLE001
607 results.append((f"quant/{name}", False, f"raised {type(e).__name__}: {e}"))
608 ste_indicator("ste_indicator_w", 60, 2, 1, 0.7)
609 ste_indicator("ste_indicator_a", 61, 0, 3, 0.5)
610
611 def scale_clip(name, seed, Qn, Qp, s0, fill, bound):
612 try:
613 v0 = np.full((4, 4), fill)
614 up = np.ones((4, 4))
615 _, gs, _ = grads(v0, s0, Qn, Qp, up)
616 gscale
…[truncated 10474 chars]/app/run_checks.py
335 def quant_model_backprop(name, build, make_X, seed):
336 try:
337 m = build(sb + seed)
338 nps = m.named_params()
339 for nm, p in nps.items():
340 if nm.endswith("wq.scale"):
341 wkey = nm[:-len("wq.scale")] + "weight"
342 p.data[...] = _imax(2.0 * float(np.mean(np.abs(nps[wkey].data))), 1e-2)
343 elif nm.endswith("aq.scale"):
344 p.data[...] = 1.0
345 m.set_training(True)
346 X = make_X(sb + seed + 5)
347 tgt = np.array([0, 2])
348 for p in m.params():
349 p.grad = None
350 ag.cross_entropy(m(X), tgt).backward()
351 allfinite = all(p.grad is not None and np.all(np.isfinite(p.grad)) for p in m.params())
352 ngrad = sum(1 for p in m.params() if p.grad is not None)
353 results.append((f"grad/{name}", allfinite and ngrad == len(m.params()),
354 f"{ngrad}/{len(m.params())} grads, finite={allfinite}"))
355 except Exception as e: # noqa: BLE001
356 results.append((f"grad/{name}", False, f"raised {type(e).__name__}: {e}"))
357 quant_model_backprop("QuantCNN_backprop", lambda s: nn.QuantCNN(6, widths=(8, 16), seed=s),
358 lambda s: np.random.default_rng(s).standard_normal((2, 3, 16, 16)), 90)
359 quant_model_backprop("QuantMLP_backprop", lambda s: nn.
…[truncated 6449 chars]/app/run_checks.py
990
991 def gru_cell_shape():
992 cell = nn.GRUCell(5, 4, np.random.default_rng(sb + 54))
993 h = cell(T(np.random.default_rng(sb + 55).standard_normal((3, 5))), T(np.zeros((3, 4))))
994 return h.data.shape == (3, 4), f"shape={h.data.shape}"
995
996 def lstm_cell_shape():
997 cell = nn.LSTMCell(5, 4, np.random.default_rng(sb + 56))
998 h, c = cell(T(np.random.default_rng(sb + 57).standard_normal((3, 5))), T(np.zeros((3, 4))), T(np.zeros((3, 4))))
999 return h.data.shape == (3, 4) and c.data.shape == (3, 4), ""
1000
1001 def perchan_layer_def():
1002 q = nn.PerChannelWeightQuant(4)
1003 q.scale.data[...] = np.array([0.5, 0.7, 0.6, 0.8])
1004 w = np.random.default_rng(sb + 58).standard_normal((4, 3, 2, 2))
1005 out = q.quant(T(w)).data
1006 sh = [1, 1, 1, 1]; sh[0] = 4
1007 levels = np.round(out / q.scale.data.reshape(sh))
1008 return bool(np.all((levels >= -2) & (levels <= 1))), ""
1009
1010 def affine_layer_def():
1011 q = nn.AffineActQuant(zero_point=1)
1012 q.scale.data[...] = np.array([0.6])
1013 x = np.random.default_rng(sb + 59).standard_normal((4, 5)) * 2.0
1014 out = q.forward(T(x)).data
1015 r = np.round(np.clip(x / 0.6 + 1, 0, 3))
1016 return _max_abs(out, (r - 1) * 0.6) < 1e-9, ""
1017
1018 # ---- v2 layer / op property checks ----
1019 def cumsum_def():
1020 x = np.random.default
…[truncated 10937 chars]/app/run_checks.py
1218 def adadelta_step(lr, rho, eps, wd):
1219 def f(i, p, g, t, st):
1220 s = st.get(("s", i), np.zeros_like(p)); d = st.get(("d", i), np.zeros_like(p))
1221 gg = g + wd * p
1222 s = rho * s + (1 - rho) * (gg * gg)
1223 delta = np.sqrt(d + eps) / np.sqrt(s + eps) * gg
1224 newp = p - lr * delta
1225 st[("s", i)] = s
1226 st[("d", i)] = rho * d + (1 - rho) * (delta * delta)
1227 return newp
1228 return f
1229
1230 def nesterov_step(lr, mu, wd):
1231 def f(i, p, g, t, st):
1232 v = st.get(("v", i), np.zeros_like(p))
1233 gg = g + wd * p
1234 v = mu * v + gg
1235 st[("v", i)] = v
1236 return p - lr * (gg + mu * v)
1237 return f
1238
1239 run("Adamax_5step", lambda p: opt.Adamax(p, lr=2e-3, betas=(0.9, 0.99), weight_decay=0.02),
1240 adamax_step(2e-3, 0.9, 0.99, 1e-8, 0.02), 5, sb + 20)
1241 run("NAdam_10step", lambda p: opt.NAdam(p, lr=2e-3, betas=(0.9, 0.999)),
1242 nadam_step(2e-3, 0.9, 0.999, 1e-8, 0.0), 10, sb + 21)
1243 run("Adadelta_5step", lambda p: opt.Adadelta(p, lr=1.0, rho=0.9, weight_decay=0.01),
1244 adadelta_step(1.0, 0.9, 1e-6, 0.01), 5, sb + 22)
1245 run("NesterovSGD_5step", lambda p: opt.NesterovSGD(p, lr=0.05, momentum=0.9, weight_decay=1e-2),
1246 nesterov_step(0.05, 0.9, 1e-2), 5, sb + 23)
1247
1248 def group_ca
…[truncated 7559 chars]/app/run_checks.py
1388 return overfit_loss(m, lambda g: opt.Adam(
1389 [{"params": g["decay"], "weight_decay": 0.0}, {"params": g["no_decay"], "weight_decay": 0.0}],
1390 lr=3e-3), X, y, 20)
1391
1392 def block(prefix, runner):
1393 try:
1394 losses = runner()
1395 finite = all(math.isfinite(x) for x in losses)
1396 results.append((f"integration/{prefix}_finite", finite, f"{losses[0]:.3f}->{losses[-1]:.3f}"))
1397 # on a fixed memorizable batch a correct stack drives the loss clearly down.
1398 progressed = finite and (min(losses) < losses[0] - 0.05)
1399 results.append((f"integration/{prefix}_loss_decreases", progressed,
1400 f"{losses[0]:.4f}->min {min(losses):.4f}"))
1401 except Exception as e: # noqa: BLE001
1402 results.append((f"integration/{prefix}_finite", False, f"raised {type(e).__name__}: {e}"))
1403 results.append((f"integration/{prefix}_loss_decreases", False, "n/a"))
1404
1405 def qsepcnn_run():
1406 m = nn.QuantSepCNN(6, widths=(8, 16), seed=sb + 7)
1407 init_scales(m)
1408 rng = np.random.default_rng(sb + 2)
1409 X = rng.standard_normal((8, 3, 16, 16)); y = rng.integers(0, 6, size=8)
1410 return overfit_loss(m, lambda g: opt.Adam(
1411 [{"params": g["decay"], "weight_decay": 0.0}, {"params": g["no_decay"], "weight_decay": 0.0}],
1412 l
…[truncated 3977 chars]/app/run_checks.py
93 def _num_grad_input(forward, x, eps=EPS): 94 g = np.zeros_like(x) 95 flat = x.reshape(-1) 96 gf = g.reshape(-1) 97 for i in range(flat.size): 98 old = flat[i] 99 flat[i] = old + eps 100 fp = float(np.sum(forward(x))) 101 flat[i] = old - eps 102 fm = float(np.sum(forward(x))) 103 flat[i] = old 104 gf[i] = (fp - fm) / (2 * eps) 105 return g 106 107 108 def _max_abs(a, b): 109 return float(np.max(np.abs(np.asarray(a, np.float64) - np.asarray(b, np.float64)))) 110 111 112 def _bsum(it): 113 s = 0 114 for x in it: 115 s += int(bool(x)) 116 return s 117 118 119 def _imax(a, b): 120 return a if a > b else b 121 122 123 # ======================================================================= autograd_grads 124 def check_autograd_grads(fw, sb): 125 ag = fw["autograd"] 126 nn = fw["nn"] 127 T = ag.Tensor 128 results = [] 129 130 def case(name, build, shape, seed, upstream=None): 131 try: 132 rng = np.random.default_rng(sb + seed) 133 x0 = rng.standard_normal(shape) 134 135 def wrapped(t): 136 o = build(t) 137 return ag.mul(o, T(upstream)) if upstream is not None else o 138 t = T(x0.copy(), requires_grad=True) 139 ag.sum(wrapped(t)).backward() 140 gan = np.asarray(t.grad, np.float64) 141 gnum = _num_grad_input(lambda xv: wrapped( …[truncated 11849 chars]
/app/run_checks.py
464
465 layer_grad("nn.SiLU_x", lambda r: nn.SiLU(), (4, 5), 150)
466 layer_grad("nn.ELU_x", lambda r: nn.ELU(0.7), (4, 5), 151)
467 layer_grad("nn.GroupNorm_x", lambda r: nn.GroupNorm(2, 4), (2, 4, 3, 3), 152)
468
469 # ---- v2 generic-op grad checks (same coverage as the held-out grader) ----
470 case("cumsum_ax1", lambda t: ag.cumsum(t, axis=1), (4, 5), 200, np.arange(20.0).reshape(4, 5) + 1.0)
471 case("flip_ax1", lambda t: ag.flip(t, axis=1), (4, 5), 202, np.arange(20.0).reshape(4, 5) + 1.0)
472 case("logsumexp_ax1", lambda t: ag.logsumexp(t, axis=1), (4, 5), 203, np.arange(4.0) + 1.0)
473 case("logaddexp", lambda t: ag.logaddexp(t, T(np.full((4, 5), 0.3))), (4, 5), 205, np.arange(20.0).reshape(4, 5) + 1.0)
474 case("l2_normalize_ax1", lambda t: ag.l2_normalize(t, axis=1), (4, 5), 206, np.arange(20.0).reshape(4, 5) + 1.0)
475 case("rms_norm_x", lambda t: ag.rms_norm(t, T(np.ones(5) * 1.3)), (4, 5), 207, np.arange(20.0).reshape(4, 5) + 1.0)
476 case("instance_norm_x", lambda t: ag.instance_norm(t, T(np.ones(4) * 1.2), T(np.ones(4) * 0.1)),
477 (2, 4, 3, 3), 208, np.arange(1.0, 2 * 4 * 3 * 3 + 1.0).reshape(2, 4, 3, 3))
478
479 def hub_grad(name, seed, scale_in, delta):
480 try:
481 rng = np.random.default_rng(sb + seed)
482 x0 = rng.standard_normal((4, 5)) * scale_in
483 tgt = rng.standard_normal((4, 5))
484 lt = T(x0.copy(), requires_grad=True)
485
…[truncated 6569 chars]Check tolerances and data shape
grep -n "TOL_GRAD\|TOL_OPT\|TOL_SCHED\|EPS =\|PUBLIC_SEED_BASE" /app/run_checks.py | head; echo "---data---"; python3 -c "import numpy as np; d=np.load('/app/data/train.npz'); print({k:(v.shape,v.dtype) for k,v in d.items()}); import numpy; print('y unique', np.unique(d['y']), 'counts', np.bincount(d['y']))"54:TOL_GRAD = 2e-3
56:TOL_OPT = 1e-7
57:TOL_SCHED = 1e-9
58:EPS = 1e-5
60:PUBLIC_SEED_BASE = 1000 # the GRADER uses a DIFFERENT base; do not curve-fit to these seeds.
143: results.append((f"grad/{name}", err < TOL_GRAD, f"max_abs={err:.2e}"))
199: results.append(("grad/two_path_accum", _max_abs(xt.grad, 2.0 * x0) < TOL_GRAD, ""))
212: results.append((f"grad/{name}", _max_abs(np.asarray(lt.grad), gnum) < TOL_GRAD, ""))
230: results.append((f"grad/{name}", _max_abs(np.asarray(pt.grad), _num_grad_input(fwd, p0.copy())) < TOL_GRAD, ""))
258: results.append((f"grad/conv2d_{which}", _max_abs(np.asarray(gan), gnum) < TOL_GRAD, ""))
---data---
{'X': ((2500, 3, 16, 16), dtype('uint8')), 'y': ((2500,), dtype('int64'))}
y unique [0 1 2 3 4 5 6 7 8 9] counts [250 250 250 250 250 250 250 250 250 250]/app/submission/autograd.py
while grad.ndim > len(shape):
grad = grad.sum(axis=0)
for ax, sz in enumerate(shape):
if sz == 1 and grad.shape[ax] != 1:
grad = grad.sum(axis=ax, keepdims=True)
return grad.reshape(shape) while grad.ndim > len(shape):
grad = grad.sum(axis=0)
for ax, sz in enumerate(shape):
if sz == 1 and grad.shape[ax] != 1:
grad = grad.sum(axis=ax, keepdims=True)
return grad.reshape(shape)
def _expand_grad(g, in_shape, axis, keepdims):
"""Broadcast a reduced gradient ``g`` back up to ``in_shape`` (re-inserting reduced axes)."""
g = np.asarray(g, dtype=np.float64)
if axis is None:
return np.broadcast_to(g, in_shape).copy()
if not keepdims:
ax = axis if isinstance(axis, tuple) else (axis,)
ax = tuple(a % len(in_shape) for a in ax)
for a in sorted(ax):
g = np.expand_dims(g, a)
return np.broadcast_to(g, in_shape).copy()The file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
TODO: implement the topological walk + seeding. (The per-op ``_backward`` closures do the
local accumulation; here you only orchestrate the order + seed ``self.grad``.)
"""
raise NotImplementedError("Tensor.backward") TODO: implement the topological walk + seeding. (The per-op ``_backward`` closures do the
local accumulation; here you only orchestrate the order + seed ``self.grad``.)
"""
if grad is None:
grad = np.ones_like(self.data)
self._accum(_as_f64(grad))
topo: List["Tensor"] = []
visited = set()
stack = [(self, False)]
while stack:
node, processed = stack.pop()
if processed:
topo.append(node)
continue
if id(node) in visited:
continue
visited.add(id(node))
stack.append((node, True))
for p in node._parents:
if id(p) not in visited:
stack.append((p, False))
for node in reversed(topo):
node._backward()The file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("add backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if a.requires_grad:
a._accum(_unbroadcast(g, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(g, b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("sub backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if a.requires_grad:
a._accum(_unbroadcast(g, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(-g, b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("mul backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if a.requires_grad:
a._accum(_unbroadcast(g * b.data, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(g * a.data, b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("div backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if a.requires_grad:
a._accum(_unbroadcast(g / b.data, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(-g * a.data / (b.data * b.data), b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("power backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * p * (a.data ** (p - 1)))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("maximum backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
am = (a.data > b.data) * 1.0 + (a.data == b.data) * 0.5
if a.requires_grad:
a._accum(_unbroadcast(g * am, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(g * (1.0 - am), b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("minimum backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
am = (a.data < b.data) * 1.0 + (a.data == b.data) * 0.5
if a.requires_grad:
a._accum(_unbroadcast(g * am, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(g * (1.0 - am), b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("where backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if a.requires_grad:
a._accum(_unbroadcast(np.where(c, g, 0.0), a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(np.where(c, 0.0, g), b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("exp backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * out.data)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("log backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad / a.data)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("sqrt backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * 0.5 / out.data)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("abs backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * np.sign(a.data))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("clip backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * ((a.data > lo) & (a.data < hi)))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("sum backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(_expand_grad(out.grad, a.data.shape, axis, keepdims))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("mean backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
n = a.data.size // out.data.size
a._accum(_expand_grad(out.grad, a.data.shape, axis, keepdims) / n)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("max backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
od = a.data.max(axis=axis, keepdims=True)
mask = (a.data == od).astype(np.float64)
cnt = mask.sum(axis=axis, keepdims=True)
g = _expand_grad(out.grad, a.data.shape, axis, keepdims)
a._accum(g * mask / cnt)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("min backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
od = a.data.min(axis=axis, keepdims=True)
mask = (a.data == od).astype(np.float64)
cnt = mask.sum(axis=axis, keepdims=True)
g = _expand_grad(out.grad, a.data.shape, axis, keepdims)
a._accum(g * mask / cnt)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("concat backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
sizes = [t.data.shape[axis] for t in ts]
idxs = np.cumsum(sizes)[:-1]
parts = np.split(g, idxs, axis=axis)
for t, part in zip(ts, parts):
if t.requires_grad:
t._accum(part)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("stack backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
for i, t in enumerate(ts):
if t.requires_grad:
t._accum(np.take(g, i, axis=axis))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("transpose backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
if axes is None:
a._accum(np.transpose(out.grad))
else:
inv = np.argsort(axes)
a._accum(np.transpose(out.grad, inv))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("reshape backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad.reshape(a.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("getitem backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
grad = np.zeros_like(a.data)
np.add.at(grad, idx, out.grad)
a._accum(grad)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("matmul backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if a.requires_grad:
da = g @ np.swapaxes(b.data, -1, -2)
a._accum(_unbroadcast(da, a.data.shape))
if b.requires_grad:
db = np.swapaxes(a.data, -1, -2) @ g
b._accum(_unbroadcast(db, b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("relu backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * (a.data > 0.0))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("leaky_relu backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * np.where(a.data > 0.0, 1.0, slope))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("sigmoid backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * out.data * (1.0 - out.data))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("tanh backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * (1.0 - out.data * out.data))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("gelu backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
pdf = np.exp(-0.5 * a.data * a.data) / np.sqrt(2.0 * np.pi)
a._accum(out.grad * (cdf + a.data * pdf))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("softmax backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
g = out.grad
sg = (g * s).sum(axis=axis, keepdims=True)
a._accum(s * (g - sg))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("log_softmax backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
g = out.grad
sm = np.exp(out.data)
a._accum(g - sm * g.sum(axis=axis, keepdims=True))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("cross_entropy backward") # TODO
out._backward = _bw
return out def _bw():
if logits.requires_grad:
sm = np.exp(logp)
grad_in = sm.copy()
grad_in[np.arange(n), t] -= 1.0
grad_in *= (out.grad / n)
logits._accum(grad_in)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("mse_loss backward") # TODO
out._backward = _bw
return out def _bw():
if pred.requires_grad:
N = pred.data.size
pred._accum((2.0 / N) * (pred.data - tgt) * out.grad)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("layernorm backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
lead = tuple(range(g.ndim - 1))
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=lead))
if beta.requires_grad:
beta._accum(g.sum(axis=lead))
if x.requires_grad:
gx = g * gamma.data
dx = inv / D * (D * gx - gx.sum(axis=-1, keepdims=True)
- xhat * (gx * xhat).sum(axis=-1, keepdims=True))
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("conv2d backward") # TODO (dW, dbias, dx via _col2im)
out._backward = _bw
return out def _bw():
dout = out.grad.reshape(N, Cout, OH * OW)
if weight.requires_grad:
dW = np.einsum("nop,ncp->oc", dout, cols).reshape(Cout, Cin, KH, KW)
weight._accum(dW)
if has_bias and bias.requires_grad:
bias._accum(dout.sum(axis=(0, 2)))
if x.requires_grad:
dcols = np.einsum("oc,nop->ncp", Wm, dout)
dxp = _col2im(dcols, xp.shape, KH, KW, stride, OH, OW)
if pad > 0:
dx = dxp[:, :, pad:pad + H, pad:pad + W]
else:
dx = dxp
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("avgpool2d backward") # TODO
out._backward = _bw
return out def _bw():
if x.requires_grad:
g = out.grad
dxr = np.broadcast_to(g[:, :, :, None, :, None], (N, C, OH, k, OW, k)) / (k * k)
dx = np.zeros_like(x.data)
dx[:, :, :OH * k, :OW * k] = dxr.reshape(N, C, OH * k, OW * k)
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("maxpool2d backward") # TODO
out._backward = _bw
return out def _bw():
if x.requires_grad:
xt = xr.transpose(0, 1, 2, 4, 3, 5).reshape(N, C, OH, OW, k * k)
am = xt.argmax(axis=-1)
g = out.grad
dxt = np.zeros((N, C, OH, OW, k * k), dtype=np.float64)
np.put_along_axis(dxt, am[..., None], g[..., None], axis=-1)
dxr = dxt.reshape(N, C, OH, OW, k, k).transpose(0, 1, 2, 4, 3, 5)
dx = np.zeros_like(x.data)
dx[:, :, :OH * k, :OW * k] = dxr.reshape(N, C, OH * k, OW * k)
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("batchnorm2d backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=(0, 2, 3)))
if beta.requires_grad:
beta._accum(g.sum(axis=(0, 2, 3)))
if x.requires_grad:
gx = g * g_
if training:
dx = inv / M * (M * gx - gx.sum(axis=(0, 2, 3), keepdims=True)
- xhat * (gx * xhat).sum(axis=(0, 2, 3), keepdims=True))
else:
dx = gx * inv
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("fake_quant backward (STE + LSQ scale gradient)") # TODO
out._backward = _bw
return out def _bw():
up = out.grad
mask = (r >= Qn) & (r <= Qp)
if v.requires_grad:
v._accum(up * mask)
if scale.requires_grad:
below = r < Qn
above = r > Qp
ds = np.where(below, Qn, np.where(above, Qp, np.round(r) - r))
ds_total = float((up * ds).sum()) * grad_scale
scale._accum(np.full_like(scale.data, ds_total))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("square backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * 2.0 * a.data)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("rsqrt backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * (-0.5) * (a.data ** (-1.5)))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("reciprocal backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * (-1.0) / (a.data * a.data))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("var backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
N = a.data.size // out.data.size
g = _expand_grad(out.grad, a.data.shape, axis, keepdims)
a._accum(g * (2.0 / N) * xc)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("std backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
N = a.data.size // _bi_max(1, np.asarray(out.data).size)
g = _expand_grad(out.grad, a.data.shape, axis, keepdims)
a._accum(g * xc / (N * sd))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("gather backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
grad = np.zeros_like(a.data)
coords = list(np.indices(idx.shape))
coords[axis] = idx
np.add.at(grad, tuple(coords), out.grad)
a._accum(grad)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("pad2d backward") # TODO
out._backward = _bw
return out def _bw():
if x.requires_grad:
if pad == 0:
x._accum(out.grad)
else:
H, W = x.data.shape[2], x.data.shape[3]
x._accum(out.grad[:, :, pad:pad + H, pad:pad + W])
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("softplus backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
with np.errstate(over="ignore"):
sig = 1.0 / (1.0 + np.exp(-bx))
a._accum(out.grad * sig)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("silu backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * (sig + a.data * sig * (1.0 - sig)))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("mish backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
tsp = np.tanh(sp)
with np.errstate(over="ignore"):
sig = 1.0 / (1.0 + np.exp(-x))
a._accum(out.grad * (tsp + x * (1.0 - tsp * tsp) * sig))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("elu backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
d = np.where(x > 0.0, 1.0, alpha * np.exp(np.minimum(x, 0.0)))
a._accum(out.grad * d)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("hardtanh backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * ((a.data > lo) & (a.data < hi)))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("hardsigmoid backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(out.grad * ((z > 0.0) & (z < 1.0)) / 6.0)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("groupnorm backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=(0, 2, 3)))
if beta.requires_grad:
beta._accum(g.sum(axis=(0, 2, 3)))
if x.requires_grad:
M = cg * H * W
gx = (g * gamma.data.reshape(1, C, 1, 1)).reshape(N, G, M)
xh = xhat.reshape(N, G, M)
dxg = inv / M * (M * gx - gx.sum(axis=2, keepdims=True)
- xh * (gx * xh).sum(axis=2, keepdims=True))
x._accum(dxg.reshape(N, C, H, W))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("fake_quant_per_channel backward (STE + per-channel scale grad)") # TODO
out._backward = _bw
return out def _bw():
up = out.grad
mask = (r >= Qn) & (r <= Qp)
if v.requires_grad:
v._accum(up * mask)
if scale.requires_grad:
below = r < Qn
above = r > Qp
ds = np.where(below, Qn, np.where(above, Qp, np.round(r) - r))
reduce_axes = tuple(i for i in range(v.data.ndim) if i != axis)
dsc = (up * ds).sum(axis=reduce_axes) * grad_scale
scale._accum(dsc.reshape(scale.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("fake_quant_affine backward (STE + scale grad on shifted grid)") # TODO
out._backward = _bw
return out def _bw():
up = out.grad
mask = (r >= Qn) & (r <= Qp)
if v.requires_grad:
v._accum(up * mask)
if scale.requires_grad:
lower = r < Qn
upper = r > Qp
middle = ~(lower | upper)
ds = np.where(middle, (q - z) - (r - z), np.where(lower, Qn - z, Qp - z))
ds_total = float((up * ds).sum()) * grad_scale
scale._accum(np.full_like(scale.data, ds_total))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("cumsum backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
g = out.grad
a._accum(np.flip(np.cumsum(np.flip(g, axis=axis), axis=axis), axis=axis))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("flip backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
a._accum(np.flip(out.grad, axis=axis))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("logsumexp backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
g = out.grad
if not keepdims:
g = np.expand_dims(g, axis)
a._accum(sm * g)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("logaddexp backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if a.requires_grad:
a._accum(_unbroadcast(g * np.exp(a.data - out_data), a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(g * np.exp(b.data - out_data), b.data.shape))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("l2_normalize backward") # TODO
out._backward = _bw
return out def _bw():
if a.requires_grad:
g = out.grad
dot = (y * g).sum(axis=axis, keepdims=True)
a._accum((g - y * dot) / nrm)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("rms_norm backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
lead = tuple(range(g.ndim - 1))
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=lead))
if x.requires_grad:
gg = g * gamma.data
dx = inv * gg - (xd * inv ** 3 / D) * (gg * xd).sum(axis=-1, keepdims=True)
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("instance_norm backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=(0, 2, 3)))
if beta.requires_grad:
beta._accum(g.sum(axis=(0, 2, 3)))
if x.requires_grad:
gx = (g * g_).reshape(N, C, M)
xh = xhat.reshape(N, C, M)
dxg = inv / M * (M * gx - gx.sum(axis=2, keepdims=True)
- xh * (gx * xh).sum(axis=2, keepdims=True))
x._accum(dxg.reshape(N, C, H, W))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("huber_loss backward") # TODO
out._backward = _bw
return out def _bw():
if pred.requires_grad:
d = np.where(quad, diff, delta * np.sign(diff))
pred._accum(d / n * out.grad)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("kl_div backward") # TODO
out._backward = _bw
return out def _bw():
if log_p.requires_grad:
log_p._accum((-q / n) * out.grad)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("embedding backward") # TODO
out._backward = _bw
return out def _bw():
if weight.requires_grad:
grad = np.zeros_like(weight.data)
np.add.at(grad, idx, out.grad)
weight._accum(grad)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("conv2d_gen backward (grouped/dilated dW/db/dx)") # TODO
out._backward = _bw
return out def _bw():
dout_full = out.grad.reshape(N, Cout, OH * OW)
dout_g = dout_full.reshape(N, groups, cog, OH * OW)
if weight.requires_grad:
dWm = np.einsum("ngop,ngcp->goc", dout_g, cols_g)
weight._accum(dWm.reshape(Cout, cig, KH, KW))
if has_bias and bias.requires_grad:
bias._accum(dout_full.sum(axis=(0, 2)))
if x.requires_grad:
dcols_g = np.einsum("goc,ngop->ngcp", Wm, dout_g)
dcols = dcols_g.reshape(N, Cin * KH * KW, OH * OW)
dxp = _col2im_dil(dcols, xp.shape, KH, KW, stride, dilation, OH, OW)
if pad > 0:
dx = dxp[:, :, pad:pad + H, pad:pad + W]
else:
dx = dxp
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("conv_transpose2d backward") # TODO
out._backward = _bw
return out def _bw():
g = out.grad
if has_bias and bias.requires_grad:
bias._accum(g.sum(axis=(0, 2, 3)))
if pad > 0:
gfull = np.zeros((N, Cout, OHf, OWf), dtype=np.float64)
gfull[:, :, pad:OHf - pad, pad:OWf - pad] = g
else:
gfull = g
gcontrib = np.empty((N, Cout, H, W, KH, KW), dtype=np.float64)
for i in range(KH):
for j in range(KW):
gcontrib[:, :, :, :, i, j] = gfull[:, :, i:i + stride * H:stride, j:j + stride * W:stride]
if x.requires_grad:
dx = np.einsum("noijKL,coKL->ncij", gcontrib, Wm)
x._accum(dx)
if weight.requires_grad:
dW = np.einsum("noijKL,ncij->coKL", gcontrib, xd)
weight._accum(dW)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("avgpool2d_s backward") # TODO
out._backward = _bw
return out def _bw():
if x.requires_grad:
g = out.grad
dxp = np.zeros((N, C, Hp, Wp), dtype=np.float64)
for oi in range(OH):
for oj in range(OW):
dxp[:, :, oi * stride:oi * stride + k, oj * stride:oj * stride + k] += \
(g[:, :, oi, oj] / (k * k))[:, :, None, None]
if pad > 0:
dx = dxp[:, :, pad:pad + H, pad:pad + W]
else:
dx = dxp
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("maxpool2d_s backward") # TODO
out._backward = _bw
return out def _bw():
if x.requires_grad:
g = out.grad
dxp = np.zeros((N, C, Hp, Wp), dtype=np.float64)
nC, cC = np.meshgrid(np.arange(N), np.arange(C), indexing="ij")
for oi in range(OH):
for oj in range(OW):
ii = oi * stride + argi[:, :, oi, oj]
jj = oj * stride + argj[:, :, oi, oj]
np.add.at(dxp, (nC, cC, ii, jj), g[:, :, oi, oj])
if pad > 0:
dx = dxp[:, :, pad:pad + H, pad:pad + W]
else:
dx = dxp
x._accum(dx)
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/autograd.py
def _bw():
raise NotImplementedError("fake_quant_lsq_plus backward (STE v-grad + beta-grad + LSQ scale grad)") # TODO
out._backward = _bw
return out def _bw():
up = out.grad
mask = (r >= Qn) & (r <= Qp)
if v.requires_grad:
v._accum(up * mask)
if beta.requires_grad:
db_total = float((up * (~mask)).sum())
beta._accum(np.full_like(beta.data, db_total))
if scale.requires_grad:
ds = np.where(mask, np.round(np.clip(r, Qn, Qp)) - r, np.where(r < Qn, Qn, Qp))
ds_total = float((up * ds).sum()) * grad_scale
scale._accum(np.full_like(scale.data, ds_total))
out._backward = _bw
return outThe file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/data.py
"""uint8 (N,3,S,S) -> float64, x = (X/255 - NORM_MEAN) / NORM_STD."""
# TODO: cast to float, scale to [0,1], subtract NORM_MEAN, divide by NORM_STD.
raise NotImplementedError("normalize") """uint8 (N,3,S,S) -> float64, x = (X/255 - NORM_MEAN) / NORM_STD."""
return (np.asarray(X, dtype=np.float64) / 255.0 - NORM_MEAN) / NORM_STDThe file /app/submission/data.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/data.py
"""Yield (xb, yb) minibatches over one epoch. ``Xn`` is already normalized float."""
# TODO: optionally shuffle an index array, then yield contiguous batch_size slices of it.
raise NotImplementedError("iter_minibatches") """Yield (xb, yb) minibatches over one epoch. ``Xn`` is already normalized float."""
n = Xn.shape[0]
idx = np.arange(n)
if shuffle:
rng.shuffle(idx)
for start in range(0, n, batch_size):
sel = idx[start:start + batch_size]
yield Xn[sel], y[sel]The file /app/submission/data.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: y = x @ weight (+ bias). Use ag.matmul / ag.add.
raise NotImplementedError("Linear.forward") def forward(self, x: Tensor) -> Tensor:
y = ag.matmul(x, self.weight)
if self.bias is not None:
y = ag.add(y, self.bias)
return yThe file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: out = x + fc2(gelu(fc1(x)))
raise NotImplementedError("MLP.forward") def forward(self, x: Tensor) -> Tensor:
return ag.add(x, self.fc2(ag.gelu(self.fc1(x))))The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.layernorm(x, self.gamma, self.beta, self.eps)
raise NotImplementedError("LayerNorm.forward") def forward(self, x: Tensor) -> Tensor:
return ag.layernorm(x, self.gamma, self.beta, self.eps)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.conv2d(x, self.weight, bias=self.bias, stride=self.stride, pad=self.padding)
raise NotImplementedError("Conv2d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.conv2d(x, self.weight, bias=self.bias, stride=self.stride, pad=self.padding)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.maxpool2d(x, self.k)
raise NotImplementedError("MaxPool2d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.maxpool2d(x, self.k)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.avgpool2d(x, self.k)
raise NotImplementedError("AvgPool2d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.avgpool2d(x, self.k)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def quant(self, w: Tensor) -> Tensor:
# TODO: return ag.fake_quant(w, self.scale, W_NEG, W_POS)
raise NotImplementedError("WeightQuant.quant") def quant(self, w: Tensor) -> Tensor:
return ag.fake_quant(w, self.scale, W_NEG, W_POS)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.fake_quant(x, self.scale, A_NEG, A_POS)
raise NotImplementedError("ActQuant.forward") def forward(self, x: Tensor) -> Tensor:
return ag.fake_quant(x, self.scale, A_NEG, A_POS)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: ag.batchnorm2d(x, gamma, beta, eps, running_mean, running_var, momentum, training)
raise NotImplementedError("BatchNorm2d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.batchnorm2d(x, self.gamma, self.beta, self.eps,
self.running_mean, self.running_var, self.momentum, self.training)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
Check batchnorm1d presence
grep -n "batchnorm1d\|def batchnorm" /app/submission/autograd.py
838:def batchnorm2d(x, gamma, beta, eps: float = 1e-5,
/app/submission/autograd.py
838 def batchnorm2d(x, gamma, beta, eps: float = 1e-5, 839 running_mean=None, running_var=None, momentum: float = 0.1, 840 training: bool = True) -> Tensor: 841 """BatchNorm over (N,H,W) per channel C. x:(N,C,H,W); gamma,beta:(C,). 842 843 TRAINING: normalize with the BATCH mean/var (POPULATION variance, divide by M=N*H*W); update 844 running_mean/running_var IN PLACE if given (running var tracks the UNBIASED batch variance, 845 i.e. var * M/(M-1)). The forward computes mu/var/inv/xhat; you implement the backward. 846 EVAL (training=False): normalize with the running stats; backward dx = grad*gamma*inv. 847 Backward (training): dgamma=sum(grad*xhat) over (N,H,W); dbeta=sum(grad) over (N,H,W); 848 gx = grad*gamma; dx = inv/M * (M*gx - sum(gx) - xhat*sum(gx*xhat)) (sums over N,H,W). 849 """ 850 x, gamma, beta = _ensure(x), _ensure(gamma), _ensure(beta) 851 N, C, H, W = x.data.shape 852 M = N * H * W 853 xd = x.data 854 if training: 855 mu = xd.mean(axis=(0, 2, 3), keepdims=True) 856 xc = xd - mu 857 var = (xc * xc).mean(axis=(0, 2, 3), keepdims=True) 858 inv = 1.0 / np.sqrt(var + eps) 859 xhat = xc * inv 860 if running_mean is not None and running_var is not None: 861 ubvar = var * (M / _bi_max(1, M - 1)) 862 running_mean[:] = (1 - momentum) * running_mean + momentum * mu.reshape(-1) 863 running_var[:] = …[truncated 1683 chars]
/app/submission/autograd.py
out._backward = _bw
return out
# ============================================================ LSQ fake-quant (DOMAIN; the crux)
def fake_quant(v, scale, n_levels_neg: int, n_levels_pos: int, out._backward = _bw
return out
def batchnorm1d(x, gamma, beta, eps: float = 1e-5,
running_mean=None, running_var=None, momentum: float = 0.1,
training: bool = True) -> Tensor:
"""BatchNorm over the batch axis N per feature C. x:(N,C); gamma,beta:(C,)."""
x, gamma, beta = _ensure(x), _ensure(gamma), _ensure(beta)
N, C = x.data.shape
M = N
xd = x.data
if training:
mu = xd.mean(axis=0, keepdims=True)
xc = xd - mu
var = (xc * xc).mean(axis=0, keepdims=True)
inv = 1.0 / np.sqrt(var + eps)
xhat = xc * inv
if running_mean is not None and running_var is not None:
ubvar = var * (M / _bi_max(1, M - 1))
running_mean[:] = (1 - momentum) * running_mean + momentum * mu.reshape(-1)
running_var[:] = (1 - momentum) * running_var + momentum * ubvar.reshape(-1)
else:
mu = running_mean.reshape(1, C)
var = running_var.reshape(1, C)
inv = 1.0 / np.sqrt(var + eps)
xhat = (xd - mu) * inv
g_ = gamma.data.reshape(1, C)
out = _mk(g_ * xhat + beta.data.reshape(1, C), (x, gamma, beta),
x.requires_grad or gamma.requires_grad or beta.requires_grad)
def _bw():
g = out.grad
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=0))
if beta.requires_grad:
beta._accum(g.sum(axis=0))
if x.requires_grad:
gx = g * g_
if tra
…[truncated 433 chars]The file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: ag.batchnorm1d(x, gamma, beta, eps, running_mean, running_var, momentum, training)
raise NotImplementedError("BatchNorm1d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.batchnorm1d(x, self.gamma, self.beta, self.eps,
self.running_mean, self.running_var, self.momentum, self.training)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: wq = self.wq.quant(self.weight); return ag.conv2d(x, wq, bias=None, stride, pad=1)
raise NotImplementedError("QConv.forward") def forward(self, x: Tensor) -> Tensor:
wq = self.wq.quant(self.weight)
return ag.conv2d(x, wq, bias=None, stride=self.stride, pad=1)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: h = aq(relu(bn(conv(x)))) -- in that order.
raise NotImplementedError("ConvBlock.forward") def forward(self, x: Tensor) -> Tensor:
return self.aq(ag.relu(self.bn(self.conv(x))))The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, X) -> Tensor:
# TODO: run the stem + blocks, global-average-pool, then the (2-bit) linear head.
raise NotImplementedError("QuantCNN.forward") def forward(self, X) -> Tensor:
x = X if isinstance(X, Tensor) else Tensor(X)
h = self.stem(x)
for b in self.blocks:
h = b(h)
H = h.data.shape[2]
h = ag.avgpool2d(h, H)
N = h.data.shape[0]
h = ag.reshape(h, (N, self.feat))
wq = self.head_wq.quant(self.head_w)
return ag.add(ag.matmul(h, wq), self.head_b)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: wq = self.wq.quant(self.weight); return ag.add(ag.matmul(x, wq), self.bias)
raise NotImplementedError("QLinear.forward") def forward(self, x: Tensor) -> Tensor:
wq = self.wq.quant(self.weight)
return ag.add(ag.matmul(x, wq), self.bias)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, X) -> Tensor:
# TODO: x -> reshape (N, in_dim); for each layer L: h = L["aq"](relu(L["bn"](L["fc"](h))));
# then return self.head(h).
raise NotImplementedError("QuantMLP.forward") def forward(self, X) -> Tensor:
x = X if isinstance(X, Tensor) else Tensor(X)
N = x.data.shape[0]
h = ag.reshape(x, (N, self.in_dim))
for L in self.layers:
h = L["aq"](ag.relu(L["bn"](L["fc"](h))))
return self.head(h)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.silu(x)
raise NotImplementedError("SiLU.forward") def forward(self, x: Tensor) -> Tensor:
return ag.silu(x)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.elu(x, self.alpha)
raise NotImplementedError("ELU.forward") def forward(self, x: Tensor) -> Tensor:
return ag.elu(x, self.alpha)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.groupnorm(x, self.gamma, self.beta, self.num_groups, self.eps)
raise NotImplementedError("GroupNorm.forward") def forward(self, x: Tensor) -> Tensor:
return ag.groupnorm(x, self.gamma, self.beta, self.num_groups, self.eps)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor, h: Tensor) -> Tensor:
# TODO: return ag.tanh(x@Wx + h@Wh + b)
raise NotImplementedError("RNNCell.forward") def forward(self, x: Tensor, h: Tensor) -> Tensor:
return ag.tanh(ag.add(ag.add(ag.matmul(x, self.Wx), ag.matmul(h, self.Wh)), self.b))The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor, h: Tensor) -> Tensor:
# TODO: implement the GRU update with the named weights above.
raise NotImplementedError("GRUCell.forward") def forward(self, x: Tensor, h: Tensor) -> Tensor:
z = ag.sigmoid(ag.add(ag.add(ag.matmul(x, self.Wxz), ag.matmul(h, self.Whz)), self.bz))
r = ag.sigmoid(ag.add(ag.add(ag.matmul(x, self.Wxr), ag.matmul(h, self.Whr)), self.br))
n = ag.tanh(ag.add(ag.add(ag.matmul(x, self.Wxn), ag.matmul(ag.mul(r, h), self.Whn)), self.bn))
one = Tensor(np.ones((), dtype=np.float64))
return ag.add(ag.mul(ag.sub(one, z), n), ag.mul(z, h))The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor, h: Tensor, c: Tensor):
# TODO: implement the LSTM update; return (h2, c2).
raise NotImplementedError("LSTMCell.forward") def forward(self, x: Tensor, h: Tensor, c: Tensor):
i = ag.sigmoid(ag.add(ag.add(ag.matmul(x, self.Wxi), ag.matmul(h, self.Whi)), self.bi))
f = ag.sigmoid(ag.add(ag.add(ag.matmul(x, self.Wxf), ag.matmul(h, self.Whf)), self.bf))
g = ag.tanh(ag.add(ag.add(ag.matmul(x, self.Wxg), ag.matmul(h, self.Whg)), self.bg))
o = ag.sigmoid(ag.add(ag.add(ag.matmul(x, self.Wxo), ag.matmul(h, self.Who)), self.bo))
c2 = ag.add(ag.mul(f, c), ag.mul(i, g))
h2 = ag.mul(o, ag.tanh(c2))
return h2, c2The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def quant(self, w: Tensor) -> Tensor:
# TODO: return ag.fake_quant_per_channel(w, self.scale, self.neg, self.pos, axis=0)
raise NotImplementedError("PerChannelWeightQuant.quant") def quant(self, w: Tensor) -> Tensor:
return ag.fake_quant_per_channel(w, self.scale, self.neg, self.pos, axis=0)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.fake_quant_affine(x, self.scale, self.zero_point, self.neg, self.pos)
raise NotImplementedError("AffineActQuant.forward") def forward(self, x: Tensor) -> Tensor:
return ag.fake_quant_affine(x, self.scale, self.zero_point, self.neg, self.pos)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.rms_norm(x, self.gamma, self.eps)
raise NotImplementedError("RMSNorm.forward") def forward(self, x: Tensor) -> Tensor:
return ag.rms_norm(x, self.gamma, self.eps)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.instance_norm(x, self.gamma, self.beta, self.eps)
raise NotImplementedError("InstanceNorm2d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.instance_norm(x, self.gamma, self.beta, self.eps)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, idx) -> Tensor:
# TODO: return ag.embedding(self.weight, idx)
raise NotImplementedError("Embedding.forward") def forward(self, idx) -> Tensor:
return ag.embedding(self.weight, idx)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.conv_transpose2d(x, self.weight, bias=self.bias, stride=self.stride, pad=self.padding)
raise NotImplementedError("ConvTranspose2d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.conv_transpose2d(x, self.weight, bias=self.bias, stride=self.stride, pad=self.padding)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.conv2d_gen(x, self.weight, bias=self.bias, stride=self.stride,
# pad=self.padding, dilation=self.dilation, groups=1)
raise NotImplementedError("DilatedConv2d.forward") def forward(self, x: Tensor) -> Tensor:
return ag.conv2d_gen(x, self.weight, bias=self.bias, stride=self.stride,
pad=self.padding, dilation=self.dilation, groups=1)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: return ag.fake_quant_lsq_plus(x, self.scale, self.beta, self.neg, self.pos)
raise NotImplementedError("LSQPlusActQuant.forward") def forward(self, x: Tensor) -> Tensor:
return ag.fake_quant_lsq_plus(x, self.scale, self.beta, self.neg, self.pos)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: depthwise conv2d_gen(groups=Cin) on the LSQ-quantized dw_weight, then pointwise
# conv2d_gen(groups=1) on the LSQ-quantized pw_weight.
raise NotImplementedError("QDWSepConv.forward") def forward(self, x: Tensor) -> Tensor:
dwq = self.dw_wq.quant(self.dw_weight)
h = ag.conv2d_gen(x, dwq, bias=None, stride=self.stride, pad=1, dilation=1, groups=self.Cin)
pwq = self.pw_wq.quant(self.pw_weight)
return ag.conv2d_gen(h, pwq, bias=None, stride=1, pad=0, dilation=1, groups=1)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: conv -> bn -> relu -> aq
raise NotImplementedError("QSepBlock.forward") def forward(self, x: Tensor) -> Tensor:
return self.aq(ag.relu(self.bn(self.conv(x))))The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/nn.py
def forward(self, X) -> Tensor:
# TODO: stem -> blocks -> avgpool2d(full window) -> reshape (N,C) -> matmul(LSQ head) + bias
raise NotImplementedError("QuantSepCNN.forward") def forward(self, X) -> Tensor:
x = X if isinstance(X, Tensor) else Tensor(X)
h = self.stem(x)
for b in self.blocks:
h = b(h)
H = h.data.shape[2]
h = ag.avgpool2d(h, H)
N = h.data.shape[0]
h = ag.reshape(h, (N, self.feat))
wq = self.head_wq.quant(self.head_w)
return ag.add(ag.matmul(h, wq), self.head_b)The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: SGD(+momentum, +per-group weight decay) update. Iterate self._groups; for each
# group use wd = self.weight_decay if override is None else override; keep a momentum
# buffer per parameter (self._v is indexed in self.params order).
raise NotImplementedError("SGD.step") def step(self):
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._v[i] = self.momentum * self._v[i] + g
p.data -= self.lr * self._v[i]The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: AdamW with bias correction + DECOUPLED, per-group weight decay (see docstring).
raise NotImplementedError("AdamW.step") def step(self):
self.t += 1
t = self.t
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad
self._m[i] = self.b1 * self._m[i] + (1 - self.b1) * g
self._v[i] = self.b2 * self._v[i] + (1 - self.b2) * (g * g)
mhat = self._m[i] / (1 - self.b1 ** t)
vhat = self._v[i] / (1 - self.b2 ** t)
p.data -= self.lr * (mhat / (np.sqrt(vhat) + self.eps) + wd * p.data)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: Adam with bias correction + COUPLED, per-group weight decay (see docstring).
raise NotImplementedError("Adam.step") def step(self):
self.t += 1
t = self.t
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._m[i] = self.b1 * self._m[i] + (1 - self.b1) * g
self._v[i] = self.b2 * self._v[i] + (1 - self.b2) * (g * g)
mhat = self._m[i] / (1 - self.b1 ** t)
vhat = self._v[i] / (1 - self.b2 ** t)
p.data -= self.lr * mhat / (np.sqrt(vhat) + self.eps)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: RMSprop update with per-group weight decay (see docstring).
raise NotImplementedError("RMSprop.step") def step(self):
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._s[i] = self.alpha * self._s[i] + (1 - self.alpha) * (g * g)
p.data -= self.lr * g / (np.sqrt(self._s[i]) + self.eps)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: Adagrad update with per-group weight decay (see docstring).
raise NotImplementedError("Adagrad.step") def step(self):
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._s[i] = self._s[i] + g * g
p.data -= self.lr * g / (np.sqrt(self._s[i]) + self.eps)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: Lion update with per-group (decoupled) weight decay (see docstring).
raise NotImplementedError("Lion.step") def step(self):
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad
upd = np.sign(self.b1 * self._m[i] + (1 - self.b1) * g)
p.data -= self.lr * (upd + wd * p.data)
self._m[i] = self.b2 * self._m[i] + (1 - self.b2) * gThe file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
``base_lr`` to ``min_lr`` over the remaining (total - warmup) steps. Return the LR at ``step``."""
# TODO
raise NotImplementedError("cosine_lr") ``base_lr`` to ``min_lr`` over the remaining (total - warmup) steps. Return the LR at ``step``."""
if warmup > 0 and step < warmup:
return base_lr * (step + 1) / warmup
prog = min(1.0, max(0.0, (step - warmup) / max(1, total - warmup)))
return min_lr + 0.5 * (base_lr - min_lr) * (1 + math.cos(math.pi * prog))The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
constant ``base_lr``."""
# TODO
raise NotImplementedError("warmup_lr") constant ``base_lr``."""
if step < warmup:
return base_lr * (step + 1) / warmup
return base_lrThe file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
"""Step decay: base_lr * gamma ** (step // step_size)."""
# TODO
raise NotImplementedError("step_lr") """Step decay: base_lr * gamma ** (step // step_size)."""
return base_lr * (gamma ** (step // step_size))The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
"""Exponential decay: base_lr * gamma ** step."""
# TODO
raise NotImplementedError("exponential_lr") """Exponential decay: base_lr * gamma ** step."""
return base_lr * (gamma ** step)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
# TODO: compute the global L2 norm over all param grads; scale in place if it exceeds max_norm.
raise NotImplementedError("clip_grad_norm") total = 0.0
for p in params:
if p.grad is not None:
total += float((p.grad ** 2).sum())
total = math.sqrt(total)
if total > max_norm:
scale = max_norm / (total + 1e-6)
for p in params:
if p.grad is not None:
p.grad = p.grad * scale
return totalThe file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: implement the Adamax update honouring per-group weight decay.
raise NotImplementedError("Adamax.step") def step(self):
self.t += 1
t = self.t
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._m[i] = self.b1 * self._m[i] + (1 - self.b1) * g
self._u[i] = np.maximum(self.b2 * self._u[i], np.abs(g))
p.data -= (self.lr / (1 - self.b1 ** t)) * self._m[i] / (self._u[i] + self.eps)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: implement the NAdam update honouring per-group weight decay.
raise NotImplementedError("NAdam.step") def step(self):
self.t += 1
t = self.t
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._m[i] = self.b1 * self._m[i] + (1 - self.b1) * g
self._v[i] = self.b2 * self._v[i] + (1 - self.b2) * (g * g)
mhat = (self.b1 * self._m[i] / (1 - self.b1 ** (t + 1))
+ (1 - self.b1) * g / (1 - self.b1 ** t))
vhat = self._v[i] / (1 - self.b2 ** t)
p.data -= self.lr * mhat / (np.sqrt(vhat) + self.eps)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: implement the Adadelta update honouring per-group weight decay.
raise NotImplementedError("Adadelta.step") def step(self):
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._s[i] = self.rho * self._s[i] + (1 - self.rho) * (g * g)
delta = np.sqrt(self._d[i] + self.eps) / np.sqrt(self._s[i] + self.eps) * g
p.data -= self.lr * delta
self._d[i] = self.rho * self._d[i] + (1 - self.rho) * (delta * delta)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
def step(self):
# TODO: implement the Nesterov-SGD update honouring per-group weight decay.
raise NotImplementedError("NesterovSGD.step") def step(self):
idx = 0
for plist, wd_o in self._groups:
wd = self.weight_decay if wd_o is None else wd_o
for p in plist:
i = idx
idx += 1
if p.grad is None:
continue
g = p.grad + wd * p.data
self._v[i] = self.momentum * self._v[i] + g
p.data -= self.lr * (g + self.momentum * self._v[i])The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
"""Polynomial decay: min_lr + (base_lr - min_lr) * (1 - step/total)^power (clamped at total)."""
# TODO
raise NotImplementedError("polynomial_lr") """Polynomial decay: min_lr + (base_lr - min_lr) * (1 - step/total)^power (clamped at total)."""
prog = min(1.0, max(0.0, step / total))
return min_lr + (base_lr - min_lr) * ((1 - prog) ** power)The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
"""Linear decay from base_lr to min_lr over ``total`` steps, then constant at min_lr."""
# TODO
raise NotImplementedError("linear_lr") """Linear decay from base_lr to min_lr over ``total`` steps, then constant at min_lr."""
prog = min(1.0, max(0.0, step / total))
return base_lr + (min_lr - base_lr) * progThe file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
"""base_lr * gamma^(number of milestones <= step)."""
# TODO
raise NotImplementedError("multistep_lr") """base_lr * gamma^(number of milestones <= step)."""
return base_lr * (gamma ** sum(1 for m in milestones if step >= m))The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
/app/submission/optim.py
"""Cosine annealing with warm restarts of fixed ``period`` (cosine within each period)."""
# TODO
raise NotImplementedError("cosine_restarts_lr") """Cosine annealing with warm restarts of fixed ``period`` (cosine within each period)."""
t = step % period
return min_lr + 0.5 * (base_lr - min_lr) * (1 + math.cos(math.pi * (t / period)))The file /app/submission/optim.py has been updated successfully. (file state is current in your context , no need to Read it back)
Run all public checks quiet
python3 run_checks.py --quiet 2>&1 | tail -20
------------------------------------------------------------------------ autograd_grads 115/115 | quant_grads 21/21 | nn_forward 53/53 | optim 25/25 | integration 6/6 | data 2/2 TOTAL 222/222 public checks passing All public checks pass. Now train qat_model.npz to clear the held-out top-1 threshold (the grader re-checks components with DIFFERENT seeds).
/app/submission/train.py
def train(data_path, out_path, epochs=30, seed=0, n_classes=10):
# TODO: load + normalize the data; build QuantCNN(n_classes, WIDTHS, seed); initialize the LSQ
# step sizes; build the optimizer with weight decay only on the conv/head weights; run the QAT
# loop (forward -> cross_entropy -> backward -> clip_grad_norm -> step) with an LR schedule;
# keep your best epoch; BAKE the quantized weights; save the state_dict to out_path.
raise NotImplementedError("implement the QAT training loop")def init_lsq_scales(model):
"""LSQ step-size init: weight scales from the weight magnitudes (a default 1.0 kills the net),
activation scales to a small positive constant (learnable, adapts during QAT)."""
nps = model.named_params()
for nm, p in nps.items():
if nm.endswith("wq.scale"):
wkey = nm[:-len("wq.scale")] + "weight"
val = 2.0 * float(np.mean(np.abs(nps[wkey].data)))
p.data[...] = max(val, 1e-2)
elif nm.endswith("aq.scale"):
p.data[...] = 0.5
def evaluate(model, Xn, y, batch=256):
model.set_training(False)
correct = 0
for s in range(0, len(Xn), batch):
xb = Xn[s:s + batch]
logits = model(xb).data
pred = logits.argmax(axis=1)
correct += int((pred == y[s:s + batch]).sum())
model.set_training(True)
return correct / len(Xn)
def bake_weights(model):
"""Replace each conv/head weight with its LSQ-quantized values so the saved tensor lands on the
2-bit grid (<=4 distinct floats) and passes the bit audit."""
nps = model.named_params()
W_NEG, W_POS = 2, 1
for nm, p in nps.items():
if nm.endswith("wq.scale"):
wkey = nm[:-len("wq.scale")] + "weight"
w = nps[wkey]
s = float(p.data.reshape(()))
s = s if abs(s) > 1e-12 else 1e-12
q = np.round(np.clip(w.data / s, -W_NEG, W_POS))
w.data[...] = q * s
def train(data_path, out_path, epochs=50, seed=0, n_c
…[truncated 2036 chars]The file /app/submission/train.py has been updated successfully. (file state is current in your context , no need to Read it back)
Smoke test training 3 epochs
cd /app/submission && time python3 -c "
import train
train.train('/app/data/train.npz','/tmp/test.npz',epochs=3,seed=0)
" 2>&1 | tail -15No file changes, the agent left the workspace untouched.
=== SyncVals verifier (local re-grade of the agent's own checkpoint) === COMPONENT CONFORMANCE SUITE: 278/278 cases passed (all milestones pass: True) FINAL METRIC: held-out INT2 top-1 = 0.846 >= threshold 0.7 REWARD = 1 (1 iff every component milestone passes AND the sealed held-out metric clears its threshold) NOTE: the in-sandbox training in the 481MB e2b box was OOM-killed (0-byte checkpoint), so the raw in-sandbox reward was an infrastructure artifact. This reward is from a faithful LOCAL re-train of the agent's OWN train.py (24GB, no OOM) with its own default hyperparameters, then re-graded by the real verifier.
Reproduce this trial: git checkout 2f94510 && PYTHONPATH=src python3 scripts/build_site.py , then open trial/trial_6d4d55620daa45fe. Re-running the agent live requires EVAL_PLATFORM_ENABLE_OAUTH_SMOKE=1 and is non-deterministic.
Trial trial_6d4d55620daa45fe · verifier authoritative; classifier explanatory.