"""Scalar Algorithm 1 from Adam arXiv:1412.6980v9; standard library only.

This computes supplied-gradient updates, not a trained model or performance result.
Run python examples/adam.py [--json].
"""
import argparse
import json
import math


# region: moments
def moments(gradients, beta1=0.9, beta2=0.999):
    """Keep the first moment and the second RAW moment, initialized to zero."""
    if not all(math.isfinite(x) for x in [beta1, beta2, *gradients]):
        raise ValueError("Finite inputs required")
    if not (0 <= beta1 < 1 and 0 <= beta2 < 1):
        raise ValueError("Decay rates must be in [0,1)")
    m, v, history = 0.0, 0.0, []
    for t, g in enumerate(gradients, 1):
        m = beta1 * m + (1 - beta1) * g
        v = beta2 * v + (1 - beta2) * g * g
        history.append((t, g, m, v))
    return history
# endregion: moments


# region: bias
def correct(m, v, t, beta1, beta2):
    """Remove zero-initialization factors; not all nonstationary estimation bias."""
    if not isinstance(t, int) or t < 1 or not (0 <= beta1 < 1 and 0 <= beta2 < 1):
        raise ValueError("Positive timestep and decay rates in [0,1) required")
    return m / (1 - beta1 ** t), v / (1 - beta2 ** t)
# endregion: bias


# region: update
def adam_trace(gradients, alpha=0.001, beta1=0.9, beta2=0.999,
               epsilon=1e-8, initial=0.0, corrected=True):
    """Epsilon is OUTSIDE sqrt, as in the selected paper's Algorithm 1."""
    if not all(math.isfinite(x) for x in (alpha, epsilon, initial)):
        raise ValueError("Finite hyperparameters required")
    if alpha < 0 or epsilon <= 0:
        raise ValueError("Nonnegative step size and positive epsilon required")
    theta, result = initial, []
    for t, g, m, v in moments(gradients, beta1, beta2):
        mh, vh = correct(m, v, t, beta1, beta2) if corrected else (m, v)
        delta = alpha * mh / (math.sqrt(vh) + epsilon)
        theta -= delta
        result.append(dict(t=t, g=g, m=m, v=v, mHat=mh, vHat=vh,
                           delta=delta, theta=theta))
    return result
# endregion: update


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--json', action='store_true')
    args = parser.parse_args()
    trace = adam_trace([0, 0, 0, 4, 0, 0, 0, 0])
    assert adam_trace([0, 0])[-1]['theta'] == 0
    assert math.isclose(adam_trace([2])[0]['delta'], .001 * 2 / (2 + 1e-8))
    assert trace[4]['delta'] > 0  # Zero CURRENT gradient still has momentum.
    print(json.dumps(trace) if args.json else 'Adam checks passed; sparse trace: ' + str(trace))


if __name__ == '__main__':
    main()
