wehub-resource-sync
292 lines
13 KiB
Python
292 lines
13 KiB
Python
# Copyright 2017 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.
|
|
# ==============================================================================
|
|
"""Test cases for operators with > 3 or arbitrary numbers of arguments."""
|
|
|
|
import unittest
|
|
|
|
import numpy as np
|
|
|
|
from tensorflow.compiler.tests import xla_test
|
|
from tensorflow.python.framework import dtypes
|
|
from tensorflow.python.framework import errors
|
|
from tensorflow.python.ops import array_ops
|
|
from tensorflow.python.ops import math_ops
|
|
from tensorflow.python.platform import googletest
|
|
|
|
|
|
class NAryOpsTest(xla_test.XLATestCase):
|
|
|
|
def _testNAry(self, op, args, expected, equality_fn=None):
|
|
with self.session() as session:
|
|
with self.test_scope():
|
|
placeholders = [
|
|
array_ops.placeholder(dtypes.as_dtype(arg.dtype), arg.shape)
|
|
for arg in args
|
|
]
|
|
feeds = {placeholders[i]: args[i] for i in range(0, len(args))}
|
|
output = op(placeholders)
|
|
result = session.run(output, feeds)
|
|
if not equality_fn:
|
|
equality_fn = self.assertAllClose
|
|
equality_fn(result, expected, rtol=1e-3)
|
|
|
|
def _nAryListCheck(self, results, expected, **kwargs):
|
|
self.assertEqual(len(results), len(expected))
|
|
for (r, e) in zip(results, expected):
|
|
self.assertAllClose(r, e, **kwargs)
|
|
|
|
def _testNAryLists(self, op, args, expected):
|
|
self._testNAry(op, args, expected, equality_fn=self._nAryListCheck)
|
|
|
|
def testFloat(self):
|
|
self._testNAry(math_ops.add_n,
|
|
[np.array([[1, 2, 3]], dtype=np.float32)],
|
|
expected=np.array([[1, 2, 3]], dtype=np.float32))
|
|
|
|
self._testNAry(math_ops.add_n,
|
|
[np.array([1, 2], dtype=np.float32),
|
|
np.array([10, 20], dtype=np.float32)],
|
|
expected=np.array([11, 22], dtype=np.float32))
|
|
self._testNAry(math_ops.add_n,
|
|
[np.array([-4], dtype=np.float32),
|
|
np.array([10], dtype=np.float32),
|
|
np.array([42], dtype=np.float32)],
|
|
expected=np.array([48], dtype=np.float32))
|
|
|
|
def testComplex(self):
|
|
for dtype in self.complex_types:
|
|
self._testNAry(
|
|
math_ops.add_n, [np.array([[1 + 2j, 2 - 3j, 3 + 4j]], dtype=dtype)],
|
|
expected=np.array([[1 + 2j, 2 - 3j, 3 + 4j]], dtype=dtype))
|
|
|
|
self._testNAry(
|
|
math_ops.add_n, [
|
|
np.array([1 + 2j, 2 - 3j], dtype=dtype),
|
|
np.array([10j, 20], dtype=dtype)
|
|
],
|
|
expected=np.array([1 + 12j, 22 - 3j], dtype=dtype))
|
|
self._testNAry(
|
|
math_ops.add_n, [
|
|
np.array([-4, 5j], dtype=dtype),
|
|
np.array([2 + 10j, -2], dtype=dtype),
|
|
np.array([42j, 3 + 3j], dtype=dtype)
|
|
],
|
|
expected=np.array([-2 + 52j, 1 + 8j], dtype=dtype))
|
|
|
|
@unittest.skip("IdentityN is temporarily CompilationOnly as workaround")
|
|
def testIdentityN(self):
|
|
self._testNAryLists(array_ops.identity_n,
|
|
[np.array([[1, 2, 3]], dtype=np.float32)],
|
|
expected=[np.array([[1, 2, 3]], dtype=np.float32)])
|
|
self._testNAryLists(array_ops.identity_n,
|
|
[np.array([[1, 2], [3, 4]], dtype=np.float32),
|
|
np.array([[3, 2, 1], [6, 5, 1]], dtype=np.float32)],
|
|
expected=[
|
|
np.array([[1, 2], [3, 4]], dtype=np.float32),
|
|
np.array([[3, 2, 1], [6, 5, 1]], dtype=np.float32)])
|
|
self._testNAryLists(array_ops.identity_n,
|
|
[np.array([[1], [2], [3], [4]], dtype=np.int32),
|
|
np.array([[3, 2, 1], [6, 5, 1]], dtype=np.float32)],
|
|
expected=[
|
|
np.array([[1], [2], [3], [4]], dtype=np.int32),
|
|
np.array([[3, 2, 1], [6, 5, 1]], dtype=np.float32)])
|
|
|
|
def testConcat(self):
|
|
self._testNAry(
|
|
lambda x: array_ops.concat(x, 0), [
|
|
np.array(
|
|
[[1, 2, 3], [4, 5, 6]], dtype=np.float32), np.array(
|
|
[[7, 8, 9], [10, 11, 12]], dtype=np.float32)
|
|
],
|
|
expected=np.array(
|
|
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=np.float32))
|
|
|
|
self._testNAry(
|
|
lambda x: array_ops.concat(x, 1), [
|
|
np.array(
|
|
[[1, 2, 3], [4, 5, 6]], dtype=np.float32), np.array(
|
|
[[7, 8, 9], [10, 11, 12]], dtype=np.float32)
|
|
],
|
|
expected=np.array(
|
|
[[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]], dtype=np.float32))
|
|
|
|
def testOneHot(self):
|
|
with self.session() as session, self.test_scope():
|
|
indices = array_ops.constant(np.array([[2, 3], [0, 1]], dtype=np.int32))
|
|
op = array_ops.one_hot(indices,
|
|
np.int32(4),
|
|
on_value=np.float32(7), off_value=np.float32(3))
|
|
output = session.run(op)
|
|
expected = np.array([[[3, 3, 7, 3], [3, 3, 3, 7]],
|
|
[[7, 3, 3, 3], [3, 7, 3, 3]]],
|
|
dtype=np.float32)
|
|
self.assertAllEqual(output, expected)
|
|
|
|
op = array_ops.one_hot(indices,
|
|
np.int32(4),
|
|
on_value=np.int32(2), off_value=np.int32(1),
|
|
axis=1)
|
|
output = session.run(op)
|
|
expected = np.array([[[1, 1], [1, 1], [2, 1], [1, 2]],
|
|
[[2, 1], [1, 2], [1, 1], [1, 1]]],
|
|
dtype=np.int32)
|
|
self.assertAllEqual(output, expected)
|
|
|
|
def testSplitV(self):
|
|
with self.session() as session:
|
|
with self.test_scope():
|
|
output = session.run(
|
|
array_ops.split(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 0, 1, 2]],
|
|
dtype=np.float32),
|
|
[2, 2], 1))
|
|
expected = [np.array([[1, 2], [5, 6], [9, 0]], dtype=np.float32),
|
|
np.array([[3, 4], [7, 8], [1, 2]], dtype=np.float32)]
|
|
self.assertAllEqual(output, expected)
|
|
|
|
def testSplitVNegativeSizes(self):
|
|
with self.session() as session:
|
|
with self.test_scope():
|
|
with self.assertRaisesRegex(
|
|
(ValueError, errors.InvalidArgumentError),
|
|
"Split size at index 1 must be >= .*. Got: -2",
|
|
):
|
|
_ = session.run(
|
|
array_ops.split(np.array([1, 2, 3], dtype=np.float32), [-1, -2],
|
|
axis=0))
|
|
|
|
def testStridedSlice(self):
|
|
self._testNAry(lambda x: array_ops.strided_slice(*x),
|
|
[np.array([[], [], []], dtype=np.float32),
|
|
np.array([1, 0], dtype=np.int32),
|
|
np.array([3, 0], dtype=np.int32),
|
|
np.array([1, 1], dtype=np.int32)],
|
|
expected=np.array([[], []], dtype=np.float32))
|
|
|
|
if np.int64 in self.int_types:
|
|
self._testNAry(
|
|
lambda x: array_ops.strided_slice(*x), [
|
|
np.array([[], [], []], dtype=np.float32), np.array(
|
|
[1, 0], dtype=np.int64), np.array([3, 0], dtype=np.int64),
|
|
np.array([1, 1], dtype=np.int64)
|
|
],
|
|
expected=np.array([[], []], dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: array_ops.strided_slice(*x),
|
|
[np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
dtype=np.float32),
|
|
np.array([1, 1], dtype=np.int32),
|
|
np.array([3, 3], dtype=np.int32),
|
|
np.array([1, 1], dtype=np.int32)],
|
|
expected=np.array([[5, 6], [8, 9]], dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: array_ops.strided_slice(*x),
|
|
[np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
dtype=np.float32),
|
|
np.array([0, 2], dtype=np.int32),
|
|
np.array([2, 0], dtype=np.int32),
|
|
np.array([1, -1], dtype=np.int32)],
|
|
expected=np.array([[3, 2], [6, 5]], dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: x[0][0:2, array_ops.newaxis, ::-1],
|
|
[np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
dtype=np.float32)],
|
|
expected=np.array([[[3, 2, 1]], [[6, 5, 4]]],
|
|
dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: x[0][1, :, array_ops.newaxis],
|
|
[np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
dtype=np.float32)],
|
|
expected=np.array([[4], [5], [6]], dtype=np.float32))
|
|
|
|
def testStridedSliceGrad(self):
|
|
# Tests cases where input shape is empty.
|
|
self._testNAry(lambda x: array_ops.strided_slice_grad(*x),
|
|
[np.array([], dtype=np.int32),
|
|
np.array([], dtype=np.int32),
|
|
np.array([], dtype=np.int32),
|
|
np.array([], dtype=np.int32),
|
|
np.float32(0.5)],
|
|
expected=np.array(np.float32(0.5), dtype=np.float32))
|
|
|
|
# Tests case where input shape is non-empty, but gradients are empty.
|
|
self._testNAry(lambda x: array_ops.strided_slice_grad(*x),
|
|
[np.array([3], dtype=np.int32),
|
|
np.array([0], dtype=np.int32),
|
|
np.array([0], dtype=np.int32),
|
|
np.array([1], dtype=np.int32),
|
|
np.array([], dtype=np.float32)],
|
|
expected=np.array([0, 0, 0], dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: array_ops.strided_slice_grad(*x),
|
|
[np.array([3, 0], dtype=np.int32),
|
|
np.array([1, 0], dtype=np.int32),
|
|
np.array([3, 0], dtype=np.int32),
|
|
np.array([1, 1], dtype=np.int32),
|
|
np.array([[], []], dtype=np.float32)],
|
|
expected=np.array([[], [], []], dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: array_ops.strided_slice_grad(*x),
|
|
[np.array([3, 3], dtype=np.int32),
|
|
np.array([1, 1], dtype=np.int32),
|
|
np.array([3, 3], dtype=np.int32),
|
|
np.array([1, 1], dtype=np.int32),
|
|
np.array([[5, 6], [8, 9]], dtype=np.float32)],
|
|
expected=np.array([[0, 0, 0], [0, 5, 6], [0, 8, 9]],
|
|
dtype=np.float32))
|
|
|
|
def ssg_test(x):
|
|
return array_ops.strided_slice_grad(*x, shrink_axis_mask=0x4,
|
|
new_axis_mask=0x1)
|
|
|
|
self._testNAry(ssg_test,
|
|
[np.array([3, 1, 3], dtype=np.int32),
|
|
np.array([0, 0, 0, 2], dtype=np.int32),
|
|
np.array([0, 3, 1, -4], dtype=np.int32),
|
|
np.array([1, 2, 1, -3], dtype=np.int32),
|
|
np.array([[[1], [2]]], dtype=np.float32)],
|
|
expected=np.array([[[0, 0, 1]], [[0, 0, 0]], [[0, 0, 2]]],
|
|
dtype=np.float32))
|
|
|
|
ssg_test2 = lambda x: array_ops.strided_slice_grad(*x, new_axis_mask=0x15)
|
|
self._testNAry(ssg_test2,
|
|
[np.array([4, 4], dtype=np.int32),
|
|
np.array([0, 0, 0, 1, 0], dtype=np.int32),
|
|
np.array([0, 3, 0, 4, 0], dtype=np.int32),
|
|
np.array([1, 2, 1, 2, 1], dtype=np.int32),
|
|
np.array([[[[[1], [2]]], [[[3], [4]]]]], dtype=np.float32)],
|
|
expected=np.array([[0, 1, 0, 2], [0, 0, 0, 0], [0, 3, 0, 4],
|
|
[0, 0, 0, 0]], dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: array_ops.strided_slice_grad(*x),
|
|
[np.array([3, 3], dtype=np.int32),
|
|
np.array([0, 2], dtype=np.int32),
|
|
np.array([2, 0], dtype=np.int32),
|
|
np.array([1, -1], dtype=np.int32),
|
|
np.array([[1, 2], [3, 4]], dtype=np.float32)],
|
|
expected=np.array([[0, 2, 1], [0, 4, 3], [0, 0, 0]],
|
|
dtype=np.float32))
|
|
|
|
self._testNAry(lambda x: array_ops.strided_slice_grad(*x),
|
|
[np.array([3, 3], dtype=np.int32),
|
|
np.array([2, 2], dtype=np.int32),
|
|
np.array([0, 1], dtype=np.int32),
|
|
np.array([-1, -2], dtype=np.int32),
|
|
np.array([[1], [2]], dtype=np.float32)],
|
|
expected=np.array([[0, 0, 0], [0, 0, 2], [0, 0, 1]],
|
|
dtype=np.float32))
|
|
|
|
if __name__ == "__main__":
|
|
googletest.main()
|