changh95's picture
tt-model push rdt2-base-p150 (container)
c869f1f verified
Raw History Blame Contribute Delete
11.9 kB
# SPDX-License-Identifier: Apache-2.0
"""RDT2-FM action expert (RDT, 14 blocks, hidden 1024) and its 5-step Euler flow-matching sampler, fp32 torch.
Semantics (thu-ml/RDT2 models/rdt_runner.py, models/rdt/{model,blocks,attention,norm,pos_emb}.py @ 0797b4c6):
s = state_adaptor(state) mlp3x_silu 20 -> 1024 -> 1024 -> 1024, state (1, 1, 20) raw (not normalized)
s += state_pos_emb (1, 1, 1024) checkpoint parameter
a_0 = noise (1, 24, 20); t_0 = 0; for k in 0..4: (t accumulated in the run dtype: t += 1/5)
te_k = TimestepEmbedder(t_k) [cos | sin](t * 10000^(-j/128)), j < 128 -> Linear 256->1024, SiLU, Linear
c_k = concat(te_k, s) (1, 2048) -- "t" of RDTBlock / FinalLayer
x = concat(act_adaptor(a_k), register_tokens) + x_pos_emb (1, 28, 1024)
block i (adaLN = Linear(SiLU(c_k)) -> 9 x 1024: shift/scale/gate for attn, cross, mlp):
x += g_a * SelfAttn(mod(rms(x))) q,k RMS-normed per head (128), 8 q / 4 kv heads, no RoPE, no mask
x += g_c * CrossAttn(mod(rms(x)), K_i, V_i, mask) q RMS-normed; K/V = Qwen layer-i cache AS IS
(post-mRoPE K, no re-projection, no norm_k), mask = keys
x += g_m * SwiGLU(mod(rms(x))) w2(silu(w1 x) * w3 x), 1024 -> 2816 -> 1024
v_k = FinalLayer(x, c_k)[:, :24] rms + adaLN(2) + Mlp 1024 -> 4096 (SiLU) -> 20; register rows dropped
a_{k+1} = v_k * 0.2 + a_k
action = (a_5 - offset) / scale UMI LinearNormalizer['action'] (gripper channels 9 / 19 -> metres)
Host/device split used by the port (``precompute_*`` below, proven equal to the direct form by the host tests):
ada_i(k) = W_i[:, :1024] @ silu(te_k) + W_i[:, 1024:] @ silu(s) + b_i (SiLU is element-wise on the concat)
= T_i[k] (input-independent, 5 x 14 x 9216, precomputed once) + S_i (per request, constant over steps)
"""
from __future__ import annotations
import math
from typing import Dict, List, Optional
import torch
import torch.nn.functional as F
from .config import CONFIG
from .ops import modulate, repeat_kv_heads, rms_norm
E = CONFIG.expert
def timestep_frequencies(t: torch.Tensor, dim: int = E.freq_dim, max_period: float = E.max_period) -> torch.Tensor:
half = dim // 2
freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half)
args = t[:, None].float() * freqs[None]
return torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
def euler_timesteps(num_steps: int = E.num_steps, dtype: torch.dtype = torch.float32) -> List[torch.Tensor]:
"""t_k exactly as the official loop produces them (``timestep += 1/num_steps`` in the run dtype)."""
t = torch.tensor([0.0], dtype=dtype)
step = 1.0 / num_steps
out = []
for _ in range(num_steps):
out.append(t.clone())
t += step
return out
class ActionExpert:
def __init__(self, sd: Dict[str, torch.Tensor], dtype: torch.dtype = torch.float32):
self.dtype = dtype
self.w = {k: v.to(dtype) for k, v in sd.items()}
# ---------------------------------------------------------------- conditioning (host-side in the port)
def mlp3(self, prefix: str, x: torch.Tensor) -> torch.Tensor:
w = self.w
x = F.linear(x, w[prefix + "0.weight"], w[prefix + "0.bias"])
x = F.linear(F.silu(x), w[prefix + "2.weight"], w[prefix + "2.bias"])
return F.linear(F.silu(x), w[prefix + "4.weight"], w[prefix + "4.bias"])
def state_cond(self, state: torch.Tensor) -> torch.Tensor:
"""state (20,) or (1, 1, 20) -> s (1, 1024) = state_adaptor(state) + state_pos_emb."""
s = self.mlp3("state_adaptor.", state.reshape(1, 1, -1).to(self.dtype))
return (s + self.w["model.state_pos_emb"]).reshape(1, E.hidden)
def time_emb(self, t: torch.Tensor) -> torch.Tensor:
w = self.w
f = timestep_frequencies(t).to(self.dtype)
h = F.linear(f, w["model.t_embedder.mlp.0.weight"], w["model.t_embedder.mlp.0.bias"])
return F.linear(F.silu(h), w["model.t_embedder.mlp.2.weight"], w["model.t_embedder.mlp.2.bias"])
def ada(self, c: torch.Tensor):
"""Direct form: per-block (1, 9216) and final (1, 2048) modulation from c (1, 2048)."""
w = self.w
sc = F.silu(c)
blocks = [F.linear(sc, w[f"model.blocks.{i}.adaLN_modulation.1.weight"], w[f"model.blocks.{i}.adaLN_modulation.1.bias"])
for i in range(E.depth)]
final = F.linear(sc, w["model.final_layer.adaLN_modulation.1.weight"], w["model.final_layer.adaLN_modulation.1.bias"])
return blocks, final
def precompute_time_part(self, ts: List[torch.Tensor]):
"""Input-independent half: per step k, block i -> W_i[:, :1024] silu(te_k) + b_i (bias folded here)."""
w = self.w
H = E.hidden
out = []
for t in ts:
st = F.silu(self.time_emb(t))
blocks = [F.linear(st, w[f"model.blocks.{i}.adaLN_modulation.1.weight"][:, :H],
w[f"model.blocks.{i}.adaLN_modulation.1.bias"]) for i in range(E.depth)]
final = F.linear(st, w["model.final_layer.adaLN_modulation.1.weight"][:, :H],
w["model.final_layer.adaLN_modulation.1.bias"])
out.append((blocks, final))
return out
def precompute_state_part(self, s: torch.Tensor):
"""Per-request half (constant over the 5 steps): W_i[:, 1024:] silu(s)."""
w = self.w
H = E.hidden
ss = F.silu(s)
blocks = [F.linear(ss, w[f"model.blocks.{i}.adaLN_modulation.1.weight"][:, H:]) for i in range(E.depth)]
final = F.linear(ss, w["model.final_layer.adaLN_modulation.1.weight"][:, H:])
return blocks, final
# ---------------------------------------------------------------- network (device-side in the port)
def _attn_qk(self, p: str, x: torch.Tensor):
w = self.w
B, N, _ = x.shape
q = F.linear(x, w[p + "wq.weight"]).view(B, N, E.heads, E.head_dim)
return rms_norm(q, w[p + "norm_q.weight"], E.norm_eps)
def self_attn(self, i: int, x: torch.Tensor) -> torch.Tensor:
w = self.w
p = f"model.blocks.{i}.attn."
B, N, _ = x.shape
q = self._attn_qk(p, x)
kv = F.linear(x, w[p + "wkv.weight"]).view(B, N, E.kv_heads, E.head_dim, 2) # k/v interleaved in the last dim
k, v = kv.unbind(-1)
k = rms_norm(k, w[p + "norm_k.weight"], E.norm_eps)
rep = E.heads // E.kv_heads
k, v = repeat_kv_heads(k, rep, 2), repeat_kv_heads(v, rep, 2)
o = F.scaled_dot_product_attention(q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2),
scale=1.0 / math.sqrt(E.head_dim))
return F.linear(o.transpose(1, 2).reshape(B, N, -1), w[p + "wo.weight"])
def cross_attn(self, i: int, x: torch.Tensor, K: torch.Tensor, V: torch.Tensor,
mask: Optional[torch.Tensor]) -> torch.Tensor:
"""K, V: (1, 4, L, 128) Qwen cache of layer i; mask: (1, L) bool (True = attend) or None."""
w = self.w
p = f"model.blocks.{i}.cross_attn."
B, N, _ = x.shape
q = self._attn_qk(p, x).transpose(1, 2) # (1, 8, 28, 128)
rep = E.heads // E.kv_heads
k, v = repeat_kv_heads(K.to(self.dtype), rep, 1), repeat_kv_heads(V.to(self.dtype), rep, 1)
m = None if mask is None else mask.reshape(B, 1, 1, -1).expand(-1, -1, N, -1)
o = F.scaled_dot_product_attention(q, k, v, attn_mask=m, scale=1.0 / math.sqrt(E.head_dim))
return F.linear(o.transpose(1, 2).reshape(B, N, -1), w[p + "wo.weight"])
def ffn(self, i: int, x: torch.Tensor) -> torch.Tensor:
w = self.w
p = f"model.blocks.{i}.ffn."
return F.linear(F.silu(F.linear(x, w[p + "w1.weight"])) * F.linear(x, w[p + "w3.weight"]), w[p + "w2.weight"])
def block(self, i: int, x: torch.Tensor, ada: torch.Tensor, K, V, mask) -> torch.Tensor:
w = self.w
p = f"model.blocks.{i}."
sa, ca, ga, sc, cc, gc, sm, cm, gm = ada.chunk(9, dim=1)
h = x + ga.unsqueeze(1) * self.self_attn(i, modulate(rms_norm(x, w[p + "attn_norm.weight"], E.norm_eps), sa, ca))
h = h + gc.unsqueeze(1) * self.cross_attn(
i, modulate(rms_norm(h, w[p + "cross_norm.weight"], E.norm_eps), sc, cc), K, V, mask)
return h + gm.unsqueeze(1) * self.ffn(i, modulate(rms_norm(h, w[p + "ffn_norm.weight"], E.norm_eps), sm, cm))
def final(self, x: torch.Tensor, ada_final: torch.Tensor) -> torch.Tensor:
w = self.w
shift, scale = ada_final.chunk(2, dim=1)
x = modulate(rms_norm(x, w["model.final_layer.ffn_norm.weight"], E.norm_eps), shift, scale)
x = F.silu(F.linear(x, w["model.final_layer.ffn.fc1.weight"], w["model.final_layer.ffn.fc1.bias"]))
return F.linear(x, w["model.final_layer.ffn.fc2.weight"], w["model.final_layer.ffn.fc2.bias"])
def velocity(self, a: torch.Tensor, ada_blocks, ada_final, K, V, mask,
taps: Optional[Dict[str, torch.Tensor]] = None, step: int = 0) -> torch.Tensor:
"""One RDT forward. a: (1, 24, 20) noisy action; K/V: (14, 1, 4, L, 128)."""
w = self.w
x0 = self.mlp3("act_adaptor.", a.to(self.dtype))
x = torch.cat([x0, w["model.register_tokens"]], dim=1) + w["model.x_pos_emb"]
if taps is not None:
taps[f"exp.step{step}.act_emb"] = x0
for i in range(E.depth):
x = self.block(i, x, ada_blocks[i], K[i], V[i], mask)
if taps is not None:
taps[f"exp.step{step}.block{i:02d}.out"] = x
out = self.final(x, ada_final)
if taps is not None:
taps[f"exp.step{step}.final_out"] = out
return out[:, :E.horizon]
def sample(self, noise: torch.Tensor, state: torch.Tensor, K: torch.Tensor, V: torch.Tensor,
mask: Optional[torch.Tensor], taps: Optional[Dict[str, torch.Tensor]] = None,
decomposed: bool = True, num_steps: int = E.num_steps) -> torch.Tensor:
"""``num_steps``-step Euler sampling (default 5, the official one). Returns the normalized action (1, 24, 20)."""
ts = euler_timesteps(num_steps, self.dtype)
s = self.state_cond(state)
if taps is not None:
taps["exp.state_emb"] = s
if decomposed:
tparts = self.precompute_time_part(ts)
sblocks, sfinal = self.precompute_state_part(s)
a = noise.to(self.dtype)
dt = 1.0 / num_steps
for k, t in enumerate(ts):
if decomposed:
tb, tf = tparts[k]
ada_blocks = [tb[i] + sblocks[i] for i in range(E.depth)]
ada_final = tf + sfinal
else:
c = torch.cat([self.time_emb(t), s], dim=1)
ada_blocks, ada_final = self.ada(c)
if taps is not None:
taps[f"exp.step{k}.t"] = t
taps[f"exp.step{k}.noisy_action"] = a
for i in range(E.depth):
taps[f"exp.step{k}.block{i:02d}.ada"] = ada_blocks[i]
v = self.velocity(a, ada_blocks, ada_final, K, V, mask, taps, k)
if taps is not None:
taps[f"exp.step{k}.velocity"] = v
a = v * dt + a
return a
def unnormalize_action(x: torch.Tensor, norm: Dict[str, torch.Tensor]) -> torch.Tensor:
return (x.float() - norm["offset"]) / norm["scale"]
def rescale_gripper_width(action: torch.Tensor) -> torch.Tensor:
"""README / deploy post-step (NOT part of RDTInferencer.step): gripper width [0, 0.088] -> [0, 0.1] m."""
out = action.clone()
for r in range(2):
out[..., r * 10 + 9] = out[..., r * 10 + 9] / 0.088 * 0.1
return out