• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• autograd-master
  • license.txt
  • examples
    • generative_adversarial_net.py
    • data.py
    • negative_binomial_maxlike.py
    • neural_net_regression.py
    • natural_gradient_black_box_svi.py
    • variational_autoencoder.py
    • rosenbrock.py
    • gplvm.py
    • gaussian_process.py
    • tanh.py
    • fluidsim
      • fluidsim.py
      • wing.py
    • neural_net.py
    • convnet.py
    • define_gradient.py
    • bayesian_neural_net.py
    • print_trace.py
    • rkhs.py
    • lstm.py
    • bayesian_optimization.py
    • dot_graph.py
    • gmm.py
    • black_box_svi.py
    • __init__.py
    • data_mnist.py
    • hmm_em.py
    • ode_net.py
    • fixed_points.py
    • rnn.py
    • mixture_variational_inference.py
    • ica.py
    • sinusoid.py
    • deep_gaussian_process.py
    • logistic_regression.py
  • autograd
    • differential_operators.py
    • util.py
    • scipy
      • signal.py
      • misc.py
      • linalg.py
      • special.py
      • integrate.py
      • __init__.py
      • stats
        • t.py
        • beta.py
        • poisson.py
        • multivariate_normal.py
        • dirichlet.py
        • norm.py
        • chi2.py
        • __init__.py
        • gamma.py
    • misc
      • tracers.py
      • flatten.py
      • optimizers.py
      • __init__.py
      • fixed_points.py
    • test_util.py
    • tracer.py
    • numpy
      • numpy_wrapper.py
      • numpy_vspaces.py
      • fft.py
      • random.py
      • numpy_boxes.py
      • linalg.py
      • __init__.py
      • numpy_jvps.py
      • numpy_vjps.py
    • __init__.py
    • wrap_util.py
    • core.py
    • builtins.py
    • extend.py
  • conda_recipe
    • conda.yaml
  • setup.py
  • benchmarks
    • asv.conf.json.sample
    • bench_rnn.py
    • bench_core.py
    • __init__.py
    • bench_util.py
    • bench_numpy_vjps.py
    • bench_mem.py
  • setup.cfg
  • .travis.yml
  • README.md
  • tests
    • test_systematic.py
    • test_misc.py
    • test_graphs.py
    • test_truediv.py
    • _test_complexity.py
    • test_linalg.py
    • test_tests.py
    • test_performance.py
    • numpy_utils.py
    • test_dict.py
    • test_wrappers.py
    • test_jacobian.py
    • check_examples_run.sh
    • test_tuple.py
    • test_logic.py
    • test_direct.py
    • test_numpy.py
    • test_list.py
    • test_vspaces.py
    • test_builtins.py
    • test_fft.py
    • test_scalar_ops.py
    • test_binary_ops.py
    • test_complex.py
    • test_scipy.py
    • test_core.py
    • profiling.py
  • .gitignore
  • docs
    • tutorial.md
    • updateguide.md
  • MANIFEST.in

import autograd.numpy as np
import autograd.numpy.random as npr
from autograd.test_util import check_grads
from autograd import dict as ag_dict, isinstance as ag_isinstance
from autograd import grad
import operator as op

npr.seed(0)

def test_getter():
    def fun(input_dict):
        A = np.sum(input_dict['item_1'])
        B = np.sum(input_dict['item_2'])
        C = np.sum(input_dict['item_2'])
        return A + B + C

    d_fun = grad(fun)
    input_dict = {'item_1' : npr.randn(5, 6),
                  'item_2' : npr.randn(4, 3),
                  'item_X' : npr.randn(2, 4)}

    result = d_fun(input_dict)
    assert np.allclose(result['item_1'], np.ones((5, 6)))
    assert np.allclose(result['item_2'], 2 * np.ones((4, 3)))
    assert np.allclose(result['item_X'], np.zeros((2, 4)))

def test_grads():
    def fun(input_dict):
        A = np.sum(np.sin(input_dict['item_1']))
        B = np.sum(np.cos(input_dict['item_2']))
        return A + B

    def d_fun(input_dict):
        g = grad(fun)(input_dict)
        A = np.sum(g['item_1'])
        B = np.sum(np.sin(g['item_1']))
        C = np.sum(np.sin(g['item_2']))
        return A + B + C

    input_dict = {'item_1' : npr.randn(5, 6),
                  'item_2' : npr.randn(4, 3),
                  'item_X' : npr.randn(2, 4)}

    check_grads(fun)(input_dict)
    check_grads(d_fun)(input_dict)

def test_iter():
    def fun(input_dict):
        A = 0.
        B = 0.
        for i, k in enumerate(sorted(input_dict)):
            A = A + np.sum(np.sin(input_dict[k])) * (i + 1.0)
            B = B + np.sum(np.cos(input_dict[k]))
        return A + B

    def d_fun(input_dict):
        g = grad(fun)(input_dict)
        A = np.sum(g['item_1'])
        B = np.sum(np.sin(g['item_1']))
        C = np.sum(np.sin(g['item_2']))
        return A + B + C

    input_dict = {'item_1' : npr.randn(5, 6),
                  'item_2' : npr.randn(4, 3),
                  'item_X' : npr.randn(2, 4)}

    check_grads(fun)(input_dict)
    check_grads(d_fun)(input_dict)

def test_items_values_keys():
    def fun(input_dict):
        A = 0.
        B = 0.
        for i, (k, v) in enumerate(sorted(input_dict.items(), key=op.itemgetter(0))):
            A = A + np.sum(np.sin(v)) * (i + 1.0)
            B = B + np.sum(np.cos(v))
        for v in input_dict.values():
            A = A + np.sum(np.sin(v))
        for k in sorted(input_dict.keys()):
            A = A + np.sum(np.cos(input_dict[k]))
        return A + B

    def d_fun(input_dict):
        g = grad(fun)(input_dict)
        A = np.sum(g['item_1'])
        B = np.sum(np.sin(g['item_1']))
        C = np.sum(np.sin(g['item_2']))
        return A + B + C

    input_dict = {'item_1' : npr.randn(5, 6),
                  'item_2' : npr.randn(4, 3),
                  'item_X' : npr.randn(2, 4)}

    check_grads(fun)(input_dict)
    check_grads(d_fun)(input_dict)

def test_get():
  def fun(d, x):
    return d.get('item_1', x)**2
  check_grads(fun, argnum=(0, 1))({'item_1': 3.}, 2.)
  check_grads(fun, argnum=(0, 1))({'item_2': 4.}, 2.)
  check_grads(fun, argnum=(0, 1))({}, 2.)

def test_make_dict():
    def fun(x):
        return ag_dict([('a', x)], b=x)
    check_grads(fun, modes=['rev'])(1.0)

    def fun(x):
        return ag_dict({'a': x})
    check_grads(fun, modes=['rev'])(1.0)

    # check some other forms of the constructor
    ag_dict()
    ag_dict(())
    ag_dict({})

def test_isinstance():
    def fun(x):
        assert ag_isinstance(x, dict)
        assert ag_isinstance(x, ag_dict)
        return x['x']
    fun({'x': 1.})
    grad(fun)({'x': 1.})