| """Frozen GUI state and action forecasts.""" |
| import copy |
| import hashlib |
| import json |
| import random |
| import sys |
| import time |
| from pathlib import Path |
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
| from common import ROOT, BASE_WORLD, atomic, digest, file_hash |
| sys.path.insert(0, str(ROOT / 'world_core/vendor/JEPA-Anything/jepa-anything-core/src')) |
| sys.path.insert(0, str(ROOT / 'world_core/src')) |
| from world import DomainEncoder, ExecutionWorld, D, K, R |
| import world, jepa_anything_core |
|
|
| class GUIEncoder(DomainEncoder): |
| """Encode public state compactly; the causal last token observes the whole state.""" |
|
|
| def forward(self, texts): |
| rendered = [] |
| for text in texts: |
| obs = json.loads(text) |
| parts = ['Task instruction: ' + obs['instruction'], 'Visible checkbox states:'] |
| for e in obs['visible_elements']: |
| parts.append(f"{e['slot']}: {e['label']} = {('checked' if e['checked'] else 'unchecked')}") |
| parts.append('Remaining actions: ' + str(obs['remaining_actions'])) |
| if 'candidate_action' in obs: |
| a = obs['candidate_action'] |
| parts.append('Candidate action: ' + ('Submit' if a['kind'] == 'submit' else f"click checkbox {a['slot']} ({obs['visible_elements'][a['slot']]['label']})")) |
| else: |
| parts.append(f"Submitted: {obs['submitted']}; terminated: {obs['terminated']}") |
| parts.append('State representation:') |
| rendered.append('\n'.join(parts)) |
| batch = self.tokenizer(rendered, padding=True, truncation=False, return_tensors='pt', add_special_tokens=False) |
| if batch['input_ids'].shape[-1] > self.max_length: |
| raise RuntimeError('GUI input exceeds frozen token limit') |
| device = next(self.backbone.parameters()).device |
| batch = {k: v.to(device) for (k, v) in batch.items()} |
| hidden = self.backbone(**batch, return_dict=True, use_cache=False).last_hidden_state |
| positions = batch['attention_mask'].sum(1) - 1 |
| pooled = hidden[torch.arange(len(texts), device=device), positions].float() |
| return self.projection(pooled) |
|
|
| class GUIWorld(ExecutionWorld): |
|
|
| def __init__(self, mode='opf'): |
| self.gui_mode = mode |
| super().__init__(GUIEncoder(BASE_WORLD, max_length=1024), mode='standard' if mode == 'standard' else 'opf') |
| self.readout = nn.Sequential(nn.LayerNorm(D), nn.Linear(D, 64), nn.GELU(), nn.Linear(64, 8)) |
| self.state_head = nn.Sequential(nn.Linear(2, 32), nn.GELU(), nn.Linear(32, 1)) |
| self.feature_encoder = nn.Sequential(nn.Linear(20, 64), nn.GELU(), nn.LayerNorm(64)) |
| self.value_head = nn.Sequential(nn.Linear(2 * D + 70, 256), nn.GELU(), nn.Linear(256, 128), nn.GELU(), nn.Linear(128, 3)) |
|
|
| def outputs(self, texts): |
| c = self.encode(texts) |
| (latent, factors) = self.predict_latent(c) |
| state = self.readout(latent) |
| features = [] |
| for text in texts: |
| obs = json.loads(text) |
| elements = obs['visible_elements'] |
| action = obs['candidate_action'] |
| bits = [float(e['checked']) for e in elements] + [0.0] * (6 - len(elements)) |
| mask = [1.0] * len(elements) + [0.0] * (6 - len(elements)) |
| ids = [0.0] * 7 |
| ids[6 if action['kind'] == 'submit' else action['slot']] = 1.0 |
| features.append(bits + mask + ids + [obs['remaining_actions'] / 8.0]) |
| visible = torch.tensor(features, device=state.device) |
| slot_input = torch.stack([visible[:, :6], visible[:, 12:18]], dim=-1) |
| state_logits = self.state_head(slot_input).squeeze(-1) + 0.1 * state[:, :6] |
| state = torch.cat([state_logits, state[:, 6:]], dim=1) |
| values = self.value_head(torch.cat([F.layer_norm(c, (D,)), F.layer_norm(latent, (D,)), torch.sigmoid(state[:, :6]), self.feature_encoder(visible)], dim=1)) |
| return (c, latent, factors, state, values) |
|
|
| @torch.no_grad() |
| def forecast(self, contexts): |
| self.eval() |
| start = time.monotonic() |
| (_, _, _, out, values) = self.outputs(contexts) |
| out = out.float() |
| values = values.float() |
| rows = [] |
| for (x, v) in zip(out, values): |
| rows.append({'checked_probabilities': torch.sigmoid(x[:6]).tolist(), 'done_probability': float(torch.sigmoid(x[6])), 'submit_success_logit': float(v[0]), 'success_probability': float(torch.sigmoid(v[0])), 'utility': float(v[1]), 'value': float(v[2]), 'seconds_prediction': float(F.softplus(x[7]) * 2)}) |
| return (rows, time.monotonic() - start) |
|
|
| @classmethod |
| def load_gui(cls, path): |
| path = Path(path) |
| metadata = json.loads((path / 'inference.json').read_text()) |
| for (name, expected) in metadata['files'].items(): |
| if hashlib.sha256((path / name).read_bytes()).hexdigest() != expected: |
| raise RuntimeError('Model file checksum mismatch: ' + name) |
| from peft.utils.save_and_load import load_peft_weights, set_peft_model_state_dict |
| model = cls(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(str(result.unexpected_keys)) |
| state = torch.load(path / 'gui_state.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.')] |
| if result.unexpected_keys or missing: |
| raise RuntimeError(str((result.unexpected_keys, missing))) |
| model.checkpoint_path = str(path) |
| return model.cuda().requires_grad_(False).eval() |
|
|
