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