def testUseExistingGraph(self):

with ops.Graph().as_default() as g, ops.device('/cpu:0'):

a = constant_op.constant(6.0, shape=[1, 1])

b = constant_op.constant(7.0, shape=[1, 1])

c = math_ops.matmul(a, b, name='matmul')

with session.Session(graph=g):

result = c.eval()

self.assertAllEqual(result, [[42.0]])

def testUseDefaultGraph(self):

with ops.Graph().as_default(), ops.device('/cpu:0'):

a = constant_op.constant(6.0, shape=[1, 1])

b = constant_op.constant(7.0, shape=[1, 1])

c = math_ops.matmul(a, b, name='matmul')

with session.Session():

result = c.eval()

self.assertAllEqual(result, [[42.0]])

def testCreate(self):

with session.Session():

inp = constant_op.constant(10.0, shape=[2, 3], name='W1')

copy = array_ops.identity(inp)

# Test with feed.

# TODO(mrry): Investigate why order='F' didn't work.

arr = np.asarray([[0, 1, 2], [3, 4, 5]], dtype=np.float32, order='C')

copy_val = copy.eval({'W1:0': arr})

self.assertAllEqual(arr, copy_val)

# Test without feed.

copy_val = copy.eval()

self.assertAllEqual(np.asarray([[10.0, 10.0, 10.0], [10.0, 10.0, 10.0]],

dtype=np.float32), copy_val)

def testManyCPUs(self):

# TODO(keveman): Implement ListDevices and test for the number of

# devices returned by ListDevices.

with session.Session(

config=config_pb2.ConfigProto(device_count={'CPU': 2})):

inp = constant_op.constant(10.0, name='W1')

self.assertAllEqual(inp.eval(), 10.0)

def testPerSessionThreads(self):

# TODO(keveman): Implement ListDevices and test for the number of

# devices returned by ListDevices.

with session.Session(

config=config_pb2.ConfigProto(use_per_session_threads=True)):

inp = constant_op.constant(10.0, name='W1')

self.assertAllEqual(inp.eval(), 10.0)

def testSessionInterOpThreadPool(self):

config = config_pb2.ConfigProto()

pool = config.session_inter_op_thread_pool.add()

with session.Session(config=config) as s:

inp = constant_op.constant(10.0, name='W1')

results = s.run([inp])

self.assertAllEqual([10.0], results)

pool = config.session_inter_op_thread_pool.add()

pool.num_threads = 1

with session.Session(config=config) as s:

inp = constant_op.constant(20.0, name='W2')

results = s.run([inp])

self.assertAllEqual([20.0], results)

def testErrorsReported(self):

with session.Session() as s:

constant_op.constant(10.0, name='W1')

with self.assertRaises(ValueError):

s.run('foo:0')

def testErrorPayload(self):

with session.Session():

a = array_ops.placeholder(dtypes.float32)

with self.assertRaisesOpError(lambda e: e.op == a.op):

a.eval()

def testErrorCodeWithNoNodeDef(self):

with session.Session() as s:

a = array_ops.placeholder(dtypes.float32, shape=[])

b = array_ops.placeholder(dtypes.float32, shape=[])

r1 = math_ops.add(a, b)

def exc_predicate(e):

return (e.op is None and e.node_def is None and

e.error_code == error_codes_pb2.INVALID_ARGUMENT)

with self.assertRaisesOpError(exc_predicate):

# Run with a bogus handle.

s.partial_run('foo', r1, feed_dict={a: 1, b: 2})

def testOpConstructionErrorPayload(self):

with session.Session():

failing_op = ops.get_default_graph().create_op(

'ConstructionFails', [], [], name='f')

def exc_predicate(e):

return (e.op == failing_op

and e.error_code == error_codes_pb2.INVALID_ARGUMENT)

with self.assertRaisesOpError(exc_predicate):

failing_op.run()

def testErrorBasedOn(self):

with session.Session() as sess:

a = constant_op.constant(0.0, shape=[2, 3])

# NOTE(mrry): The original_op is nonsense, but used here to test that the

# errors are reported correctly.

# pylint: disable=protected-access

with sess.graph._original_op(a.op):

b = array_ops.identity(a, name='id')

with sess.graph._original_op(b.op):

c = array_ops.placeholder(dtypes.float32)

# pylint: enable=protected-access

def exc_predicate(e):

return (e.op == c.op

and e.op._original_op == b.op

and e.op._original_op._original_op == a.op)

with self.assertRaisesOpError(exc_predicate):

c.eval()

def testFetchNone(self):

with session.Session() as s:

a = constant_op.constant(1.0)

with self.assertRaises(TypeError):

s.run(None)

with self.assertRaises(TypeError):

s.run([None])

with self.assertRaises(TypeError):

s.run({'b': None})

with self.assertRaises(TypeError):

s.run({'a': a, 'b': None})

def testFetchSingleton(self):

with session.Session() as sess:

a = constant_op.constant(42.0)

res = sess.run(a)

self.assertEqual(42.0, res)

res = sess.run(a.op) # An op, not a tensor.

self.assertEqual(None, res)

def testFetchSingletonByName(self):

with session.Session() as sess:

a = constant_op.constant(42.0)

res = sess.run(a.name)

self.assertEqual(42.0, res)

res = sess.run(a.op) # An op, not a tensor.

self.assertEqual(None, res)

def testFetchList(self):

with session.Session() as sess:

a = constant_op.constant(42.0)

b = control_flow_ops.no_op() # An op, not a tensor.

c = constant_op.constant(44.0)

v = variables.Variable([54.0])

assign = v.assign([63.0])

res = sess.run([a, b, c, a.name, assign.op])

self.assertTrue(isinstance(res, list))

self.assertEqual(42.0, res[0])

self.assertEqual(None, res[1])

self.assertEqual(44.0, res[2])

self.assertEqual(42.0, res[3])

self.assertEqual(None, res[4])

self.assertEqual(63.0, sess.run(v))

def testFetchTuple(self):

with session.Session() as sess:

a = constant_op.constant(42.0)

b = control_flow_ops.no_op() # An op, not a tensor.

c = constant_op.constant(44.0)

res = sess.run((a, b, c, a.name))

self.assertTrue(isinstance(res, tuple))

self.assertEqual(42.0, res[0])

self.assertEqual(None, res[1])

self.assertEqual(44.0, res[2])

self.assertEqual(42.0, res[3])

def testFetchNamedTuple(self):

# pylint: disable=invalid-name

ABC = collections.namedtuple('ABC', ['a', 'b', 'c'])

# pylint: enable=invalid-name

with session.Session() as sess:

a = constant_op.constant(42.0)

b = control_flow_ops.no_op() # An op, not a tensor.

c = constant_op.constant(44.0)

res = sess.run(ABC(a, b, c))

self.assertTrue(isinstance(res, ABC))

self.assertEqual(42.0, res.a)

self.assertEqual(None, res.b)

self.assertEqual(44.0, res.c)

def testFetchDict(self):

with session.Session() as sess:

a = constant_op.constant(42.0)

b = control_flow_ops.no_op() # An op, not a tensor.

c = constant_op.constant(44.0)

res = sess.run({'a': a, 'b': b, 'c': c})

self.assertTrue(isinstance(res, dict))

self.assertEqual(42.0, res['a'])

self.assertEqual(None, res['b'])

self.assertEqual(44.0, res['c'])

def testFetchOrderedDict(self):

with session.Session() as sess:

a = constant_op.constant(42.0)

b = control_flow_ops.no_op() # An op, not a tensor.

c = constant_op.constant(44.0)

res = sess.run(collections.OrderedDict([(3, a), (2, b), (1, c)]))

self.assertTrue(isinstance(res, collections.OrderedDict))

self.assertEqual([3, 2, 1], list(res.keys()))

self.assertEqual(42.0, res[3])

self.assertEqual(None, res[2])

self.assertEqual(44.0, res[1])

def testFetchNestingEmptyOneLevel(self):

with session.Session() as sess:

a_val = 11.0

a = constant_op.constant(a_val)

res = sess.run([[], tuple(), {}])

self.assertTrue(isinstance(res, list))

self.assertEquals(3, len(res))

self.assertTrue(isinstance(res[0], list))

self.assertEqual(0, len(res[0]))

self.assertTrue(isinstance(res[1], tuple))

self.assertEqual(0, len(res[1]))

self.assertTrue(isinstance(res[2], dict))

self.assertEqual(0, len(res[2]))

res = sess.run([[], tuple(), {}, a])

self.assertTrue(isinstance(res, list))

self.assertEquals(4, len(res))

self.assertTrue(isinstance(res[0], list))

self.assertEqual(0, len(res[0]))

self.assertTrue(isinstance(res[1], tuple))

self.assertEqual(0, len(res[1]))

self.assertTrue(isinstance(res[2], dict))

self.assertEqual(0, len(res[2]))

self.assertEqual(a_val, res[3])

def testFetchNestingOneLevel(self):

with session.Session() as sess:

# pylint: disable=invalid-name

ABC = collections.namedtuple('ABC', ['a', 'b', 'c'])

DEFG = collections.namedtuple('DEFG', ['d', 'e', 'f', 'g'])

# pylint: enable=invalid-name

a_val = 42.0

b_val = None

c_val = 44.0

a = constant_op.constant(a_val)

b = control_flow_ops.no_op() # An op, not a tensor.

c = constant_op.constant(c_val)

# List of lists, tuples, namedtuple, and dict

res = sess.run([[a, b, c], (a, b, c), ABC(a=a, b=b, c=c),

{'a': a.name, 'c': c, 'b': b}])

self.assertTrue(isinstance(res, list))

self.assertEqual(4, len(res))

self.assertTrue(isinstance(res[0], list))

self.assertEqual(3, len(res[0]))

self.assertEqual(a_val, res[0][0])

self.assertEqual(b_val, res[0][1])

self.assertEqual(c_val, res[0][2])

self.assertTrue(isinstance(res[1], tuple))

self.assertEqual(3, len(res[1]))

self.assertEqual(a_val, res[1][0])

self.assertEqual(b_val, res[1][1])

self.assertEqual(c_val, res[1][2])

self.assertTrue(isinstance(res[2], ABC))

self.assertEqual(a_val, res[2].a)

self.assertEqual(b_val, res[2].b)

self.assertEqual(c_val, res[2].c)

self.assertTrue(isinstance(res[3], dict))

self.assertEqual(3, len(res[3]))

self.assertEqual(a_val, res[3]['a'])

self.assertEqual(b_val, res[3]['b'])

self.assertEqual(c_val, res[3]['c'])

# Tuple of lists, tuples, namedtuple, and dict

res = sess.run(([a, b, c], (a.name, b, c), ABC(a=a, b=b, c=c),

{'a': a, 'c': c, 'b': b}))

self.assertTrue(isinstance(res, tuple))

self.assertEqual(4, len(res))

self.assertTrue(isinstance(res[0], list))

self.assertEqual(3, len(res[0]))

self.assertEqual(a_val, res[0][0])

self.assertEqual(b_val, res[0][1])

self.assertEqual(c_val, res[0][2])

self.assertTrue(isinstance(res[1], tuple))

self.assertEqual(3, len(res[1]))

self.assertEqual(a_val, res[1][0])

self.assertEqual(b_val, res[1][1])

self.assertEqual(c_val, res[1][2])

self.assertTrue(isinstance(res[2], ABC))

self.assertEqual(a_val, res[2].a)

self.assertEqual(b_val, res[2].b)

self.assertEqual(c_val, res[2].c)

self.assertTrue(isinstance(res[3], dict))

self.assertEqual(3, len(res[3]))

self.assertEqual(a_val, res[3]['a'])

self.assertEqual(b_val, res[3]['b'])

self.assertEqual(c_val, res[3]['c'])

# Namedtuple of lists, tuples, namedtuples, and dict

res = sess.run(DEFG(d=[a, b, c],

e=(a, b, c),

f=ABC(a=a.name, b=b, c=c),

g={'a': a, 'c': c, 'b': b}))

self.assertTrue(isinstance(res, DEFG))

self.assertTrue(isinstance(res.d, list))

self.assertEqual(3, len(res.d))

self.assertEqual(a_val, res.d[0])

self.assertEqual(b_val, res.d[1])

self.assertEqual(c_val, res.d[2])

self.assertTrue(isinstance(res.e, tuple))

self.assertEqual(3, len(res.e))

self.assertEqual(a_val, res.e[0])

self.assertEqual(b_val, res.e[1])

self.assertEqual(c_val, res.e[2])

self.assertTrue(isinstance(res.f, ABC))

self.assertEqual(a_val, res.f.a)

self.assertEqual(b_val, res.f.b)

self.assertEqual(c_val, res.f.c)

self.assertTrue(isinstance(res.g, dict))

self.assertEqual(3, len(res.g))

self.assertEqual(a_val, res.g['a'])

self.assertEqual(b_val, res.g['b'])

self.assertEqual(c_val, res.g['c'])

# Dict of lists, tuples, namedtuples, and dict

res = sess.run({'d': [a, b, c],

'e': (a, b, c),

'f': ABC(a=a, b=b, c=c),

'g': {'a': a.name, 'c': c, 'b': b}})

self.assertTrue(isinstance(res, dict))

self.assertEqual(4, len(res))

self.assertTrue(isinstance(res['d'], list))

self.assertEqual(3, len(res['d']))

self.assertEqual(a_val, res['d'][0])

self.assertEqual(b_val, res['d'][1])

self.assertEqual(c_val, res['d'][2])

self.assertTrue(isinstance(res['e'], tuple))

self.assertEqual(3, len(res['e']))

self.assertEqual(a_val, res['e'][0])

self.assertEqual(b_val, res['e'][1])

self.assertEqual(c_val, res['e'][2])

self.assertTrue(isinstance(res['f'], ABC))

self.assertEqual(a_val, res['f'].a)

self.assertEqual(b_val, res['f'].b)

self.assertEqual(c_val, res['f'].c)

self.assertTrue(isinstance(res['g'], dict))

self.assertEqual(3, len(res['g']))

self.assertEqual(a_val, res['g']['a'])

self.assertEqual(b_val, res['g']['b'])

self.assertEqual(c_val, res['g']['c'])

def testFetchTensorObject(self):

with session.Session() as s:

a = constant_op.constant(1.0, shape=[1, 2])

b = constant_op.constant(2.0, shape=[2, 3])

c = math_ops.matmul(a, b)

results_with_list = s.run([c])

self.assertAllEqual([[4.0, 4.0, 4.0]], results_with_list[0])

results_with_single = s.run(c)

self.assertAllEqual([[4.0, 4.0, 4.0]], results_with_single)

results_with_get = c.eval()

self.assertAllEqual([[4.0, 4.0, 4.0]], results_with_get)

a_val, b_val = s.run([a, b]) # Test multiple fetches.

self.assertAllEqual([[1.0, 1.0]], a_val)

self.assertAllEqual([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]], b_val)

results_with_dict = s.run({'a': [a], 'b': b, 'z': [a, b]})

self.assertAllEqual([[1.0, 1.0]], results_with_dict['a'][0])

self.assertAllEqual([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]],

results_with_dict['b'])

self.assertAllEqual(results_with_dict['a'][0], results_with_dict['z'][0])

self.assertAllEqual(results_with_dict['b'], results_with_dict['z'][1])

# Test nested structures

results_with_nested_list = s.run([[[a, b], b], a, [a, b]])

self.assertAllEqual([[1.0, 1.0]], results_with_nested_list[0][0][0])

self.assertAllEqual([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]],

results_with_nested_list[0][0][1])

self.assertAllEqual(results_with_nested_list[0][0][0],

results_with_nested_list[1])

self.assertAllEqual(results_with_nested_list[1],

results_with_nested_list[2][0])

self.assertAllEqual(results_with_nested_list[0][0][1],

results_with_nested_list[0][1])

self.assertAllEqual(results_with_nested_list[0][1],

results_with_nested_list[2][1])

def testFetchScalar(self):

with session.Session() as s:

for scalar in np.int32, np.int64, np.float16, np.float32, np.float64:

x = scalar(7)

y = scalar(8)

tf_x = constant_op.constant(x, shape=[])

tf_y = constant_op.constant(y)

tf_xy = math_ops.add(tf_x, tf_y)

# Single fetch

xy = s.run(tf_xy)

self.assertEqual(scalar, type(xy))

self.assertEqual(x + y, xy)

# List fetch

xy, = s.run([tf_xy])

self.assertEqual(scalar, type(xy))

self.assertEqual(x + y, xy)

# Dict fetch

xy = s.run({'xy': tf_xy})['xy']

self.assertEqual(scalar, type(xy))

self.assertEqual(x + y, xy)

# Nested list fetch

xy = s.run([[[tf_xy]], tf_xy, [tf_xy]])

self.assertAllEqual(xy, [[[x + y]], x + y, [x + y]])

self.assertEqual(scalar, type(xy[0][0][0]))

self.assertEqual(scalar, type(xy[1]))

self.assertEqual(scalar, type(xy[2][0]))

def testFetchOperationObject(self):

with session.Session() as s:

a = constant_op.constant(1.0, shape=[1, 2])

v = variables.Variable(a, name='testFetchOperationObject_v')

s.run(v.initializer)

v_val = s.run(v)

self.assertAllEqual([[1.0, 1.0]], v_val)

def testFetchSparseTensor(self):

with session.Session() as s:

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

values = np.array([1.0, 2.0]).astype(np.float32)

shape = np.array([7, 9, 2]).astype(np.int64)

sp = sparse_tensor.SparseTensor(

constant_op.constant(indices),

constant_op.constant(values),

constant_op.constant(shape))

# Single fetch, use as tuple

sp_out = s.run(sp)

indices_out, values_out, shape_out = sp_out

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Single fetch, use as SparseTensorValue

sp_out = s.run(sp)

self.assertAllEqual(sp_out.indices, indices)

self.assertAllEqual(sp_out.values, values)

self.assertAllEqual(sp_out.dense_shape, shape)

# Tuple fetch, use as tuple

indices_out, values_out, shape_out = s.run(sp)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# List fetch, use as tuple

(indices_out, values_out, shape_out), = s.run([sp])

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# List fetch, use as SparseTensorValue

sp_out, = s.run([sp])

self.assertAllEqual(sp_out.indices, indices)

self.assertAllEqual(sp_out.values, values)

self.assertAllEqual(sp_out.dense_shape, shape)

# Dict fetch (single value), use as tuple

indices_out, values_out, shape_out = s.run({'sp': sp})['sp']

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Dict fetch (list value), use as tuple

(indices_out, values_out, shape_out), = s.run({'sp': [sp]})['sp']

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Dict fetch, use as SparseTensorValue

sp_out = s.run({'sp': sp})['sp']

self.assertAllEqual(sp_out.indices, indices)

self.assertAllEqual(sp_out.values, values)

self.assertAllEqual(sp_out.dense_shape, shape)

# Nested list fetch use as tuple

sp_out = s.run([[[sp]], sp])

indices_out, values_out, shape_out = sp_out[0][0][0]

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

indices_out, values_out, shape_out = sp_out[1]

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Nested list fetch, use as SparseTensorValue

sp_out = s.run([[[sp]], sp])

self.assertAllEqual(sp_out[0][0][0].indices, indices)

self.assertAllEqual(sp_out[0][0][0].values, values)

self.assertAllEqual(sp_out[0][0][0].dense_shape, shape)

self.assertAllEqual(sp_out[1].indices, indices)

self.assertAllEqual(sp_out[1].values, values)

self.assertAllEqual(sp_out[1].dense_shape, shape)

def testFeedSparseTensor(self):

with session.Session() as s:

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

values = np.array([1.0, 2.0]).astype(np.float32)

shape = np.array([7, 9, 2]).astype(np.int64)

sp = sparse_tensor.SparseTensor(

array_ops.placeholder(dtype=np.int64, shape=(2, 3)),

array_ops.placeholder(dtype=np.float32, shape=(2,)),

array_ops.placeholder(dtype=np.int64, shape=(3,)),)

sp_indices = array_ops.identity(sp.indices)

sp_values = array_ops.identity(sp.values)

sp_shape = array_ops.identity(sp.dense_shape)

sp2 = sparse_tensor.SparseTensor(sp_indices, sp_values, sp_shape)

# Feed with tuple

indices_out, values_out, shape_out = s.run(

[sp_indices, sp_values, sp_shape], {sp: (indices, values, shape)})

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Feed with tuple, fetch sp directly

sp_out = s.run(sp, {sp: (indices, values, shape)})

self.assertAllEqual(sp_out.indices, indices)

self.assertAllEqual(sp_out.values, values)

self.assertAllEqual(sp_out.dense_shape, shape)

# Feed with SparseTensorValue

indices_out, values_out, shape_out = s.run(

[sp_indices, sp_values, sp_shape],

{sp: sparse_tensor.SparseTensorValue(indices, values, shape)})

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Feed with SparseTensorValue, fetch SparseTensorValue

sp2_out = s.run(

sp2, {sp: sparse_tensor.SparseTensorValue(indices, values, shape)})

self.assertAllEqual(sp2_out.indices, indices)

self.assertAllEqual(sp2_out.values, values)

self.assertAllEqual(sp2_out.dense_shape, shape)

# Feed SparseTensorValue and fetch sp directly.

sp_out = s.run(

sp, {sp: sparse_tensor.SparseTensorValue(indices, values, shape)})

self.assertAllEqual(sp_out.indices, indices)

self.assertAllEqual(sp_out.values, values)

self.assertAllEqual(sp_out.dense_shape, shape)

def testFeedSparsePlaceholder(self):

with session.Session() as s:

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

values = np.array([1.0, 2.0]).astype(np.float32)

shape = np.array([7, 9, 2]).astype(np.int64)

sp = array_ops.sparse_placeholder(dtype=np.float32, name='placeholder1')

sp_indices = array_ops.identity(sp.indices)

sp_values = array_ops.identity(sp.values)

sp_shape = array_ops.identity(sp.dense_shape)

sp2 = sparse_tensor.SparseTensor(sp_indices, sp_values, sp_shape)

# Feed with tuple

indices_out, values_out, shape_out = s.run(

[sp_indices, sp_values, sp_shape], {sp: (indices, values, shape)})

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Feed with SparseTensorValue

indices_out, values_out, shape_out = s.run(

[sp_indices, sp_values, sp_shape],

{sp: sparse_tensor.SparseTensorValue(indices, values, shape)})

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Feed with SparseTensorValue, fetch SparseTensorValue

sp2_out = s.run(

sp2, {sp: sparse_tensor.SparseTensorValue(indices, values, shape)})

self.assertAllEqual(sp2_out.indices, indices)

self.assertAllEqual(sp2_out.values, values)

self.assertAllEqual(sp2_out.dense_shape, shape)

def testFeedSparsePlaceholderPartialShape(self):

with session.Session() as s:

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

values = np.array([1.0, 2.0]).astype(np.float32)

shape = np.array([7, 9, 2]).astype(np.int64)

sp = array_ops.sparse_placeholder(

shape=[None, 9, 2], dtype=np.float32, name='placeholder1')

sp_indices = array_ops.identity(sp.indices)

sp_values = array_ops.identity(sp.values)

sp_shape = array_ops.identity(sp.dense_shape)

sp2 = sparse_tensor.SparseTensor(sp_indices, sp_values, sp_shape)

# Feed with tuple

indices_out, values_out, shape_out = s.run(

[sp_indices, sp_values, sp_shape], {sp: (indices, values, shape)})

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Feed with SparseTensorValue

indices_out, values_out, shape_out = s.run(

[sp_indices, sp_values, sp_shape],

{sp: sparse_tensor.SparseTensorValue(indices, values, shape)})

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

# Feed with SparseTensorValue, fetch SparseTensorValue

sp2_out = s.run(

sp2, {sp: sparse_tensor.SparseTensorValue(indices, values, shape)})

self.assertAllEqual(sp2_out.indices, indices)

self.assertAllEqual(sp2_out.values, values)

self.assertAllEqual(sp2_out.dense_shape, shape)

def testFeedSparsePlaceholderConstantShape(self):

with session.Session() as s:

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

values = np.array([1.0, 2.0]).astype(np.float32)

shape = np.array([7, 9, 2]).astype(np.int64)

sp = array_ops.sparse_placeholder(dtype=np.float32,

shape=shape,

name='placeholder1')

self.assertAllEqual(sp.dense_shape.eval(session=s), shape)

self.assertAllEqual(tensor_util.constant_value(sp.dense_shape), shape)

sp_indices = array_ops.identity(sp.indices)

sp_values = array_ops.identity(sp.values)

sp_shape = array_ops.identity(sp.dense_shape)

# Feed with tuple

indices_out, values_out, shape_out = s.run(

[sp_indices, sp_values, sp_shape], {sp: (indices, values)})

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(values_out, values)

self.assertAllEqual(shape_out, shape)

def testFetchIndexedSlices(self):

with session.Session() as s:

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

values = np.array([1.0, 2.0]).astype(np.float32)

dense_shape = np.array([7, 9, 2]).astype(np.int64)

ind = ops.IndexedSlices(

constant_op.constant(values), constant_op.constant(indices),

constant_op.constant(dense_shape))

# Single fetch, use as tuple

ind_out = s.run(ind)

values_out, indices_out, dense_shape_out = ind_out

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# Single fetch, use as IndexedSlicesValue

ind_out = s.run(ind)

self.assertAllEqual(ind_out.values, values)

self.assertAllEqual(ind_out.indices, indices)

self.assertAllEqual(ind_out.dense_shape, dense_shape)

# Tuple fetch, use as tuple

values_out, indices_out, dense_shape_out = s.run(ind)

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# List fetch, use as tuple

(values_out, indices_out, dense_shape_out), = s.run([ind])

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# List fetch, use as IndexedSlicesValue

ind_out, = s.run([ind])

self.assertAllEqual(ind_out.values, values)

self.assertAllEqual(ind_out.indices, indices)

self.assertAllEqual(ind_out.dense_shape, dense_shape)

def testFeedIndexedSlices(self):

with session.Session() as s:

values = np.array([1.0, 2.0]).astype(np.float32)

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

dense_shape = np.array([7, 9, 2]).astype(np.int64)

ind = ops.IndexedSlices(

array_ops.placeholder(dtype=np.float32,

shape=(2,)),

array_ops.placeholder(dtype=np.int64,

shape=(2, 3)),

array_ops.placeholder(dtype=np.int64,

shape=(3,)),)

ind_values = array_ops.identity(ind.values)

ind_indices = array_ops.identity(ind.indices)

ind_dense_shape = array_ops.identity(ind.dense_shape)

ind2 = ops.IndexedSlices(ind_values, ind_indices, ind_dense_shape)

# Feed with tuple

values_out, indices_out, dense_shape_out = s.run(

[ind_values, ind_indices, ind_dense_shape],

{ind: (values, indices, dense_shape)})

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# Feed with IndexedSlicesValue

values_out, indices_out, dense_shape_out = s.run(

[ind_values, ind_indices, ind_dense_shape],

{ind: ops.IndexedSlicesValue(values, indices, dense_shape)})

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# Feed with IndexedSlicesValue, fetch IndexedSlicesValue

ind2_out = s.run(ind2, {ind: ops.IndexedSlicesValue(values, indices,

dense_shape)})

self.assertAllEqual(ind2_out.values, values)

self.assertAllEqual(ind2_out.indices, indices)

self.assertAllEqual(ind2_out.dense_shape, dense_shape)

def testFetchIndexedSlicesWithoutDenseShape(self):

with session.Session() as s:

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

values = np.array([1.0, 2.0]).astype(np.float32)

dense_shape = None

ind = ops.IndexedSlices(

constant_op.constant(values), constant_op.constant(indices), None)

# Single fetch, use as tuple

ind_out = s.run(ind)

values_out, indices_out, dense_shape_out = ind_out

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# Single fetch, use as IndexedSlicesValue

ind_out = s.run(ind)

self.assertAllEqual(ind_out.values, values)

self.assertAllEqual(ind_out.indices, indices)

self.assertAllEqual(ind_out.dense_shape, dense_shape)

# Tuple fetch, use as tuple

values_out, indices_out, dense_shape_out = s.run(ind)

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# List fetch, use as tuple

(values_out, indices_out, dense_shape_out), = s.run([ind])

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

self.assertAllEqual(dense_shape_out, dense_shape)

# List fetch, use as IndexedSlicesValue

ind_out, = s.run([ind])

self.assertAllEqual(ind_out.values, values)

self.assertAllEqual(ind_out.indices, indices)

self.assertAllEqual(ind_out.dense_shape, dense_shape)

def testFeedIndexedSlicesWithoutDenseShape(self):

with session.Session() as s:

values = np.array([1.0, 2.0]).astype(np.float32)

indices = np.array([[3, 2, 0], [4, 5, 1]]).astype(np.int64)

dense_shape = None

ind = ops.IndexedSlices(

array_ops.placeholder(dtype=np.float32,

shape=(2,)),

array_ops.placeholder(dtype=np.int64,

shape=(2, 3)),

None)

ind_values = array_ops.identity(ind.values)

ind_indices = array_ops.identity(ind.indices)

ind2 = ops.IndexedSlices(ind_values, ind_indices)

# Feed with tuple

values_out, indices_out = s.run(

[ind_values, ind_indices], {ind: (values, indices)})

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

# Feed with IndexedSlicesValue

values_out, indices_out = s.run(

[ind_values, ind_indices],

{ind: ops.IndexedSlicesValue(values, indices, dense_shape)})

self.assertAllEqual(values_out, values)

self.assertAllEqual(indices_out, indices)

# Feed with IndexedSlicesValue, fetch IndexedSlicesValue

ind2_out = s.run(ind2, {ind: ops.IndexedSlicesValue(values, indices,

dense_shape)})

self.assertAllEqual(ind2_out.values, values)

self.assertAllEqual(ind2_out.indices, indices)

self.assertAllEqual(ind2_out.dense_shape, dense_shape)

def testExtendWithStatelessOperations(self):

with session.Session() as s:

a = constant_op.constant(1.0, shape=[1, 2])

b = constant_op.constant(2.0, shape=[2, 3])

c = math_ops.matmul(a, b)

c_val = s.run(c)

self.assertAllEqual([[4.0, 4.0, 4.0]], c_val)

d = constant_op.constant([1.0, 2.0, 3.0], shape=[3, 1])

e = math_ops.matmul(c, d)

# Extend will happen here.

e_val = s.run(e)

self.assertAllEqual([[24.0]], e_val)

def testExtendWithStatefulOperations(self):

with session.Session() as s:

a = constant_op.constant(1.0, shape=[1, 2])

b = constant_op.constant(2.0, shape=[2, 3])

c = math_ops.matmul(a, b)

v = variables.Variable(c, name='testExtendWithStatefulOperations_v')

v.initializer.run()

v_val = v.eval()

self.assertAllEqual([[4.0, 4.0, 4.0]], v_val)

d = constant_op.constant(3.0, shape=[2, 3])

e = math_ops.matmul(a, d)

assign_e_to_v = state_ops.assign(v, e)

# Extend will happen here.

e_val = e.eval()

self.assertAllEqual([[6.0, 6.0, 6.0]], e_val)

v_val = v.eval()