• Search by Module
• Search by Word
• Project Search
• Top Python APIs
• Popular Projects

• Java
• C++
• Python
• Scala
• Blog

• zhusuan-master
  • zhusuan
    • sgmcmc.py
    • evaluation.py
    • hmc.py
    • variational
      • inclusive_kl.py
      • exclusive_kl.py
      • monte_carlo.py
      • __init__.py
      • base.py
    • distributions
      • univariate.py
      • multivariate.py
      • __init__.py
      • utils.py
      • base.py
    • transform.py
    • diagnostics.py
    • framework
      • bn.py
      • __init__.py
      • utils.py
      • meta_bn.py
    • __init__.py
    • utils.py
    • legacy
      • distributions
        • special.py
        • __init__.py
      • framework
        • stochastic.py
        • __init__.py
      • __init__.py
  • examples
    • toy_examples
      • mixture_sgnht.py
      • toy2d_intractable.py
      • __init__.py
      • gaussian.py
    • utils
      • optimizers.py
      • multi_gpu.py
      • __init__.py
      • utils.py
      • dataset.py
    • probabilistic_matrix_factorization
      • pmf_hmc.py
      • __init__.py
    • semi_supervised_vae
      • vae_ssl.py
      • vae_ssl_adaptive_is.py
      • __init__.py
    • normalizing_flows
      • __init__.py
      • vae_nf.py
    • topic_models
      • lntm_mcem.py
      • __init__.py
    • generative_adversarial_nets
      • dcgan.py
      • wasserstein_gan.py
      • __init__.py
    • __init__.py
    • variational_autoencoders
      • bernoulli_latent_vae.py
      • vae.py
      • iwae.py
      • __init__.py
      • vae_conv.py
    • conf.py
    • bayesian_neural_nets
      • variational_dropout.py
      • bnn_sgmcmc.py
      • __init__.py
      • bnn_vi.py
    • sigmoid_belief_nets
      • sbn_vimco.py
      • sbn_adaptive_is.py
      • __init__.py
    • gaussian_process
      • svgp.py
      • __init__.py
      • utils.py
    • .gitignore
  • LICENSE
  • CONTRIBUTING.md
  • setup.py
  • requirements-dev.txt
  • setup.cfg
  • .travis.yml
  • README.md
  • tests
    • test_diagnostics.py
    • test_evaluation.py
    • test_utils.py
    • _div_op.py
    • variational
      • test_base.py
      • test_exclusive_kl.py
      • test_monte_carlo.py
      • __init__.py
      • utils.py
      • test_inclusive_kl.py
    • distributions
      • test_base.py
      • test_utils.py
      • test_multivariate.py
      • __init__.py
      • utils.py
      • test_univariate.py
    • test_mcmc.py
    • framework
      • test_base.py
      • test_utils.py
      • __init__.py
      • test_stochastic.py
    • __init__.py
    • test_transform.py
    • _true_div_op.py
  • requirements.txt
  • .gitignore
  • docs
    • refs.bib
    • Makefile
    • post_apidoc.py
    • mathjax.py
    • api
      • zhusuan.variational.rst
      • zhusuan.distributions.rst
      • zhusuan.hmc.rst
      • zhusuan.legacy.rst
      • zhusuan.utils.rst
      • zhusuan.diagnostics.rst
      • zhusuan.framework.rst
      • zhusuan.evaluation.rst
      • zhusuan.transform.rst
      • zhusuan.sgmcmc.rst
    • tutorials
      • vae.rst
      • bnn.rst
      • lntm.rst
      • concepts.rst
    • requirements.txt
    • index.rst
    • conf.py
    • _static
      • images
        • zhusuan-logo-v.svg
        • zhusuan-logo-h.svg
      • css
        • style.css
    • contributing.rst

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
from itertools import permutations

import tensorflow as tf

from zhusuan.framework.utils import *
from zhusuan.framework.utils import Context


class TestContext(tf.test.TestCase):
    def test_Context(self):
        self.assertEqual(Context.get_contexts(), [])
        with self.assertRaisesRegexp(RuntimeError, "No contexts on the stack"):
            Context.get_context()
        with Context() as context:
            self.assertEqual(Context.get_contexts(), [context])
            self.assertEqual(Context.get_context(), context)
            with Context() as context_inner:
                self.assertEqual(Context.get_contexts(),
                                 [context, context_inner])
                self.assertEqual(Context.get_context(), context_inner)
            self.assertEqual(Context.get_contexts(), [context])
            self.assertEqual(Context.get_context(), context)
        self.assertEqual(Context.get_contexts(), [])
        with self.assertRaisesRegexp(RuntimeError, "No contexts on the stack"):
            Context.get_context()


class TestGetBackwardTensors(tf.test.TestCase):
    def testGetBackwardOpsChain(self):
        # a -> b -> c
        a = tf.placeholder(tf.float32)
        b = tf.sqrt(a)
        c = tf.square(b)
        for n in range(4):
            for seed_tensors in permutations([a, b, c], n):
                if c in seed_tensors:
                    truth = [a.op, b.op, c.op]
                elif b in seed_tensors:
                    truth = [a.op, b.op]
                elif a in seed_tensors:
                    truth = [a.op]
                else:
                    truth = []
                self.assertEqual(get_backward_ops(seed_tensors), truth)

        self.assertEqual(get_backward_ops([c], treat_as_inputs=[b]), [c.op])
        self.assertEqual(
            get_backward_ops([b, c], treat_as_inputs=[b]), [c.op])
        self.assertEqual(
            get_backward_ops([a, c], treat_as_inputs=[b]), [a.op, c.op])

    def testGetBackwardOpsSplit(self):
        # a -> b -> c
        #       \-> d
        a = tf.placeholder(tf.float32)
        b = tf.exp(a)
        c = tf.log(b)
        d = tf.negative(b)
        self.assertEqual(get_backward_ops([d]), [a.op, b.op, d.op])
        self.assertEqual(get_backward_ops([c]), [a.op, b.op, c.op])
        self.assertEqual(
            get_backward_ops([c, d]), [a.op, b.op, c.op, d.op])
        self.assertEqual(get_backward_ops([b, d]), [a.op, b.op, d.op])
        self.assertEqual(get_backward_ops([a, d]), [a.op, b.op, d.op])

        self.assertEqual(
            get_backward_ops([c, d], treat_as_inputs=[b]), [c.op, d.op])
        self.assertEqual(
            get_backward_ops([c], treat_as_inputs=[d]), [a.op, b.op, c.op])

    def testGetBackwardOpsMerge(self):
        # a -> c -> d
        # b ->/
        a = tf.placeholder(tf.float32)
        b = tf.constant(0, dtype=tf.int32)
        c = tf.reduce_sum(a, reduction_indices=b)
        d = tf.stop_gradient(c)
        self.assertEqual(
            get_backward_ops([d]), [a.op, b.op, c.op, d.op])
        self.assertEqual(get_backward_ops([d], treat_as_inputs=[c]), [d.op])
        self.assertEqual(
            get_backward_ops([d], treat_as_inputs=[a]), [b.op, c.op, d.op])

    def testGetBackwardOpsBridge(self):
        # a -> b -> c -> d -> e
        #       \    ---    /
        a = tf.placeholder(tf.int32)
        b = tf.identity(a)
        c = tf.cast(b, tf.float32)
        d = tf.tile(c, b)
        e = tf.tanh(d)
        self.assertEqual(
            get_backward_ops([e]), [a.op, b.op, c.op, d.op, e.op])
        self.assertEqual(get_backward_ops([c]), [a.op, b.op, c.op])
        self.assertEqual(get_backward_ops([e], treat_as_inputs=[c]),
                         [a.op, b.op, d.op, e.op])

    def testGetBackwardOpsControlDeps(self):
        # a -> b - \
        # c -> d - e
        #       \ /
        #        f
        a = tf.placeholder(tf.float32, name='a')
        b = tf.identity(a, name='b')
        c = tf.placeholder(tf.float32, name='c')
        d = tf.identity(c, name='d')
        with tf.control_dependencies([b, d]):
            e = tf.placeholder(tf.float32, name='e')
        with tf.control_dependencies([e, d]):
            f = tf.placeholder(tf.float32, name='f')
        self.assertEqual(get_backward_ops([f]),
                         [a.op, b.op, c.op, d.op, e.op, f.op])
        self.assertEqual(get_backward_ops([d, f]),
                         [c.op, d.op, a.op, b.op, e.op, f.op])

        self.assertEqual(get_backward_ops([f], treat_as_inputs=[b]),
                         [a.op, b.op, c.op, d.op, e.op, f.op])
        self.assertEqual(get_backward_ops([f], treat_as_inputs=[b, c]),
                         [a.op, b.op, d.op, e.op, f.op])
        self.assertEqual(get_backward_ops([f], treat_as_inputs=[d, e]),
                         [a.op, b.op, c.op, d.op, e.op, f.op])
        self.assertEqual(get_backward_ops([d, f], treat_as_inputs=[b]),
                         [c.op, d.op, a.op, b.op, e.op, f.op])

    def test_get_backward_ops_control_flow(self):
        # while_loop, scan, TensorArray
        pass