#!/usr/bin/env python3
"""Compare repetition with reversed history on the same targets in Pythia-70M."""
import argparse
import hashlib
import json
from pathlib import Path
import torch
import torch.nn.functional as F
import transformers
from transformers import AutoModelForCausalLM
import induction_heads as induction


def losses(model, tokens, reverse=False, ablate=None):
    prefix = tokens.flip(0) if reverse else tokens
    ids = torch.cat((prefix, tokens)).unsqueeze(0)
    handle = None
    if ablate is not None:
        layer, head = ablate
        width = model.config.hidden_size // model.config.num_attention_heads
        def remove(_module, inputs):
            x = inputs[0].clone()
            x[..., head * width:(head + 1) * width] = 0
            return (x, *inputs[1:])
        handle = model.gpt_neox.layers[layer].attention.dense.register_forward_pre_hook(remove)
    try:
        with torch.no_grad():
            logits = model(ids, use_cache=False).logits
    finally:
        if handle is not None:
            handle.remove()
    n = len(tokens)
    values = F.cross_entropy(logits[0, :-1], ids[0, 1:], reduction='none')
    return values[n:2*n-1].tolist()


def run(model, discovery_seed, test_seed, control=(0, 0)):
    if any(not 0 <= x < 2**32 for x in (discovery_seed, test_seed)) or discovery_seed == test_seed:
        raise ValueError('Brug to forskellige seeds mellem 0 og 2³²−1.')
    discover = induction.measure(model, induction.sequence(discovery_seed), attention=True)
    scores = torch.tensor(discover['scores'])
    index = int(scores.flatten().argmax())
    selected = [index // model.config.num_attention_heads, index % model.config.num_attention_heads]
    if len(control) != 2 or not 0 <= control[0] < 6 or not 0 <= control[1] < 8 or list(control) == selected:
        raise ValueError('Vælg et andet gyldigt kontrolhead end det udvalgte.')
    tokens = induction.sequence(test_seed)
    conditions = {}
    for name, reverse in [('repeated', False), ('reversed', True)]:
        conditions[name] = {'intact': losses(model, tokens, reverse), 'ablated': losses(model, tokens, reverse, selected), 'control_ablated': losses(model, tokens, reverse, control)}
    return {'format':'learning-lab-induction-prefix-v1', 'model':induction.MODEL, 'revision':induction.REVISION,
            'torch_version':str(torch.__version__), 'transformers_version':transformers.__version__,
            'source_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
            'helper_sha256':hashlib.sha256(Path(induction.__file__).read_bytes()).hexdigest(),
            'discover_seed':discovery_seed, 'test_seed':test_seed, 'selected':selected, 'control':list(control),
            'token_ids':tokens.tolist(), 'conditions':conditions}


def main():
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument('--discover-seed',type=int,default=7);p.add_argument('--test-seed',type=int,default=17)
    p.add_argument('--output',type=Path,default=Path('induction-prefix.json'));p.add_argument('--offline',action='store_true');p.add_argument('--control',type=int,nargs=2,default=[0,0],metavar=('LAG','HEAD'))
    a=p.parse_args()
    if a.output.exists():p.error('Outputfilen findes allerede. Vælg et nyt navn.')
    if any(not 0 <= x < 2**32 for x in (a.discover_seed,a.test_seed)) or a.discover_seed==a.test_seed:p.error('Brug to forskellige seeds mellem 0 og 2³²−1.')
    torch.set_num_threads(1)
    model=AutoModelForCausalLM.from_pretrained(induction.MODEL,revision=induction.REVISION,local_files_only=a.offline,attn_implementation='eager').eval()
    result=run(model,a.discover_seed,a.test_seed,a.control)
    with a.output.open('x',encoding='utf-8') as f:json.dump(result,f,ensure_ascii=False,indent=2,allow_nan=False);f.write('\n')
    print(f"Valgt head {result['selected']}; gemt {a.output}")
if __name__=='__main__':main()
