| """Run the predeclared local experiment; no paid services. MIT.""" |
| import argparse |
| import datetime |
| import hashlib |
| import importlib.metadata |
| import json |
| import os |
| import platform |
| import time |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parent |
| os.environ['HF_HOME'] = str(ROOT/'hf-cache') |
| os.environ['HF_HUB_OFFLINE'] = '1' |
| os.environ['HF_HUB_DISABLE_IMPLICIT_TOKEN'] = '1' |
| os.environ['HF_HUB_DISABLE_TELEMETRY'] = '1' |
| os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8' |
| os.environ['OMP_NUM_THREADS'] = '1' |
| os.environ['MKL_NUM_THREADS'] = '1' |
|
|
| from study import score, SEED |
|
|
|
|
| def sha(path): |
| with path.open('rb') as stream: |
| return hashlib.file_digest(stream,'sha256').hexdigest() |
|
|
|
|
| def main(): |
| parser=argparse.ArgumentParser() |
| parser.add_argument('--smoke-only',action='store_true') |
| args=parser.parse_args() |
| print('Importing runtime libraries',flush=True) |
| import torch |
| from transformers import AutoModelForCausalLM,AutoTokenizer,GenerationConfig |
| print('Runtime imported; checking CUDA and artifact hashes',flush=True) |
|
|
| if not torch.cuda.is_available(): |
| raise RuntimeError('CUDA unavailable; no silent CPU or paid-cloud fallback') |
| if not torch.cuda.is_bf16_supported(): |
| raise RuntimeError('BF16 unsupported; protocol needs an explicit revision') |
| torch.set_num_threads(1) |
| torch.manual_seed(SEED) |
| torch.cuda.manual_seed_all(SEED) |
| torch.backends.cuda.matmul.allow_tf32=False |
| torch.backends.cudnn.allow_tf32=False |
| torch.use_deterministic_algorithms(True,warn_only=True) |
| metadata=json.loads((ROOT/'model-artifacts.json').read_text(encoding='utf-8')) |
| for file in metadata['files']: |
| path=ROOT/'model'/file['file'] |
| if sha(path)!=file['sha256']: |
| raise RuntimeError('Local artifact changed: '+file['file']) |
| corpus=json.loads((ROOT/'corpus.json').read_text(encoding='utf-8')) |
| env=dict(model=metadata['model'],revision=metadata['revision'],python=platform.python_version(), |
| os=platform.system(),torch=torch.__version__,cuda=torch.version.cuda,gpu=torch.cuda.get_device_name(0), |
| dtype='bfloat16',batch_size=1,seed=SEED,max_new_tokens=1536,do_sample=False, |
| device_map='cuda:0',cpu_threads=1, |
| corpus_sha256=sha(ROOT/'corpus.json'),protocol_sha256=sha(ROOT/'PROTOCOL.md'), |
| runner_sha256=sha(Path(__file__)),scorer_sha256=sha(ROOT/'study.py'), |
| packages={n:importlib.metadata.version(n) for n in ('transformers','huggingface-hub','tokenizers','safetensors','accelerate')}, |
| started_utc=datetime.datetime.now(datetime.timezone.utc).isoformat(),cash_expense=0, |
| determinism='Fixed seeds, greedy decoding, deterministic algorithms warn_only; exact cross-hardware identity not guaranteed') |
| tokenizer=AutoTokenizer.from_pretrained(str(ROOT/'model'),trust_remote_code=True,local_files_only=True) |
| print('Loading pinned original BF16 weights',flush=True) |
| model=AutoModelForCausalLM.from_pretrained(str(ROOT/'model'),trust_remote_code=True,local_files_only=True,dtype=torch.bfloat16,device_map='cuda:0').eval() |
| generation=GenerationConfig(do_sample=False,max_new_tokens=1536,use_cache=True, |
| bos_token_id=tokenizer.bos_token_id,eos_token_id=tokenizer.eos_token_id,pad_token_id=tokenizer.pad_token_id) |
| effective,_=model._prepare_generation_config(generation,use_model_defaults=False,do_sample=False,max_new_tokens=1536) |
| if effective.do_sample or effective.num_beams!=1 or effective.max_new_tokens!=1536: |
| raise RuntimeError('Resolved generation config differs from frozen greedy protocol') |
| env['effective_generation_config']=effective.to_dict() |
| env['use_model_defaults']=False |
| print('Resolved generation mode:',effective.get_generation_mode(),flush=True) |
|
|
| def generate(prompt,thinking,budget): |
| rendered=tokenizer.apply_chat_template([dict(role='user',content=prompt)],tokenize=False,add_generation_prompt=True,enable_thinking=thinking) |
| tokens=tokenizer(rendered,return_tensors='pt',add_special_tokens=False).to('cuda') |
| torch.cuda.synchronize();torch.cuda.reset_peak_memory_stats();start=time.perf_counter() |
| with torch.inference_mode(): |
| output=model.generate(**tokens,generation_config=generation,use_model_defaults=False,do_sample=False,max_new_tokens=budget) |
| torch.cuda.synchronize() |
| ids=output[0,tokens['input_ids'].shape[1]:].tolist() |
| text=tokenizer.decode(ids,skip_special_tokens=False) |
| eos=tokenizer.eos_token_id |
| finished=bool(ids and ids[-1]==eos) |
| |
| scored_text=tokenizer.decode(ids[:-1] if finished else ids,skip_special_tokens=False) |
| return dict(rendered_prompt=rendered,input_ids=tokens['input_ids'][0].tolist(),output_ids=ids, |
| output=text,scoring_text=scored_text,input_tokens=tokens['input_ids'].shape[1],output_tokens=len(ids), |
| seconds=time.perf_counter()-start,peak_allocated_bytes=torch.cuda.max_memory_allocated(), |
| ended_with_eos=finished,truncated=not finished and len(ids)>=budget) |
|
|
| smoke=generate('What is 2+3? Reply with only the number.',False,64) |
| (ROOT/'smoke.json').write_text(json.dumps(dict(environment=env,result=smoke),ensure_ascii=False,indent=2)+'\n',encoding='utf-8') |
| print('Smoke:',repr(smoke['output']),f"{smoke['seconds']:.1f}s",flush=True) |
| if args.smoke_only: |
| return |
| output_path=ROOT/'runs.jsonl' |
| if output_path.exists(): |
| raise RuntimeError('Measured run file already exists; do not silently repeat/select runs') |
| (ROOT/'environment.json').write_text(json.dumps(env,ensure_ascii=False,indent=2)+'\n',encoding='utf-8') |
| with output_path.open('x',encoding='utf-8') as out: |
| index=0 |
| for thinking in (False,True): |
| for case in corpus['cases']: |
| index+=1 |
| torch.manual_seed(SEED);torch.cuda.manual_seed_all(SEED) |
| print(f"Starting {index}/32 {case['id']} thinking={thinking}",flush=True) |
| result=generate(case['prompt'],thinking,1536) |
| judgment=score(case,result['scoring_text'],thinking,result['truncated']) |
| row=dict(case_id=case['id'],thinking=thinking,**result,score=judgment) |
| out.write(json.dumps(row,ensure_ascii=False)+'\n');out.flush() |
| print(f"Finished {index}/32 {judgment['reason']} tokens={result['output_tokens']} seconds={result['seconds']:.1f}",flush=True) |
| print('All 32 measured generations saved; analysis and submission still required',flush=True) |
|
|
|
|
| if __name__=='__main__': |
| main() |
|
|
