#!/usr/bin/env python3
"""Compare autograd with central differences for one trained XOR-model weight."""
import argparse
import hashlib
import json
import math
from pathlib import Path

import torch
from torch import nn
from train import make_data, dataset_sha256

PARAMETERS = {
    'hidden-weight': ('0.weight', (0, 0), '0.weight[0,0]'),
    'hidden-bias': ('0.bias', (0,), '0.bias[0]'),
    'output-weight': ('2.weight', (0, 0), '2.weight[0,0]'),
    'output-bias': ('2.bias', (0,), '2.bias[0]'),
}

EPSILONS = (1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7)


def examine(model, data, choice="hidden-weight"):
    """Inspect one scalar in float64; restore it after every perturbation."""
    model = model.double().eval()
    x, y = (tensor.double() for tensor in data)
    criterion = nn.BCEWithLogitsLoss()
    name, index, label = PARAMETERS[choice]
    parameter = dict(model.named_parameters())[name]
    initial = parameter.detach().clone()
    baseline = criterion(model(x), y)
    analytic = torch.autograd.grad(baseline, parameter)[0][index].item()
    original = parameter[index].item()
    rows = []
    try:
        for epsilon in EPSILONS:
            with torch.no_grad():
                parameter[index] = original + epsilon
                plus = criterion(model(x), y).item()
                parameter[index] = original - epsilon
                minus = criterion(model(x), y).item()
                parameter[index] = original
            numeric = (plus - minus) / (2 * epsilon)
            absolute = abs(numeric - analytic)
            relative = absolute / max(1e-12, abs(numeric), abs(analytic))
            rows.append({'epsilon': epsilon, 'loss_plus': plus, 'loss_minus': minus,
                         'numeric': numeric, 'absolute_error': absolute, 'relative_error': relative})
    finally:
        with torch.no_grad():
            parameter.copy_(initial)
    with torch.no_grad():
        restored_loss = criterion(model(x), y).item()
    result = {'format': 'learning-lab-gradient-check-v1', 'parameter': label,
              'dtype': 'float64', 'train_count': len(x), 'train_seed': 104729,
              'weight': original, 'baseline_loss': baseline.item(), 'analytic': analytic,
              'restored_loss_error': abs(restored_loss - baseline.item()),
              'parameter_restore_error': (parameter.detach() - initial).abs().max().item(),
              'rows': rows}
    if not all(math.isfinite(v) for v in (original, baseline.item(), analytic, restored_loss)) or not all(math.isfinite(v) for row in rows for v in row.values()):
        raise ValueError('Beregningen gav ikke-endelige tal.')
    return result


def main():
    parser = argparse.ArgumentParser(description='Sammenlign én gradient med centrale differenser.')
    parser.add_argument('--parameter', choices=PARAMETERS, default='hidden-weight', help='Parameter, der undersøges')
    parser.add_argument('--model', type=Path, required=True, help='model.pt fra PyTorch-projektet')
    parser.add_argument('--output', type=Path, default=Path('gradient_check.json'), help='Ny resultatfil; overskrives ikke')
    args = parser.parse_args()
    if not args.model.is_file():
        parser.error('Modelfilen findes ikke.')
    if args.output.exists():
        parser.error('Resultatfilen findes allerede. Vælg en ny sti med --output.')
    torch.set_num_threads(1)
    model = nn.Sequential(nn.Linear(2, 8), nn.Tanh(), nn.Linear(8, 1))
    model.load_state_dict(torch.load(args.model, map_location='cpu', weights_only=True))
    training = make_data(256, 104729)
    result = examine(model, training, args.parameter)
    result.update({'model_sha256': hashlib.sha256(args.model.read_bytes()).hexdigest(),
                   'train_data_sha256': dataset_sha256(training), 'torch_version': str(torch.__version__)})
    with args.output.open('x', encoding='utf-8') as file:
        json.dump(result, file, ensure_ascii=False, indent=2, allow_nan=False)
    print(f"Autograd: {result['analytic']:.10g}. Gemt i {args.output}.")
    print('Kun én parameter og ét datasæt er undersøgt; enighed er ikke bevis for hele modellens korrekthed.')


if __name__ == '__main__':
    main()
