Download dory/chain.py from senku21x/dory_implementation: direct link, hf CLI and curl.
- Browser
- Download file 3.11 kB
-
https://huggingface.co/senku21x/dory_implementation/resolve/main/dory/chain.py
- Command line
-
hf download hf://senku21x/dory_implementation/dory/chain.py
-
curl -L -o chain.py https://huggingface.co/senku21x/dory_implementation/resolve/main/dory/chain.py
3.11 kB
| """A chain-lens analogue for Dory (after "The Chain Lens [interim]", vgel & Douglas 2026). | |
| The published chain lens rolls a lens's top tokens out into short phrases with the model's multi-token-prediction | |
| head. Dory has no such head. Here the model itself does the roll-out: the state under study is placed at one | |
| "anchor" position at its own node, the rest of the network is run on it, and the chain tokens that follow may | |
| attend only to the anchor (from that node on) and to each other. Nothing else of the original prompt is present, | |
| so whatever the chain says about the prompt came through that one state. Decoding is contrastive against the | |
| same roll-out from the node's mean state (Li et al. 2022: among tokens within a factor of the best, pick the one | |
| whose log-probability rises most over the prior). | |
| Restriction: a node inside loop t is rolled out with exactly t loops, so the anchor never needs the input-block | |
| output of a prompt it no longer has. | |
| """ | |
| from __future__ import annotations | |
| import torch | |
| from .model import ATTN, Dory | |
| def rollout_logits(model: Dory, anchors: torch.Tensor, node: tuple, k: int, chain: torch.Tensor) -> torch.Tensor: | |
| """Next-token logits after each chain. anchors [B, d] (states at `node`), chain [B, m] token ids, m >= 1.""" | |
| assert node[0] not in ("u", "rec", "s") or node[1] == k, "roll a loop-t node out with k = t loops" | |
| B, m = chain.shape | |
| ids = torch.cat([chain[:, :1], chain], dim=1) # position 0 is the anchor (its token is a placeholder) | |
| block = torch.zeros(m + 1, dtype=torch.bool); block[0] = True | |
| ATTN.block = block | |
| def tap(name, h): | |
| if name == node: | |
| h = h.clone(); h[:, 0] = anchors.to(h.dtype) | |
| ATTN.block = None # from here on the chain can see the anchor | |
| return h | |
| try: | |
| final = model.forward(ids, n_loops=k, tap=tap) | |
| finally: | |
| ATTN.block = None | |
| return model.unembed(final[:, -1]) | |
| def chains(model: Dory, h: torch.Tensor, node: tuple, k: int, seeds: torch.Tensor, steps: int = 4, | |
| prior: torch.Tensor | None = None, alpha: float = 0.1, ban: torch.Tensor | None = None) -> torch.Tensor: | |
| """Extend each seed token by `steps` tokens. h [d]; seeds [K]; prior [d] = the mean state at `node` for | |
| contrastive decoding (None = plain greedy). Returns token ids [K, 1 + steps].""" | |
| K = seeds.shape[0] | |
| chain = seeds[:, None].clone() | |
| A = h[None].expand(K, -1) | |
| for _ in range(steps): | |
| lp = torch.log_softmax(rollout_logits(model, A, node, k, chain), -1) | |
| if ban is not None: | |
| lp = lp.masked_fill(ban, -1e9) | |
| if prior is None: | |
| nxt = lp.argmax(-1) | |
| else: | |
| lq = torch.log_softmax(rollout_logits(model, prior[None].expand(K, -1), node, k, chain), -1) | |
| ok = lp >= lp.max(-1, keepdim=True).values + torch.log(torch.tensor(alpha)) | |
| nxt = (lp - lq).masked_fill(~ok, -1e9).argmax(-1) | |
| chain = torch.cat([chain, nxt[:, None]], dim=1) | |
| return chain | |