File size: 5,101 Bytes
672ecc3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 | 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()
|