# Copyright 2015 The TensorFlow Authors. All Rights Reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ==============================================================================

"""Tests for tensorflow.python.client.session.Session."""

import collections

import os

import random

import sys

import threading

import time

import warnings

import numpy as np

import six

from tensorflow.core.framework import attr_value_pb2

from tensorflow.core.lib.core import error_codes_pb2

from tensorflow.core.protobuf import config_pb2

from tensorflow.python.client import session

from tensorflow.python.eager import context

from tensorflow.python.eager import def_function

from tensorflow.python.framework import config

from tensorflow.python.framework import constant_op

from tensorflow.python.framework import device as framework_device_lib

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import errors

from tensorflow.python.framework import function

from tensorflow.python.framework import importer

from tensorflow.python.framework import indexed_slices

from tensorflow.python.framework import ops

from tensorflow.python.framework import sparse_tensor

from tensorflow.python.framework import tensor_util

from tensorflow.python.framework import test_util

from tensorflow.python.framework import versions

from tensorflow.python.ops import array_ops

from tensorflow.python.ops import control_flow_ops

from tensorflow.python.ops import data_flow_ops

from tensorflow.python.ops import gen_control_flow_ops

# Import gradients to resolve circular imports

from tensorflow.python.ops import gradients # pylint: disable=unused-import

from tensorflow.python.ops import gradients_impl

from tensorflow.python.ops import math_ops

# Import resource_variable_ops for the variables-to-tensor implicit conversion.

from tensorflow.python.ops import resource_variable_ops # pylint: disable=unused-import

from tensorflow.python.ops import state_ops

from tensorflow.python.ops import variables

from tensorflow.python.platform import googletest

from tensorflow.python.training import server_lib

from tensorflow.python.util import compat

try:

import attr # pylint:disable=g-import-not-at-top

except ImportError:

attr = None

try:

from frozendict import frozendict # pylint:disable=g-import-not-at-top

except ImportError:

frozendict = dict # pylint:disable=invalid-name

defaultdict = collections.defaultdict # pylint:disable=invalid-name

@test_util.with_eager_op_as_function

class SessionTest(test_util.TensorFlowTestCase):

def setUp(self):

super(SessionTest, self).setUp()

warnings.simplefilter('always')

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):

with session.Session(

config=config_pb2.ConfigProto(device_count={

'CPU': 2, 'GPU': 0

})) as sess:

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

self.assertAllEqual(inp, 10.0)

num_cpu_devices = 0

num_gpu_devices = 0

for device in sess.list_devices():

device_type = framework_device_lib.DeviceSpec.from_string(

device.name).device_type

if device_type == 'CPU':

num_cpu_devices += 1

elif device_type == 'GPU':

num_gpu_devices += 1

self.assertEqual(2, num_cpu_devices)

self.assertEqual(0, num_gpu_devices)

def testPerSessionThreads(self):

with session.Session(

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

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

self.assertAllEqual(inp, 10.0)

def testSessionInterOpThreadPool(self):

config_pb = config_pb2.ConfigProto()

pool = config_pb.session_inter_op_thread_pool.add()

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

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

results = s.run([inp])

self.assertAllEqual([10.0], results)

pool = config_pb.session_inter_op_thread_pool.add()

pool.num_threads = 1

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

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

results = s.run([inp])

self.assertAllEqual([20.0], results)

pool = config_pb.session_inter_op_thread_pool.add()

pool.num_threads = 1

pool.global_name = 't1'

run_options = config_pb2.RunOptions()

run_options.inter_op_thread_pool = (

len(config_pb.session_inter_op_thread_pool) - 1)

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

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

results = s.run([inp], options=run_options)

self.assertAllEqual([30.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 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.

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)

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.assertIsNone(res)

tensor_runner = sess.make_callable(a)

res = tensor_runner()

self.assertEqual(42.0, res)

op_runner = sess.make_callable(a.op)

res = op_runner()

self.assertIsNone(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.assertIsNone(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.assertIsInstance(res, list)

self.assertEqual([42.0, None, 44.0, 42.0, None], res)

list_runner = sess.make_callable([a, b, c, a.name, assign.op])

res = list_runner()

self.assertIsInstance(res, list)

self.assertEqual([42.0, None, 44.0, 42.0, None], res)

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.assertIsInstance(res, tuple)

self.assertEqual((42.0, None, 44.0, 42.0), res)

tuple_runner = sess.make_callable((a, b, c, a.name))

res = tuple_runner()

self.assertIsInstance(res, tuple)

self.assertEqual((42.0, None, 44.0, 42.0), res)

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.assertIsInstance(res, ABC)

self.assertEqual(42.0, res.a)

self.assertIsNone(res.b)

self.assertEqual(44.0, res.c)

namedtuple_runner = sess.make_callable(ABC(a, b, c))

res = namedtuple_runner()

self.assertIsInstance(res, ABC)

self.assertEqual(42.0, res.a)

self.assertIsNone(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.assertIsInstance(res, dict)

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

self.assertIsNone(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.assertIsInstance(res, collections.OrderedDict)

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

self.assertEqual(42.0, res[3])

self.assertIsNone(res[2])

self.assertEqual(44.0, res[1])

@test_util.run_v1_only('b/120545219')

def testFetchAttrs(self):

if attr is None:

self.skipTest('attr module is unavailable.')

@attr.s

class SampleAttr(object):

field1 = attr.ib()

field2 = attr.ib()

val1 = np.array([1.2, 3.4, 5.6])

val2 = np.array([[1, 2], [4, 3]])

val3 = np.array([10, 20, 30])

t1 = constant_op.constant(val1)

t2 = constant_op.constant(val2)

sample = SampleAttr(t1, t2)

with session.Session() as sess:

result = sess.run(sample)

self.assertIsInstance(result, SampleAttr)

self.assertAllEqual(val1, result.field1)

self.assertAllEqual(val2, result.field2)

result = sess.run(sample, feed_dict={sample.field1: val3})

self.assertIsInstance(result, SampleAttr)

self.assertAllEqual(val3, result.field1)

self.assertAllEqual(val2, result.field2)

@test_util.run_v1_only('b/120545219')

def testFetchNestedAttrs(self):

if attr is None:

self.skipTest('attr module is unavailable.')

@attr.s

class SampleAttr(object):

field0 = attr.ib()

field1 = attr.ib()

v1 = 10

v2 = 20

v3 = np.float32(1.2)

v4 = np.float32(3.4)

v5 = np.float64(100.001)

v6 = np.float64(-23.451)

arr1 = np.array([1.2, 6.7, 3.4])

arr2 = np.array([7, 11, 3])

sample = SampleAttr(

SampleAttr(

SampleAttr(constant_op.constant(v1), constant_op.constant(v2)),

SampleAttr(constant_op.constant(arr1), constant_op.constant(arr2))),

{'A': SampleAttr(constant_op.constant(v3), constant_op.constant(v4)),

'B': [SampleAttr(constant_op.constant(v5), constant_op.constant(v6))]})

with session.Session() as sess:

result = sess.run(sample)

self.assertIsInstance(result, SampleAttr)

self.assertIsInstance(result.field0, SampleAttr)

self.assertIsInstance(result.field0.field0, SampleAttr)

self.assertIsInstance(result.field0.field1, SampleAttr)

self.assertIsInstance(result.field0.field1.field0, np.ndarray)

self.assertAllEqual(arr1, result.field0.field1.field0)

self.assertIsInstance(result.field0.field1.field1, np.ndarray)

self.assertAllEqual(arr2, result.field0.field1.field1)

self.assertIsInstance(result.field1, dict)

self.assertIn('A', result.field1)

self.assertIn('B', result.field1)

self.assertIsInstance(result.field1['A'], SampleAttr)

self.assertAllEqual(

[v3, v4],

[result.field1['A'].field0, result.field1['A'].field1])

self.assertIsInstance(result.field1['B'], list)

self.assertEqual(1, len(result.field1['B']))

self.assertIsInstance(result.field1['B'][0], SampleAttr)

self.assertAllEqual(

[v5, v6],

[result.field1['B'][0].field0, result.field1['B'][0].field1])

def testFetchNestingEmptyOneLevel(self):

with session.Session() as sess:

a_val = 11.0

a = constant_op.constant(a_val)

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

self.assertIsInstance(res, list)

self.assertEqual(3, len(res))

self.assertIsInstance(res[0], list)

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

self.assertIsInstance(res[1], tuple)

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

self.assertIsInstance(res[2], dict)

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

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

self.assertIsInstance(res, list)

self.assertEqual(4, len(res))

self.assertIsInstance(res[0], list)

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

self.assertIsInstance(res[1], tuple)

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

self.assertIsInstance(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'])

DEFGHI = collections.namedtuple('DEFGHI', ['d', 'e', 'f', 'g', 'h', 'i'])

# 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)

test_dct = {'a': a.name, 'c': c, 'b': b}

test_dct_types = [dict, frozendict, defaultdict]

# List of lists, tuples, namedtuple, dict, frozendict, and defaultdict

res = sess.run([

[a, b, c],

(a, b, c),

ABC(a=a, b=b, c=c),

dict(test_dct),

frozendict(test_dct),

defaultdict(str, test_dct),

])

self.assertIsInstance(res, list)

self.assertEqual(6, len(res))

self.assertIsInstance(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.assertIsInstance(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.assertIsInstance(res[2], ABC)

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

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

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

for expected_type, r in zip(test_dct_types, res[3:]):

self.assertIsInstance(r, expected_type)

self.assertEqual(3, len(r))

self.assertEqual(a_val, r['a'])

self.assertEqual(b_val, r['b'])

self.assertEqual(c_val, r['c'])

self.assertEqual(res[5].default_factory, str)

# Tuple of lists, tuples, namedtuple, dict, frozendict, and defaultdict

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

c=c), dict(test_dct),

frozendict(test_dct), defaultdict(str, test_dct)))

self.assertIsInstance(res, tuple)

self.assertEqual(6, len(res))

self.assertIsInstance(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.assertIsInstance(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.assertIsInstance(res[2], ABC)

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

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

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

for expected_type, r in zip(test_dct_types, res[3:]):

self.assertIsInstance(r, expected_type)

self.assertEqual(3, len(r))

self.assertEqual(a_val, r['a'])

self.assertEqual(b_val, r['b'])

self.assertEqual(c_val, r['c'])

self.assertEqual(res[5].default_factory, str)

# Namedtuple of lists, tuples, namedtuples, dict, frozendict, defaultdict

res = sess.run(

DEFGHI(

d=[a, b, c],

e=(a, b, c),

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

g=dict(test_dct),

h=frozendict(test_dct),

i=defaultdict(str, test_dct)))

self.assertIsInstance(res, DEFGHI)

self.assertIsInstance(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.assertIsInstance(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.assertIsInstance(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.assertIsInstance(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'])

self.assertIsInstance(res.h, frozendict)

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

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

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

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

self.assertIsInstance(res.i, defaultdict)

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

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

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

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

self.assertEqual(res.i.default_factory, str)

# Dict of lists, tuples, namedtuples, dict, frozendict, defaultdict

res = sess.run({

'd': [a, b, c],

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

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

'g': dict(test_dct),

'h': frozendict(test_dct),

'i': defaultdict(str, test_dct),

})

self.assertIsInstance(res, dict)

self.assertEqual(6, len(res))

self.assertIsInstance(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.assertIsInstance(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.assertIsInstance(res['f'], ABC)

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

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

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

for expected_type, r_key in zip(test_dct_types, ('g', 'h', 'i')):

r = res[r_key]

self.assertIsInstance(r, expected_type)

self.assertEqual(3, len(r))

self.assertEqual(a_val, r['a'])

self.assertEqual(b_val, r['b'])

self.assertEqual(c_val, r['c'])

self.assertEqual(res['i'].default_factory, str)

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.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 = indexed_slices.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 = indexed_slices.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 = indexed_slices.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: indexed_slices.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: indexed_slices.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 = indexed_slices.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 = indexed_slices.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 = indexed_slices.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: indexed_slices.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: indexed_slices.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])