worst-group-spurious-dfr

    return grad.reshape(shape)


class Tensor:

    return grad.reshape(shape)


def _restore(grad, axis, keepdims, shape):
    """Broadcast a reduced gradient back to ``shape`` (for sum/mean/var/std/max/min)."""
    g = np.asarray(grad, dtype=np.float64)
    if axis is None:
        return np.broadcast_to(g, shape)
    axes = (axis,) if isinstance(axis, int) else tuple(axis)
    nd = len(shape)
    axes = sorted(ax % nd for ax in axes)
    if not keepdims:
        for ax in axes:
            g = np.expand_dims(g, ax)
    return np.broadcast_to(g, shape)


class Tensor:

        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``.)
        """
        topo: List["Tensor"] = []
        visited = set()

        def build(v: "Tensor"):
            if id(v) in visited:
                return
            visited.add(id(v))
            for p in v._parents:
                build(p)
            topo.append(v)

        build(self)
        if grad is None:
            grad = np.ones_like(self.data)
        self._accum(_as_f64(grad))
        for v in reversed(topo):
            if v.grad is not None:
                v._backward()

    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 out

    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 out

    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 out

    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 out

    def _bw():
        raise NotImplementedError("power backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            a._accum(out.grad * pf * (a.data ** (pf - 1.0)))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("maximum backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad
        sel = (a.data > b.data).astype(np.float64) + 0.5 * (a.data == b.data)
        if a.requires_grad:
            a._accum(_unbroadcast(g * sel, a.data.shape))
        if b.requires_grad:
            b._accum(_unbroadcast(g * (1.0 - sel), b.data.shape))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("minimum backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad
        sel = (a.data < b.data).astype(np.float64) + 0.5 * (a.data == b.data)
        if a.requires_grad:
            a._accum(_unbroadcast(g * sel, a.data.shape))
        if b.requires_grad:
            b._accum(_unbroadcast(g * (1.0 - sel), b.data.shape))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("where backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad
        cb = c.astype(bool)
        if a.requires_grad:
            a._accum(_unbroadcast(g * cb, a.data.shape))
        if b.requires_grad:
            b._accum(_unbroadcast(g * (~cb), b.data.shape))
    out._backward = _bw
    return out

    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 out

    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 out

    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 out

    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 out

    def _bw():
        raise NotImplementedError("clip backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            mask = (a.data > lo) & (a.data < hi)
            a._accum(out.grad * mask)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("sum backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            a._accum(_restore(out.grad, axis, keepdims, a.data.shape))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("mean backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            a._accum(_restore(out.grad, axis, keepdims, a.data.shape) / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("max backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            mfull = a.data.max(axis=axis, keepdims=True)
            mask = (a.data == mfull).astype(np.float64)
            counts = mask.sum(axis=axis, keepdims=True)
            gfull = _restore(out.grad, axis, keepdims, a.data.shape)
            a._accum(mask * gfull / counts)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("min backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            mfull = a.data.min(axis=axis, keepdims=True)
            mask = (a.data == mfull).astype(np.float64)
            counts = mask.sum(axis=axis, keepdims=True)
            gfull = _restore(out.grad, axis, keepdims, a.data.shape)
            a._accum(mask * gfull / counts)
    out._backward = _bw
    return out

    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 out

    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 out

    def _bw():
        raise NotImplementedError("getitem backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            ga = np.zeros_like(a.data)
            np.add.at(ga, idx, out.grad)
            a._accum(ga)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("concat backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        splits = np.cumsum(sizes)[:-1]
        parts = np.split(out.grad, splits, axis=axis)
        for ti, part in zip(ts, parts):
            if ti.requires_grad:
                ti._accum(part)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("stack backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        for i, ti in enumerate(ts):
            if ti.requires_grad:
                sl = [slice(None)] * out.grad.ndim
                sl[axis] = i
                ti._accum(out.grad[tuple(sl)])
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("matmul backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad
        ad, bd = a.data, b.data
        if a.requires_grad:
            ga = g @ np.swapaxes(bd, -1, -2)
            a._accum(_unbroadcast(ga, ad.shape))
        if b.requires_grad:
            gb = np.swapaxes(ad, -1, -2) @ g
            b._accum(_unbroadcast(gb, bd.shape))
    out._backward = _bw
    return out

    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 out

    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, sl))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("sigmoid backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            sd = out.data
            a._accum(out.grad * sd * (1.0 - sd))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("tanh backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            td = out.data
            a._accum(out.grad * (1.0 - td * td))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("gelu backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            pdf = np.exp(-0.5 * x * x) / np.sqrt(2.0 * np.pi)
            a._accum(out.grad * (cdf + x * pdf))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("softmax backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            g = out.grad
            sd = out.data
            a._accum(sd * (g - (g * sd).sum(axis=axis, keepdims=True)))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("log_softmax backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            g = out.grad
            a._accum(g - s * g.sum(axis=axis, keepdims=True))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("softplus backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            a._accum(out.grad * (1.0 / (1.0 + np.exp(-bx))))
    out._backward = _bw
    return out

    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 out

    def _bw():
        raise NotImplementedError("elu backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            a._accum(out.grad * np.where(x > 0.0, 1.0, al * ex))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("mish backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            sig = 1.0 / (1.0 + np.exp(-x))
            a._accum(out.grad * (t + x * (1.0 - t * t) * sig))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("hardtanh backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            mask = (a.data > lo) & (a.data < hi)
            a._accum(out.grad * mask)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("var backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            denom = n - ddof
            gfull = _restore(out.grad, axis, keepdims, a.data.shape)
            a._accum(gfull * 2.0 * (a.data - mu) / denom)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("std backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            gfull = _restore(out.grad, axis, keepdims, a.data.shape)
            a._accum(gfull * (a.data - mu) / (n * skeep))
    out._backward = _bw
    return out

    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))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("mse_loss backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if pred.requires_grad:
            pred._accum(out.grad * 2.0 * diff / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("cross_entropy backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            y = np.zeros_like(sm)
            y[np.arange(n), t] = 1.0
            logits._accum(out.grad * (sm - y) / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("group_weighted_ce backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            y = np.zeros_like(sm)
            y[np.arange(n), t] = 1.0
            logits._accum(out.grad * (sm - y) * scale[:, None])
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("reweighted_ce backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            y = np.zeros_like(sm)
            y[np.arange(n), t] = 1.0
            logits._accum(out.grad * (sm - y) * (w[:, None] / wsum))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("group_dro_loss backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            y = np.zeros_like(sm)
            y[np.arange(n), t] = 1.0
            logits._accum(out.grad * (sm - y) * scale[:, None])
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("logit_adjusted_ce backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            y = np.zeros_like(sm)
            y[np.arange(n), t] = 1.0
            logits._accum(out.grad * (sm - y) / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("focal_loss backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            term = g * ((1.0 - p) ** (g - 1.0)) * np.log(pc) - ((1.0 - p) ** g) / pc
            fac = term * p
            grad = -fac[:, None] * sm
            grad[np.arange(n), t] += fac
            logits._accum(out.grad * grad / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("irm_penalty backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            sx = (sm * x).sum(axis=-1, keepdims=True)
            inner = (sm - y) + sm * (x - sx)
            logits._accum(out.grad * 2.0 * grad_w * inner / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("gce_loss backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            y = np.zeros_like(sm)
            y[np.arange(n), t] = 1.0
            pq = pc ** qf
            grad = -pq[:, None] * (y - sm)
            logits._accum(out.grad * grad / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("vrex_penalty backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if r.requires_grad:
            grad = (2.0 / K) * (rd - mu) * out.grad
            r._accum(grad.reshape(r.data.shape))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("ldam_loss backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            y = np.zeros_like(sm)
            y[np.arange(n), t] = 1.0
            logits._accum(out.grad * sc * (sm - y) / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("spectral_decoupling backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if logits.requires_grad:
            logits._accum(out.grad * lm * x / n)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("layernorm backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad
        if gamma.requires_grad:
            gamma._accum(_unbroadcast(g * xhat, gamma.data.shape))
        if beta.requires_grad:
            beta._accum(_unbroadcast(g, beta.data.shape))
        if a.requires_grad:
            gy = g * gamma.data
            mean1 = gy.mean(axis=-1, keepdims=True)
            mean2 = (gy * xhat).mean(axis=-1, keepdims=True)
            a._accum(inv * (gy - mean1 - xhat * mean2))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("batchnorm backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad
        if gamma.requires_grad:
            gamma._accum(_unbroadcast(g * xhat, gamma.data.shape))
        if beta.requires_grad:
            beta._accum(_unbroadcast(g, beta.data.shape))
        if a.requires_grad:
            gy = g * gamma.data
            mean1 = gy.mean(axis=0, keepdims=True)
            mean2 = (gy * xhat).mean(axis=0, keepdims=True)
            a._accum(inv * (gy - mean1 - xhat * mean2))
    out._backward = _bw
    return out

    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:
            gg = gamma.data.reshape(1, C, 1, 1)
            gy = g * gg
            if training:
                mean1 = gy.mean(axis=(0, 2, 3), keepdims=True)
                mean2 = (gy * xhat).mean(axis=(0, 2, 3), keepdims=True)
                x._accum(inv * (gy - mean1 - xhat * mean2))
            else:
                x._accum(gy * inv)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("rms_norm backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad
        if gamma.requires_grad:
            gamma._accum(_unbroadcast(g * xhat, gamma.data.shape))
        if a.requires_grad:
            gy = g * gamma.data
            s = (gy * x).sum(axis=-1, keepdims=True)
            a._accum(r * gy - (r ** 3 / D) * x * s)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("groupnorm2d 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:
            gy = (g * gamma.data.reshape(1, C, 1, 1)).reshape(N, G, cg * H * W)
            xhatg = xhat.reshape(N, G, cg * H * W)
            mean1 = gy.mean(axis=2, keepdims=True)
            mean2 = (gy * xhatg).mean(axis=2, keepdims=True)
            dxg = inv * (gy - mean1 - xhatg * mean2)
            x._accum(dxg.reshape(N, C, H, W))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("conv2d backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        g = out.grad  # (N, Cout, OH, OW)
        go = g.reshape(N, Cout, OH * OW)
        if bias.requires_grad:
            bias._accum(g.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)
            H, W = x.data.shape[2], x.data.shape[3]
            dcols6 = dcols.reshape(N, Cin, kh, kw, OH, OW)
            Hp, Wp = H + 2 * pad, W + 2 * pad
            dxp = np.zeros((N, Cin, Hp, Wp))
            for i in range(kh):
                for j in range(kw):
                    dxp[:, :, i:i + st * OH:st, j:j + st * OW:st] += dcols6[:, :, i, j, :, :]
            if pad > 0:
                x._accum(dxp[:, :, pad:pad + H, pad:pad + W])
            else:
                x._accum(dxp)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("maxpool2d backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if x.requires_grad:
            m = xr.max(axis=(3, 5), keepdims=True)
            mask = (xr == m).astype(np.float64)
            counts = mask.sum(axis=(3, 5), keepdims=True)
            gg = out.grad.reshape(N, C, H // k, 1, W // k, 1)
            dxr = mask * gg / counts
            x._accum(dxr.reshape(N, C, H, W))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("maxpool2d_stride backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if x.requires_grad:
            m = win.max(axis=(2, 3), keepdims=True)
            mask = (win == m).astype(np.float64)
            counts = mask.sum(axis=(2, 3), keepdims=True)
            gg = out.grad.reshape(N, C, 1, 1, OH, OW)
            contrib = mask * gg / counts
            dxp = np.zeros_like(xp)
            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:
                x._accum(dxp[:, :, pad:pad + H, pad:pad + W])
            else:
                x._accum(dxp)
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("avgpool2d backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if x.requires_grad:
            gg = out.grad.reshape(N, C, H // k, 1, W // k, 1)
            dxr = np.empty((N, C, H // k, k, W // k, k))
            dxr[...] = gg / (k * k)
            x._accum(dxr.reshape(N, C, H, W))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("global_avg_pool backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if x.requires_grad:
            gg = out.grad[:, :, None, None] / (H * W)
            x._accum(np.broadcast_to(gg, (N, C, H, W)))
    out._backward = _bw
    return out

    def _bw():
        raise NotImplementedError("embedding backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if weight.requires_grad:
            dw = np.zeros_like(weight.data)
            np.add.at(dw, idx, out.grad)
            weight._accum(dw)
    out._backward = _bw
    return out

        def _bw_id():
            raise NotImplementedError("dropout backward")  # TODO
        out._backward = _bw_id
        return out

        def _bw_id():
            if a.requires_grad:
                a._accum(out.grad)
        out._backward = _bw_id
        return out

    def _bw():
        raise NotImplementedError("dropout backward")  # TODO
    out._backward = _bw
    return out

    def _bw():
        if a.requires_grad:
            a._accum(out.grad * keep)
    out._backward = _bw
    return out

    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}

    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)
    def named_params(self):
        return {"weight": self.weight, "bias": self.bias}

    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):

    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):

    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):

    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)

    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):

    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):

    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)

    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)

    def forward(self, X, training: bool = True) -> Tensor:
        # 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")

    def forward(self, X, training: bool = True) -> Tensor:
        h = ag.silu(self.gn0(self.stem(X)))
        # block 1
        r = h
        h = ag.silu(self.b1n1(self.b1c1(h)))
        h = self.b1n2(self.b1c2(h))
        h = ag.silu(ag.add(h, r))
        # block 2
        r = h
        h = ag.silu(self.b2n1(self.b2c1(h)))
        h = self.b2n2(self.b2c2(h))
        h = ag.silu(ag.add(h, r))
        # strided downsample
        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)

    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))
        h = ag.maxpool2d(h, 2)
        h = ag.relu(self.bn2(self.conv2(h), training))
        h = ag.maxpool2d(h, 2)
        h = ag.relu(self.bn3(self.conv3(h), 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))

    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
        last = len(self.layers) - 1
        for i, lin in enumerate(self.layers):
            h = lin(h)
            if i < last:
                h = ag.relu(h)
        return h
    def named_params(self) -> Dict[str, Tensor]:
        d: Dict[str, Tensor] = {}
        for i, lin in enumerate(self.layers):

    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:
            z = blk["ln"](h)
            z = blk["fc1"](z)
            z = ag.gelu(z)
            z = blk["fc2"](z)
            h = ag.add(h, z)
        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():

    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))
        h = ag.avgpool2d(h, 2)
        h = ag.relu(self.bn2(self.conv2(h), training))
        h = ag.maxpool2d(h, 2)
        N = X.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"):

from typing import Dict, List

import numpy as np

import math
from typing import Dict, List

import numpy as np

    balanced-group / DFR weighting). If ``n_groups`` is None it is inferred as max(group_ids)+1."""
    # TODO: implement (numpy only). See docstring.
    raise NotImplementedError("balanced_group_weights")
def class_balanced_weights(targets, n_classes=None, beta=0.0):

    balanced-group / DFR weighting). If ``n_groups`` is None it is inferred as max(group_ids)+1."""
    gids = np.asarray(group_ids).astype(np.int64).reshape(-1)
    present = np.unique(gids)
    if n_groups is None:
        n_groups = int(gids.max()) + 1
    w = np.zeros(int(n_groups), dtype=np.float64)
    w[present] = 1.0 / len(present)
    return w
def class_balanced_weights(targets, n_classes=None, beta=0.0):

    effective number is (1-beta^n_c)/(1-beta) (Cui et al.); beta=0 reduces to inverse-frequency
    1/n_c. Each sample gets its class weight, and the vector is normalized to mean 1."""
    # TODO: implement (numpy only). See docstring.
    raise NotImplementedError("class_balanced_weights")
def log_class_prior(targets, n_classes=None, eps=1e-6):

    effective number is (1-beta^n_c)/(1-beta) (Cui et al.); beta=0 reduces to inverse-frequency
    1/n_c. Each sample gets its class weight, and the vector is normalized to mean 1."""
    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:
        eff = (1.0 - beta ** counts) / (1.0 - beta)
    else:
        eff = counts
    cw = np.zeros(int(n_classes), dtype=np.float64)
    nz = counts > 0
    cw[nz] = 1.0 / eff[nz]
    w = cw[t]
    w = w / w.mean()
    return w
def log_class_prior(targets, n_classes=None, eps=1e-6):

    vector. Empty classes get log(eps)."""
    # TODO: implement (numpy only). See docstring.
    raise NotImplementedError("log_class_prior")
def ldam_margins(targets, n_classes=None, max_margin=0.5):

    vector. Empty classes get log(eps)."""
    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
    lp = np.full(int(n_classes), math.log(eps), dtype=np.float64)
    nz = counts > 0
    lp[nz] = np.log(counts[nz] / N)
    return lp
def ldam_margins(targets, n_classes=None, max_margin=0.5):

    margins on rare classes. Rare classes get bigger margins.
    Returns a length-``n_classes`` vector."""
    # TODO: implement (numpy only). See docstring.
    raise NotImplementedError("ldam_margins")
def effective_number_weights(targets, n_classes=None, beta=0.999):

    margins on rare classes. Rare classes get bigger margins.
    Returns a length-``n_classes`` vector."""
    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.zeros(int(n_classes), dtype=np.float64)
    nz = counts > 0
    m[nz] = counts[nz] ** (-0.25)
    if m.max() > 0:
        m = m / m.max() * max_margin
    return m
def effective_number_weights(targets, n_classes=None, beta=0.999):

    # TODO: implement (numpy only). See docstring.
    raise NotImplementedError("ldam_margins")
def effective_number_weights(targets, n_classes=None, beta=0.999):

    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.zeros(int(n_classes), dtype=np.float64)
    nz = counts > 0
    m[nz] = counts[nz] ** (-0.25)
    if m.max() > 0:
        m = m / m.max() * max_margin
    return m
def effective_number_weights(targets, n_classes=None, beta=0.999):

    the PRESENT classes. Returns a length-``n_classes`` per-CLASS weight vector (NOT per-sample)."""
    # TODO: implement (numpy only). See docstring.
    raise NotImplementedError("effective_number_weights")

    the PRESENT classes. Returns a length-``n_classes`` per-CLASS weight vector (NOT per-sample)."""
    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)
    w = np.zeros(int(n_classes), dtype=np.float64)
    nz = counts > 0
    eff = (1.0 - beta ** counts[nz]) / (1.0 - beta)
    w[nz] = 1.0 / eff
    w[nz] = w[nz] / w[nz].mean()
    return w

    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:
            mask = np.ones(self.n_groups, dtype=bool)
        else:
            mask = np.asarray(present, dtype=bool).reshape(-1)
        first = mask & (~self._init)
        blend = mask & self._init
        self.l[first] = gl[first]
        self.l[blend] = self.beta * self.l[blend] + (1.0 - self.beta) * gl[blend]
        self._init[first] = True
        return self.l.copy()

    def worst_group(self):
        return int(np.argmax(self.l))

    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()

def group_ids(y: np.ndarray, g: np.ndarray, n_classes: int) -> np.ndarray:
    """Flatten (y, g) to a single group id y*n_classes + g (int64)."""
    # TODO
    raise NotImplementedError("group_ids")


def iterate(X, y, g, batch_size, rng):
    """Yield (Xb, yb, gb) minibatches over a random permutation of the dataset."""
    # TODO
    raise NotImplementedError("iterate")


def worst_group_acc(preds, y, g, n_classes) -> Tuple[float, float, Dict[int, float]]:
    """Return (min over (y,g) groups of within-group accuracy, average accuracy, per-group dict)."""
    # TODO
    raise NotImplementedError("worst_group_acc")


def stratified_group_split(y, g, n_classes, frac, rng) -> np.ndarray:
    """Boolean mask selecting ~frac of EACH (y,g) group (keeps both slices group-balanced)."""
    # TODO
    raise NotImplementedError("stratified_group_split")

def group_ids(y: np.ndarray, g: np.ndarray, n_classes: int) -> np.ndarray:
    """Flatten (y, g) to a single group id y*n_classes + g (int64)."""
    return (np.asarray(y).astype(np.int64) * int(n_classes) + np.asarray(g).astype(np.int64))


def iterate(X, y, g, batch_size, rng):
    """Yield (Xb, yb, gb) minibatches over a random permutation of the dataset."""
    n = X.shape[0]
    perm = rng.permutation(n)
    for i in range(0, n, batch_size):
        idx = perm[i:i + batch_size]
        yield X[idx], y[idx], g[idx]


def worst_group_acc(preds, y, g, n_classes) -> Tuple[float, float, Dict[int, float]]:
    """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()) if correct.size else 0.0
    per: Dict[int, float] = {}
    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, per


def stratified_group_split(y, g, n_classes, frac, rng) -> np.ndarray:
    """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(y.shape[0], dtype=bool)
    for k in np.u
…[truncated 233 chars]

    def step(self):
        # TODO: implement the SGD update (see module docstring). Update p.data in place.
        raise NotImplementedError("SGD.step")

    def step(self):
        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 * upd

    def step(self):
        # TODO: implement the Adagrad update (see module docstring). Update p.data in place.
        raise NotImplementedError("Adagrad.step")

    def step(self):
        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._s[i] + g * g
            p.data -= self.lr * g / (np.sqrt(self._s[i]) + self.eps)

    def step(self):
        # TODO: implement the RMSprop update (see module docstring). Update p.data in place.
        raise NotImplementedError("RMSprop.step")

    def step(self):
        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)

    def step(self):
        # TODO: implement the Adam update (see module docstring). Update p.data in place.
        raise NotImplementedError("Adam.step")

    def step(self):
        self.t += 1
        b1, b2 = self.b1, self.b2
        bc1 = 1.0 - b1 ** self.t
        bc2 = 1.0 - b2 ** 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)
            mhat = self._m[i] / bc1
            vhat = self._v[i] / bc2
            p.data -= self.lr * mhat / (np.sqrt(vhat) + self.eps)

    def step(self):
        # TODO: implement the AdamW update (see module docstring). Update p.data in place.
        raise NotImplementedError("AdamW.step")

    def step(self):
        self.t += 1
        b1, b2 = self.b1, self.b2
        bc1 = 1.0 - b1 ** self.t
        bc2 = 1.0 - b2 ** self.t
        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] / bc1
            vhat = self._v[i] / bc2
            p.data -= self.lr * (mhat / (np.sqrt(vhat) + self.eps) + self.weight_decay * p.data)

    def step(self):
        # TODO: implement the Adamax update (see module docstring). Update p.data in place.
        raise NotImplementedError("Adamax.step")

    def step(self):
        self.t += 1
        b1, b2 = self.b1, self.b2
        bc1 = 1.0 - b1 ** 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._u[i] = np.maximum(b2 * self._u[i], np.abs(g))
            p.data -= (self.lr / bc1) * self._m[i] / (self._u[i] + self.eps)

    def step(self):
        # TODO: implement the NAdam update (see module docstring). Update p.data in place.
        raise NotImplementedError("NAdam.step")

    def step(self):
        self.t += 1
        b1, b2 = self.b1, self.b2
        bc1 = 1.0 - b1 ** self.t
        bc2 = 1.0 - b2 ** 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)
            mhat = self._m[i] / bc1
            vhat = self._v[i] / bc2
            mnes = b1 * mhat + (1.0 - b1) * g / bc1
            p.data -= self.lr * mnes / (np.sqrt(vhat) + self.eps)

    def step(self):
        # TODO: implement the Lion update (see module docstring). Update p.data in place.
        raise NotImplementedError("Lion.step")

    def step(self):
        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) * g

    def step(self):
        # TODO: implement the RAdam update (see module docstring). Update p.data in place.
        raise NotImplementedError("RAdam.step")

    def step(self):
        self.t += 1
        b1, b2 = self.b1, self.b2
        bc1 = 1.0 - b1 ** self.t
        bc2 = 1.0 - b2 ** self.t
        rinf = 2.0 / (1.0 - b2) - 1.0
        rt = rinf - 2.0 * self.t * (b2 ** self.t) / bc2
        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] / bc1
            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 * mhat

    def step(self):
        # TODO: implement the AdaBelief update (see module docstring). Update p.data in place.
        raise NotImplementedError("AdaBelief.step")

    def step(self):
        self.t += 1
        b1, b2 = self.b1, self.b2
        bc1 = 1.0 - b1 ** self.t
        bc2 = 1.0 - b2 ** self.t
        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] / bc1
            shat = self._s[i] / bc2
            p.data -= self.lr * (mhat / (np.sqrt(shat) + self.eps) + self.weight_decay * p.data)

    exceeds ``max_norm`` every grad is scaled by ``max_norm / (total_norm + 1e-6)``."""
    # TODO: implement (see docstring).
    raise NotImplementedError("clip_grad_norm")
def clip_grad_value(params: List[Tensor], clip_value: float) -> None:
    """Element-wise gradient clamp to [-clip_value, clip_value] (in place)."""
    # TODO: implement (see docstring).
    raise NotImplementedError("clip_grad_value")

    exceeds ``max_norm`` every grad is scaled by ``max_norm / (total_norm + 1e-6)``."""
    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 total
def clip_grad_value(params: List[Tensor], clip_value: float) -> None:
    """Element-wise gradient clamp to [-clip_value, clip_value] (in place)."""
    for p in params:
        if p.grad is not None:
            p.grad = np.clip(p.grad, -clip_value, clip_value)

    ``total``. ``step`` is 0-based. Holds at ``min_lr`` past ``total``."""
    # TODO: implement (see docstring).
    raise NotImplementedError("cosine_lr")
def warmup_lr(step, base_lr, warmup):
    """Linear warmup to ``base_lr`` over ``warmup`` steps, then constant ``base_lr``."""
    # TODO: implement (see docstring).
    raise NotImplementedError("warmup_lr")
def step_lr(step, base_lr, step_size, gamma=0.1):
    """Step decay: lr = base_lr * gamma ** (step // step_size)."""
    # TODO: implement (see docstring).
    raise NotImplementedError("step_lr")
def exponential_lr(step, base_lr, gamma=0.99):
    """Exponential decay: lr = base_lr * gamma ** step."""
    # TODO: implement (see docstring).
    raise NotImplementedError("exponential_lr")
def polynomial_lr(step, base_lr, total, power=1.0, min_lr=0.0):
    """Polynomial decay: lr = (base_lr - min_lr) * (1 - step/total)^power + min_lr, clamped so
    ``step >= total`` holds at ``min_lr``. ``step`` is 0-based."""
    # TODO: implement (see docstring).
    raise NotImplementedError("polynomial_lr")
def cosine_restart_lr(step, period, base_lr, min_lr=0.0, t_mult=1):
    """SGDR cosine annealing with warm restarts (Loshchilov & Hutter). The schedule restarts every
    ``period`` steps (each cycle's length multiplied by ``t_mult``). Within a cycle of length T at
    in-cycle step s: lr = min_lr + 0.5*(base_lr-min_lr)*(1+cos(pi*s/T)). ``step`` is 0-based."""
    # TODO: implement (see docstring).
    raise NotImplementedError(
…[truncated 20 chars]

    ``total``. ``step`` is 0-based. Holds at ``min_lr`` past ``total``."""
    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))
def warmup_lr(step, base_lr, warmup):
    """Linear warmup to ``base_lr`` over ``warmup`` steps, then constant ``base_lr``."""
    if step < warmup:
        return base_lr * (step + 1) / warmup
    return base_lr
def step_lr(step, base_lr, step_size, gamma=0.1):
    """Step decay: lr = base_lr * gamma ** (step // step_size)."""
    return base_lr * (gamma ** (step // step_size))
def exponential_lr(step, base_lr, gamma=0.99):
    """Exponential decay: lr = base_lr * gamma ** step."""
    return base_lr * (gamma ** step)
def polynomial_lr(step, base_lr, total, power=1.0, min_lr=0.0):
    """Polynomial decay: lr = (base_lr - min_lr) * (1 - step/total)^power + min_lr, clamped so
    ``step >= total`` holds at ``min_lr``. ``step`` is 0-based."""
    if step >= total:
        return min_lr
    return (base_lr - min_lr) * ((1.0 - step / total) ** power) + min_lr
def cosine_restart_lr(step, period, base_lr, min_lr=0.0, t_mult=1):
    """SGDR cosine annealing with warm restarts (Loshchilov & Hutter). The schedule restarts every
    ``period`` steps (each cycle's length multiplied by ``t_mult``). Within a cycle of length T at
    in-cycle step s: lr = min_lr + 0.5*(base_lr-min_lr)*(
…[truncated 209 chars]

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--train", default="/app/data/train.npz")
    ap.add_argument("--reweight", default="/app/data/reweight.npz")
    ap.add_argument("--out", default="/app/submission/model.npz")
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()

    # TODO: build a SmallCNN(n_classes, img_size, width=WIDTH, embed_dim=EMBED_DIM), train a
    #       worst-group-robust recipe with your framework (forward -> loss -> backward -> clip ->
    #       optimizer step), then save:
    #           save_checkpoint(args.out, model.state_dict(), n_classes, img_size)
    raise NotImplementedError("implement training and call save_checkpoint")


if __name__ == "__main__":
    main()

def _evaluate(model, X, y, g, n_classes, bs=256):
    preds = []
    for i in range(0, len(X), bs):
        logits = model.forward(X[i:i + bs], training=False).data
        preds.append(logits.argmax(axis=1))
    preds = np.concatenate(preds)
    return D.worst_group_acc(preds, y, g, n_classes)


def _train_epoch(model, X, y, g, opt, n_classes, bs, rng, lr=None):
    if lr is not None:
        opt.lr = lr
    for Xb, yb, gb in D.iterate(X, y, g, bs, rng):
        for p in model.params():
            p.grad = None
        logits = model.forward(Xb, training=True)
        loss = ag.cross_entropy(logits, yb)
        loss.backward()
        O.clip_grad_norm(model.params(), 5.0)
        opt.step()


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--train", default="/app/data/train.npz")
    ap.add_argument("--reweight", default="/app/data/reweight.npz")
    ap.add_argument("--out", default="/app/submission/model.npz")
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()

    Xtr, ytr, gtr = D.load_npz(args.train)
    Xrw, yrw, grw = D.load_npz(args.reweight)
    n_classes = int(max(ytr.max(), yrw.max())) + 1
    img_size = Xtr.shape[-1]
    rng = np.random.default_rng(args.seed)

    model = SmallCNN(n_classes, img_size, width=WIDTH, embed_dim=EMBED_DIM, seed=args.seed)

    # ---------------- Phase 1: ERM feature learning on the correlated train split -------------
    E1 = 22
    opt = O.AdamW(model.params(), lr=2e-3, weight_decay=1e-
…[truncated 2390 chars]