def testUseAfterNewStep(self): with imperative_mode.ImperativeMode(self._target) as mode: x = constant_op.constant(1) self.assertAllClose(x.value, 1) with mode.new_step(): pass self.assertAllClose(x.value, 1)
def testVarChange(self): with imperative_mode.ImperativeMode(self._target) as mode: x = variables.Variable(constant_op.constant(1.0)) for i in range(10): with mode.new_step() as step: step.run(state_ops.assign_sub(x, 0.1)) self.assertAllClose(array_ops.identity(x).value, 1.0 - (i + 1) * 0.1)
def testBoolCoercion(self): with imperative_mode.ImperativeMode(self._target): self.assertFalse(not constant_op.constant([1.0])) with self.assertRaises(ValueError) as ve: _ = not constant_op.constant(np.random.rand(2)) self.assertTrue('The truth value of an array with' ' more than one element is ambiguous.' ' Use a.any() or a.all()' in str(ve.exception))
def testVariable(self): """Makes sure that variables can be evaluated before running initializer.""" with imperative_mode.ImperativeMode(self._target): x = variables.Variable(1, name='xy') self.assertEqual(x.value().value, 1) x = x.assign_add(41) self.assertEqual(x.value, 1 + 41) y = variables.Variable(3, name='y') self.assertEqual(y.value().value, 3)
def testExpGrad(self): """Tests gradients.""" with imperative_mode.ImperativeMode(self._target): x = variables.Variable(np.random.rand(1, 3)) x_init = x.value().value y = math_ops.exp(x) dy = gradients_impl.gradients(y, x) self.assertAllClose(np.exp(x_init), y.value) # dy/dx should be equal to y (= exp(x)) self.assertAllClose(y.value, dy[0].value)
def testGradientThroughNewStep(self): with imperative_mode.ImperativeMode(self._target) as mode: x = constant_op.constant(np.random.rand(3)) y = math_ops.tanh(x) with mode.new_step(): z = constant_op.constant(np.random.rand(3)) w = math_ops.multiply(y, z) dx = gradients_impl.gradients(w, x) self.assertAllClose(dx[0].value, z.value * (1.0 - y.value ** 2))
def testLoopGrads(self): """Tests gradients in the presence of Python loops.""" with imperative_mode.ImperativeMode(self._target): w = variables.Variable(np.eye(3)) x = constant_op.constant(np.eye(3)) for _ in range(3): x = math_ops.add(x, w) y = gradients_impl.gradients(x, w) self.assertAllClose(y[0].value, np.array([3.] * 9).reshape(3, 3))
def testEscape(self): """Makes sure that values don't escape a `new_step` scope.""" with imperative_mode.ImperativeMode(self._target) as mode: x = constant_op.constant(1) with mode.new_step(): y = math_ops.add(x, constant_op.constant(3)) self.assertEqual(y.value, 4) with mode.new_step(): with imperative_graph.add_session_attr(ops.Tensor, None): with self.assertRaises(KeyError): _ = y + constant_op.constant(1)
def testNewStep(self): """Tests the `new_step` functionality.""" with imperative_mode.ImperativeMode(self._target) as mode: for _ in range(4): with mode.new_step() as step: a = random_ops.random_uniform([]) a_init = a.value for _ in range(4): with step.new_step(): # Values coming from outside this step's scope should not # be changing. self.assertEqual(a.value, a_init) b = a + random_ops.random_uniform([], minval=0.1) self.assertGreaterEqual(b.value, a.value)
def testTrainingLoop(self): with imperative_mode.ImperativeMode(self._target) as mode: w = variables.Variable(np.random.rand(3)) x = constant_op.constant(np.random.rand(3)) y = math_ops.multiply(x, w) dw = gradients_impl.gradients(y, w) self.assertAllClose(dw[0].value, x.value) for _ in range(3): with mode.new_step(): x = constant_op.constant(np.random.rand(3)) y = math_ops.multiply(x, w) dw = gradients_impl.gradients(y, w) self.assertAllClose(dw[0].value, x.value)
def testBasic(self): """Tests basic functionality. Fetching the value of `d` with `d.value` will evaluate `c` again in non-imperative mode. However, in imperative mode, `c` should have the value it had when it was first evaluated with `c.value`. """ with imperative_mode.ImperativeMode(self._target): a = random_ops.random_normal([]) b = random_ops.random_normal([]) c = a + b c_val = c.value d = c + 1.0 d_val = d.value self.assertAllClose(c_val + 1.0, d_val)
def testStringify(self): with imperative_mode.ImperativeMode(self._target): np_a = np.random.rand(2, 2) a = constant_op.constant(np_a) self.assertEqual(str(a), str(np_a))
def testZeroSized(self): """Tests evaluating zero-sized tensors.""" with imperative_mode.ImperativeMode(self._target): x = constant_op.constant(1) y = array_ops.shape(x) self.assertEqual(list(y.value), [])
def testVarUseInNewStep(self): with imperative_mode.ImperativeMode(self._target) as mode: x = variables.Variable(1.0) with mode.new_step(): self.assertEqual(array_ops.identity(x).value, 1.0)
def testMeanGrad(self): with imperative_mode.ImperativeMode(self._target): x = constant_op.constant([1.0, 2.0]) y = math_ops.reduce_mean(x) dy = gradients_impl.gradients(y, x)[0] self.assertAllEqual(dy.value, [0.5, 0.5])