#!/usr/bin/env python3
"""Compare individual and joint head ablations on repeated-token sequences."""
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 validate(head_a, head_b, seeds):
    for head in (head_a, head_b):
        if len(head) != 2 or any(type(x) is not int for x in head) or not 0 <= head[0] < 6 or not 0 <= head[1] < 8:
            raise ValueError('Et head skal have lag 0–5 og headnummer 0–7.')
    if head_a == head_b:
        raise ValueError('Vælg to forskellige heads.')
    if not 2 <= len(seeds) <= 10 or len(set(seeds)) != len(seeds) or any(type(x) is not int or not 0 <= x < 2**32 for x in seeds):
        raise ValueError('Vælg 2–10 forskellige seeds fra 0 til 2³²−1.')


def measure(model, tokens, heads):
    ids = torch.cat((tokens, tokens)).unsqueeze(0)
    width = model.config.hidden_size // model.config.num_attention_heads
    by_layer = {}
    for layer, head in heads:
        by_layer.setdefault(layer, []).append(head)
    handles = []
    try:
        for layer, selected in by_layer.items():
            def zero_heads(_module, inputs, selected=tuple(selected)):
                combined = inputs[0].clone()
                for head in selected:
                    combined[..., head * width:(head + 1) * width] = 0
                return (combined, *inputs[1:])
            handles.append(model.gpt_neox.layers[layer].attention.dense.register_forward_pre_hook(zero_heads))
        with torch.inference_mode():
            logits = model(ids, use_cache=False).logits
        losses = F.cross_entropy(logits[0, :-1], ids[0, 1:], reduction='none')
        return losses[induction.LENGTH:2 * induction.LENGTH - 1].tolist()
    finally:
        for handle in handles:
            handle.remove()


def experiment(model, head_a, head_b, seeds):
    validate(head_a, head_b, seeds)
    rows = []
    for seed in seeds:
        tokens = induction.sequence(seed)
        rows.append({'seed': seed, 'token_ids': tokens.tolist(),
                     'baseline': measure(model, tokens, []),
                     'head_a': measure(model, tokens, [head_a]),
                     'head_b': measure(model, tokens, [head_b]),
                     'both': measure(model, tokens, [head_a, head_b])})
    return {'format': 'learning-lab-induction-joint-v1', 'model': induction.MODEL,
            'revision': induction.REVISION, 'head_a': head_a, 'head_b': head_b,
            'torch_version': str(torch.__version__), 'transformers_version': transformers.__version__,
            'script_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
            'sequence_sha256': hashlib.sha256(Path(induction.__file__).read_bytes()).hexdigest(),
            'rows': rows}


def main():
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument('--head-a', type=int, nargs=2, default=[3, 6], metavar=('LAG', 'HEAD'))
    p.add_argument('--head-b', type=int, nargs=2, default=[0, 0], metavar=('LAG', 'HEAD'))
    p.add_argument('--seeds', type=int, nargs='+', default=[17, 31, 41, 53, 67])
    p.add_argument('--output', type=Path, default=Path('induction-joint.json'))
    p.add_argument('--offline', action='store_true')
    args = p.parse_args()
    try:
        validate(args.head_a, args.head_b, args.seeds)
    except ValueError as exc:
        p.error(str(exc))
    if args.output.exists():
        p.error('Outputfilen findes allerede. Vælg et andet navn.')
    torch.set_num_threads(1)
    model = AutoModelForCausalLM.from_pretrained(induction.MODEL, revision=induction.REVISION,
             local_files_only=args.offline, attn_implementation='eager').eval()
    result = experiment(model, args.head_a, args.head_b, args.seeds)
    with args.output.open('x', encoding='utf-8') as out:
        json.dump(result, out, ensure_ascii=False, indent=2, allow_nan=False)
        out.write('\n')
    print(f"Sammenlignede {args.head_a} og {args.head_b} på {len(args.seeds)} følger; gemt: {args.output}")


if __name__ == '__main__':
    main()
