| """Three resumable native-attention studies on a fixed 100-example cohort. |
| |
| prepare exports existing data, extract extends common traces, and analyze fits |
| native r and measures token sweeps, query drift, and theoretical rank diagnostics. |
| All outputs have independent names; legacy experiment artifacts are read-only. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import ast |
| import contextlib |
| import hashlib |
| import json |
| import os |
| from pathlib import Path |
| import subprocess |
| import sys |
| import time |
|
|
| import numpy as np |
| import torch |
| import yaml |
|
|
| from prefix.attention_bounds import diameter, evaluate |
| from prefix.native_attention import NativeHead, LENGTHS, conditions, fit_shift, query_sets, subspace, perturbations |
| from prefix.runner import tee_stdout, write_json_atomic |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| COHORT = ROOT / 'data/section4_native_cohort.json' |
| PREAMBLE = ( |
| 'Additional context for interpreting the request: read the complete request below before responding. ' |
| 'Keep track of the entities, actions, constraints, and qualifications explicitly stated in it. ' |
| 'The request itself follows this introductory context. Do not treat this introductory context as ' |
| 'a separate question. Base your response on the request and explain your answer in clear language. ' |
| ) |
|
|
|
|
| def digest(value): |
| return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() |
|
|
|
|
| def file_digest(path): |
| checksum = hashlib.sha256() |
| with Path(path).open('rb') as stream: |
| for block in iter(lambda: stream.read(1024 * 1024), b''): |
| checksum.update(block) |
| return checksum.hexdigest() |
|
|
|
|
| def analysis_fingerprint(source): |
| names = {'analyze', 'drift_study', 'controlled_dimensions'} |
| functions = [ast.dump(node, include_attributes=False) for node in ast.parse(source).body |
| if isinstance(node, ast.FunctionDef) and node.name in names] |
| if len(functions) != len(names): |
| raise ValueError('incomplete analysis implementation') |
| return digest(functions) |
|
|
|
|
| def resume_batch(path, identity, rows, completed): |
| batch = identity['indices'] |
| state = json.loads(path.read_text()) if path.exists() else dict(identity=identity, |
| tokens=[rows[i]['seed_generated_ids'].copy() for i in batch]) |
| pending = [i for i in batch if i not in completed] |
| tokens = [state['tokens'][batch.index(i)] for i in pending] |
| if state['identity'] != identity or (tokens and len({len(x) for x in tokens}) != 1): |
| raise ValueError('decoding checkpoint mismatch') |
| return state, pending, tokens |
|
|
|
|
| def choose_examples(lengths, count): |
| if count > len(lengths): |
| raise ValueError('requested count exceeds available examples') |
| long = sorted(i for i, length in lengths.items() if length >= 128) |
| short = sorted((i for i in lengths if i not in long), key=lambda i: (-lengths[i], i)) |
| return long[:count] + short[:max(0, count - len(long))] |
|
|
|
|
| def expanded_input(tokenizer, request, minimum=128): |
| added = '' |
| for _ in range(16): |
| ids = tokenizer.apply_chat_template([{'role':'user', 'content':added + request}], |
| tokenize=True, add_generation_prompt=True, enable_thinking=False, return_dict=False) |
| if len(ids) >= minimum: |
| return ids, added |
| added += PREAMBLE + '\n\n' |
| raise ValueError('context expansion failed to reach requested input length') |
|
|
|
|
| def save_tensor(path, payload): |
| temporary = path.with_suffix('.tmp') |
| torch.save(payload, temporary) |
| os.replace(temporary, path) |
|
|
|
|
| def load_tensor(path): |
| return torch.load(path, weights_only=True, mmap=True) |
|
|
|
|
| def validate_result(row, identity, queries): |
| if (row.get('identity') != identity or not row.get('complete') or row.get('queries') != queries |
| or len(row.get('errors', [])) != len(queries)): |
| raise ValueError('result identity or query coverage mismatch') |
| if not all(np.isfinite(value) and value >= 0 for value in row['errors']): |
| raise ValueError('invalid measured error') |
|
|
|
|
| def prepare(config): |
| from transformers import AutoTokenizer |
| torch.serialization.add_safe_globals([torch.torch_version.TorchVersion]) |
| records = json.loads((ROOT / 'data/section4_harmbench.json').read_text()) |
| lengths = {i: load_tensor(ROOT / f'checkpoints/section4_long_activations_{i:03d}.pt')['base_length'] |
| for i in range(len(records))} |
| indices = choose_examples(lengths, config['sample_count']) |
| tokenizer = AutoTokenizer.from_pretrained(config['model'], revision=config['revision'], local_files_only=True) |
| old_meta = json.loads((ROOT / 'results/section4_long_manifest.json').read_text()) |
| cohort = dict(version=1, config=config, examples=[], source_manifest=old_meta, |
| selection='all original inputs >=128 tokens, then longest short inputs with explicit context expansion') |
| weights = load_tensor(ROOT / 'checkpoints/section4_weights.pt') |
| selected_weights = {f'{config["layer"]}_{head}': weights[f'{config["layer"]}_{head}'] for head in config['heads']} |
| weight_path = ROOT / 'checkpoints/section4_native_weights.pt' |
| if not weight_path.exists(): |
| save_tensor(weight_path, selected_weights) |
| cohort['weights_sha256'] = file_digest(weight_path) |
| for index in indices: |
| original = load_tensor(ROOT / f'checkpoints/section4_activations_{index:03d}.pt') |
| long = load_tensor(ROOT / f'checkpoints/section4_long_activations_{index:03d}.pt') |
| record = records[index] |
| n = lengths[index] |
| added = '' |
| base_ids = original['tokens'][:n] |
| if n < config['minimum_input_tokens']: |
| context = record.get('ContextString', '').strip() |
| request = f'{context}\n\n{record["Behavior"]}' if context else record['Behavior'] |
| base_ids, added = expanded_input(tokenizer, request, config['minimum_input_tokens']) |
| prompt_ids = old_meta['prompt_ids'] |
| row = dict(index=index, behavior_id=record['BehaviorID'], original_input_tokens=n, |
| input_tokens=len(base_ids), expanded=bool(added), added_context=added, |
| functional_category=record.get('FunctionalCategory'), base_ids=base_ids, |
| prompt_ids=prompt_ids, seed_generated_ids=[] if added else long['generated_ids']) |
| row['fingerprint'] = digest(row) |
| path = ROOT / f'checkpoints/section4_native_seed_{index:03d}.pt' |
| if path.exists(): |
| if load_tensor(path)['metadata'] != row: |
| raise ValueError(f'seed mismatch: {path}') |
| else: |
| payload = {'metadata':row, 'prompt_hidden':None if added else long['layers'][config['layer']][n:n+128].clone()} |
| save_tensor(path, payload) |
| cohort['examples'].append(row) |
| print(f'prepared {index}: input {n} -> {len(base_ids)}, expanded={bool(added)}', flush=True) |
| write_json_atomic(ROOT / 'checkpoints/section4_native_prepare.json', dict(config=config, examples=cohort['examples'])) |
| cohort['fingerprint'] = digest(cohort) |
| if COHORT.exists() and json.loads(COHORT.read_text()) != cohort: |
| raise ValueError('cohort changed; refuse to reuse existing native artifacts') |
| write_json_atomic(COHORT, cohort) |
| print(f'cohort saved: {len(indices)}, expanded={sum(r["expanded"] for r in cohort["examples"])}', flush=True) |
|
|
|
|
| def extract(config, cohort, indices, batch_size, device): |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| rows = {row['index']:row for row in cohort['examples']} |
| done = [] |
| for i in indices: |
| path = ROOT / f'checkpoints/section4_native_activations_{i:03d}.pt' |
| if path.exists(): |
| if load_tensor(path)['fingerprint'] != rows[i]['fingerprint']: |
| raise ValueError('activation identity mismatch') |
| done.append(i) |
| if len(done) == len(indices): |
| print(f'extract: all {len(indices)} examples cached', flush=True) |
| return |
| tokenizer = AutoTokenizer.from_pretrained(config['model'], revision=config['revision'], local_files_only=True) |
| model = AutoModelForCausalLM.from_pretrained(config['model'], revision=config['revision'], local_files_only=True, |
| dtype=torch.bfloat16, attn_implementation='sdpa').to(device).eval() |
| stop_ids = model.generation_config.eos_token_id |
| stop_ids = [stop_ids] if isinstance(stop_ids, int) else list(stop_ids or []) |
|
|
| def padded(sequences): |
| width = max(map(len, sequences)) |
| ids = torch.full((len(sequences), width), tokenizer.pad_token_id, device=device, dtype=torch.long) |
| mask = torch.zeros_like(ids) |
| for j, seq in enumerate(sequences): |
| ids[j, -len(seq):] = torch.tensor(seq, device=device) |
| mask[j, -len(seq):] = 1 |
| return ids, mask, (mask.cumsum(-1) - 1).clamp_min(0) |
|
|
| def capture(sequences): |
| captured = [] |
| def hook(_module, args, kwargs): |
| captured.append(kwargs.get('hidden_states', args[0] if args else None).detach().cpu()) |
| handle = model.model.layers[config['layer']].self_attn.register_forward_pre_hook(hook, with_kwargs=True) |
| try: |
| ids, mask, positions = padded(sequences) |
| model(ids, attention_mask=mask, position_ids=positions, use_cache=False, logits_to_keep=1) |
| finally: |
| handle.remove() |
| return [captured[0][j, -len(seq):].clone() for j, seq in enumerate(sequences)] |
|
|
| |
| with torch.inference_mode(): |
| for initial_count in sorted({len(rows[i]['seed_generated_ids']) for i in indices}): |
| group = [i for i in indices if len(rows[i]['seed_generated_ids']) == initial_count] |
| for start in range(0, len(group), batch_size): |
| batch = group[start:start+batch_size] |
| if all(i in done for i in batch): |
| continue |
| t = time.monotonic() |
| identity = dict(cohort=cohort['fingerprint'], indices=batch, generated=config['generated_tokens']) |
| journal = ROOT / f'checkpoints/section4_native_decode_{digest(identity)[:16]}.json' |
| state, pending, tokens_by_example = resume_batch(journal,identity,rows,set(done)) |
| prefixes = [rows[i]['base_ids'] + rows[i]['prompt_ids'][:config['generation_prompt_tokens']] for i in pending] |
| ids, mask, positions = padded([p+t for p,t in zip(prefixes,tokens_by_example)]) |
| cache = None |
| while len(tokens_by_example[0]) < config['generated_tokens']: |
| out = model(ids, attention_mask=mask, position_ids=positions, past_key_values=cache, |
| use_cache=True, logits_to_keep=1) |
| cache = out.past_key_values |
| new = out.logits[:,-1].argmax(-1) |
| for tokens, token in zip(tokens_by_example, new.tolist()): |
| tokens.append(token) |
| write_json_atomic(journal, state) |
| ids = new[:,None] |
| mask = torch.cat([mask, torch.ones((len(pending),1), device=device, dtype=mask.dtype)], -1) |
| positions = mask.sum(-1, keepdim=True) - 1 |
| del cache, ids, mask, positions |
| captures = capture([p+t for p,t in zip(prefixes,tokens_by_example)]) |
| for j,index in enumerate(pending): |
| meta = rows[index] |
| n = meta['input_tokens'] |
| seed = load_tensor(ROOT / f'checkpoints/section4_native_seed_{index:03d}.pt') |
| prompt_h = seed['prompt_hidden'] |
| if prompt_h is None: |
| prompt_h = capture([meta['base_ids'] + meta['prompt_ids']])[0][n:] |
| generation_h = captures[j] |
| hidden = torch.cat([generation_h[:n], prompt_h, |
| generation_h[n+config['generation_prompt_tokens']:]], 0) |
| tokens = tokens_by_example[j] |
| first_eos = next((k+1 for k,token in enumerate(tokens) if token in stop_ids), None) |
| payload = dict(fingerprint=meta['fingerprint'], index=index, hidden=hidden, |
| generated_ids=tokens, first_eos=first_eos, stop_ids=stop_ids, |
| generation_policy='fixed-length greedy; EOS recorded, not used to truncate', |
| library='frozen prompt states plus one common 8-token-prompt continuation') |
| save_tensor(ROOT / f'checkpoints/section4_native_activations_{index:03d}.pt', payload) |
| write_json_atomic(ROOT / f'checkpoints/section4_native_extract_{index:03d}.json', |
| dict(index=index, fingerprint=meta['fingerprint'], complete=True, |
| generated_tokens=len(tokens), first_eos=first_eos)) |
| done.append(index) |
| print(f'extract {batch}: complete in {time.monotonic()-t:.1f}s ({len(done)}/{len(indices)})', flush=True) |
|
|
|
|
| def identity_for(cohort, index, head, condition, config): |
| return dict(version=1, cohort=cohort['fingerprint'], index=index, head=head, condition=condition, |
| layer=config['layer'], fit_steps=config['max_fit_steps'], fit_tolerance=config['fit_tolerance'], |
| native_implementation_sha256=file_digest(ROOT / 'src/prefix/native_attention.py'), |
| analysis_sha256=analysis_fingerprint(Path(__file__).read_text())) |
|
|
|
|
| def drift_study(study, c, r, identity, path, config): |
| state = json.loads(path.read_text()) if path.exists() else dict(identity=identity, units={}) |
| if state['identity'] != identity: |
| raise ValueError('query-drift manifest mismatch') |
| m,b,g = c['m'],c['b'],c['g'] |
| directions, z = study.theoretical_directions(m,b,g) |
| basis, rank = subspace(directions, config['rank_rtol']) |
| selected = list(range(study.n-b,study.n)) + list(range(study.n+study.prompt_slots,study.n+study.prompt_slots+g)) |
| prompt = list(range(study.n,study.n+m)) |
| shared = [i for i in list(range(study.n)) + list(range(study.n+study.prompt_slots,len(study.h))) if i not in selected] |
| k,v = study.k.cpu().numpy(),study.v.cpu().numpy() |
| q0 = study.q[-1] |
| dk = (study.w['wk']@r).cpu().numpy() |
| dv = (study.w['wv']@r).cpu().numpy() |
| base_d = diameter(v[shared+selected+prompt]) |
| for scale in config['drift_scales']: |
| changes = perturbations(basis, rank, float(q0.norm()) * scale, config['seed'] + identity['index'] + identity['head']) |
| for name,change in changes.items(): |
| key = f'{name}_{scale:g}' |
| if key in state['units']: |
| continue |
| raw = (q0 + change)[None] |
| qs = [len(study.h)-1] |
| native = float((study.outputs(m,b,g,qs,r,'steer',raw) - study.outputs(m,b,g,qs,None,'prompt',raw)).norm()) |
| linear = evaluate(k,v,q0.cpu().numpy(),raw[0].cpu().numpy(),selected,prompt,shared,dk,dv, |
| original_diameter=base_d,anchor=study.n-1) |
| state['units'][key] = dict(direction=name, scale=scale, query_change_norm=float(change.norm()), |
| rho=float((basis[:rank]@change).norm()), native_error=native, |
| linear_error=linear['error'], linear_residual_aware_bound=linear['bound_certified'], |
| linear_reference_mismatch=linear['beta'], diagnostic_dimension=study.k.shape[1]-rank) |
| write_json_atomic(path, state) |
| state['complete'] = True |
| write_json_atomic(path, state) |
| return state |
|
|
|
|
| def controlled_dimensions(study, config): |
| directions,_ = study.theoretical_directions(1,1,0) |
| basis,rank = subspace(directions,config['rank_rtol']) |
| rows = [] |
| for count in LENGTHS: |
| redundant = torch.cat([directions, directions[:1].repeat(count-1,1)]) |
| independent = torch.cat([directions, basis[rank:rank+count-1]]) |
| for name,matrix in [('redundant',redundant),('independent',independent)]: |
| rows.append(dict(count=count,control=name,dimension=study.k.shape[1]-subspace(matrix,config['rank_rtol'])[1])) |
| return rows |
|
|
|
|
| def analyze(config, cohort, indices, device): |
| weights = load_tensor(ROOT / 'checkpoints/section4_native_weights.pt') |
| metadata = {r['index']:r for r in cohort['examples']} |
| for index in indices: |
| payload = load_tensor(ROOT / f'checkpoints/section4_native_activations_{index:03d}.pt') |
| meta = metadata[index] |
| if payload['fingerprint'] != meta['fingerprint']: |
| raise ValueError('wrong activation identity') |
| for head in config['heads']: |
| w = {k:v.to(device=device,dtype=torch.float64) if torch.is_tensor(v) else v |
| for k,v in weights[f'{config["layer"]}_{head}'].items()} |
| study = NativeHead(payload['hidden'].to(device=device,dtype=torch.float64),w,meta['input_tokens'], |
| config['prompt_slots'],config['generated_tokens']) |
| controls = controlled_dimensions(study,config) |
| for c in conditions(): |
| start = time.monotonic() |
| m,b,g = c['m'],c['b'],c['g'] |
| identity = identity_for(cohort,index,head,c,config) |
| name = f'{index:03d}_h{head:02d}_{c["id"]}' |
| queries = query_sets(study.n,study.prompt_slots,study.generated,b,g) |
| path = ROOT / f'results/section4_native_{name}.json' |
| if path.exists(): |
| validate_result(json.loads(path.read_text()),identity,queries['all']) |
| print(f'analyze {name}: cached', flush=True) |
| continue |
| fit_path = ROOT / f'checkpoints/section4_native_fit_{name}.json' |
| fitted = fit_shift(study,m,b,g,fit_path,identity,config['max_fit_steps'],config['fit_tolerance']) |
| r = torch.tensor(fitted['r'],device=device,dtype=torch.float64) |
| with torch.no_grad(): |
| errors = [] |
| for start_q in range(0,len(queries['all']),128): |
| q = queries['all'][start_q:start_q+128] |
| delta = study.outputs(m,b,g,q,r,'steer') - study.outputs(m,b,g,q,None,'prompt') |
| errors.extend(delta.norm(dim=-1).cpu().tolist()) |
| directions,z = study.theoretical_directions(m,b,g) |
| _,rank = subspace(directions,config['rank_rtol']) |
| singular = torch.linalg.svdvals(directions) |
| result = dict(identity=identity, complete=True, queries=queries['all'], errors=errors, |
| query_sets=queries, fit={k:v for k,v in fitted.items() if k not in ('r','shift')}, |
| diagnostic_dimension=study.k.shape[1]-rank, singular_values=singular.cpu().tolist(), |
| controlled_dimensions=controls, first_eos=payload['first_eos'], expanded=meta['expanded']) |
| if (m,b,g) in [(1,1,0),(4,1,0),(4,4,0),(4,1,3)]: |
| drift_study(study,c,r,identity,ROOT/f'results/section4_native_drift_{name}.json',config) |
| write_json_atomic(path,result) |
| print(f'analyze {name}: {len(errors)} queries, fit={fitted["final_error"]:.3g}, ' |
| f'steps={fitted["steps"]}, dim={result["diagnostic_dimension"]}, ' |
| f'{time.monotonic()-start:.2f}s',flush=True) |
|
|
|
|
| def run_workers(args, indices): |
| """Overlap durable checkpoint I/O on disjoint examples within one GPU job.""" |
| count = min(args.workers, len(indices)) |
| processes = [] |
| try: |
| for shard in range(count): |
| command = [sys.executable, '-u', str(Path(__file__).resolve()), 'analyze', |
| '--config', str(args.config), '--device', args.device, |
| '--shards', str(count), '--shard', str(shard), '--indices', *map(str,indices)] |
| processes.append(subprocess.Popen(command)) |
| for process in processes: |
| code = process.wait() |
| if code: |
| raise subprocess.CalledProcessError(code, 'native analysis worker') |
| finally: |
| pending = [process for process in processes if process.poll() is None] |
| for process in pending: |
| process.terminate() |
| for process in pending: |
| try: |
| process.wait(timeout=15) |
| except subprocess.TimeoutExpired: |
| process.kill() |
| process.wait() |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('phase',choices=['prepare','extract','analyze']) |
| parser.add_argument('--config',type=Path,default=ROOT/'configs/section4_native.yaml') |
| parser.add_argument('--indices',type=int,nargs='+') |
| parser.add_argument('--batch-size',type=int) |
| parser.add_argument('--device',default='cuda') |
| parser.add_argument('--shard',type=int,default=0) |
| parser.add_argument('--shards',type=int,default=1) |
| parser.add_argument('--workers',type=int,default=4) |
| args = parser.parse_args() |
| config = yaml.safe_load(args.config.read_text()) |
| torch.set_num_threads(1 if args.shards > 1 else 2) |
| torch.backends.cuda.matmul.allow_tf32 = False |
| log = ROOT / f'logs/section4_native_{args.phase}_{args.shard}.log' |
| with tee_stdout(log), contextlib.redirect_stderr(sys.stdout): |
| if args.phase == 'prepare': |
| prepare(config) |
| else: |
| cohort = json.loads(COHORT.read_text()) |
| if cohort['config'] != config: |
| raise ValueError('config differs from prepared cohort') |
| indices = args.indices or [r['index'] for r in cohort['examples']] |
| if not set(indices) <= {r['index'] for r in cohort['examples']}: |
| raise ValueError('requested indices outside prepared cohort') |
| if not 0 <= args.shard < args.shards: |
| raise ValueError('invalid shard') |
| indices = indices[args.shard::args.shards] |
| if args.phase == 'extract': |
| extract(config,cohort,indices,args.batch_size or config['batch_size'],args.device) |
| elif args.shards == 1 and args.workers > 1 and len(indices) > 1: |
| print(f'launching {min(args.workers,len(indices))} disjoint analysis workers on {args.device}',flush=True) |
| run_workers(args,indices) |
| else: |
| analyze(config,cohort,indices,args.device) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
