def _testDuplicateTensorArrayFails(self, use_gpu): with self.test_session(use_gpu=use_gpu) as sess: h1 = data_flow_ops.TensorArray( size=1, dtype=tf.float32, tensor_array_name="foo") c1 = h1.write(0, 4.0) h2 = data_flow_ops.TensorArray( size=1, dtype=tf.float32, tensor_array_name="foo") c2 = h2.write(0, 5.0) with self.assertRaises(errors.AlreadyExistsError): sess.run([c1.flow, c2.flow])
def _testMultiTensorArray(self, use_gpu): with self.test_session(use_gpu=use_gpu): h1 = data_flow_ops.TensorArray( size=1, dtype=tf.float32, tensor_array_name="foo") w1 = h1.write(0, 4.0) r1 = w1.read(0) h2 = data_flow_ops.TensorArray( size=1, dtype=tf.float32, tensor_array_name="bar") w2 = h2.write(0, 5.0) r2 = w2.read(0) r = r1 + r2 self.assertAllClose(9.0, r.eval())
def _testTensorArrayReadWrongIndexOrDataTypeFails(self, use_gpu): with self.test_session(use_gpu=use_gpu): h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) w0 = h.write(0, [[4.0, 5.0]]) # Test reading wrong datatype r0_bad = gen_data_flow_ops._tensor_array_read( handle=w0.handle, index=0, dtype=tf.int64, flow_in=w0.flow) with self.assertRaisesOpError( "TensorArray dtype is float but Op requested dtype int64."): r0_bad.eval() # Test reading from a different index than the one we wrote to r1 = w0.read(1) with self.assertRaisesOpError( "Could not read from TensorArray index 1 because " "it has not yet been written to."): r1.eval() # Test reading from a negative index with self.assertRaisesOpError( r"Tried to read from index -1 but array size is: 3"): h.read(-1).eval() # Test reading from too large an index with self.assertRaisesOpError( "Tried to read from index 3 but array size is: 3"): h.read(3).eval()
def _TensorArrayReadGrad(op, grad): handle = op.inputs[0] index = op.inputs[1] dtype = op.get_attr("dtype") g = data_flow_ops.TensorArray(size=None, dtype=dtype, handle=handle).grad() w_g = g.write(index, grad) return [None, None, w_g.flow]
def _testTensorArrayUnpackRead(self, tf_dtype, use_gpu): dtype = tf_dtype.as_numpy_dtype() with self.test_session(use_gpu=use_gpu) as sess: h = data_flow_ops.TensorArray( dtype=tf_dtype, tensor_array_name="foo", size=3) if tf_dtype == tf.string: convert = lambda x: np.asarray(x).astype(np.str) else: convert = lambda x: np.asarray(x).astype(dtype) # Unpack a vector into scalars w0 = h.unpack(convert([1.0, 2.0, 3.0])) r0 = w0.read(0) r1 = w0.read(1) r2 = w0.read(2) d0, d1, d2 = sess.run([r0, r1, r2]) self.assertAllEqual(convert(1.0), d0) self.assertAllEqual(convert(2.0), d1) self.assertAllEqual(convert(3.0), d2) # Unpack a matrix into vectors w1 = h.unpack(convert([[1.0, 1.1], [2.0, 2.1], [3.0, 3.1]])) r0 = w1.read(0) r1 = w1.read(1) r2 = w1.read(2) d0, d1, d2 = sess.run([r0, r1, r2]) self.assertAllEqual(convert([1.0, 1.1]), d0) self.assertAllEqual(convert([2.0, 2.1]), d1) self.assertAllEqual(convert([3.0, 3.1]), d2)
def _testTensorGradArrayWriteRead(self, use_gpu): with self.test_session(use_gpu=use_gpu) as sess: h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) g_h = h.grad() w0 = h.write(0, [[4.0, 5.0]]) w1 = w0.write(1, [[1.0]]) w2 = w1.write(2, -3.0) g_w0 = g_h.write(0, [[5.0, 6.0]]) g_w1 = g_w0.write(1, [[2.0]]) g_w2 = g_w1.write(2, -2.0) r0 = w2.read(0) r1 = w2.read(1) r2 = w2.read(2) g_r0 = g_w2.read(0) g_r1 = g_w2.read(1) g_r2 = g_w2.read(2) d0, d1, d2, g_d0, g_d1, g_d2 = sess.run([r0, r1, r2, g_r0, g_r1, g_r2]) self.assertAllEqual([[4.0, 5.0]], d0) self.assertAllEqual([[1.0]], d1) self.assertAllEqual(-3.0, d2) self.assertAllEqual([[5.0, 6.0]], g_d0) self.assertAllEqual([[2.0]], g_d1) self.assertAllEqual(-2.0, g_d2)
def _TensorArrayUnpackGrad(op, flow): # handle is the output store_handle of TensorArrayReadGrad or # the handle output of TensorArrayUnpackGrad. we must use this one. handle = op.inputs[0] dtype = op.get_attr("T") g = data_flow_ops.TensorArray(size=None, dtype=dtype, handle=handle).grad() with ops.control_dependencies([flow]): grad = g.pack() return [None, grad, flow]
def testTensorArrayPackNotAllValuesAvailableFails(self): with self.test_session(): h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) with self.assertRaisesOpError( "Could not read from TensorArray index 1 " "because it has not yet been written to."): h.write(0, [[4.0, 5.0]]).pack().eval()
def testTensorArrayUnpackWrongMajorSizeFails(self): with self.test_session(): h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) with self.assertRaisesOpError( r"Input value must have first dimension " r"equal to the array size \(2 vs. 3\)"): h.unpack([1.0, 2.0]).flow.eval()
def _testTensorArrayWriteMultipleFails(self, use_gpu): with self.test_session(use_gpu=use_gpu): h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) with self.assertRaisesOpError( "Could not write to TensorArray index 2 because " "it has already been written to."): h.write(2, 3.0).write(2, 3.0).flow.eval()
def _testWriteCloseTensorArray(self, use_gpu): with self.test_session(use_gpu=use_gpu): h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) w0 = h.write(0, [[4.0, 5.0]]) w1 = w0.write(1, [3.0]) w1.close().run() # Expected to run without problems with self.assertRaisesOpError(r"Tensor foo has already been closed."): with tf.control_dependencies([w1.close()]): w1.write(2, 3.0).flow.eval()
def _testTensorArrayWriteGradientAddMultipleAddsType(self, use_gpu, dtype): with self.test_session(use_gpu=use_gpu): h = data_flow_ops.TensorArray( dtype=dtype, tensor_array_name="foo", size=3) h._gradient_add = True c = lambda x: np.asarray(x, dtype=dtype.as_numpy_dtype) w0 = h.write(2, c(3.0)) w1 = w0.write(2, c(4.0)) self.assertAllEqual(c(7.00), w1.read(2).eval())
def _testTensorGradAccessTwiceReceiveSameObject(self, use_gpu): with self.test_session(use_gpu=use_gpu) as sess: h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) g_h_0 = h.grad() g_h_1 = h.grad() with tf.control_dependencies([g_h_0.write(0, [[4.0, 5.0]]).flow]): # Write with one gradient handle, read with another copy of it r1_0 = g_h_1.read(0) t_g_h_0, t_g_h_1, d_r1_0 = sess.run([g_h_0.handle, g_h_1.handle, r1_0]) self.assertAllEqual(t_g_h_0, t_g_h_1) self.assertAllEqual([[4.0, 5.0]], d_r1_0)
def _testTensorArrayWritePack(self, tf_dtype, use_gpu): dtype = tf_dtype.as_numpy_dtype() with self.test_session(use_gpu=use_gpu): h = data_flow_ops.TensorArray( dtype=tf_dtype, tensor_array_name="foo", size=3) if tf_dtype == tf.string: convert = lambda x: np.asarray(x).astype(np.str) else: convert = lambda x: np.asarray(x).astype(dtype) w0 = h.write(0, convert([[4.0, 5.0]])) w1 = w0.write(1, convert([[6.0, 7.0]])) w2 = w1.write(2, convert([[8.0, 9.0]])) c0 = w2.pack() self.assertAllEqual( convert([[[4.0, 5.0]], [[6.0, 7.0]], [[8.0, 9.0]]]), c0.eval())
def _testTensorArrayWriteWrongIndexOrDataTypeFails(self, use_gpu): with self.test_session(use_gpu=use_gpu): h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) # Test writing the wrong datatype with self.assertRaisesOpError( "TensorArray dtype is float but Op is trying to write dtype string"): h.write(-1, "wrong_type_scalar").flow.eval() # Test writing to a negative index with self.assertRaisesOpError( "Tried to write to index -1 but array size is: 3"): h.write(-1, 3.0).flow.eval() # Test reading from too large an index with self.assertRaisesOpError( "Tried to write to index 3 but array size is: 3"): h.write(3, 3.0).flow.eval()
def _testTensorArrayGradientUnpackRead(self, use_gpu): with self.test_session(use_gpu=use_gpu) as sess: h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=2) value = tf.constant([[1.0, -1.0], [10.0, -10.0]]) w = h.unpack(value) r0 = w.read(0) r0_1 = w.read(0) r1 = w.read(1) # Test combined gradients + aggregation of read(0) grad = tf.gradients( ys=[r0, r0_1, r1], xs=[value], grad_ys= [[2.0, 3.0], [-1.5, 1.5], [4.0, 5.0]]) grad_vals = sess.run(grad) self.assertEqual(len(grad_vals), 1) self.assertAllClose([[2.0 - 1.5, 3.0 + 1.5], [4.0, 5.0]], grad_vals[0])
def _testTensorArrayGradientWriteReadType(self, use_gpu, dtype): with self.test_session(use_gpu=use_gpu) as sess: h = data_flow_ops.TensorArray( dtype=tf.as_dtype(dtype), tensor_array_name="foo", size=3) c = lambda x: np.array(x, dtype=dtype) value_0 = tf.constant(c([[4.0, 5.0]])) value_1 = tf.constant(c(3.0)) w0 = h.write(0, value_0) w1 = w0.write(1, value_1) r0 = w1.read(0) r1 = w1.read(1) r0_2 = w1.read(0) # Test individual components' gradients grad_just_r0 = tf.gradients( ys=[r0], xs=[value_0], grad_ys=[c([[2.0, 3.0]])]) grad_just_r0_vals = sess.run(grad_just_r0) self.assertAllEqual(c([[2.0, 3.0]]), grad_just_r0_vals[0]) grad_r0_r0_2 = tf.gradients( ys=[r0, r0_2], xs=[value_0], grad_ys=[c([[2.0, 3.0]]), c([[1.0, -1.0]])]) grad_r0_r0_2_vals = sess.run(grad_r0_r0_2) self.assertAllEqual(c([[3.0, 2.0]]), grad_r0_r0_2_vals[0]) grad_just_r1 = tf.gradients( ys=[r1], xs=[value_1], grad_ys=[c(-2.0)]) grad_just_r1_vals = sess.run(grad_just_r1) self.assertAllEqual(c(-2.0), grad_just_r1_vals[0]) # Test combined gradients grad = tf.gradients( ys=[r0, r0_2, r1], xs=[value_0, value_1], grad_ys=[c(-1.0), c(-2.0), c([[2.0, 3.0]])]) grad_vals = sess.run(grad) self.assertEqual(len(grad_vals), 2) self.assertAllClose(c(-3.0), grad_vals[0]) self.assertAllEqual(c([[2.0, 3.0]]), grad_vals[1])
def _testTensorArrayGradientWritePackAndRead(self, use_gpu): with self.test_session(use_gpu=use_gpu) as sess: h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=2) value_0 = tf.constant([-1.0, 1.0]) value_1 = tf.constant([-10.0, 10.0]) w0 = h.write(0, value_0) w1 = w0.write(1, value_1) p0 = w1.pack() r0 = w1.read(0) # Test gradient accumulation between read(0) and pack() grad_r = tf.gradients( ys=[p0, r0], xs=[value_0, value_1], grad_ys=[ [[2.0, 3.0], [4.0, 5.0]], [-0.5, 1.5]]) grad_vals = sess.run(grad_r) # 2 + 2 entries self.assertAllClose([2.0 - 0.5, 3.0 + 1.5], grad_vals[0]) self.assertAllEqual([4.0, 5.0], grad_vals[1])
def _TensorArrayPackGrad(op, grad): handle = op.inputs[0] dtype = op.get_attr("dtype") g = data_flow_ops.TensorArray(size=None, dtype=dtype, handle=handle).grad() u_g = g.unpack(grad) return [None, u_g.flow]
def _testCloseTensorArray(self, use_gpu): with self.test_session(use_gpu=use_gpu) as sess: h = data_flow_ops.TensorArray( dtype=tf.float32, tensor_array_name="foo", size=3) c1 = h.close() sess.run(c1)