File size: 15,431 Bytes
c8420ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1777460
c8420ab
 
1777460
c8420ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1777460
c8420ab
 
 
1777460
c8420ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1777460
 
 
c8420ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1777460
c8420ab
 
1777460
 
 
c8420ab
1777460
c8420ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1777460
c8420ab
 
 
 
 
 
 
 
 
d65fc2e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
c8420ab
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
"""Feature sources for set 5 (VM).  Every source returns, for the requested blocks (1-indexed block outputs), a list of
patch-token tensors [B, 256, D] in float32.  Checkpoints are re-checked against the step-0 size and sha256 records and
loaded with torch.load(weights_only=True) (encoders: same allow-list helper as step 0c).

  SiTSource  latent SD-VAE input x_s = (1-s)*x0 + s*eps, x0 = 0.18215 * posterior mean; willisma/SiT path
             x_t = t*data + (1-t)*noise, so t = 1 - s; null label 1000; velocity output (data - noise).
  JiTSource  pixel input in [-1, 1]; JiT z = t*x + (1-t)*noise_scale*eps (noise_scale 1.0), so with s the noise
             coefficient z = (1-s)*x + s*eps and t = 1 - s; null label 1000; x-prediction; the 32 in-context class
             tokens (prepended from block 4 of B / 8 of L) are dropped.
  EncoderSource  clean image, ImageNet mean/std, 256 px with pos_embed bicubic-resampled to 16x16 (224 px for patch 14);
             prefix tokens (CLS) dropped from the patch tokens and returned separately.
Forward passes run in fp32 (TF32 off) so features do not depend on reduced-precision matmuls.
"""
from __future__ import annotations

import argparse
import json
import subprocess
import sys
from pathlib import Path

import numpy as np
import torch
import torch.nn.functional as F

CODE = Path(__file__).resolve().parent
sys.path.insert(0, str(CODE))
from common5 import CKPT, OUT_DRIVE, OUT_LOCAL, WORK, log, sha256  # noqa: E402

NULL_LABEL = 1000
IMNET_MEAN = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
IMNET_STD = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)


def step0_record(name):
    for d in (OUT_LOCAL / "step0", OUT_DRIVE / "step0", CODE / "step0"):
        if (d / name).exists():
            return json.loads((d / name).read_text())
    raise FileNotFoundError(f"step-0 record {name}")


def verify(path, rec, what):
    path = Path(path)
    size, digest = path.stat().st_size, sha256(path)
    want_size = rec.get("size_bytes")
    if digest != rec["sha256"] or (want_size and size != want_size):
        raise RuntimeError(f"{what}: {path.name} size/sha256 ({size}, {digest[:16]}) differ from step 0 "
                           f"({want_size}, {rec['sha256'][:16]})")
    return {"file": path.name, "size_bytes": size, "sha256": digest}


class _Stop(Exception):
    pass


def tap_blocks(block_modules, wanted, run, post=None):
    """Outputs of blocks `wanted` (1-indexed) during run(); the forward is stopped after the deepest one."""
    wanted = sorted(set(wanted))
    out, hs = {}, []
    for b in wanted:
        def hook(_m, _i, o, b=b):
            out[b] = post(b, o) if post else o
            if b == wanted[-1]:
                raise _Stop
        hs.append(block_modules[b - 1].register_forward_hook(hook))
    try:
        run()
    except _Stop:
        pass
    finally:
        for h in hs:
            h.remove()
    return [out[b].float() for b in wanted]


# ----------------------------------------------------------------------------- SD-VAE (SiT input)
class VAE:
    """stabilityai/sd-vae-ft-ema (SiT's training default; ft-ema and ft-mse share the encoder).  latent = 0.18215 *
    posterior mean (the protocol's choice; SiT training samples from the posterior)."""

    def __init__(self, device="cuda"):
        from diffusers.models import AutoencoderKL
        self.vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-ema").to(device).eval()
        self.device = device

    @torch.no_grad()
    def encode(self, img_u8):  # [B, 256, 256, 3] uint8 (numpy or tensor) -> [B, 4, 32, 32]
        x = torch.as_tensor(np.asarray(img_u8)).to(self.device).permute(0, 3, 1, 2).float() / 127.5 - 1.0
        return torch.cat([self.vae.encode(c).latent_dist.mean for c in x.split(32)]) * 0.18215  # chunks: memory

    @torch.no_grad()
    def decode(self, z):
        return torch.cat([self.vae.decode(c / 0.18215).sample for c in z.split(50)])


def latents(split, img, vae_holder, cache_dir, bs=64):
    """Cached SiT input latents of a whole split ([N, 4, 32, 32] float32)."""
    p = Path(cache_dir) / f"{split}_lat.npy"
    if p.exists():
        return np.load(p)
    vae = vae_holder()
    out = np.zeros((len(img), 4, 32, 32), np.float32)
    for i in range(0, len(img), bs):
        out[i:i + bs] = vae.encode(img[i:i + bs]).cpu().numpy()
    np.save(p, out)
    log(f"[latents] {split}: {out.shape}, mean {out.mean():.3f}, std {out.std():.3f}")
    return out


# ----------------------------------------------------------------------------- SiT
SIT_REPO, SIT_COMMIT = "https://github.com/willisma/SiT.git", "cbde832a40b153ccc79603412409da9c9b0c568c"


def sit_code():
    d = WORK / "willisma_sit"
    if not (d / "models.py").exists():
        subprocess.run(["git", "clone", "-q", SIT_REPO, str(d)], check=True)
        subprocess.run(["git", "-C", str(d), "checkout", "-q", SIT_COMMIT], check=True)
    if str(d) not in sys.path:
        sys.path.insert(0, str(d))
    import models as sit_models
    return sit_models


class SiTSource:
    kind = "latent"
    group = "denoise_latent"

    def __init__(self, size, device="cuda"):
        from huggingface_hub import hf_hub_download
        sit_models = sit_code()
        p = Path(hf_hub_download("nyu-visionx/SiT-collections", f"SiT-{size}-2-256.pt", local_dir=str(CKPT)))
        self.ckpt = verify(p, step0_record(f"sit_{size}_n4000.json"), f"SiT-{size}")
        sd = torch.load(p, map_location="cpu", weights_only=True)
        m = sit_models.SiT_models[f"SiT-{size}/2"](input_size=32, num_classes=1000, learn_sigma=True)
        m.load_state_dict(sd, strict=True)
        self.m = m.to(device).eval()
        self.path, self.device = p, device
        self.name, self.size = f"sit_{size.lower()}", size
        self.n_blocks, self.dim = len(m.blocks), m.pos_embed.shape[-1]

    @staticmethod
    def t_of_s(s):
        return 1.0 - s

    def _t(self, B, t):
        return torch.full((B,), float(t), device=self.device)

    @torch.no_grad()
    def tokens(self, x0, eps, s, blocks, y=None):
        B = x0.shape[0]
        xs = (1 - s) * x0 + s * eps
        y = torch.full((B,), NULL_LABEL, device=self.device, dtype=torch.long) if y is None else y
        return tap_blocks(self.m.blocks, blocks, lambda: self.m(xs, self._t(B, self.t_of_s(s)), y))

    @torch.no_grad()
    def predict(self, x, t, y=None):
        y = torch.full((x.shape[0],), NULL_LABEL, device=self.device, dtype=torch.long) if y is None else y
        return self.m(x, self._t(x.shape[0], t) if not torch.is_tensor(t) else t, y)

    @torch.no_grad()
    def sample_grid(self, vae, classes, seed=0):
        """SDE Euler-Maruyama 250 steps, no CFG (the step-0 FID setting), fp32 network."""
        from transport import Sampler, create_transport
        fn = Sampler(create_transport("Linear", "velocity", None, None, None)).sample_sde(
            sampling_method="Euler", diffusion_form="sigma", diffusion_norm=1.0, last_step="Mean",
            last_step_size=0.04, num_steps=250)
        torch.manual_seed(seed)
        z = torch.randn(len(classes), 4, 32, 32, device=self.device)
        x = fn(z, self.m.forward, y=torch.tensor(classes, device=self.device))[-1]
        return ((vae.decode(x) + 1) * 127.5).clamp(0, 255).round().to(torch.uint8)

    def close(self):
        del self.m
        torch.cuda.empty_cache()


# ----------------------------------------------------------------------------- JiT
class JiTSource:
    kind = "pixel"
    group = "denoise_pixel"
    CFG = {"B": 3.0, "L": 2.4, "H": 2.2}

    def __init__(self, size, device="cuda"):
        import s0b_jit
        Denoiser = s0b_jit.jit_code()
        p = s0b_jit.local(size)
        if not p.exists() or p.stat().st_size != s0b_jit.FILES[size][1]:
            subprocess.run(["curl", "-sSfL", "--retry", "10", "-C", "-", "-o", str(p), s0b_jit.url(size)], check=True)
        self.ckpt = verify(p, step0_record(f"jit_{size}_inspect.json"), f"JiT-{size}")
        torch.serialization.add_safe_globals([argparse.Namespace])
        ck = torch.load(p, map_location="cpu", weights_only=True)
        a = argparse.Namespace(model=f"JiT-{size}/16", img_size=256, class_num=1000, attn_dropout=0.0,
                               proj_dropout=0.0, label_drop_prob=0.1, P_mean=-0.8, P_std=0.8, t_eps=5e-2,
                               noise_scale=1.0, ema_decay1=0.9999, ema_decay2=0.9996, sampling_method="heun",
                               num_sampling_steps=50, cfg=1.0, interval_min=0.1, interval_max=1.0)
        den = Denoiser(a)
        den.load_state_dict(ck["model_ema1"], strict=True)
        del ck
        self.den = den.to(device).eval()
        self.net = self.den.net
        self.path, self.device = p, device
        self.name, self.size = f"jit_{size.lower()}", size
        self.n_blocks, self.dim = len(self.net.blocks), self.net.pos_embed.shape[-1]
        self.noise_scale = a.noise_scale
        self.ic_len, self.ic_start = self.net.in_context_len, self.net.in_context_start  # start is 0-based

    @staticmethod
    def t_of_s(s):
        return 1.0 - s

    def _post(self, b, o):
        o = o[:, self.ic_len:] if (b - 1) >= self.ic_start else o
        assert o.shape[1] == 256, o.shape
        return o

    @torch.no_grad()
    def tokens(self, x, eps, s, blocks, y=None):
        B = x.shape[0]
        z = (1 - s) * x + s * self.noise_scale * eps
        t = torch.full((B,), self.t_of_s(s), device=self.device)
        y = torch.full((B,), NULL_LABEL, device=self.device, dtype=torch.long) if y is None else y
        return tap_blocks(self.net.blocks, blocks, lambda: self.net(z, t, y), self._post)

    @torch.no_grad()
    def predict(self, z, t, y=None):
        y = torch.full((z.shape[0],), NULL_LABEL, device=self.device, dtype=torch.long) if y is None else y
        return self.net(z, torch.full((z.shape[0],), float(t), device=self.device), y)

    @torch.no_grad()
    def sample_grid(self, classes, cfg, seed=0):
        self.den.cfg_scale = cfg
        torch.manual_seed(seed)
        x = self.den.generate(torch.tensor(classes, device=self.device))
        return ((x.clamp(-1, 1) + 1) * 127.5).round().to(torch.uint8)

    def close(self):
        del self.den, self.net
        torch.cuda.empty_cache()


# ----------------------------------------------------------------------------- ViT encoders
GROUP = {"mae": "masked", "mocov3": "joint_embedding", "dino": "joint_embedding", "ibot": "joint_embedding",
         "deit3": "supervised", "dinov2": "external_data"}


class EncoderSource:
    kind = "image"

    def __init__(self, name, device="cuda", native=False):
        """native=True: run at the encoder's training resolution 224 px with its own pos_embed (14x14 tokens for
        patch 16; DINOv2/14 is always at 224 -> 16x16) -- the protocol's side check of the 256 px interpolation."""
        import timm
        from timm.layers import resample_abs_pos_embed
        import s0c_encoders as E
        sp = E.SPECS[name]
        rec = step0_record(f"enc_{name}.json")
        if "timm" in sp:
            from huggingface_hub import hf_hub_download
            from safetensors.torch import load_file
            p = Path(hf_hub_download(f"timm/{sp['timm']}", "model.safetensors", local_dir=str(CKPT / name)))
            self.ckpt = verify(p, rec, name)
            sd = load_file(str(p))
        else:
            p = CKPT / f"{name}.pth"
            if not p.exists():
                subprocess.run(["curl", "-sSfL", "--retry", "10", "-o", str(p), sp["url"]], check=True)
            self.ckpt = verify(p, rec, name)
            ck, _ = E.torch_load_weights_only(p)
            sd = ck[sp["key"]] if sp["key"] else ck
            if "teacher" in sp:  # teacher / momentum encoder (step 0c, user decision 2026-11-20 for MoCo v3)
                sd = (E.mm_rename if sp.get("mm") else E.strip)(sd, sp["teacher"])
            del ck
        sd = {k: v for k, v in sd.items() if not k.startswith(("head", "masked_embed", "mask_token", "decoder"))}
        self.px = 224 if ("patch14" in sp["arch"] or native) else 256
        m = timm.create_model(sp["arch"], pretrained=False, num_classes=0, img_size=self.px)
        no_embed_class = bool(getattr(m, "no_embed_class", False))
        if not (native and "patch14" not in sp["arch"]):
            sd["pos_embed"] = resample_abs_pos_embed(sd["pos_embed"], new_size=(16, 16),
                                                     num_prefix_tokens=0 if no_embed_class else m.num_prefix_tokens)
        m.load_state_dict(sd, strict=True)
        self.grid = self.px // (14 if "patch14" in sp["arch"] else 16)
        self.m = m.to(device).eval()
        self.path, self.device, self.name = p, device, name
        self.group = GROUP[name.split("_")[0]]
        self.prefix = m.num_prefix_tokens
        self.n_blocks, self.dim = len(m.blocks), m.embed_dim

    def _in(self, img_u8):
        x = torch.as_tensor(np.asarray(img_u8)).to(self.device).permute(0, 3, 1, 2).float() / 255.0
        if self.px != 256:
            x = F.interpolate(x, size=(self.px, self.px), mode="bicubic", align_corners=False, antialias=True)
        return (x - IMNET_MEAN.to(self.device)) / IMNET_STD.to(self.device)

    @torch.no_grad()
    def tokens(self, img_u8, blocks, with_cls=False):
        x = self._in(img_u8)
        outs = tap_blocks(self.m.blocks, blocks, lambda: self.m.forward_features(x))
        patches = [o[:, self.prefix:] for o in outs]
        assert patches[0].shape[1] == self.grid ** 2, patches[0].shape
        if with_cls:
            return patches, [o[:, 0] for o in outs]
        return patches

    def close(self):
        del self.m
        torch.cuda.empty_cache()


# ----------------------------------------------------------------------------- lower baselines
def patchify(x, p):
    B, C, H, W = x.shape
    return x.reshape(B, C, H // p, p, W // p, p).permute(0, 2, 4, 1, 3, 5).reshape(B, (H // p) * (W // p), C * p * p)


class PatchBaseline:
    """Protocol lower baselines (one 'layer'): 'latent' = noisy SD-VAE latent patches (2x2x4 = 16 dims, SiT input),
    'pixel' = noisy pixel patches in [-1, 1] (16x16x3 = 768, JiT input), 'pixel_clean' = clean ImageNet-normalised
    pixel patches (encoder input).  Same noise bank and s as the models they bound."""

    def __init__(self, which, device="cuda"):
        self.which, self.device = which, device
        self.kind = {"latent": "latent", "pixel": "pixel", "pixel_clean": "image"}[which]
        self.name, self.group, self.n_blocks = f"base_{which}", "baseline", 1
        self.dim = 16 if which == "latent" else 768
        self.ckpt = None

    @torch.no_grad()
    def tokens(self, a, b=None, s=None, blocks=None, with_cls=False):
        if self.kind == "image":  # tokens(img_u8, blocks, with_cls)
            with_cls = s if isinstance(s, bool) else with_cls
            x = torch.as_tensor(np.asarray(a)).to(self.device).permute(0, 3, 1, 2).float() / 255.0
            out = [patchify((x - IMNET_MEAN.to(self.device)) / IMNET_STD.to(self.device), 16)]
            return (out, None) if with_cls else out
        x = (1 - s) * a + s * b
        return [patchify(x, 2 if self.kind == "latent" else 16)]

    def close(self):
        pass


def no_tf32():
    torch.backends.cuda.matmul.allow_tf32 = False
    torch.backends.cudnn.allow_tf32 = False
    torch.set_float32_matmul_precision("highest")