"""Authored 2->2->2 sigmoid network, equations from Rumelhart et al. Nature 1986.
Python standard library only; no dataset, training result, or pretrained output.
"""
import argparse
import json
import math

PARAMETERS = [.3, -.2, .4, .1, .05, -.1, .6, -.5, -.4, .7, .1, -.2]


# region: forward
def sigmoid(z):
    """Numerically stable logistic activation, including saturated boundaries."""
    e = math.exp(-z if z >= 0 else z)
    return 1 / (1 + e) if z >= 0 else e / (1 + e)


def forward(p, x=(1, -.5), target=(1, 0)):
    """Two hidden and two output units; half sum-of-squares over outputs."""
    if len(p) != 12 or len(x) != 2 or len(target) != 2:
        raise ValueError("Expected 12 parameters, 2 inputs and 2 targets")
    if not all(math.isfinite(v) for v in [*p, *x, *target]):
        raise ValueError("Finite inputs required")
    z1 = [p[4+i] + p[2*i]*x[0] + p[2*i+1]*x[1] for i in range(2)]
    hidden = [sigmoid(z) for z in z1]
    z2 = [p[10+i] + p[6+2*i]*hidden[0] + p[7+2*i]*hidden[1] for i in range(2)]
    output = [sigmoid(z) for z in z2]
    loss = .5 * sum((y-t)**2 for y, t in zip(output, target))
    return dict(z1=z1, hidden=hidden, z2=z2, output=output, loss=loss)
# endregion: forward


# region: output
def output_deltas(output, target):
    """dL/dz = (y-target)*y*(1-y), for sigmoid plus half squared error."""
    return [(y-t)*y*(1-y) for y, t in zip(output, target)]
# endregion: output


# region: reverse
def gradient(p, x=(1, -.5), target=(1, 0)):
    """Sum EVERY downstream contribution before applying a hidden derivative."""
    f = forward(p, x, target)
    delta2 = output_deltas(f['output'], target)
    signal = [sum(d*p[6+2*i+j] for i, d in enumerate(delta2)) for j in range(2)]
    delta1 = [h*(1-h)*s for h, s in zip(f['hidden'], signal)]
    values = ([d*v for d in delta1 for v in x] + delta1
              + [d*h for d in delta2 for h in f['hidden']] + delta2)
    return dict(values=values, outputDelta=delta2,
                hiddenSignal=signal, hiddenDelta=delta1)
# endregion: reverse


def finite_difference(p, index, h=1e-5, x=(1, -.5), target=(1, 0)):
    if not 0 <= index < 12 or not math.isfinite(h) or h <= 0:
        raise ValueError("Valid index and positive step required")
    left, right = list(p), list(p)
    left[index] -= h
    right[index] += h
    return (forward(right, x, target)['loss'] - forward(left, x, target)['loss']) / (2*h)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--json', action='store_true')
    args = parser.parse_args()
    result = dict(forward=forward(PARAMETERS), gradient=gradient(PARAMETERS),
                  finite=[finite_difference(PARAMETERS, i) for i in range(12)])
    for analytic, numeric in zip(result['gradient']['values'], result['finite']):
        assert math.isclose(analytic, numeric, abs_tol=1e-8)
    updated = [p-.1*d for p, d in zip(PARAMETERS, result['gradient']['values'])]
    assert forward(updated)['loss'] < result['forward']['loss']
    assert sigmoid(-1000) == 0 and sigmoid(1000) == 1
    print(json.dumps(result) if args.json else 'All 12 finite-difference gradients passed: ' + str(result))


if __name__ == '__main__':
    main()
