| """Strict CPU loading helpers for the unwrapped LingBot rank-8 adapter. |
| |
| These helpers do not select training preprocessing or normalization. Those must |
| come from the training run before constructing a policy for closed-loop use. |
| """ |
| import re |
|
|
|
|
| def expand_fused_experts(state): |
| """Convert official [expert, out, in] weights to eager nn.Linear keys.""" |
| result = {} |
| for name, tensor in state.items(): |
| match = re.fullmatch(r"(.+\.experts)\.(gate_proj|up_proj|down_proj)", name) |
| if match: |
| if tensor.ndim != 3: |
| raise ValueError("Fused expert must have three dimensions: " + name) |
| items = [(f"{match[1]}.{i}.{match[2]}.weight", value) |
| for i, value in enumerate(tensor.unbind(0))] |
| else: |
| items = [(name, tensor)] |
| for key, value in items: |
| if key in result: |
| raise ValueError("Duplicate converted key: " + key) |
| result[key] = value |
| return result |
|
|
|
|
| def validate_adapter(state, targets, expected_weights, rank=8): |
| """Reject partial, malformed or nonfinite adapters before policy startup.""" |
| import torch |
|
|
| expected = {target + suffix for target in targets |
| for suffix in ('.lora_A.weight', '.lora_B.weight')} |
| if set(state) != expected: |
| raise ValueError("Adapter key inventory differs from target modules") |
| for target in targets: |
| a, b = (state[target + suffix] |
| for suffix in ('.lora_A.weight', '.lora_B.weight')) |
| weight = expected_weights[target + '.weight'] |
| if (a.ndim != 2 or b.ndim != 2 or a.shape[0] != rank or |
| b.shape[1] != rank or tuple(weight.shape) != (b.shape[0], a.shape[1])): |
| raise ValueError("Adapter/base shape mismatch: " + target) |
| if any(t.dtype != torch.float32 or not torch.isfinite(t).all().item() |
| for t in (a, b)): |
| raise ValueError("Adapter must contain finite FP32 values: " + target) |
|
|
|
|
| def inject_and_load_adapter(policy, config, state): |
| """Use in-place PEFT injection and verify every loaded adapter value.""" |
| import torch |
| from peft import inject_adapter_in_model |
| from peft.utils.save_and_load import set_peft_model_state_dict |
|
|
| if config.r != 8 or config.lora_alpha != 8 or config.bias != 'none': |
| raise ValueError("This profile requires rank=8, alpha=8, bias=none") |
| if config.modules_to_save or config.use_dora or config.use_rslora: |
| raise ValueError("Unsupported adapter variant") |
| validate_adapter(state, config.target_modules, policy.state_dict(), rank=config.r) |
| policy = inject_adapter_in_model(config, policy, adapter_name='default') |
| loaded = set_peft_model_state_dict(policy, state, adapter_name='default') |
| if loaded.unexpected_keys or any('lora_' in k for k in loaded.missing_keys): |
| raise ValueError("Adapter loading left missing or unexpected adapter keys") |
| actual = policy.state_dict() |
| for key, tensor in state.items(): |
| target = key.replace('.lora_A.weight', '.lora_A.default.weight').replace( |
| '.lora_B.weight', '.lora_B.default.weight') |
| if not torch.equal(actual[target].cpu(), tensor.cpu()): |
| raise ValueError("Loaded adapter differs from source: " + key) |
| policy.requires_grad_(False) |
| policy.eval() |
| return policy |
|
|
