gradient_check.py 文件源码

def numerical_grad(f, inputs, grad_outputs, eps=1e-3):
    """Computes numerical gradient by finite differences.

    This function is used to implement gradient check. For usage example, see
    unit tests of :mod:`chainer.functions`.

    Args:
        f (function): Python function with no arguments that runs forward
            computation and returns the result.
        inputs (tuple of arrays): Tuple of arrays that should be treated as
            inputs. Each element of them is slightly modified to realize
            numerical gradient by finite differences.
        grad_outputs (tuple of arrays): Tuple of arrays that are treated as
            output gradients.
        eps (float): Epsilon value of finite differences.

    Returns:
        tuple: Numerical gradient arrays corresponding to ``inputs``.

    """
    assert eps > 0
    inputs = tuple(inputs)
    grad_outputs = tuple(grad_outputs)
    gpu = any(isinstance(x, cuda.ndarray) for x in inputs + grad_outputs)
    cpu = any(isinstance(x, numpy.ndarray) for x in inputs + grad_outputs)

    if gpu and cpu:
        raise RuntimeError('Do not mix GPU and CPU arrays in `numerical_grad`')

    if gpu:
        xp = cuda.cupy
    else:
        xp = numpy
    grads = tuple(xp.zeros_like(x) for x in inputs)
    for x, gx in zip(inputs, grads):
        for i in numpy.ndindex(x.shape):
            orig = x[i].copy()  # hold original value
            x[i] = orig + eps
            ys1 = _copy_arrays(f())
            x[i] = orig - eps
            ys2 = _copy_arrays(f())
            x[i] = orig
            for y1, y2, gy in zip(ys1, ys2, grad_outputs):
                if gy is not None:
                    dot = ((y1 - y2) * gy).sum()
                    gx[i] += dot / (2 * eps)
    return grads