"""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)] # Group by existing trace length; each atomic JSON journal owns a stable batch. 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()