Exemplo n.º 1
0
  def testSquare(self):
    """Test basic testing infrastructure."""

    def f(x):
      return x * x

    self._generic_test(f, [
        Example(arg=(3,), out=9., failure=[], bugs=[]),
        Example(arg=(3.2,), out=10.24, failure=[], bugs=[]),
        Example(
            arg=(tf.constant(3.),), out=tf.constant(9.), failure=[], bugs=[]),
    ])
Exemplo n.º 2
0
  def testSquare(self):
    """Test basic testing infrastructure."""

    def f(x):
      return x * x

    # Tests involving type promotions are added to:
    # //tensorflow/tools/consistency_integration_test/type_promotion_tests.py
    self._generic_test(f, [
        Example(arg=(3,), out=9., failure=[], bugs=[]),
        Example(
            arg=(tf.constant(3.),), out=tf.constant(9.), failure=[], bugs=[]),
    ])
Exemplo n.º 3
0
  def testFloatingPointPrecision(self):
    """Tests inconsistent floating point precision between eager vs. graph.

    Bugs:   b/187097409
    Status: Inconsistent floating point precision
    Issue:  Output returned from a function is different between when the
            function is decorated with tf.function or not. Running the
            tf.function in XLA mode also is inconsistent with running the
            function in RAW mode (i.e. running tf.function eagerly).

    Notes:
    * This behavior is consistent with the tensor wrapping rules (i.e.
      `tf.constant`s are taken as `tf.float32` by default) but requires further
      discussion for achieving better consistency.
    * For getting consistent results back, the suggestion is to explicitly
      construct tensors for inputs. See the test case below that passes
      `tf.constant(3.2)` as `arg`.
    """

    def f(x):
      return x * x

    # Note that running the same test in different modes results in different
    # floating point precisions.
    # RunMode: RAW
    self._generic_test(
        f, [
            Example(arg=(3.2,), out=10.240000000000002, failure=[], bugs=[]),
        ],
        # TODO(b/187250924): `RunMode.SAVED` fails to run.
        skip_modes=[RunMode.FUNCTION, RunMode.XLA, RunMode.SAVED])

    # RunMode: FUNCTION, XLA, SAVED
    self._generic_test(
        f, [
            Example(arg=(3.2,), out=10.239999771118164, failure=[], bugs=[]),
        ],
        skip_modes=[RunMode.RAW])

    # Explicitly construct tensor for input for getting consistent results
    # across all `RunMode`s.
    # RunMode: RAW, FUNCTION, XLA, SAVED
    self._generic_test(
        f, [
            Example(
                arg=(tf.constant(3.2),),
                out=10.24000072479248,
                failure=[],
                bugs=[]),
        ],
        skip_modes=[])
    def testFailureParamAsDict(self):
        """Tests passing in a `dict` for `failure` param to `_generic_test`."""
        def f(ta):
            return ta.stack()

        ta = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0)
        ta = ta.write(0, tf.constant([1.0, 2.0]))
        ta = ta.write(1, tf.constant([3.0, 4.0]))

        out_t = tf.constant([[1.0, 2.0], [3.0, 4.0]])
        input_signature = [
            tf.TensorArraySpec(element_shape=None,
                               dtype=tf.float32,
                               dynamic_size=True)
        ]

        self._generic_test(f, [
            Example(arg=(ta, ),
                    out=out_t,
                    failure={
                        RunMode.FUNCTION:
                        'If shallow structure is a sequence, input must also '
                        'be a sequence',
                        RunMode.XLA:
                        'If shallow structure is a sequence, input must also '
                        'be a sequence',
                        RunMode.SAVED:
                        'Found zero restored functions for caller function',
                    },
                    bugs=['b/162452468'])
        ],
                           input_signature=input_signature,
                           skip_modes=[])
        return
    def testObjectInput(self):
        """Test taking a Python object. Should work in tf.function but not sm."""
        class A:
            def __init__(self):
                self.value = 3.0

        def f(x):
            return x.value

        self._generic_test(
            f,
            [Example(arg=(A(), ), out=3.0, failure=[RunMode.SAVED], bugs=[])])
        return
Exemplo n.º 6
0
  def testSkipModes(self):
    """Tests `skip_modes` option available with `_generic_test`."""

    class A:

      def __init__(self, x):
        self.value = x

    def f(x):
      return A(x)

    self._generic_test(
        f, [Example(arg=(3.,), out=3.0, failure=[], bugs=[])],
        # Skip all tests as the test will fail in all modes.
        skip_modes=[RunMode.RAW, RunMode.XLA, RunMode.FUNCTION, RunMode.SAVED])
    return
    def testTensorArrayBasic(self):
        """Tests `_generic_test` with a `tf.TensorArray` as input to tf.function."""
        def f(x):
            return x.stack()

        ta = tf.TensorArray(dtype=tf.int32, dynamic_size=True, size=0)
        ta = ta.write(0, tf.constant([1, 2, 3]))
        ta = ta.write(1, tf.constant([4, 5, 6]))

        self._generic_test(
            f,
            [
                Example(
                    arg=(ta, ),
                    out=tf.constant([[1, 2, 3], [4, 5, 6]]),
                    failure=[RunMode.SAVED],  # TODO(b/187250924): Investigate.
                    bugs=['b/180921284'])
            ])
        return
Exemplo n.º 8
0
  def testObjectOutput(self):
    """Test returning a Python object. Doesn't and shouldn't work."""

    class A:

      def __init__(self, x):
        self.value = x

    def f(x):
      return A(x)

    self._generic_test(f, [
        Example(
            arg=(3.,),
            out=3.0,
            failure=[RunMode.XLA, RunMode.FUNCTION, RunMode.SAVED],
            bugs=[])
    ])
    return
Exemplo n.º 9
0
  def testNotEqualOutput(self):
    """Tests that an error is thrown if the outputs are not equal.

    This test case is meant to test the consistency test infrastructure that the
    output of executing `f()` matches the groundtruth we provide as the `out`
    param in `_generic_test()`.
    """
    mock_func = test.mock.MagicMock(name='method')
    mock_func.return_value = 0  # This differs from the `expected` value below.
    mock_func.__doc__ = 'Tested with a mock function.'

    failure_modes = [RunMode.RAW, RunMode.FUNCTION, RunMode.XLA, RunMode.SAVED]
    input_args = [3, 3.2, tf.constant(3.)]
    expected = 1  # Randomly picked value just for testing purposes.

    for input_arg in input_args:
      self._generic_test(mock_func, [
          Example(
              arg=(input_arg,), out=expected, failure=failure_modes, bugs=[])
      ])