EMC / emcdraft /target.py
mudassiruddin21's picture
Engine-based data generation and an unattended GPU driver
b80a86d verified
Raw History Blame Contribute Delete
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]
@torch.no_grad()
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")
@torch.no_grad()
def hidden(self, ids: torch.Tensor) -> torch.Tensor:
return self._forward(ids, self.mode)