| import copy |
| import hashlib |
| import json |
| import math |
| from collections import defaultdict |
| from pathlib import Path |
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
| from world import D |
| REVISION = 'world-update-v3-routed-suite-listwise-20261006-r2' |
| PUBLIC = 'per_public_test' |
| GLOBAL = 'whole_training_suite' |
|
|
| class SemanticExecutionWorld(nn.Module): |
|
|
| def __init__(self, public_world): |
| super().__init__() |
| if public_world.mode != 'opf': |
| raise ValueError('Extension requires the native OPF world') |
| self.public_world = public_world |
| self.suite_readout = copy.deepcopy(public_world.readout) |
| old = self.suite_readout[-1] |
| final = nn.Linear(old.in_features, 7, device=old.weight.device, dtype=old.weight.dtype) |
| with torch.no_grad(): |
| final.weight[:6].copy_(old.weight) |
| final.bias[:6].copy_(old.bias) |
| final.weight[6].zero_() |
| final.bias[6].zero_() |
| self.suite_readout[-1] = final |
|
|
| @torch.no_grad() |
| def score_suite(self, contexts): |
| self.eval() |
| encoded = self.public_world.encode(contexts) |
| (latent, _) = self.public_world.predict_latent(encoded) |
| output = self.suite_readout(latent) |
| probabilities = F.softmax(output[:, :5], dim=-1) |
| partial = torch.sigmoid(output[:, 6]) |
| return dict(scope=GLOBAL, full_suite_pass_probability=probabilities[:, 0], predicted_pass_fraction=partial, utility=probabilities[:, 0] + 0.25 * partial, failure_status_probabilities=probabilities, predicted_mean_normalized_seconds=F.softplus(output[:, 5]), calibration_verified=False, semantic_correctness_guaranteed=False) |
|
|
| @torch.no_grad() |
| def score_public(self, contexts): |
| return self.public_world.score(contexts) |
|
|
| @classmethod |
| def load(cls, path, base_path, device='cpu'): |
| from artifacts import checkpoint_manifest |
| from world import ExecutionWorld |
| (manifest, identity) = checkpoint_manifest(path) |
| if manifest['mode'] != 'semantic_opf': |
| raise ValueError('Unexpected model architecture') |
| world = ExecutionWorld.load(Path(path) / 'public_world', base_path, device=device) |
| if manifest['arithmetic_precision'] == 'float32': |
| world.float() |
| elif manifest['arithmetic_precision'] != 'native_bfloat16_backbone_float32_domain': |
| raise ValueError('Unknown model precision') |
| model = cls(world) |
| state = torch.load(Path(path) / 'suite_readout.pt', map_location=device, weights_only=True) |
| model.suite_readout.load_state_dict(state, strict=True) |
| model.identity = identity |
| return model.to(device).requires_grad_(False).eval() |
|
|
