Download emcdraft/target.py from mudassiruddin21/EMC: direct link, hf CLI and curl.
- Browser
- Download file 3 kB
-
https://huggingface.co/datasets/mudassiruddin21/EMC/resolve/main/emcdraft/target.py
- Command line
-
hf download hf://datasets/mudassiruddin21/EMC/emcdraft/target.py
-
curl -L -o target.py https://huggingface.co/datasets/mudassiruddin21/EMC/resolve/main/emcdraft/target.py
3 kB
| """Thin wrapper around the Hugging Face implementation of the target model (offline use only). | |
| It returns the final, post-norm hidden state of every position - exactly the tensor the engine | |
| hands to the MTP head - for whole sequences in one teacher-forced forward pass. Sequences in a | |
| batch are right-padded: in a causal model, padding *after* a sequence cannot change its hidden | |
| states, so no attention mask and no position bookkeeping is needed. | |
| """ | |
| from __future__ import annotations | |
| import torch | |
| PAD_ID = 248044 | |
| def load_model(path: str): | |
| import transformers | |
| errs = [] | |
| for name in ("AutoModelForImageTextToText", "AutoModelForCausalLM"): | |
| cls = getattr(transformers, name, None) | |
| if cls is None: | |
| continue | |
| for dk in ("dtype", "torch_dtype"): | |
| try: | |
| model = cls.from_pretrained(path, device_map={"": 0}, **{dk: torch.bfloat16}) | |
| if next(model.parameters()).dtype != torch.bfloat16: | |
| raise RuntimeError("model was not loaded in bfloat16") | |
| return model.eval() | |
| except Exception as e: # noqa: BLE001 - try the next class / spelling | |
| errs.append(f"{name}({dk}): {type(e).__name__}: {str(e)[:300]}") | |
| torch.cuda.empty_cache() | |
| raise RuntimeError("could not load the target model:\n " + "\n ".join(errs)) | |
| class Target: | |
| def __init__(self, path: str): | |
| self.model = load_model(path) | |
| head = self.model.get_output_embeddings() | |
| self.W = head.weight | |
| self.E = self.model.get_input_embeddings().weight | |
| self.device = self.W.device | |
| self._cap = None | |
| head.register_forward_pre_hook(self._hook) | |
| self.mode = self._select_mode() | |
| def _hook(self, _mod, args): | |
| self._cap = args[0] | |
| def _forward(self, ids, mode): | |
| if mode == "base": | |
| return self.model.model(input_ids=ids, use_cache=False).last_hidden_state | |
| out = self.model(input_ids=ids, use_cache=False, output_hidden_states=True, logits_to_keep=1) | |
| return out.hidden_states[-1] | |
| def _select_mode(self) -> str: | |
| """Pick the call whose output equals the tensor the LM head consumes.""" | |
| ids = torch.tensor([[248045, 846, 198, 6820, 488, 513, 264, 5484, 6618, 22839, 13]] * 2, | |
| device=self.device) | |
| self.model(input_ids=ids, use_cache=False) | |
| ref = self._cap.float() | |
| for mode in ("base", "states"): | |
| try: | |
| h = self._forward(ids, mode).float() | |
| if h.shape == ref.shape and float((h - ref).abs().max()) <= 0.02 * float(ref.abs().max()): | |
| return mode | |
| except Exception: # noqa: BLE001 | |
| pass | |
| raise RuntimeError("could not obtain the final hidden states from the target model") | |
| def hidden(self, ids: torch.Tensor) -> torch.Tensor: | |
| return self._forward(ids, self.mode) | |