| import copy, sys |
| from pathlib import Path |
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
| CORE = Path(__file__).resolve().parents[1] / 'vendor/jepa-anything-core/src' |
| sys.path.insert(0, str(CORE)) |
| from jepa_anything_core import OrthogonalFactorProjection, UnconstrainedMultiHeadPredictor, MLPPredictor |
| (D, K, R) = (256, 4, 64) |
|
|
| class Overlength(ValueError): |
| pass |
|
|
| class DomainEncoder(nn.Module): |
|
|
| def __init__(self, base_path, max_length=16384): |
| super().__init__() |
| from transformers import AutoModel, AutoTokenizer |
| from peft import LoraConfig, get_peft_model, TaskType |
| self.tokenizer = AutoTokenizer.from_pretrained(base_path, local_files_only=True) |
| self.tokenizer.pad_token = self.tokenizer.eos_token |
| self.tokenizer.padding_side = 'right' |
| self.max_length = max_length |
| base = AutoModel.from_pretrained(base_path, dtype=torch.bfloat16, local_files_only=True, attn_implementation='sdpa') |
| config = LoraConfig(task_type=TaskType.FEATURE_EXTRACTION, r=16, lora_alpha=32, lora_dropout=0.0, target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj'], inference_mode=True) |
| self.backbone = get_peft_model(base, config) |
| self.backbone.config.use_cache = False |
| self.projection = nn.Sequential(nn.Linear(base.config.hidden_size, D), nn.LayerNorm(D)) |
|
|
| def forward(self, texts): |
| batch = self.tokenizer(texts, padding=True, truncation=False, return_tensors='pt') |
| if batch['input_ids'].shape[-1] > self.max_length: |
| raise Overlength('encoder input exceeds explicit limit') |
| device = next(self.backbone.parameters()).device |
| batch = {k: v.to(device) for (k, v) in batch.items()} |
| outputs = self.backbone(**batch, return_dict=True, use_cache=False).last_hidden_state |
| mask = batch['attention_mask'].unsqueeze(-1) |
| pooled = (outputs.float() * mask).sum(1) / mask.sum(1).clamp_min(1) |
| return self.projection(pooled) |
|
|
| class ExecutionWorld(nn.Module): |
|
|
| def __init__(self, encoder, mode='opf'): |
| super().__init__() |
| self.mode = mode |
| self.online = encoder |
| if mode == 'opf': |
| self.opf = OrthogonalFactorProjection(D, K, R) |
| self.predictor = UnconstrainedMultiHeadPredictor(D, D, K, R, 512) |
| elif mode == 'multi': |
| self.opf = None |
| self.predictor = UnconstrainedMultiHeadPredictor(D, D, K, R, 640) |
| elif mode in ('standard', 'ce'): |
| self.opf = None |
| self.predictor = MLPPredictor(D, D, 640) |
| else: |
| raise ValueError(mode) |
| self.log_temperature = nn.Parameter(torch.zeros(())) |
| self.readout = nn.Sequential(nn.LayerNorm(D), nn.Linear(D, 64), nn.GELU(), nn.Linear(64, 6)) |
|
|
| def predict_latent(self, context): |
| p = self.predictor(context) |
| if self.mode == 'opf': |
| return (self.opf.compose(p), p) |
| if self.mode == 'multi': |
| return (p.flatten(-2), p) |
| return (p, p.reshape(-1, K, R)) |
|
|
| def encode(self, texts, microbatch=1): |
| encoder = self.online |
| rows = [] |
| for i in range(0, len(texts), microbatch): |
| rows.append(encoder(texts[i:i + microbatch])) |
| return torch.cat(rows, dim=0) |
|
|
| @torch.no_grad() |
| def score(self, contexts): |
| self.eval() |
| c = self.encode(contexts) |
| (z, _) = self.predict_latent(c) |
| p = F.softmax(self.readout(z)[:, :5] / self.log_temperature.exp().clamp(0.2, 5.0), -1) |
| return p |
|
|
| @torch.no_grad() |
| def details(self, contexts): |
| self.eval() |
| z = self.encode(contexts) |
| (latent, _) = self.predict_latent(z) |
| out = self.readout(latent) |
| return (F.softmax(out[:, :5] / self.log_temperature.exp().clamp(0.2, 5.0), -1), F.softplus(out[:, 5])) |
|
|
| @classmethod |
| def load(cls, path, base_path, device='cuda'): |
| from artifacts import checkpoint_manifest |
| from peft.utils.save_and_load import load_peft_weights, set_peft_model_state_dict |
| (metadata, identity) = checkpoint_manifest(path) |
| path = Path(path) |
| encoder = DomainEncoder(base_path, max_length=metadata.get('encoder_max_length', 8192)) |
| model = cls(encoder, metadata['mode']) |
| result = set_peft_model_state_dict(model.online.backbone, load_peft_weights(str(path / 'online_lora'), device='cpu'), adapter_name='default') |
| if result.unexpected_keys: |
| raise RuntimeError('Unexpected adapter keys: ' + str(result.unexpected_keys)) |
| state = torch.load(path / 'domain.pt', map_location='cpu', weights_only=True) |
| result = model.load_state_dict(state, strict=False) |
| missing = [k for k in result.missing_keys if not k.startswith('online.backbone.') and k != 'log_temperature'] |
| if result.unexpected_keys or missing: |
| raise RuntimeError('Model state mismatch: ' + str((result.unexpected_keys, missing))) |
| model.identity = identity |
| model.checkpoint_path = str(path) |
| return model.to(device).requires_grad_(False).eval() |
|
|
