tests/test.sh exit code (0 → resolved); the classification below is post-hoc and cannot change it.List app structure
ls -la && echo "---SUBMISSION---" && ls -la submission/ && echo "---DATA---" && ls -la data/
total 89 drwxr-xr-x 4 user user 4096 Jun 30 23:00 . drwxr-xr-x 21 root root 4096 Jun 30 23:00 .. -rw-r--r-- 1 user user 14914 Jun 30 23:00 PROMPT.txt -rw-r--r-- 1 user user 5 Jun 30 23:00 agent.pid -rw-r--r-- 1 user user 0 Jun 30 23:00 agent.stderr -rw-r--r-- 1 user user 4498 Jun 30 23:00 agent_trajectory.jsonl drwxr-xr-x 2 user user 60 Jun 30 23:00 data -rw-r--r-- 1 user user 0 Jun 30 23:00 run.log -rwxr-xr-x 1 user user 45855 Jun 30 11:01 run_checks.py drwxr-xr-x 3 user user 128 Jun 30 23:00 submission -rwxr-xr-x 1 user user 1318 Jun 30 11:01 test.sh -rwxr-xr-x 1 user user 629 Jun 30 11:01 timer.sh ---SUBMISSION--- total 100 drwxr-xr-x 3 user user 128 Jun 30 23:00 . drwxr-xr-x 4 user user 4096 Jun 30 23:00 .. drwxr-xr-x 2 user user 4096 Jun 30 23:00 __pycache__ -rw-r--r-- 1 user user 48121 Jun 30 11:01 autograd.py -rw-r--r-- 1 user user 1692 Jun 30 11:01 data.py -rw-r--r-- 1 user user 23705 Jun 30 11:01 nn.py -rw-r--r-- 1 user user 12275 Jun 30 11:01 optim.py -rw-r--r-- 1 user user 2900 Jun 30 11:01 train.py ---DATA--- total 11108 drwxr-xr-x 2 user user 60 Jun 30 23:00 . drwxr-xr-x 4 user user 4096 Jun 30 23:00 .. -rw-r--r-- 1 user user 3953364 Jun 30 11:01 reweight.npz -rw-r--r-- 1 user user 7411924 Jun 30 11:01 train.npz
/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 differentiates each 5 op below with central finite differences and compares against YOUR analytic backward, so every 6 backward must be correct (a single wrong reduction / Jacobian / group-weighting fails the checks). 7 8 A ``Tensor`` wraps one ``numpy.ndarray`` (stored as ``float64`` in ``self.data``) and records 9 the op that produced it so ``.backward()`` can accumulate ``.grad`` into every leaf. 10 11 CONTRACT (the grader builds its own reference against this exact API): 12 * ``Tensor(data, requires_grad=False)`` -- ``self.data`` is ``float64``; ``self.grad`` is None 13 until backward, then a same-shape ``float64`` array. requires_grad leaves accumulate grad. 14 * Every op returns a NEW Tensor whose ``requires_grad`` is the OR of its differentiable inputs, 15 and whose ``_backward`` closure does ``input._accum(local_grad)`` (so multiple paths add up). 16 * ``t.backward(grad=None)`` -- seeds ``grad`` (all-ones for a scalar) and walks the graph in 17 reverse topological order, calling each node's ``_backward``. Repeated backward accumulates. 18 * BROADCASTING: binary ops broadcast like numpy; the backward MUST reduce (sum) the upstream 19 gradient back to each input's ORIGINAL shape (use the provided ``_unbroadcast`` helper). 20 * …[truncated 52049 chars]
/app/submission/nn.py
1 """Neural-network layers + models + the robustness machinery, built on YOUR autograd engine. 2 3 Implement every ``# TODO`` forward (and the robustness-helper bodies). The parameters + 4 ``named_params`` naming + the checkpoint round-trip are already wired; you compose the autograd 5 ops. The grader checks each layer's forward against its OWN reference AND finite-difference-checks 6 the gradients that flow through your autograd, so the composition must be exactly right. 7 8 THE FINAL-METRIC MODEL is the pinned ``SmallCNN`` (a conv FEATURE EXTRACTOR + a single linear 9 CLASSIFIER). The split is what makes last-layer retraining (DFR) on a group-balanced set 10 expressible against the pinned graph: freeze the extractor and re-fit ONLY ``classifier``. 11 ``featurize(X, training)`` returns the post-ReLU embedding so you can freeze the extractor. 12 13 The other layers/models (Linear / Conv2d / BatchNorm2d / BatchNorm1d / LayerNorm / Dropout / 14 AvgPool2d / MLP / ResidualMLP / a TinyConvNet) are exercised by the conformance suite across a 15 WIDE surface -- each is an independent potential bug. The robustness machinery (``GroupDROState`` 16 exponentiated-gradient adversary-weight update, ``balanced_group_weights``, 17 ``class_balanced_weights``, ``log_class_prior``) is the domain-specific heart this task adds; the 18 ``robust`` milestone checks them. 19 20 SmallCNN naming contract (do not change -- the verifier indexes by these exact keys): 21 conv1.weight (Wd,3,3,3) | con …[truncated 24273 chars]
/app/submission/optim.py
1 """Optimizers + LR schedulers + grad clipping over a flat list of autograd ``Tensor`` parameters. 2 3 Implement the ``# TODO`` update math. All optimizers operate IN PLACE on ``param.data`` using 4 ``param.grad``. ``zero_grad()`` resets every grad to None. ``t`` is the 1-based step count. The 5 grader runs one (and several) steps of each and compares your updated params against its 6 reference within a tight tolerance, so the math must be EXACTLY right -- every optimizer / 7 scheduler / clipper is an independent potential bug. 8 9 The training recipe uses AdamW (decoupled weight decay) + ``clip_grad_norm`` for the ERM 10 extractor and the last-layer (DFR) retrain; the rest of the zoo is graded for parity. 11 12 SGD : g = grad + wd*p; v = mu*v + g; upd = (g + mu*v) if nesterov else v; p -= lr*upd 13 Adagrad : g = grad + wd*p; s += g^2; p -= lr*g/(sqrt(s)+eps) 14 RMSprop : g = grad + wd*p; s = alpha*s + (1-alpha)*g^2; p -= lr*g/(sqrt(s)+eps) 15 Adam : g = grad + wd*p (COUPLED L2); m,v EMA; mhat=m/(1-b1^t); vhat=v/(1-b2^t); 16 p -= lr*mhat/(sqrt(vhat)+eps) 17 AdamW : DECOUPLED wd; m,v EMA; p -= lr*( mhat/(sqrt(vhat)+eps) + wd*p ) 18 Adamax : m=b1*m+(1-b1)*g; u=max(b2*u, |g|); p -= (lr/(1-b1^t))*m/(u+eps) (infinity-norm) 19 NAdam : m,v EMA; mhat=m/(1-b1^t); vhat=v/(1-b2^t); 20 mnes = b1*mhat + (1-b1)*g/(1-b1^t); p -= lr*mnes/(sqrt(vhat)+eps) 21 Lion : upd = sign(b1*m + (1-b1)*g); p -= lr*(upd + wd*p); m = b2*m + (1-b2 …[truncated 11759 chars]
/app/submission/data.py
1 """Data loading + group helpers for the worst-group / spurious-correlation task.
2
3 Implement the ``# TODO`` bodies (numpy only). The splits ship as ``.npz`` files with arrays
4 ``X`` (N,3,S,S) float, ``y`` (the SHAPE class to predict) and ``g`` (the spurious background-color
5 id). A "group" is the pair ``(y, g)``; ``group_ids(y, g, n_classes) = y*n_classes + g`` flattens it
6 to a single id in ``[0, n_classes**2)``.
7 """
8 from __future__ import annotations
9
10 from typing import Dict, Tuple
11
12 import numpy as np
13
14
15 def load_npz(path: str) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
16 """Load (X, y, g) from a .npz; return float64 X, int64 y, int64 g. (Provided.)"""
17 d = np.load(path)
18 return (np.asarray(d["X"], dtype=np.float64),
19 np.asarray(d["y"], dtype=np.int64),
20 np.asarray(d["g"], dtype=np.int64))
21
22
23 def group_ids(y: np.ndarray, g: np.ndarray, n_classes: int) -> np.ndarray:
24 """Flatten (y, g) to a single group id y*n_classes + g (int64)."""
25 # TODO
26 raise NotImplementedError("group_ids")
27
28
29 def iterate(X, y, g, batch_size, rng):
30 """Yield (Xb, yb, gb) minibatches over a random permutation of the dataset."""
31 # TODO
32 raise NotImplementedError("iterate")
33
34
35 def worst_group_acc(preds, y, g, n_classes) -> Tuple[float, float, Dict[int, float]]:
36 """Return (min over (y,g) groups of within-group accuracy, average accuracy, per-group dict)."""
37
…[truncated 318 chars]/app/submission/train.py
1 """Training entry point. Implement your worst-group-robust recipe, train the pinned SmallCNN,
2 and save the checkpoint the grader will load.
3
4 Run it however you like (e.g. ``python3 /app/submission/train.py``). It MUST end by writing
5 ``/app/submission/model.npz`` via ``save_checkpoint`` below. The grader loads that file into its
6 OWN reference SmallCNN (architecture pinned to WIDTH/EMBED_DIM below -- keep these) and evaluates
7 WORST-GROUP accuracy on a SEALED, group-balanced test set; you pass the metric part iff
8 worst-group accuracy >= the frozen threshold. (You ALSO must pass the component conformance suite
9 over autograd.py / nn.py / optim.py.)
10
11 A naive cross-entropy ("ERM") run on the correlated train split will reach high AVERAGE accuracy
12 but ~0 worst-group accuracy -- it keys on the spurious background color. Removing that reliance is
13 the task. One well-known cheap recipe: train the feature extractor on the correlated data, then
14 RE-FIT ONLY the final ``classifier`` on the GROUP-BALANCED reweight split with a group-balanced
15 (group-weighted) loss so the head stops keying off color. You are free to use any method, as long
16 as you submit a state_dict for the pinned architecture.
17 """
18 from __future__ import annotations
19
20 import argparse
21 import json
22 import os
23 import sys
24
25 import numpy as np
26
27 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
28 sys.path.insert(0, "/app")
29 sys.path.insert(0, "/app/su
…[truncated 1589 chars]/app/run_checks.py
1 #!/usr/bin/env python3 2 """PUBLIC component check runner for the from-scratch numpy framework (worst-group / spurious- 3 correlation task). 4 5 Run this AS OFTEN AS YOU LIKE while you implement to get a per-check progress signal: 6 7 python3 /app/run_checks.py # check the framework in /app/submission 8 python3 /app/run_checks.py --submission /dir 9 python3 /app/run_checks.py --only robust # focus a single milestone 10 11 It imports YOUR modules from /app/submission (autograd.py / nn.py / optim.py / data.py), exactly 12 as the grader does, and runs a PUBLIC portion of the component conformance suite, printing a clear 13 per-check report. Each FAIL line names the exact op / layer / optimizer / robustness-loss that is 14 wrong. 15 16 HOW THIS RELATES TO YOUR GRADE 17 ------------------------------ 18 This runner is a DEBUGGING AID, not the grader. It checks your framework against self-consistent 19 references it computes on its own: 20 * autograd_grads : central FINITE-DIFFERENCE of YOUR forward vs YOUR analytic backward. 21 * nn_forward : mathematical PROPERTIES your forward must satisfy. 22 * optim : YOUR optimizer step vs the closed-form update re-derived here in numpy, for 23 every optimizer + the LR schedulers + both grad clippers. 24 * robust : finite-diff of YOUR robustness-loss backward + the per-group-normalization / 25 Group-DRO / weight-helper PROPERTI …[truncated 47999 chars]
Inspect data shapes and groups
cat test.sh && echo "---" && OMP_NUM_THREADS=1 python3 -c "
import numpy as np
d=np.load('data/train.npz'); print('train', {k:d[k].shape for k in d.files}, 'y range', d['y'].min(), d['y'].max(), 'g range', d['g'].min(), d['g'].max())
import collections
print('train group counts', collections.Counter(zip(d['y'].tolist(),d['g'].tolist())))
r=np.load('data/reweight.npz'); print('reweight', {k:r[k].shape for k in r.files})
print('reweight group counts', collections.Counter(zip(r['y'].tolist(),r['g'].tolist())))
"#!/usr/bin/env bash
# Smoke test (NOT the grader): confirms the environment is wired -- numpy imports, the train +
# reweight splits load, and the submission stubs are present. It does NOT check correctness (the
# stubs raise NotImplementedError until you implement them).
set -uo pipefail
python3 - <<'PY'
import numpy as np, os
for f in ("train.npz", "reweight.npz"):
assert os.path.exists(f"/app/data/{f}"), f"missing /app/data/{f}"
d = np.load("/app/data/train.npz"); r = np.load("/app/data/reweight.npz")
print(f"train X {d['X'].shape} y {d['y'].shape} g {d['g'].shape}; reweight X {r['X'].shape}")
assert r["X"].shape[1:] == d["X"].shape[1:], (r["X"].shape, d["X"].shape)
for f in ("autograd.py", "nn.py", "optim.py", "data.py", "train.py"):
assert os.path.exists(f"/app/submission/{f}"), f"missing /app/submission/{f}"
assert os.path.exists("/app/run_checks.py"), "missing /app/run_checks.py"
print("submission stubs present:", sorted(os.listdir("/app/submission")))
print("numpy", np.__version__)
PY
# The visible check runner is present + runnable (it exits 1 on the unfilled stub, which is
# expected -- the stubs raise NotImplementedError until you implement them).
python3 /app/run_checks.py --quiet || true
echo "app_test smoke OK (run 'python3 /app/run_checks.py' to test your implementation)"
---
train {'X': (2400, 3, 16, 16), 'y': (2400,), 'g': (2400,)} y range 0 3 g range 0 3
train group counts Counter({(2, 2): 586, (0, 0): 585, (1, 1): 580, (3, 3): 576, (1, 3): 11, (3,
…[truncated 405 chars]/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(g, shape, axis, keepdims):
"""Expand a reduced gradient ``g`` back to ``shape`` over ``axis`` (the backward of a
sum/mean-style reduction)."""
g = np.asarray(g, dtype=np.float64)
if axis is None:
return np.broadcast_to(g, shape).copy()
axes = (axis,) if isinstance(axis, int) else tuple(axis)
axes = tuple(ax % len(shape) for ax in axes)
if not keepdims:
ks = list(shape)
for ax in axes:
ks[ax] = 1
g = g.reshape(ks)
return np.broadcast_to(g, 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
raise NotImplementedError("Tensor.backward") topo = []
visited = set()
def build(t):
if id(t) in visited:
return
visited.add(id(t))
for p in t._parents:
build(p)
topo.append(t)
build(self)
if grad is None:
grad = np.ones_like(self.data)
else:
grad = _as_f64(grad)
if self.grad is None:
self.grad = np.zeros_like(self.data)
self.grad += grad
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
raise NotImplementedError("add backward") # TODO 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))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
raise NotImplementedError("sub backward") # TODO 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))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
raise NotImplementedError("mul backward") # TODO 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))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
raise NotImplementedError("div backward") # TODO 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))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
raise NotImplementedError("power backward") # TODO if a.requires_grad:
a._accum(out.grad * pf * (a.data ** (pf - 1.0)))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
raise NotImplementedError("maximum backward") # TODO g = out.grad
ga = np.where(a.data > b.data, 1.0, np.where(a.data == b.data, 0.5, 0.0))
if a.requires_grad:
a._accum(_unbroadcast(g * ga, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(g * (1.0 - ga), b.data.shape))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
raise NotImplementedError("minimum backward") # TODO g = out.grad
ga = np.where(a.data < b.data, 1.0, np.where(a.data == b.data, 0.5, 0.0))
if a.requires_grad:
a._accum(_unbroadcast(g * ga, a.data.shape))
if b.requires_grad:
b._accum(_unbroadcast(g * (1.0 - ga), b.data.shape))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
raise NotImplementedError("where backward") # TODO 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))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
raise NotImplementedError("exp backward") # TODO if a.requires_grad:
a._accum(out.grad * e)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
raise NotImplementedError("log backward") # TODO if a.requires_grad:
a._accum(out.grad / a.data)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
raise NotImplementedError("sqrt backward") # TODO if a.requires_grad:
a._accum(out.grad * 0.5 / s)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
raise NotImplementedError("abs backward") # TODO if a.requires_grad:
a._accum(out.grad * np.sign(a.data))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
raise NotImplementedError("clip backward") # TODO if a.requires_grad:
mask = (a.data > lo) & (a.data < hi)
a._accum(out.grad * mask)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
raise NotImplementedError("sum backward") # TODO if a.requires_grad:
a._accum(_expand(out.grad, a.data.shape, axis, keepdims))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
raise NotImplementedError("mean backward") # TODO if a.requires_grad:
a._accum(_expand(out.grad, a.data.shape, axis, keepdims) / n)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
raise NotImplementedError("max backward") # TODO if a.requires_grad:
mm = a.data.max(axis=axis, keepdims=True)
mask = (a.data == mm).astype(np.float64)
counts = mask.sum(axis=axis, keepdims=True)
g = _expand(out.grad, a.data.shape, axis, keepdims)
a._accum(mask * g / counts)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
raise NotImplementedError("min backward") # TODO if a.requires_grad:
mm = a.data.min(axis=axis, keepdims=True)
mask = (a.data == mm).astype(np.float64)
counts = mask.sum(axis=axis, keepdims=True)
g = _expand(out.grad, a.data.shape, axis, keepdims)
a._accum(mask * g / counts)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
raise NotImplementedError("transpose backward") # TODO 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, tuple(inv)))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
raise NotImplementedError("reshape backward") # TODO if a.requires_grad:
a._accum(out.grad.reshape(a.data.shape))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
raise NotImplementedError("getitem backward") # TODO if a.requires_grad:
ga = np.zeros_like(a.data)
np.add.at(ga, idx, out.grad)
a._accum(ga)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
raise NotImplementedError("concat backward") # TODO g = out.grad
idx = 0
for t, sz in zip(ts, sizes):
sl = [slice(None)] * g.ndim
sl[axis] = slice(idx, idx + sz)
if t.requires_grad:
t._accum(g[tuple(sl)])
idx += szThe 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
raise NotImplementedError("stack backward") # TODO g = out.grad
for i, t in enumerate(ts):
sl = [slice(None)] * g.ndim
sl[axis] = i
if t.requires_grad:
t._accum(g[tuple(sl)])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
raise NotImplementedError("matmul backward") # TODO g = out.grad
A = a.data
B = b.data
if a.requires_grad:
da = g @ np.swapaxes(B, -1, -2)
a._accum(_unbroadcast(da, A.shape))
if b.requires_grad:
db = np.swapaxes(A, -1, -2) @ g
b._accum(_unbroadcast(db, B.shape))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
raise NotImplementedError("relu backward") # TODO if a.requires_grad:
a._accum(out.grad * (a.data > 0.0))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
raise NotImplementedError("leaky_relu backward") # TODO if a.requires_grad:
a._accum(out.grad * np.where(a.data > 0.0, 1.0, sl))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
raise NotImplementedError("sigmoid backward") # TODO if a.requires_grad:
a._accum(out.grad * s * (1.0 - s))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
raise NotImplementedError("tanh backward") # TODO if a.requires_grad:
a._accum(out.grad * (1.0 - t * t))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
raise NotImplementedError("gelu backward") # TODO if a.requires_grad:
pdf = np.exp(-0.5 * x * x) / np.sqrt(2.0 * np.pi)
a._accum(out.grad * (cdf + x * pdf))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
raise NotImplementedError("softmax backward") # TODO if a.requires_grad:
g = out.grad
a._accum(s * (g - (g * s).sum(axis=axis, keepdims=True)))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
raise NotImplementedError("log_softmax backward") # TODO if a.requires_grad:
g = out.grad
a._accum(g - s * g.sum(axis=axis, keepdims=True))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
raise NotImplementedError("softplus backward") # TODO if a.requires_grad:
a._accum(out.grad / (1.0 + np.exp(-bx)))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
raise NotImplementedError("silu backward") # TODO if a.requires_grad:
a._accum(out.grad * (sig + a.data * sig * (1.0 - sig)))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
raise NotImplementedError("elu backward") # TODO if a.requires_grad:
a._accum(out.grad * np.where(x > 0.0, 1.0, al * ex))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
raise NotImplementedError("mish backward") # TODO if a.requires_grad:
sig = 1.0 / (1.0 + np.exp(-x))
a._accum(out.grad * (t + x * (1.0 - t * t) * sig))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
raise NotImplementedError("hardtanh backward") # TODO if a.requires_grad:
mask = (a.data > lo) & (a.data < hi)
a._accum(out.grad * mask)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
raise NotImplementedError("var backward") # TODO if a.requires_grad:
g = _expand(out.grad, a.data.shape, axis, keepdims)
a._accum(g * 2.0 * (a.data - mu) / (n - ddof))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
raise NotImplementedError("std backward") # TODO if a.requires_grad:
g = _expand(out.grad, a.data.shape, axis, keepdims)
a._accum(g * (a.data - mu) / (n * skeep))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
raise NotImplementedError("cumsum backward") # TODO if a.requires_grad:
g = out.grad
a._accum(np.flip(np.cumsum(np.flip(g, axis=axis), axis=axis), axis=axis))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
raise NotImplementedError("mse_loss backward") # TODO if pred.requires_grad:
pred._accum(2.0 * diff / n * out.grad)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
raise NotImplementedError("cross_entropy backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
logits._accum((sm - y) / n * out.grad)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
raise NotImplementedError("group_weighted_ce backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
logits._accum((sm - y) * scale[:, None] * out.grad)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
raise NotImplementedError("reweighted_ce backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
logits._accum((sm - y) * (w[:, None] / wsum) * out.grad)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
raise NotImplementedError("group_dro_loss backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
logits._accum((sm - y) * scale[:, None] * out.grad)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
raise NotImplementedError("logit_adjusted_ce backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
logits._accum((sm - y) / n * out.grad)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
raise NotImplementedError("focal_loss backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
dfdp = g * (1.0 - p) ** (g - 1.0) * np.log(pc) - (1.0 - p) ** g / pc
coef = dfdp * p
logits._accum(coef[:, None] * (y - sm) / n * out.grad)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
raise NotImplementedError("irm_penalty backward") # TODO if logits.requires_grad:
sx = (sm * x).sum(axis=-1, keepdims=True)
term = (sm - y) + sm * (x - sx)
logits._accum(2.0 * grad_w * (1.0 / n) * term * out.grad)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
raise NotImplementedError("gce_loss backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
logits._accum(-(pc ** qf)[:, None] * (y - sm) / n * out.grad)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
raise NotImplementedError("vrex_penalty backward") # TODO if r.requires_grad:
grad = (2.0 / K) * (r.data - mu) * out.grad
r._accum(grad)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
raise NotImplementedError("ldam_loss backward") # TODO if logits.requires_grad:
y = np.zeros_like(sm)
y[np.arange(n), t] = 1.0
logits._accum(sc * (sm - y) / n * out.grad)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
raise NotImplementedError("spectral_decoupling backward") # TODO if logits.requires_grad:
logits._accum(lm * x / n * out.grad)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
raise NotImplementedError("layernorm backward") # TODO g = out.grad
gy = g * gamma.data
mean_gy = gy.mean(axis=-1, keepdims=True)
mean_gyxhat = (gy * xhat).mean(axis=-1, keepdims=True)
if a.requires_grad:
a._accum(inv * (gy - mean_gy - xhat * mean_gyxhat))
axes = tuple(range(g.ndim - 1))
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=axes))
if beta.requires_grad:
beta._accum(g.sum(axis=axes))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
raise NotImplementedError("batchnorm backward") # TODO g = out.grad
gy = g * gamma.data
mean_gy = gy.mean(axis=0, keepdims=True)
mean_gyxhat = (gy * xhat).mean(axis=0, keepdims=True)
if a.requires_grad:
a._accum(inv * (gy - mean_gy - xhat * mean_gyxhat))
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=0))
if beta.requires_grad:
beta._accum(g.sum(axis=0))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
raise NotImplementedError("batchnorm2d backward") # TODO g = out.grad
gy = g * gamma.data.reshape(1, C, 1, 1)
if x.requires_grad:
if training:
sum_gy = gy.sum(axis=(0, 2, 3), keepdims=True)
sum_gyxhat = (gy * xhat).sum(axis=(0, 2, 3), keepdims=True)
dx = inv * (gy - sum_gy / m - xhat * sum_gyxhat / m)
else:
dx = gy * inv
x._accum(dx)
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)))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
raise NotImplementedError("rms_norm backward") # TODO g = out.grad
gy = g * gamma.data
ssum = (gy * x).sum(axis=-1, keepdims=True)
if a.requires_grad:
a._accum(r * gy - (r ** 3 / D) * x * ssum)
axes = tuple(range(g.ndim - 1))
if gamma.requires_grad:
gamma._accum((g * xhat).sum(axis=axes))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
raise NotImplementedError("groupnorm2d backward") # TODO g = out.grad
gg = g * g_
gy = gg.reshape(N, G, cg * H * W)
xhat_g = xhat.reshape(N, G, cg * H * W)
mean_gy = gy.mean(axis=2, keepdims=True)
mean_gyxhat = (gy * xhat_g).mean(axis=2, keepdims=True)
if x.requires_grad:
dx_g = inv * (gy - mean_gy - xhat_g * mean_gyxhat)
x._accum(dx_g.reshape(N, C, H, W))
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)))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
return cols.reshape(N, C * kh * kw, OH * OW), OH, OW
return cols.reshape(N, C * kh * kw, OH * OW), OH, OW
def _col2im(cols, x_shape, kh, kw, pad, stride, OH, OW):
"""Inverse of ``_im2col``: scatter-add the column gradients back to the (strided, padded)
input positions, then unpad."""
N, C, H, W = x_shape
Hp = H + 2 * pad
Wp = W + 2 * pad
xp = np.zeros((N, C, Hp, Wp), dtype=np.float64)
cols = cols.reshape(N, C, kh, kw, OH, OW)
for i in range(kh):
for j in range(kw):
xp[:, :, i:i + stride * OH:stride, j:j + stride * OW:stride] += cols[:, :, i, j]
if pad:
return xp[:, :, pad:pad + H, pad:pad + W]
return xpThe 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
raise NotImplementedError("conv2d backward") # TODO go = out.grad.reshape(N, Cout, OH * OW)
if bias.requires_grad:
bias._accum(out.grad.sum(axis=(0, 2, 3)))
if weight.requires_grad:
dWm = np.einsum("nop,nkp->ok", go, cols)
weight._accum(dWm.reshape(Cout, Cin, kh, kw))
if x.requires_grad:
dcols = np.einsum("ok,nop->nkp", Wm, go)
dx = _col2im(dcols, x.data.shape, kh, kw, pad, st, OH, OW)
x._accum(dx)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
raise NotImplementedError("maxpool2d backward") # TODO if x.requires_grad:
g = out.grad
m = outd[:, :, :, None, :, None]
mask = (xr == m).astype(np.float64)
counts = mask.sum(axis=(3, 5), keepdims=True)
gg = g[:, :, :, None, :, None] / counts
dx = (mask * gg).reshape(N, C, H, W)
x._accum(dx)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
raise NotImplementedError("maxpool2d_stride backward") # TODO if x.requires_grad:
g = out.grad
m = outd[:, :, None, None, :, :]
mask = (win == m).astype(np.float64)
counts = mask.sum(axis=(2, 3), keepdims=True)
contrib = mask * (g[:, :, None, None, :, :] / counts)
dxp = np.zeros((N, C, Hp, Wp), dtype=np.float64)
for i in range(k):
for j in range(k):
dxp[:, :, i:i + st * OH:st, j:j + st * OW:st] += contrib[:, :, i, j]
if pad:
dx = dxp[:, :, pad:pad + H, pad:pad + W]
else:
dx = dxp
x._accum(dx)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
raise NotImplementedError("avgpool2d backward") # TODO if x.requires_grad:
g = out.grad
dx = np.empty((N, C, H // k, k, W // k, k), dtype=np.float64)
dx[...] = g[:, :, :, None, :, None] / (k * k)
x._accum(dx.reshape(N, C, H, W))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
raise NotImplementedError("global_avg_pool backward") # TODO if x.requires_grad:
g = out.grad
dx = np.broadcast_to(g[:, :, None, None] / (H * W), (N, C, H, W)).copy()
x._accum(dx)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
raise NotImplementedError("embedding backward") # TODO if weight.requires_grad:
ga = np.zeros_like(weight.data)
np.add.at(ga, idx, out.grad)
weight._accum(ga)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_id():
raise NotImplementedError("dropout backward") # TODO def _bw_id():
if a.requires_grad:
a._accum(out.grad)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
raise NotImplementedError("dropout backward") # TODO if a.requires_grad:
a._accum(out.grad * keep)The file /app/submission/autograd.py has been updated successfully. (file state is current in your context , no need to Read it back)
Check remaining stubs in autograd
grep -n "NotImplementedError" submission/autograd.py; echo "---count---"; grep -c "NotImplementedError" submission/autograd.py
3:YOU MUST IMPLEMENT EVERYTHING MARKED ``# TODO`` / ``raise NotImplementedError`` using numpy ---count--- 1
/app/submission/nn.py
def forward(self, x: Tensor) -> Tensor:
# TODO: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self):
d = {"weight": self.weight} def forward(self, x: Tensor) -> Tensor:
out = ag.matmul(x, self.weight)
if self.bias is not None:
out = ag.add(out, self.bias)
return out
def named_params(self):
d = {"weight": self.weight}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: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self):
return {"weight": self.weight, "bias": self.bias} def forward(self, x: Tensor) -> Tensor:
return ag.conv2d(x, self.weight, self.bias, pad=self.pad, stride=1)
def named_params(self):
return {"weight": self.weight, "bias": 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, training: bool = True) -> Tensor:
# TODO: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self):
return {"gamma": self.gamma, "beta": self.beta}
def buffers(self): def forward(self, x: Tensor, training: bool = True) -> Tensor:
return ag.batchnorm2d(x, self.gamma, self.beta, self.running_mean, self.running_var,
training=training, momentum=self.momentum, eps=self.eps)
def named_params(self):
return {"gamma": self.gamma, "beta": self.beta}
def buffers(self):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: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self):
return {"gamma": self.gamma, "beta": self.beta}
class LayerNorm(Module): def forward(self, x: Tensor) -> Tensor:
return ag.batchnorm(x, self.gamma, self.beta, eps=self.eps)
def named_params(self):
return {"gamma": self.gamma, "beta": self.beta}
class LayerNorm(Module):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: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self):
return {"gamma": self.gamma, "beta": self.beta}
class Dropout(Module): def forward(self, x: Tensor) -> Tensor:
return ag.layernorm(x, self.gamma, self.beta, eps=self.eps)
def named_params(self):
return {"gamma": self.gamma, "beta": self.beta}
class Dropout(Module):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, training: bool = False, rng=None) -> Tensor:
# TODO: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward") def forward(self, x: Tensor, training: bool = False, rng=None) -> Tensor:
return ag.dropout(x, self.p, training, rng)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: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self):
return {}
class MaxPool2d(Module): def forward(self, x: Tensor) -> Tensor:
return ag.avgpool2d(x, self.k)
def named_params(self):
return {}
class MaxPool2d(Module):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: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self):
return {}
class RMSNorm(Module): def forward(self, x: Tensor) -> Tensor:
return ag.maxpool2d(x, self.k)
def named_params(self):
return {}
class RMSNorm(Module):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: implement (compose ag.rms_norm). See the docstring/contract.
raise NotImplementedError("forward") def forward(self, x: Tensor) -> Tensor:
return ag.rms_norm(x, self.gamma, eps=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: implement (compose ag.groupnorm2d). See the docstring/contract.
raise NotImplementedError("forward") def forward(self, x: Tensor) -> Tensor:
return ag.groupnorm2d(x, self.gamma, self.beta, self.num_groups, eps=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
# TODO: implement (stem->gn0->silu; then 2 residual blocks
# r=h; h=silu(b*n1(b*c1(h))); h=b*n2(b*c2(h)); h=silu(h + r);
# then strided downsample via ag.conv2d(h, down.weight, down.bias, pad=1, stride=2) + silu;
# then global-avg-pool over axes (2,3); then the linear head). Compose ag.* ops.
raise NotImplementedError("forward") h = ag.silu(self.gn0(self.stem(X)))
r = h
h = ag.silu(self.b1n1(self.b1c1(h)))
h = self.b1n2(self.b1c2(h))
h = ag.silu(ag.add(h, r))
r = h
h = ag.silu(self.b2n1(self.b2c1(h)))
h = self.b2n2(self.b2c2(h))
h = ag.silu(ag.add(h, r))
h = ag.silu(ag.conv2d(h, self.down.weight, self.down.bias, pad=1, stride=2))
h = ag.global_avg_pool(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 featurize(self, X, training: bool = True) -> Tensor:
# TODO: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("featurize")
def forward(self, X, training: bool = True) -> Tensor:
# TODO: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward") def featurize(self, X, training: bool = True) -> Tensor:
h = ag.relu(self.bn1(self.conv1(X), training=training))
h = ag.maxpool2d(h, 2)
h = ag.relu(self.bn2(self.conv2(h), training=training))
h = ag.maxpool2d(h, 2)
h = ag.relu(self.bn3(self.conv3(h), training=training))
h = ag.global_avg_pool(h)
h = ag.relu(self.embed(h))
return h
def forward(self, X, training: bool = True) -> Tensor:
return self.classifier(self.featurize(X, training=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:
# TODO: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self) -> Dict[str, Tensor]:
d: Dict[str, Tensor] = {}
for i, lin in enumerate(self.layers): def forward(self, x) -> Tensor:
h = x
for i, lin in enumerate(self.layers):
h = lin(h)
if i < len(self.layers) - 1:
h = ag.relu(h)
return h
def named_params(self) -> Dict[str, Tensor]:
d: Dict[str, Tensor] = {}
for i, lin in enumerate(self.layers):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: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self) -> Dict[str, Tensor]:
d: Dict[str, Tensor] = {}
for k, v in self.proj_in.named_params().items(): def forward(self, x) -> Tensor:
h = self.proj_in(x)
for blk in self.blocks:
n = blk["ln"](h)
f = blk["fc2"](ag.gelu(blk["fc1"](n)))
h = ag.add(h, f)
return self.proj_out(h)
def named_params(self) -> Dict[str, Tensor]:
d: Dict[str, Tensor] = {}
for k, v in self.proj_in.named_params().items():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, training: bool = True) -> Tensor:
# TODO: implement (compose ag.* ops). See the docstring/contract.
raise NotImplementedError("forward")
def named_params(self) -> Dict[str, Tensor]:
d: Dict[str, Tensor] = {}
for name in ("conv1", "bn1", "conv2", "bn2", "head"): def forward(self, X, training: bool = True) -> Tensor:
h = ag.relu(self.bn1(self.conv1(X), training=training))
h = ag.avgpool2d(h, 2)
h = ag.relu(self.bn2(self.conv2(h), training=training))
h = ag.maxpool2d(h, 2)
N = h.shape[0]
h = ag.reshape(h, (N, 2 * self.W * self.side * self.side))
return self.head(h)
def named_params(self) -> Dict[str, Tensor]:
d: Dict[str, Tensor] = {}
for name in ("conv1", "bn1", "conv2", "bn2", "head"):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
# TODO: implement (numpy only). See docstring.
raise NotImplementedError("balanced_group_weights") gids = np.asarray(group_ids).astype(np.int64).reshape(-1)
if n_groups is None:
n_groups = int(gids.max()) + 1
present = np.unique(gids)
K = len(present)
w = np.zeros(int(n_groups), dtype=np.float64)
w[present] = 1.0 / K
return wThe 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
# TODO: implement (numpy only). See docstring.
raise NotImplementedError("class_balanced_weights") t = np.asarray(targets).astype(np.int64).reshape(-1)
if n_classes is None:
n_classes = int(t.max()) + 1
counts = np.bincount(t, minlength=int(n_classes)).astype(np.float64)
if beta == 0.0:
cw = np.where(counts > 0, 1.0 / np.maximum(counts, 1.0), 0.0)
else:
eff = (1.0 - beta ** counts) / (1.0 - beta)
cw = np.where(counts > 0, 1.0 / np.maximum(eff, 1e-12), 0.0)
w = cw[t]
w = w / w.mean()
return wThe 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
# TODO: implement (numpy only). See docstring.
raise NotImplementedError("log_class_prior") t = np.asarray(targets).astype(np.int64).reshape(-1)
if n_classes is None:
n_classes = int(t.max()) + 1
counts = np.bincount(t, minlength=int(n_classes)).astype(np.float64)
N = t.size
prior = counts / N
lp = np.where(counts > 0, np.log(np.maximum(prior, eps)), np.log(eps))
return lpThe 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
# TODO: implement (numpy only). See docstring.
raise NotImplementedError("ldam_margins") t = np.asarray(targets).astype(np.int64).reshape(-1)
if n_classes is None:
n_classes = int(t.max()) + 1
counts = np.bincount(t, minlength=int(n_classes)).astype(np.float64)
m = np.where(counts > 0, np.maximum(counts, 1.0) ** (-0.25), 0.0)
mx = m.max()
if mx > 0:
m = m / mx * max_margin
return mThe 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
# TODO: implement (numpy only). See docstring.
raise NotImplementedError("effective_number_weights") t = np.asarray(targets).astype(np.int64).reshape(-1)
if n_classes is None:
n_classes = int(t.max()) + 1
counts = np.bincount(t, minlength=int(n_classes)).astype(np.float64)
eff = (1.0 - beta ** counts) / (1.0 - beta)
w = np.where(counts > 0, 1.0 / np.maximum(eff, 1e-12), 0.0)
present = counts > 0
w[present] = w[present] / w[present].mean()
return wThe 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 update(self, group_losses, present=None):
# TODO: implement the masked EMA update (see docstring). Return self.l.copy().
raise NotImplementedError("EMAGroupLoss.update")
def worst_group(self):
# TODO: implement (argmax of the current EMA). See docstring.
raise NotImplementedError("EMAGroupLoss.worst_group") def update(self, group_losses, present=None):
gl = np.asarray(group_losses, dtype=np.float64).reshape(-1)
if present is None:
present = np.ones(self.n_groups, dtype=bool)
else:
present = np.asarray(present, dtype=bool).reshape(-1)
for k in range(self.n_groups):
if not present[k]:
continue
if not self._init[k]:
self.l[k] = gl[k]
self._init[k] = True
else:
self.l[k] = self.beta * self.l[k] + (1.0 - self.beta) * gl[k]
return self.l.copy()
def worst_group(self):
return int(np.argmax(self.l))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 update(self, group_losses):
# TODO: exponentiated-gradient update of self.q on group_losses; renormalize.
raise NotImplementedError("GroupDROState.update") def update(self, group_losses):
gl = np.asarray(group_losses, dtype=np.float64).reshape(-1)
self.q = self.q * np.exp(self.eta_q * gl)
self.q = self.q / self.q.sum()
return self.q.copy()The file /app/submission/nn.py has been updated successfully. (file state is current in your context , no need to Read it back)
Check remaining stubs in nn.py
grep -n "NotImplementedError\|# TODO" submission/nn.py
3:Implement every ``# TODO`` forward (and the robustness-helper bodies). The parameters + 44: raise NotImplementedError
/app/submission/optim.py
# TODO: implement the SGD update (see module docstring). Update p.data in place.
raise NotImplementedError("SGD.step") for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad + self.weight_decay * p.data
v = self.momentum * self._v[i] + g
self._v[i] = v
upd = (g + self.momentum * v) if self.nesterov else v
p.data -= self.lr * updThe 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: implement the Adagrad update (see module docstring). Update p.data in place.
raise NotImplementedError("Adagrad.step") for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad + self.weight_decay * p.data
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
# TODO: implement the RMSprop update (see module docstring). Update p.data in place.
raise NotImplementedError("RMSprop.step") for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad + self.weight_decay * p.data
self._s[i] = self.alpha * self._s[i] + (1.0 - 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
# TODO: implement the Adam update (see module docstring). Update p.data in place.
raise NotImplementedError("Adam.step") self.t += 1
b1, b2 = self.b1, self.b2
for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad + self.weight_decay * p.data
self._m[i] = b1 * self._m[i] + (1.0 - b1) * g
self._v[i] = b2 * self._v[i] + (1.0 - b2) * (g * g)
mhat = self._m[i] / (1.0 - b1 ** self.t)
vhat = self._v[i] / (1.0 - b2 ** self.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
# TODO: implement the AdamW update (see module docstring). Update p.data in place.
raise NotImplementedError("AdamW.step") self.t += 1
b1, b2 = self.b1, self.b2
for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad
self._m[i] = b1 * self._m[i] + (1.0 - b1) * g
self._v[i] = b2 * self._v[i] + (1.0 - b2) * (g * g)
mhat = self._m[i] / (1.0 - b1 ** self.t)
vhat = self._v[i] / (1.0 - b2 ** self.t)
p.data -= self.lr * (mhat / (np.sqrt(vhat) + self.eps) + self.weight_decay * 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
# TODO: implement the Adamax update (see module docstring). Update p.data in place.
raise NotImplementedError("Adamax.step") self.t += 1
b1, b2 = self.b1, self.b2
for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad + self.weight_decay * p.data
self._m[i] = b1 * self._m[i] + (1.0 - b1) * g
self._u[i] = np.maximum(b2 * self._u[i], np.abs(g))
p.data -= (self.lr / (1.0 - b1 ** self.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
# TODO: implement the NAdam update (see module docstring). Update p.data in place.
raise NotImplementedError("NAdam.step") self.t += 1
b1, b2 = self.b1, self.b2
for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad + self.weight_decay * p.data
self._m[i] = b1 * self._m[i] + (1.0 - b1) * g
self._v[i] = b2 * self._v[i] + (1.0 - b2) * (g * g)
mhat = self._m[i] / (1.0 - b1 ** self.t)
vhat = self._v[i] / (1.0 - b2 ** self.t)
mnes = b1 * mhat + (1.0 - b1) * g / (1.0 - b1 ** self.t)
p.data -= self.lr * mnes / (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
# TODO: implement the Lion update (see module docstring). Update p.data in place.
raise NotImplementedError("Lion.step") b1, b2 = self.b1, self.b2
for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad
upd = np.sign(b1 * self._m[i] + (1.0 - b1) * g)
p.data -= self.lr * (upd + self.weight_decay * p.data)
self._m[i] = b2 * self._m[i] + (1.0 - 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
# TODO: implement the RAdam update (see module docstring). Update p.data in place.
raise NotImplementedError("RAdam.step") self.t += 1
b1, b2 = self.b1, self.b2
t = self.t
for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad + self.weight_decay * p.data
self._m[i] = b1 * self._m[i] + (1.0 - b1) * g
self._v[i] = b2 * self._v[i] + (1.0 - b2) * (g * g)
bc2 = 1.0 - b2 ** t
mhat = self._m[i] / (1.0 - b1 ** t)
rinf = 2.0 / (1.0 - b2) - 1.0
rt = rinf - 2.0 * t * (b2 ** t) / bc2
if rt > 4.0:
l = np.sqrt(bc2 / (self._v[i] + self.eps))
r = math.sqrt(((rt - 4.0) * (rt - 2.0) * rinf) /
((rinf - 4.0) * (rinf - 2.0) * rt))
p.data -= self.lr * mhat * r * l
else:
p.data -= self.lr * mhatThe 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: implement the AdaBelief update (see module docstring). Update p.data in place.
raise NotImplementedError("AdaBelief.step") self.t += 1
b1, b2 = self.b1, self.b2
for i, p in enumerate(self.params):
if p.grad is None:
continue
g = p.grad
self._m[i] = b1 * self._m[i] + (1.0 - b1) * g
d = g - self._m[i]
self._s[i] = b2 * self._s[i] + (1.0 - b2) * (d * d) + self.eps
mhat = self._m[i] / (1.0 - b1 ** self.t)
shat = self._s[i] / (1.0 - b2 ** self.t)
p.data -= self.lr * (mhat / (np.sqrt(shat) + self.eps) + self.weight_decay * 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
# TODO: implement (see docstring).
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 *= 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
# TODO: implement (see docstring).
raise NotImplementedError("clip_grad_value") for p in params:
if p.grad is not None:
np.clip(p.grad, -clip_value, clip_value, out=p.grad)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: implement (see docstring).
raise NotImplementedError("cosine_lr") 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.0 + 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
# TODO: implement (see docstring).
raise NotImplementedError("warmup_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
# TODO: implement (see docstring).
raise NotImplementedError("step_lr")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
# TODO: implement (see docstring).
raise NotImplementedError("exponential_lr")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: implement (see docstring).
raise NotImplementedError("polynomial_lr") if step >= total:
return min_lr
return (base_lr - min_lr) * ((1.0 - step / total) ** power) + min_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
# TODO: implement (see docstring).
raise NotImplementedError("cosine_restart_lr") s = step
T = period
while s >= T:
s -= T
T *= t_mult
return min_lr + 0.5 * (base_lr - min_lr) * (1.0 + math.cos(math.pi * s / max(1, T)))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/data.py
"""Flatten (y, g) to a single group id y*n_classes + g (int64)."""
# TODO
raise NotImplementedError("group_ids") """Flatten (y, g) to a single group id y*n_classes + g (int64)."""
return (np.asarray(y).astype(np.int64) * n_classes + np.asarray(g).astype(np.int64))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/data.py
"""Yield (Xb, yb, gb) minibatches over a random permutation of the dataset."""
# TODO
raise NotImplementedError("iterate") """Yield (Xb, yb, gb) minibatches over a random permutation of the dataset."""
n = X.shape[0]
perm = rng.permutation(n)
for start in range(0, n, batch_size):
idx = perm[start:start + batch_size]
yield X[idx], y[idx], g[idx]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/data.py
"""Return (min over (y,g) groups of within-group accuracy, average accuracy, per-group dict)."""
# TODO
raise NotImplementedError("worst_group_acc") """Return (min over (y,g) groups of within-group accuracy, average accuracy, per-group dict)."""
preds = np.asarray(preds).reshape(-1)
y = np.asarray(y).reshape(-1)
g = np.asarray(g).reshape(-1)
gid = group_ids(y, g, n_classes)
correct = (preds == y).astype(np.float64)
avg = float(correct.mean())
per = {}
for k in np.unique(gid):
mask = gid == k
per[int(k)] = float(correct[mask].mean())
wga = min(per.values()) if per else 0.0
return wga, avg, perThe 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
"""Boolean mask selecting ~frac of EACH (y,g) group (keeps both slices group-balanced)."""
# TODO
raise NotImplementedError("stratified_group_split") """Boolean mask selecting ~frac of EACH (y,g) group (keeps both slices group-balanced)."""
y = np.asarray(y).reshape(-1)
g = np.asarray(g).reshape(-1)
gid = group_ids(y, g, n_classes)
mask = np.zeros(len(y), dtype=bool)
for k in np.unique(gid):
idx = np.where(gid == k)[0]
rng.shuffle(idx)
nsel = int(round(frac * len(idx)))
nsel = max(0, min(len(idx), nsel))
mask[idx[:nsel]] = True
return maskThe file /app/submission/data.py has been updated successfully. (file state is current in your context , no need to Read it back)
Run all public checks quiet
OMP_NUM_THREADS=1 python3 run_checks.py --quiet 2>&1 | tail -20
---------------------------------------------------------------------- autograd_grads 81/81 | nn_forward 21/21 | optim 21/21 | robust 13/13 | robust2 8/8 | data 3/3 TOTAL 147/147 public checks passing All public checks pass. Now make sure model.npz clears the held-out worst-group accuracy threshold; the grader re-checks with DIFFERENT seeds.
"""Training entry point: worst-group-robust SmallCNN via ERM extractor + DFR last-layer retrain.
Recipe:
1. Train the full SmallCNN on the correlated train split (ERM) -> good general features +
batchnorm running buffers.
2. (optional) Fine-tune the full model on the group-balanced reweight split so the conv
features encode the SHAPE (the only predictor on balanced data).
3. DFR: freeze the extractor and re-fit ONLY the classifier on the balanced reweight split with
a group-weighted (balanced-group) loss so the head stops keying off background color.
Writes /app/submission/model.npz via save_checkpoint.
"""
from __future__ import annotations
import argparse
import json
import os
import sys
os.environ.setdefault("OMP_NUM_THREADS", "1")
os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
os.environ.setdefault("MKL_NUM_THREADS", "1")
import numpy as np
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, "/app")
sys.path.insert(0, "/app/submission")
import autograd as ag # noqa: E402,F401
import data as D # noqa: E402,F401
import optim as O # noqa: E402,F401
from nn import SmallCNN # noqa: E402,F401
# Pinned architecture (MUST match the grader's reference; do not change).
WIDTH = 16
EMBED_DIM = 48
def save_checkpoint(path, state_dict, n_classes, img_size):
os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
arrs = {k: np.asarray(v, dtype=np.float32) for k, v in stat
…[truncated 5425 chars]The file /app/submission/train.py has been updated successfully. (file state is current in your context , no need to Read it back)
Time one ERM epoch
OMP_NUM_THREADS=1 python3 -c "
import time, numpy as np, sys
sys.path.insert(0,'submission')
import data as D, optim as O, autograd as ag
from nn import SmallCNN
Xtr,ytr,gtr=D.load_npz('data/train.npz')
m=SmallCNN(n_classes=4,img_size=16,width=16,embed_dim=48,seed=0)
params=m.params(); opt=O.AdamW(params,lr=2e-3,weight_decay=1e-4)
t0=time.time()
bs=128; rng=np.random.default_rng(0); perm=rng.permutation(len(ytr))
for s in range(0,len(ytr),bs):
idx=perm[s:s+bs]; opt.zero_grad()
loss=ag.cross_entropy(m(Xtr[idx],training=True),ytr[idx]); loss.backward()
O.clip_grad_norm(params,5.0); opt.step()
print('1 epoch sec', round(time.time()-t0,2), 'last loss', round(float(loss.data),3))
" 2>&1 | tail -5No file changes, the agent left the workspace untouched.
=== SyncVals verifier (local re-grade of the agent's own checkpoint) === COMPONENT CONFORMANCE SUITE: 194/194 cases passed (all milestones pass: True) FINAL METRIC: worst-group accuracy = 0.91 >= threshold 0.86 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_59f774a8be4e4983. Re-running the agent live requires EVAL_PLATFORM_ENABLE_OAUTH_SMOKE=1 and is non-deterministic.
Trial trial_59f774a8be4e4983 · verifier authoritative; classifier explanatory.