KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use compare method in ava

Best JavaScript code snippet using ava

reduction_ops_test.py

Source:reduction_ops_test.py

...108    data = np.random.rand(*shape).astype(dtype.as_numpy_dtype)109    if dtype.is_complex:110      data -= 2j * data111    return data112  def _compare(self, x, reduction_axes, keepdims, feed_dict=None):113    np_ans = self._np_reduce(x, reduction_axes, keepdims)114    with self.cached_session(use_gpu=True) as sess:115      tf_ans = self._tf_reduce(x, reduction_axes, keepdims)116      out = sess.run(tf_ans, feed_dict)117    self.assertAllClose(np_ans, out)118    self.assertShapeEqual(np_ans, tf_ans)119  def _compareAll(self, x, reduction_axes, feed_dict=None):120    if reduction_axes is not None and np.shape(reduction_axes) == (1,):121      # Test scalar reduction_axes argument122      self._compareAll(x, reduction_axes[0])123    self._compare(x, reduction_axes, keepdims=False, feed_dict=feed_dict)124    self._compare(x, reduction_axes, keepdims=True, feed_dict=feed_dict)125  def _compareAllAxes(self, x, feed_dict=None):126    self._compareAll(x, None)127    for axes in _powerset(range(x.ndim)):128      self._compareAll(x, axes, feed_dict)129  def _compareGradient(self, x, reduction_axes, rtol=1e-8, atol=1e-8):130    if reduction_axes is not None and np.shape(reduction_axes) == (1,):131      # Test scalar reduction_axes argument132      self._compareGradient(x, reduction_axes[0], rtol=rtol, atol=atol)133    with self.cached_session(use_gpu=True):134      t = ops.convert_to_tensor(x)135      su = self._tf_reduce(t, reduction_axes, False)136      jacob_t, jacob_n = gradient_checker.compute_gradient(137          t, x.shape, su, su.get_shape().as_list(), x_init_value=x, delta=1)138    self.assertAllClose(jacob_t, jacob_n, rtol=rtol, atol=atol)139  def _compareGradientAxes(self, x, rtol=1e-8, atol=1e-8):140    self._compareGradient(x, None, rtol=rtol, atol=atol)141    self._compareGradient(x, [], rtol=rtol, atol=atol)142    self._compareGradient(x, 0, rtol=rtol, atol=atol)143    self._compareGradient(x, [1], rtol=rtol, atol=atol)144    self._compareGradient(x, [2], rtol=rtol, atol=atol)145    self._compareGradient(x, [1, 2], rtol=rtol, atol=atol)146    self._compareGradient(x, [0, 1, 2, 3], rtol=rtol, atol=atol)147class SumReductionTest(BaseReductionTest):148  def _tf_reduce(self, x, reduction_axes, keepdims):149    return math_ops.reduce_sum(x, reduction_axes, keepdims)150  def _np_reduce(self, x, reduction_axes, keepdims):151    if isinstance(reduction_axes, list) or isinstance(reduction_axes,152                                                      np.ndarray):153      reduction_axes = tuple(reduction_axes)154    return np.sum(x, axis=reduction_axes, keepdims=keepdims)155  def testAxesType(self):156    for dtype in [dtypes.int64, dtypes.int32]:157      with self.cached_session(use_gpu=True) as sess:158        v = math_ops.reduce_sum([0, 0], constant_op.constant(0, dtype=dtype))159        tf_v = self.evaluate(v)160      self.assertAllEqual(tf_v, 0)161  @test_util.run_deprecated_v1162  def testInfinity(self):163    for dtype in [np.float32, np.float64]:164      for special_value_x in [-np.inf, np.inf]:165        for special_value_y in [-np.inf, np.inf]:166          np_arr = np.array([special_value_x, special_value_y]).astype(dtype)167          self._compareAll(np_arr, None)168  @test_util.run_deprecated_v1169  def testInt32(self):170    for rank in range(1, _MAX_RANK + 1):171      np_arr = self._makeIncremental((2,) * rank, dtypes.int32)172      self._compareAllAxes(np_arr)173  @test_util.run_deprecated_v1174  def testFloat16(self):175    for rank in range(1, _MAX_RANK + 1):176      np_arr = self._makeIncremental((2,) * rank, dtypes.float16)177      self._compareAllAxes(np_arr)178    # test that mean doesn't overflow179    # only on GPU, since it has the more accurate implementation180    if not test.is_gpu_available():181      return182    arr = np.ones([68000], dtype=np.float16)183    with self.session(graph=ops.Graph(), use_gpu=True) as sess:184      tf_arr = variables.Variable(arr)185      variables.global_variables_initializer().run()186      tf_mean = math_ops.reduce_mean(tf_arr, 0, False)187      tf_out_mean = self.evaluate(tf_mean)188    self.assertAllClose(tf_out_mean, 1.)189  @test_util.run_deprecated_v1190  def testFloat32(self):191    for rank in range(1, _MAX_RANK + 1):192      np_arr = self._makeIncremental((2,) * rank, dtypes.float32)193      self._compareAllAxes(np_arr)194    for _ in range(10):195      size_x = int(2**np.random.uniform(0, 15))196      size_y = int(2**np.random.uniform(0, 15))197      if size_x * size_y > 1e7:198        size_y = int(1e7 / size_x)199      arr = np.ones([size_x, size_y], dtype=np.float32)200      col_sum = np.sum(arr, axis=0)201      row_sum = np.sum(arr, axis=1)202      with self.session(graph=ops.Graph(), use_gpu=True) as sess:203        tf_row_sum = self._tf_reduce(arr, 1, False)204        tf_col_sum = self._tf_reduce(arr, 0, False)205        tf_out_row, tf_out_col = self.evaluate([tf_row_sum, tf_col_sum])206      self.assertAllClose(col_sum, tf_out_col)207      self.assertAllClose(row_sum, tf_out_row)208    for size_x in [1, 3, 16, 33]:209      for size_y in [1, 3, 16, 33]:210        for size_z in [1, 3, 16, 33]:211          arr = np.ones([size_x, size_y, size_z], dtype=np.float32)212          sum_y = np.sum(arr, axis=1)213          sum_xz = np.sum(arr, axis=(0, 2))214          with self.session(graph=ops.Graph(), use_gpu=True) as sess:215            tf_sum_xz = self._tf_reduce(arr, [0, 2], False)216            tf_sum_y = self._tf_reduce(arr, 1, False)217            tf_out_sum_xz, tf_out_sum_y = self.evaluate([tf_sum_xz, tf_sum_y])218          self.assertAllClose(sum_y, tf_out_sum_y)219          self.assertAllClose(sum_xz, tf_out_sum_xz)220  @test_util.run_deprecated_v1221  def testFloat64(self):222    for rank in range(1, _MAX_RANK + 1):223      np_arr = self._makeIncremental((2,) * rank, dtypes.float64)224      self._compareAllAxes(np_arr)225  @test_util.run_deprecated_v1226  def testComplex64(self):227    for rank in range(1, _MAX_RANK + 1):228      np_arr = self._makeIncremental((2,) * rank, dtypes.complex64)229      self._compareAllAxes(np_arr)230  @test_util.run_deprecated_v1231  def testComplex128(self):232    for rank in range(1, _MAX_RANK + 1):233      np_arr = self._makeIncremental((2,) * rank, dtypes.complex128)234      self._compareAllAxes(np_arr)235  @test_util.run_deprecated_v1236  def testInvalidIndex(self):237    np_arr = np.arange(0, 10).reshape([2, 5]).astype(np.float32)238    input_tensor = ops.convert_to_tensor(np_arr)239    with self.assertRaisesWithPredicateMatch(240        ValueError, lambda e: "Invalid reduction dimension" in str(e)):241      math_ops.reduce_sum(input_tensor, [-3])242    with self.assertRaisesWithPredicateMatch(243        ValueError, lambda e: "Invalid reduction dimension" in str(e)):244      math_ops.reduce_sum(input_tensor, [2])245    with self.assertRaisesWithPredicateMatch(246        ValueError, lambda e: "Invalid reduction dimension" in str(e)):247      math_ops.reduce_sum(input_tensor, [0, 2])248  @test_util.run_deprecated_v1249  def testPartialShapes(self):250    np.random.seed(1618)251    # Input shape is unknown.252    reduction_axes = [1, 2]253    c_unknown = array_ops.placeholder(dtypes.float32)254    s_unknown = math_ops.reduce_sum(c_unknown, reduction_axes)255    self.assertEqual(tensor_shape.unknown_shape(), s_unknown.get_shape())256    np_input = np.random.randn(3, 3, 3)257    self._compareAll(np_input, reduction_axes, {c_unknown: np_input})258    # Input shape only has known rank.259    c_known_rank = array_ops.placeholder(dtypes.float32)260    c_known_rank.set_shape(tensor_shape.unknown_shape(rank=3))261    s_known_rank = math_ops.reduce_sum(262        c_known_rank, reduction_axes, keepdims=True)263    self.assertEqual(3, s_known_rank.get_shape().rank)264    np_input = np.random.randn(3, 3, 3)265    self._compareAll(np_input, reduction_axes, {c_known_rank: np_input})266    # Reduction indices are unknown.267    unknown_indices = array_ops.placeholder(dtypes.int32)268    c_unknown_indices = constant_op.constant([[10.0], [20.0]])269    s_unknown_indices = math_ops.reduce_sum(270        c_unknown_indices, unknown_indices, keepdims=False)271    self.assertEqual(tensor_shape.unknown_shape(),272                     s_unknown_indices.get_shape())273    s_unknown_indices_keep = math_ops.reduce_sum(274        c_unknown_indices, unknown_indices, keepdims=True)275    self.assertEqual(2, s_unknown_indices_keep.get_shape().rank)276  @test_util.run_deprecated_v1277  def testWrongShapeForReductionIndices(self):278    reduction_axes = [[1], [2]]279    c_unknown = array_ops.placeholder(dtypes.float32)280    with self.assertRaisesWithPredicateMatch(ValueError,281                                             ".*must be at most rank 1.*"):282      math_ops.reduce_sum(c_unknown, reduction_axes)283  # Int64??284  @test_util.run_deprecated_v1285  def testGradient(self):286    for dtype in [287        dtypes.float32, dtypes.float64, dtypes.complex64, dtypes.complex128288    ]:289      x = self._makeIncremental([2, 3, 4, 2], dtype)290      self._compareGradientAxes(x)291  @test_util.run_deprecated_v1292  def testHighRank(self):293    # Do a bunch of random high dimensional reductions294    np.random.seed(42)295    for _ in range(20):296      rank = np.random.randint(4, 10 + 1)297      axes, = np.nonzero(np.random.randint(2, size=rank))298      shape = tuple(np.random.randint(1, 3 + 1, size=rank))299      data = np.random.randint(1024, size=shape)300      self._compareAll(data, axes)301    # Check some particular axis patterns302    for rank in 4, 7, 10:303      shape = tuple(np.random.randint(1, 3 + 1, size=rank))304      data = np.random.randint(1024, size=shape)305      for axes in ([], np.arange(rank), np.arange(0, rank, 2),306                   np.arange(1, rank, 2)):307        self._compareAll(data, axes)308  @test_util.run_deprecated_v1309  def testExpand(self):310    # Reduce an empty tensor to a nonempty tensor311    x = np.zeros((5, 0))312    self._compareAll(x, [1])313  @test_util.run_deprecated_v1314  def testEmptyGradients(self):315    with self.session(use_gpu=True):316      x = array_ops.zeros([0, 3])317      y = math_ops.reduce_sum(x, [1])318      error = gradient_checker.compute_gradient_error(x, [0, 3], y, [0])319      self.assertEqual(error, 0)320  @test_util.run_deprecated_v1321  def testDegenerate(self):322    with self.session(use_gpu=True):323      for dtype in (dtypes.float16, dtypes.float32, dtypes.float64,324                    dtypes.complex64, dtypes.complex128):325        # A large number is needed to get Eigen to die326        x = array_ops.zeros((0, 9938), dtype=dtype)327        y = math_ops.reduce_sum(x, [0])328        self.assertAllEqual(y.eval(), np.zeros(9938))329class MeanReductionTest(BaseReductionTest):330  def _tf_reduce(self, x, reduction_axes, keepdims):331    return math_ops.reduce_mean(x, reduction_axes, keepdims)332  def _np_reduce(self, x, reduction_axes, keepdims):333    if isinstance(reduction_axes, list) or isinstance(reduction_axes,334                                                      np.ndarray):335      reduction_axes = tuple(reduction_axes)336    elif isinstance(reduction_axes, numbers.Integral):337      reduction_axes = (reduction_axes,)338    if reduction_axes is None:339      count = np.prod(x.shape)340    else:341      count = np.prod([x.shape[ax] for ax in reduction_axes])342    # np.mean automatically converts integer inputs to float, while TensorFlow's343    # reduce_mean does not. For integer inputs, we emulate TensorFlow's behavior344    # using np.sum and truncating division.345    np_sum = np.sum(x, axis=reduction_axes, keepdims=keepdims)346    if np.issubdtype(x.dtype, np.integer):347      return np_sum // count348    return np_sum / count349  def testAxesType(self):350    for dtype in [dtypes.int64, dtypes.int32]:351      with self.cached_session(use_gpu=True) as sess:352        v = math_ops.reduce_mean([0, 0], constant_op.constant(0, dtype=dtype))353        tf_v = self.evaluate(v)354      self.assertAllEqual(tf_v, 0)355  @test_util.run_deprecated_v1356  def testInfinity(self):357    for dtype in [np.float32, np.float64]:358      for special_value_x in [-np.inf, np.inf]:359        for special_value_y in [-np.inf, np.inf]:360          np_arr = np.array([special_value_x, special_value_y]).astype(dtype)361          self._compareAll(np_arr, None)362  @test_util.run_deprecated_v1363  def testInt32(self):364    for rank in range(1, _MAX_RANK + 1):365      np_arr = self._makeIncremental((2,) * rank, dtypes.int32)366      self._compareAllAxes(np_arr)367  @test_util.run_deprecated_v1368  def testUint8(self):369    for rank in range(1, _MAX_RANK + 1):370      np_arr = self._makeRandom((2,) * rank, dtypes.uint8)371      self._compareAllAxes(np_arr)372  # This tests the issue reported in b/145030710.373  @test_util.run_deprecated_v1374  def testSizeOverflowUint8(self):375    np_arr = self._makeRandom((2**8,), dtypes.uint8)376    self._compareAllAxes(np_arr)377  @test_util.run_deprecated_v1378  def testSizeOverflowInt8(self):379    np_arr = self._makeRandom((2**7,), dtypes.int8)380    self._compareAllAxes(np_arr)381  @test_util.run_deprecated_v1382  def testSizeOverflowUint16(self):383    np_arr = self._makeRandom((2**16,), dtypes.uint16)384    self._compareAllAxes(np_arr)385  @test_util.run_deprecated_v1386  def testSizeOverflowInt16(self):387    np_arr = self._makeRandom((2**15,), dtypes.int16)388    self._compareAllAxes(np_arr)389  @test_util.run_deprecated_v1390  def testFloat32(self):391    for rank in range(1, _MAX_RANK + 1):392      np_arr = self._makeIncremental((2,) * rank, dtypes.float32)393      self._compareAllAxes(np_arr)394  @test_util.run_deprecated_v1395  def testFloat64(self):396    for rank in range(1, _MAX_RANK + 1):397      np_arr = self._makeIncremental((2,) * rank, dtypes.float64)398      self._compareAllAxes(np_arr)399  @test_util.run_deprecated_v1400  def testComplex64(self):401    for rank in range(1, _MAX_RANK + 1):402      np_arr = self._makeIncremental((2,) * rank, dtypes.complex64)403      self._compareAllAxes(np_arr)404  @test_util.run_deprecated_v1405  def testComplex128(self):406    for rank in range(1, _MAX_RANK + 1):407      np_arr = self._makeIncremental((2,) * rank, dtypes.complex128)408      self._compareAllAxes(np_arr)409  @test_util.run_deprecated_v1410  def testGradient(self):411    s = [2, 3, 4, 2]412    for dtype in [dtypes.float32, dtypes.float64]:413      x = self._makeIncremental(s, dtype)414      self._compareGradientAxes(x, rtol=1e-3, atol=1e-3)415  @test_util.run_deprecated_v1416  def testEmptyGradients(self):417    with self.session(use_gpu=True):418      x = array_ops.zeros([0, 3])419      y = math_ops.reduce_mean(x, [1])420      error = gradient_checker.compute_gradient_error(x, [0, 3], y, [0])421      self.assertEqual(error, 0)422  @test_util.run_deprecated_v1423  def testDegenerate(self):424    with self.session(use_gpu=True):425      for dtype in (dtypes.float16, dtypes.float32, dtypes.float64):426        # A large number is needed to get Eigen to die427        x = array_ops.zeros((0, 9938), dtype=dtype)428        y = math_ops.reduce_mean(x, [0]).eval()429        self.assertEqual(y.shape, (9938,))430        self.assertTrue(np.all(np.isnan(y)))431class EuclideanNormReductionTest(BaseReductionTest):432  def _tf_reduce(self, x, reduction_axes, keepdims):433    return math_ops.reduce_euclidean_norm(x, reduction_axes, keepdims)434  def _np_reduce(self, x, reduction_axes, keepdims):435    if isinstance(reduction_axes, list) or isinstance(reduction_axes,436                                                      np.ndarray):437      reduction_axes = tuple(reduction_axes)438    np_fro = np.sqrt(439        np.sum(x * np.conj(x), axis=reduction_axes, keepdims=keepdims))440    if np.issubdtype(x.dtype, np.integer):441      np_fro = np.floor(np_fro)442    return np_fro443  @test_util.run_deprecated_v1444  def testAxesType(self):445    for dtype in [dtypes.int64, dtypes.int32]:446      with self.cached_session(use_gpu=True):447        v = math_ops.reduce_mean([0, 0], constant_op.constant(0, dtype=dtype))448        tf_v = self.evaluate(v)449      self.assertAllEqual(tf_v, 0)450  @test_util.run_deprecated_v1451  def testInfinity(self):452    for dtype in [np.float32, np.float64]:453      for special_value_x in [-np.inf, np.inf]:454        for special_value_y in [-np.inf, np.inf]:455          np_arr = np.array([special_value_x, special_value_y]).astype(dtype)456          self._compareAll(np_arr, None)457  @test_util.run_deprecated_v1458  def testSingleton(self):459    for dtype in [np.float32, np.float64]:460      np_arr = np.array([-1.]).astype(dtype)461      self._compareAll(np_arr, None)462  @test_util.run_deprecated_v1463  def testInt32(self):464    for rank in range(1, _MAX_RANK + 1):465      np_arr = self._makeIncremental((2,) * rank, dtypes.int32)466      self._compareAllAxes(np_arr)467  @test_util.run_deprecated_v1468  def testFloat32(self):469    for rank in range(1, _MAX_RANK + 1):470      np_arr = self._makeIncremental((2,) * rank, dtypes.float32)471      self._compareAllAxes(np_arr)472  @test_util.run_deprecated_v1473  def testFloat64(self):474    for rank in range(1, _MAX_RANK + 1):475      np_arr = self._makeIncremental((2,) * rank, dtypes.float64)476      self._compareAllAxes(np_arr)477  @test_util.run_deprecated_v1478  def testComplex64(self):479    for rank in range(1, _MAX_RANK + 1):480      np_arr = self._makeIncremental((2,) * rank, dtypes.complex64)481      self._compareAllAxes(np_arr)482  @test_util.run_deprecated_v1483  def testComplex128(self):484    for rank in range(1, _MAX_RANK + 1):485      np_arr = self._makeIncremental((2,) * rank, dtypes.complex128)486      self._compareAllAxes(np_arr)487    with self.session(use_gpu=True):488      for dtype in (dtypes.float16, dtypes.float32, dtypes.float64):489        # A large number is needed to get Eigen to die490        x = array_ops.zeros((0, 9938), dtype=dtype)491        y = math_ops.reduce_euclidean_norm(x, [0]).eval()492        self.assertEqual(y.shape, (9938,))493        self.assertAllEqual(y, np.zeros(9938))494  @test_util.run_deprecated_v1495  def testGradient(self):496    shape = [2, 3, 4, 2]497    for dtype in [dtypes.float32, dtypes.float64]:498      # zero value entry will result NaN gradient if reduction doesn't happen.499      # e.g., `tf.math.reduce_sum([0, 1], axis=[])` so add one to avoid it.500      x = self._makeIncremental(shape, dtype) + 1.0501      self._compareGradientAxes(x, rtol=1e-2, atol=1e-2)502class ProdReductionTest(BaseReductionTest):503  def _tf_reduce(self, x, reduction_axes, keepdims):504    return math_ops.reduce_prod(x, reduction_axes, keepdims)505  def _np_reduce(self, x, reduction_axes, keepdims):506    if isinstance(reduction_axes, list) or isinstance(reduction_axes,507                                                      np.ndarray):508      reduction_axes = tuple(reduction_axes)509    return np.prod(x, axis=reduction_axes, keepdims=keepdims)510  def testAxesType(self):511    for dtype in [dtypes.int64, dtypes.int32]:512      with self.cached_session(use_gpu=True) as sess:513        v = math_ops.reduce_prod([0, 0], constant_op.constant(0, dtype=dtype))514        tf_v = self.evaluate(v)515      self.assertAllEqual(tf_v, 0)516  @test_util.run_deprecated_v1517  def testInfinity(self):518    for dtype in [np.float32, np.float64]:519      for special_value_x in [-np.inf, np.inf]:520        for special_value_y in [-np.inf, np.inf]:521          np_arr = np.array([special_value_x, special_value_y]).astype(dtype)522          self._compareAll(np_arr, None)523  @test_util.run_deprecated_v1524  def testInt32(self):525    # Numpy automatically upgrades the type of np.prod from int32 to int64, so526    # Numpy does not overflow an int32 np.prod while TensorFlow does. To avoid527    # overflow, divide the incremental int32 array by 2.528    for rank in range(1, _MAX_RANK + 1):529      np_arr = self._makeIncremental((2,) * rank, dtypes.int32) / 2530      self._compareAllAxes(np_arr)531  @test_util.run_deprecated_v1532  def testFloat32(self):533    for rank in range(1, _MAX_RANK + 1):534      np_arr = self._makeIncremental((2,) * rank, dtypes.float32)535      self._compareAllAxes(np_arr)536  @test_util.run_deprecated_v1537  def testFloat64(self):538    for rank in range(1, _MAX_RANK + 1):539      np_arr = self._makeIncremental((2,) * rank, dtypes.float64)540      self._compareAllAxes(np_arr)541  @test_util.run_deprecated_v1542  def testComplex64(self):543    for rank in range(1, _MAX_RANK + 1):544      np_arr = self._makeIncremental((2,) * rank, dtypes.complex64)545      self._compareAllAxes(np_arr)546  @test_util.run_deprecated_v1547  def testComplex128(self):548    for rank in range(1, _MAX_RANK + 1):549      np_arr = self._makeIncremental((2,) * rank, dtypes.complex128)550      self._compareAllAxes(np_arr)551  @test_util.run_deprecated_v1552  def testGradientWithZeros(self):553    s = [2, 3, 4, 2]554    x = self._makeIncremental(s, dtypes.float32) / 20.555    # No zeros in input556    self._compareGradientAxes(x, rtol=1e-3, atol=1e-3)557    # Zero at beginning558    x1 = x.copy()559    x1[:, :, 0, :] = 0560    self._compareGradientAxes(x1, rtol=1e-3, atol=1e-3)561    # Zero at end562    x2 = x.copy()563    x2[:, :, -1, :] = 0564    self._compareGradientAxes(x2, rtol=1e-3, atol=1e-3)565    # Zero in middle566    x3 = x.copy()567    x3[:, :, 2, :] = 0568    self._compareGradientAxes(x3, rtol=1e-3, atol=1e-3)569    # All zeros570    x4 = x.copy()571    x4[:, :, :, :] = 0572    self._compareGradientAxes(x4, rtol=1e-3, atol=1e-3)573  @test_util.run_deprecated_v1574  def testEmptyGradients(self):575    with self.session(use_gpu=True):576      x = array_ops.zeros([0, 3])577      y = math_ops.reduce_prod(x, [1])578      error = gradient_checker.compute_gradient_error(x, [0, 3], y, [0])579      self.assertEqual(error, 0)580  @test_util.run_deprecated_v1581  def testDegenerate(self):582    with self.session(use_gpu=True):583      for dtype in (dtypes.float16, dtypes.float32, dtypes.float64):584        # A large number is needed to get Eigen to die585        x = array_ops.zeros((0, 9938), dtype=dtype)586        y = math_ops.reduce_prod(x, [0])587        self.assertAllEqual(y.eval(), np.ones(9938))588class MinReductionTest(test.TestCase):589  def _compare(self, x, reduction_axes, keepdims, use_gpu=False):590    np_ans = x591    if reduction_axes is None:592      np_ans = np.amin(np_ans, keepdims=keepdims)593    else:594      for ra in reduction_axes[::-1]:595        np_ans = np.amin(np_ans, axis=ra, keepdims=keepdims)596    with self.cached_session(use_gpu=use_gpu):597      if reduction_axes is not None:598        reduction_axes = np.array(reduction_axes).astype(np.int32)599      tf_ans = math_ops.reduce_min(x, reduction_axes, keepdims)600      out = self.evaluate(tf_ans)601    self.assertAllClose(np_ans, out)602    self.assertShapeEqual(np_ans, tf_ans)603  def _compareAll(self, x, reduction_axes):604    self._compare(x, reduction_axes, False, use_gpu=True)605    self._compare(x, reduction_axes, False, use_gpu=False)606    self._compare(x, reduction_axes, True, use_gpu=True)607    self._compare(x, reduction_axes, True, use_gpu=False)608  def testAxesType(self):609    for dtype in [dtypes.int64, dtypes.int32]:610      with self.cached_session(use_gpu=True) as sess:611        v = math_ops.reduce_min([0, 0], constant_op.constant(0, dtype=dtype))612        tf_v = self.evaluate(v)613      self.assertAllEqual(tf_v, 0)614  @test_util.run_deprecated_v1615  def testInfinity(self):616    for dtype in [np.float32, np.float64]:617      for special_value_x in [-np.inf, np.inf]:618        for special_value_y in [-np.inf, np.inf]:619          np_arr = np.array([special_value_x, special_value_y]).astype(dtype)620          self._compareAll(np_arr, None)621  def testFloatReduce3D(self):622    # Create a 3D array of floats and reduce across all possible623    # dimensions624    np_arr = np.arange(1, 31).reshape([2, 3, 5]).astype(np.float32)625    self._compareAll(np_arr, None)626    self._compareAll(np_arr, [])627    self._compareAll(np_arr, [0])628    self._compareAll(np_arr, [1])629    self._compareAll(np_arr, [2])630    self._compareAll(np_arr, [0, 1])631    self._compareAll(np_arr, [1, 2])632    self._compareAll(np_arr, [0, 2])633    self._compareAll(np_arr, [0, 1, 2])634  def testDoubleReduce3D(self):635    # Create a 3D array of doubles and reduce across all possible636    # dimensions637    np_arr = np.arange(1, 31).reshape([2, 3, 5]).astype(np.float64)638    self._compareAll(np_arr, None)639    self._compareAll(np_arr, [])640    self._compareAll(np_arr, [0])641    self._compareAll(np_arr, [1])642    self._compareAll(np_arr, [2])643    self._compareAll(np_arr, [0, 1])644    self._compareAll(np_arr, [1, 2])645    self._compareAll(np_arr, [0, 2])646    self._compareAll(np_arr, [0, 1, 2])647  @test_util.run_deprecated_v1648  def testGradient(self):649    s = [2, 3, 4, 2]650    x = np.arange(1.0, 49.0).reshape(s).astype(np.float64)651    with self.cached_session():652      t = ops.convert_to_tensor(x)653      su = math_ops.reduce_min(t, [1, 2])654      jacob_t, jacob_n = gradient_checker.compute_gradient(655          t, s, su, [2, 2], x_init_value=x, delta=1)656    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)657  @test_util.run_deprecated_v1658  def testGradient2(self):659    s = [2, 3, 4, 2]660    x = np.arange(1.0, 49.0).reshape(s).astype(np.float64)661    with self.cached_session():662      t = ops.convert_to_tensor(x)663      su = math_ops.reduce_min(t, [1])664      jacob_t, jacob_n = gradient_checker.compute_gradient(665          t, s, su, [2, 4, 2], x_init_value=x, delta=1)666    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)667  @test_util.run_deprecated_v1668  def testGradient3(self):669    s = [2, 3, 4, 2]670    x = np.arange(1.0, 49.0).reshape(s).astype(np.float64)671    with self.cached_session():672      t = ops.convert_to_tensor(x)673      su = math_ops.reduce_min(t, [2])674      jacob_t, jacob_n = gradient_checker.compute_gradient(675          t, s, su, [2, 3, 2], x_init_value=x, delta=1)676    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)677  @test_util.run_deprecated_v1678  def testGradient4(self):679    s = [2, 3, 4, 2]680    x = np.arange(1.0, 49.0).reshape(s).astype(np.float64)681    with self.cached_session():682      t = ops.convert_to_tensor(x)683      su = math_ops.reduce_min(t)684      jacob_t, jacob_n = gradient_checker.compute_gradient(685          t, s, su, [1], x_init_value=x, delta=1)686    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)687  @test_util.run_deprecated_v1688  def testEmptyGradients(self):689    with self.cached_session():690      x = array_ops.zeros([0, 3])691      y = math_ops.reduce_min(x, [1])692      error = gradient_checker.compute_gradient_error(x, [0, 3], y, [0])693      self.assertEqual(error, 0)694class MaxReductionTest(test.TestCase):695  def _compare(self, x, reduction_axes, keepdims, use_gpu=False):696    np_ans = x697    if reduction_axes is None:698      np_ans = np.amax(np_ans, keepdims=keepdims)699    else:700      for ra in reduction_axes[::-1]:701        np_ans = np.amax(np_ans, axis=ra, keepdims=keepdims)702    with self.cached_session(use_gpu=use_gpu):703      if reduction_axes is not None:704        reduction_axes = np.array(reduction_axes).astype(np.int32)705      tf_ans = math_ops.reduce_max(x, reduction_axes, keepdims)706      out = self.evaluate(tf_ans)707    self.assertAllClose(np_ans, out)708    self.assertShapeEqual(np_ans, tf_ans)709  def _compareAll(self, x, reduction_axes):710    self._compare(x, reduction_axes, False, use_gpu=True)711    self._compare(x, reduction_axes, False, use_gpu=False)712    self._compare(x, reduction_axes, True, use_gpu=True)713    self._compare(x, reduction_axes, True, use_gpu=False)714  def testAxesType(self):715    for dtype in [dtypes.int64, dtypes.int32]:716      with self.cached_session(use_gpu=True) as sess:717        v = math_ops.reduce_max([0, 0], constant_op.constant(0, dtype=dtype))718        tf_v = self.evaluate(v)719      self.assertAllEqual(tf_v, 0)720  @test_util.run_deprecated_v1721  def testInfinity(self):722    for dtype in [np.float32, np.float64]:723      for special_value_x in [-np.inf, np.inf]:724        for special_value_y in [-np.inf, np.inf]:725          np_arr = np.array([special_value_x, special_value_y]).astype(dtype)726          self._compareAll(np_arr, None)727  def testInt64Reduce3D(self):728    # Create a 3D array of int64s and reduce across all possible729    # dimensions730    np_arr = np.arange(-31, -1).reshape([2, 3, 5]).astype(np.int64)731    self._compareAll(np_arr, None)732    self._compareAll(np_arr, [])733    self._compareAll(np_arr, [0])734    self._compareAll(np_arr, [1])735    self._compareAll(np_arr, [2])736    self._compareAll(np_arr, [0, 1])737    self._compareAll(np_arr, [1, 2])738    self._compareAll(np_arr, [0, 2])739    self._compareAll(np_arr, [0, 1, 2])740  def testFloatReduce3D(self):741    # Create a 3D array of floats and reduce across all possible742    # dimensions743    np_arr = np.arange(-31, -1).reshape([2, 3, 5]).astype(np.float32)744    self._compareAll(np_arr, None)745    self._compareAll(np_arr, [])746    self._compareAll(np_arr, [0])747    self._compareAll(np_arr, [1])748    self._compareAll(np_arr, [2])749    self._compareAll(np_arr, [0, 1])750    self._compareAll(np_arr, [1, 2])751    self._compareAll(np_arr, [0, 2])752    self._compareAll(np_arr, [0, 1, 2])753  def testDoubleReduce3D(self):754    # Create a 3D array of doubles and reduce across all possible755    # dimensions756    np_arr = np.arange(-31, -1).reshape([2, 3, 5]).astype(np.float64)757    self._compareAll(np_arr, None)758    self._compareAll(np_arr, [])759    self._compareAll(np_arr, [0])760    self._compareAll(np_arr, [1])761    self._compareAll(np_arr, [2])762    self._compareAll(np_arr, [0, 1])763    self._compareAll(np_arr, [1, 2])764    self._compareAll(np_arr, [0, 2])765    self._compareAll(np_arr, [0, 1, 2])766  @test_util.run_deprecated_v1767  def testGradient(self):768    s = [2, 3, 4, 2]769    x = np.arange(-49.0, -1.0).reshape(s).astype(np.float64)770    with self.cached_session():771      t = ops.convert_to_tensor(x)772      su = math_ops.reduce_max(t, [1, 2])773      jacob_t, jacob_n = gradient_checker.compute_gradient(774          t, s, su, [2, 2], x_init_value=x, delta=1)775    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)776  @test_util.run_deprecated_v1777  def testGradient2(self):778    s = [2, 3, 4, 2]779    x = np.arange(-49.0, -1.0).reshape(s).astype(np.float64)780    with self.cached_session():781      t = ops.convert_to_tensor(x)782      su = math_ops.reduce_max(t, [1])783      jacob_t, jacob_n = gradient_checker.compute_gradient(784          t, s, su, [2, 4, 2], x_init_value=x, delta=1)785    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)786  @test_util.run_deprecated_v1787  def testGradient3(self):788    s = [2, 3, 4, 2]789    x = np.arange(-49.0, -1.0).reshape(s).astype(np.float64)790    with self.cached_session():791      t = ops.convert_to_tensor(x)792      su = math_ops.reduce_max(t, [2])793      jacob_t, jacob_n = gradient_checker.compute_gradient(794          t, s, su, [2, 3, 2], x_init_value=x, delta=1)795    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)796  @test_util.run_deprecated_v1797  def testGradient4(self):798    s = [2, 3, 4, 2]799    x = np.arange(-49.0, -1.0).reshape(s).astype(np.float64)800    with self.cached_session():801      t = ops.convert_to_tensor(x)802      su = math_ops.reduce_max(t)803      jacob_t, jacob_n = gradient_checker.compute_gradient(804          t, s, su, [1], x_init_value=x, delta=1)805    self.assertAllClose(jacob_t, jacob_n, rtol=1e-8, atol=1e-8)806  @test_util.run_deprecated_v1807  def testEmptyGradients(self):808    with self.cached_session():809      x = array_ops.zeros([0, 3])810      y = math_ops.reduce_max(x, [1])811      error = gradient_checker.compute_gradient_error(x, [0, 3], y, [0])812      self.assertEqual(error, 0)813class AllReductionTest(test.TestCase):814  def _compare(self, x, reduction_axes, keepdims, use_gpu=False):815    np_ans = x816    if reduction_axes is None:817      np_ans = np.all(np_ans, keepdims=keepdims)818    else:819      for ra in reduction_axes[::-1]:820        np_ans = np.all(np_ans, axis=ra, keepdims=keepdims)821    with self.cached_session(use_gpu=use_gpu):822      if reduction_axes is not None:823        reduction_axes = np.array(reduction_axes).astype(np.int32)824      tf_ans = math_ops.reduce_all(x, reduction_axes, keepdims)825      out = self.evaluate(tf_ans)826    self.assertAllEqual(np_ans, out)827    self.assertShapeEqual(np_ans, tf_ans)828  def _compareAll(self, x, reduction_axes):829    self._compare(x, reduction_axes, False, use_gpu=True)830    self._compare(x, reduction_axes, False, use_gpu=False)831    self._compare(x, reduction_axes, True, use_gpu=True)832    self._compare(x, reduction_axes, True, use_gpu=False)833  def testAxesType(self):834    for dtype in [dtypes.int64, dtypes.int32]:835      with self.session(use_gpu=True) as sess:836        v = math_ops.reduce_all([True, True],837                                constant_op.constant(0, dtype=dtype))838        tf_v = self.evaluate(v)839      self.assertAllEqual(tf_v, True)840  def testAll3D(self):841    # Create a 3D array of bools and reduce across all possible842    # dimensions843    np_arr = (np.random.uniform(0, 1, 30) > 0.1).reshape([2, 3, 5])844    self._compareAll(np_arr, None)845    self._compareAll(np_arr, [])846    self._compareAll(np_arr, [0])847    self._compareAll(np_arr, [1])848    self._compareAll(np_arr, [2])849    self._compareAll(np_arr, [0, 1])850    self._compareAll(np_arr, [1, 2])851    self._compareAll(np_arr, [0, 2])852    self._compareAll(np_arr, [0, 1, 2])853  def testEmpty(self):854    self._compareAll([], [0])855class AnyReductionTest(test.TestCase):856  def _compare(self, x, reduction_axes, keepdims, use_gpu=False):857    np_ans = x858    if reduction_axes is None:859      np_ans = np.any(np_ans, keepdims=keepdims)860    else:861      for ra in reduction_axes[::-1]:862        np_ans = np.any(np_ans, axis=ra, keepdims=keepdims)863    with self.cached_session(use_gpu=use_gpu):864      if reduction_axes is not None:865        reduction_axes = np.array(reduction_axes).astype(np.int32)866      tf_ans = math_ops.reduce_any(x, reduction_axes, keepdims)867      out = self.evaluate(tf_ans)868    self.assertAllEqual(np_ans, out)869    self.assertShapeEqual(np_ans, tf_ans)870  def _compareAll(self, x, reduction_axes):871    self._compare(x, reduction_axes, False, use_gpu=True)872    self._compare(x, reduction_axes, False, use_gpu=False)873    self._compare(x, reduction_axes, True, use_gpu=True)874    self._compare(x, reduction_axes, True, use_gpu=False)875  def testAxesType(self):876    for dtype in [dtypes.int64, dtypes.int32]:877      with self.session(use_gpu=True) as sess:878        v = math_ops.reduce_any([True, True],879                                constant_op.constant(0, dtype=dtype))880        tf_v = self.evaluate(v)881      self.assertAllEqual(tf_v, True)882  def testAll3D(self):883    # Create a 3D array of bools and reduce across all possible884    # dimensions885    np_arr = (np.random.uniform(0, 1, 30) > 0.9).reshape([2, 3, 5])886    self._compareAll(np_arr, None)887    self._compareAll(np_arr, [])888    self._compareAll(np_arr, [0])889    self._compareAll(np_arr, [1])890    self._compareAll(np_arr, [2])891    self._compareAll(np_arr, [0, 1])892    self._compareAll(np_arr, [1, 2])893    self._compareAll(np_arr, [0, 2])894    self._compareAll(np_arr, [0, 1, 2])895  def testEmpty(self):896    self._compareAll([], [0])897class CountNonzeroReductionTest(test.TestCase):898  def _compare(self, x, reduction_axes, keepdims, use_gpu=False, zero=0,899               feed_dict=None):900    np_ans = (x != zero).astype(np.int32)901    if reduction_axes is None:902      np_ans = np.sum(np_ans, keepdims=keepdims)903    else:904      reduction_axes = np.array(reduction_axes).astype(np.int32)905      for ra in reduction_axes.ravel()[::-1]:906        np_ans = np.sum(np_ans, axis=ra, keepdims=keepdims)907    with self.cached_session(use_gpu=use_gpu) as sess:908      tf_ans = math_ops.count_nonzero(x, reduction_axes, keepdims)909      out = sess.run(tf_ans, feed_dict)910    self.assertAllClose(np_ans, out)911    self.assertShapeEqual(np_ans, tf_ans)912  def _compareAll(self, x, reduction_axes, feed_dict=None):913    if reduction_axes is not None and np.shape(reduction_axes) == (1,):914      # Test scalar reduction_axes argument915      self._compareAll(x, reduction_axes[0])916    self._compare(x, reduction_axes, False, use_gpu=True, feed_dict=feed_dict)917    self._compare(x, reduction_axes, False, use_gpu=False, feed_dict=feed_dict)918    self._compare(x, reduction_axes, True, use_gpu=True, feed_dict=feed_dict)919    self._compare(x, reduction_axes, True, use_gpu=False, feed_dict=feed_dict)920  @test_util.run_deprecated_v1921  def testBoolReduce1D(self):922    # Create a 1D array of floats923    np_arr = np.asarray([False, False, True, False, False, True])924    self._compareAll(np_arr, None)925    self._compareAll(np_arr, [])926    self._compareAll(np_arr, [0])927  @test_util.run_deprecated_v1928  def testFloatReduce1D(self):929    # Create a 1D array of floats930    np_arr = np.asarray([0.0, 1.0, -1.0, 0.0, 0.0, 3.0]).astype(np.float32)931    self._compareAll(np_arr, [0])932  @test_util.run_deprecated_v1933  def testFloatReduce4D(self):934    # Create a 4D array of floats and reduce across some935    # dimensions936    np_arr = np.floor(np.arange(0.0, 210.0) / 100.0).reshape([2, 3, 5,937                                                              7]).astype(938                                                                  np.float32)939    self._compareAll(np_arr, None)940    self._compareAll(np_arr, [])941    self._compareAll(np_arr, [0])942    self._compareAll(np_arr, [1])943    self._compareAll(np_arr, [2])944    self._compareAll(np_arr, [0, 1])945    self._compareAll(np_arr, [1, 2])946    # Need specialization for reduce(4D, [0, 2])947    # self._compareAll(np_arr, [0, 2])948    self._compareAll(np_arr, [0, 1, 2])949    self._compareAll(np_arr, [1, 2, 3])950    self._compareAll(np_arr, [0, 1, 2, 3])951  @test_util.run_deprecated_v1952  def testExpand(self):953    # Reduce an empty tensor to a nonempty tensor954    x = np.zeros((5, 0))955    self._compareAll(x, [1])956  @test_util.run_deprecated_v1957  def testDegenerate(self):958    for use_gpu in False, True:959      with self.cached_session(use_gpu=use_gpu):960        for dtype in (dtypes.bool,):961          # A large number is needed to get Eigen to die962          x = array_ops.zeros((0, 9938), dtype=dtype)963          y = math_ops.count_nonzero(x, [0])964          self.assertAllEqual(y.eval(), np.zeros(9938))965  def testStringReduce(self):966    # Test case for GitHub issue 18712967    with self.cached_session() as sess:968      v = math_ops.count_nonzero(constant_op.constant(["test"]))969      self.assertAllClose(self.evaluate(v), 1)970  @test_util.run_deprecated_v1971  def testStringReduce1D(self):972    # Create a 1D array of strings973    x = np.asarray(["", "", "a", "", "", "b"])974    self._compare(x, None, keepdims=False, zero=np.str(""))975    self._compare(x, [], keepdims=False, zero=np.str(""))976    self._compare(x, [0], keepdims=False, zero=np.str(""))977    self._compare(x, None, keepdims=True, zero=np.str(""))978    self._compare(x, [], keepdims=True, zero=np.str(""))979    self._compare(x, [0], keepdims=True, zero=np.str(""))980  @test_util.run_deprecated_v1981  def testStringReduce2D(self):982    # Create a 2D array of strings983    x = np.asarray([["", "", "a", "", "", "b"],984                    ["", "c", "", "d", "", ""],985                    ["e", "", "f", "", "", ""]])986    self._compare(x, None, keepdims=False, zero=np.str(""))987    self._compare(x, [], keepdims=False, zero=np.str(""))988    self._compare(x, [0], keepdims=False, zero=np.str(""))989    self._compare(x, [1], keepdims=False, zero=np.str(""))990    self._compare(x, [0, 1], keepdims=False, zero=np.str(""))991    self._compare(x, None, keepdims=True, zero=np.str(""))992    self._compare(x, [], keepdims=True, zero=np.str(""))993    self._compare(x, [0], keepdims=True, zero=np.str(""))994    self._compare(x, [0, 1], keepdims=True, zero=np.str(""))995if __name__ == "__main__":...

cwise_ops_binary_test.py

Source:cwise_ops_binary_test.py

...729        for y in data:730          self.assertEqual(self._compareScalar(math_ops.equal, x, y, t), x == y)731          self.assertEqual(732              self._compareScalar(math_ops.not_equal, x, y, t), x != y)733  def _compare(self, x, y, np_func, tf_func):734    np_ans = np_func(x, y)735    with test_util.use_gpu():736      out = tf_func(ops.convert_to_tensor(x), ops.convert_to_tensor(y))737      tf_ans = self.evaluate(out)738    self.assertAllEqual(np_ans, tf_ans)739  def testTensorCompareTensor(self):740    x = np.linspace(-15, 15, 6).reshape(1, 3, 2)741    y = np.linspace(20, -10, 6).reshape(1, 3, 2)742    for t in [np.float16, np.float32, np.float64, np.int32, np.int64]:743      xt = x.astype(t)744      yt = y.astype(t)745      self._compare(xt, yt, np.less, math_ops.less)746      self._compare(xt, yt, np.less_equal, math_ops.less_equal)747      self._compare(xt, yt, np.greater, math_ops.greater)748      self._compare(xt, yt, np.greater_equal, math_ops.greater_equal)749      self._compare(xt, yt, np.equal, math_ops.equal)750      self._compare(xt, yt, np.not_equal, math_ops.not_equal)751    # Complex types do not support ordering but do support equality tests.752    for t in [np.complex64, np.complex128]:753      xt = x.astype(t)754      xt -= 1j * xt755      yt = y.astype(t)756      yt -= 1j * yt757      self._compare(xt, yt, np.equal, math_ops.equal)758      self._compare(xt, yt, np.not_equal, math_ops.not_equal)759  def _compareBCast(self, xs, ys, dtype, np_func, tf_func):760    x = np.linspace(-15, 15, np.prod(xs)).astype(dtype).reshape(xs)761    y = np.linspace(20, -10, np.prod(ys)).astype(dtype).reshape(ys)762    if dtype in (np.complex64, np.complex128):763      x -= 1j * x764      y -= 1j * y765    self._compare(x, y, np_func, tf_func)766    self._compare(y, x, np_func, tf_func)767  def _testBCastByFunc(self, np_func, tf_func, include_complex=False):768    shapes = [769        ([1, 3, 2], [1]),770        ([1, 3, 2], [2]),771        ([1, 3, 2], [3, 2]),772        ([1, 3, 2], [3, 1]),773        ([1, 3, 2], [1, 3, 2]),774        ([1, 3, 2], [2, 3, 1]),775        ([1, 3, 2], [2, 1, 1]),776        ([1, 3, 2], [1, 3, 1]),777        ([2, 1, 5], [2, 3, 1]),778        ([2, 0, 5], [2, 0, 1]),779        ([2, 3, 0], [2, 3, 1]),780    ]...

cwise_ops_unary_test.py

Source:cwise_ops_unary_test.py

1# Copyright 2018 The TensorFlow Authors. All Rights Reserved.2#3# Licensed under the Apache License, Version 2.0 (the "License");4# you may not use this file except in compliance with the License.5# You may obtain a copy of the License at6#7#     http://www.apache.org/licenses/LICENSE-2.08#9# Unless required by applicable law or agreed to in writing, software10# distributed under the License is distributed on an "AS IS" BASIS,11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.12# See the License for the specific language governing permissions and13# limitations under the License.14# ==============================================================================15"""Functional tests for unary coefficient-wise operations."""16from __future__ import absolute_import17from __future__ import division18from __future__ import print_function19import math20import numpy as np21from tensorflow.python.eager import backprop22from tensorflow.python.framework import constant_op23from tensorflow.python.framework import dtypes as dtypes_lib24from tensorflow.python.framework import ops25from tensorflow.python.framework import sparse_tensor26from tensorflow.python.framework import test_util27from tensorflow.python.ops import gen_math_ops28from tensorflow.python.ops import gradient_checker29from tensorflow.python.ops import gradient_checker_v230from tensorflow.python.ops import math_ops31from tensorflow.python.ops import nn_grad  # pylint: disable=unused-import32from tensorflow.python.platform import test33from tensorflow.python.platform import tf_logging34_NEG = lambda x: -x35_ABS = abs36# TODO(zongheng): it'd be great to factor out this function and various random37# SparseTensor gen funcs.38def _sparsify(x, thresh=0.5, index_dtype=np.int64):39  x[x < thresh] = 040  non_zero = np.where(x)41  x_indices = np.vstack(non_zero).astype(index_dtype).T42  x_values = x[non_zero]43  x_shape = x.shape44  return sparse_tensor.SparseTensor(45      indices=x_indices, values=x_values, dense_shape=x_shape), x_values46def _default_tolerance(dtype):47  """Returns a sensible default tolerance for comparing results of a given type.48  Args:49    dtype: A datatype.50  """51  if dtype == np.float16:52    return 5e-353  elif dtype in (np.float32, np.complex64):54    return 1e-355  elif dtype in (np.float64, np.complex128):56    return 1e-557  else:58    return None  # Fail fast for unexpected types59class UnaryOpTest(test.TestCase):60  def _compareCpu(self, x, np_func, tf_func, grad_rtol=None, grad_atol=None):61    if grad_rtol is None:62      grad_rtol = _default_tolerance(x.dtype)63    if grad_atol is None:64      grad_atol = _default_tolerance(x.dtype)65    np_ans = np_func(x)66    with self.cached_session(use_gpu=False):67      inx = ops.convert_to_tensor(x)68      if x.dtype in (np.float32, np.float64,69                     dtypes_lib.bfloat16.as_numpy_dtype):70        y = 1.1 * tf_func(inx)71        np_ans *= 1.172      else:73        y = tf_func(inx)74      tf_cpu = self.evaluate(y)75      self.assertShapeEqual(np_ans, y)76      if x.dtype == np.float16:77        self.assertAllClose(np_ans, tf_cpu, rtol=1e-3, atol=1e-3)78      elif x.dtype == dtypes_lib.bfloat16.as_numpy_dtype:79        self.assertAllClose(np_ans, tf_cpu, rtol=1e-2, atol=1e-2)80      else:81        self.assertAllClose(np_ans, tf_cpu)82      if x.dtype in (np.complex64, np.complex128) and tf_func == math_ops.sign:83        return  # Return early84      if x.dtype == np.float16:85        s = list(np.shape(x))86        jacob_t, _ = gradient_checker.compute_gradient(87            inx, s, y, s, x_init_value=x)88        xf = x.astype(np.float)89        inxf = ops.convert_to_tensor(xf)90        yf = tf_func(inxf)91        _, jacob_n = gradient_checker.compute_gradient(92            inxf, s, yf, s, x_init_value=xf, delta=1e-2)93        jacob_n = jacob_n.astype(np.float16)94        self.assertAllClose(jacob_t, jacob_n, rtol=grad_rtol, atol=grad_atol)95      elif x.dtype in (np.float32, np.complex64):96        s = list(np.shape(x))97        jacob_t, jacob_n = gradient_checker.compute_gradient(98            inx, s, y, s, x_init_value=x, delta=1e-3)99        self.assertAllClose(jacob_t, jacob_n, rtol=grad_rtol, atol=grad_atol)100      elif x.dtype in (np.float64, np.complex128):101        s = list(np.shape(x))102        jacob_t, jacob_n = gradient_checker.compute_gradient(103            inx, s, y, s, x_init_value=x, delta=1e-5)104        self.assertAllClose(jacob_t, jacob_n, rtol=grad_rtol, atol=grad_atol)105  def _check(self, result_tensor, result_np, input_sp_t, tol):106    self.assertTrue(isinstance(result_tensor, sparse_tensor.SparseTensor))107    self.assertTrue(isinstance(input_sp_t, sparse_tensor.SparseTensor))108    self.assertAllEqual(input_sp_t.indices, result_tensor.indices)109    self.assertAllEqual(input_sp_t.dense_shape, result_tensor.dense_shape)110    if tol is None:111      self.assertAllClose(result_np, result_tensor.values)112    else:113      self.assertAllClose(result_np, result_tensor.values, rtol=tol, atol=tol)114  def _compareSparseCpu(self, x, np_func, tf_func, tol):115    x_sp, x_sp_vals = _sparsify(x)116    res_np = np_func(x_sp_vals)117    with test_util.force_cpu():118      self._check(tf_func(x_sp), res_np, x_sp, tol)119  def _compareGpu(self, x, np_func, tf_func):120    np_ans = np_func(x)121    with test_util.use_gpu():122      result = tf_func(ops.convert_to_tensor(x))123      tf_gpu = self.evaluate(result)124    if x.dtype == np.float16:125      self.assertAllClose(np_ans, tf_gpu, rtol=1e-3, atol=1e-3)126    else:127      self.assertAllClose(np_ans, tf_gpu)128    # TODO(zhifengc/ke): make gradient checker work on GPU.129  def _compareSparseGpu(self, x, np_func, tf_func, tol):130    x_sp, x_sp_vals = _sparsify(x)131    res_np = np_func(x_sp_vals)132    with test_util.use_gpu():133      self._check(tf_func(x_sp), res_np, x_sp, tol)134  def _compareBoth(self, x, np_func, tf_func):135    self._compareCpu(x, np_func, tf_func)136    self._compareGpu(x, np_func, tf_func)137  def _compareBothSparse(self, x, np_func, tf_func, tol=None):138    self._compareSparseCpu(x, np_func, tf_func, tol)139    self._compareSparseGpu(x, np_func, tf_func, tol)140  def _inv(self, x):141    return 1.0 / x142  def _rsqrt(self, x):143    return self._inv(np.sqrt(x))144  def _sigmoid(self, x):145    return 1.0 / (1.0 + np.exp(-x))146  def _log_sigmoid(self, x):147    return np.log(self._sigmoid(x))148  def _replace_domain_error_with_inf(self, fn):149    def func(x):150      try:151        return fn(x)152      except ValueError as e:153        if "domain error" in str(e):154          return np.inf * np.ones_like(x)155        else:156          raise e157    return func158  @test_util.run_deprecated_v1159  def testFloatBasic(self):160    x = np.arange(-3, 3).reshape(1, 3, 2).astype(np.float32)161    w = x - x.min() + 1.02  # all greater than 1162    y = (x + .5).astype(np.float32)  # no zero163    z = (x + 15.5).astype(np.float32)  # all positive164    k = np.arange(-0.90, 0.90, 0.25).astype(np.float32)  # between -1 and 1165    self._compareBoth(x, np.abs, math_ops.abs)166    self._compareBoth(x, np.abs, _ABS)167    self._compareBoth(x, np.negative, math_ops.negative)168    self._compareBoth(x, np.negative, _NEG)169    self._compareBoth(y, self._inv, math_ops.reciprocal)170    self._compareBoth(x, np.square, math_ops.square)171    self._compareBoth(z, np.sqrt, math_ops.sqrt)172    self._compareBoth(z, self._rsqrt, math_ops.rsqrt)173    self._compareBoth(x, np.exp, math_ops.exp)174    self._compareBoth(x, np.expm1, math_ops.expm1)175    self._compareBoth(z, np.log, math_ops.log)176    self._compareBoth(z, np.log1p, math_ops.log1p)177    self._compareBoth(x, np.sinh, math_ops.sinh)178    self._compareBoth(x, np.cosh, math_ops.cosh)179    self._compareBoth(x, np.tanh, math_ops.tanh)180    self._compareBoth(x, np.arcsinh, math_ops.asinh)181    self._compareBoth(w, np.arccosh, math_ops.acosh)182    self._compareBoth(k, np.arctanh, math_ops.atanh)183    self._compareBoth(x, self._sigmoid, math_ops.sigmoid)184    self._compareBoth(x, self._log_sigmoid, math_ops.log_sigmoid)185    self._compareBoth(y, np.sign, math_ops.sign)186    self._compareBoth(x, np.sin, math_ops.sin)187    self._compareBoth(x, np.cos, math_ops.cos)188    self._compareBoth(k, np.arcsin, math_ops.asin)189    self._compareBoth(k, np.arccos, math_ops.acos)190    self._compareBoth(x, np.arctan, math_ops.atan)191    self._compareBoth(x, np.tan, math_ops.tan)192    self._compareBoth(193        y, np.vectorize(self._replace_domain_error_with_inf(math.lgamma)),194        math_ops.lgamma)195    self._compareBoth(x, np.vectorize(math.erf), math_ops.erf)196    self._compareBoth(x, np.vectorize(math.erfc), math_ops.erfc)197    try:198      from scipy import special  # pylint: disable=g-import-not-at-top199      self._compareBoth(x, special.i0e, math_ops.bessel_i0e)200      self._compareBoth(x, special.i1e, math_ops.bessel_i1e)201    except ImportError as e:202      tf_logging.warn("Cannot test special functions: %s" % str(e))203    self._compareBothSparse(x, np.abs, math_ops.abs)204    self._compareBothSparse(x, np.negative, math_ops.negative)205    self._compareBothSparse(x, np.square, math_ops.square)206    self._compareBothSparse(z, np.sqrt, math_ops.sqrt, tol=1e-3)207    self._compareBothSparse(x, np.tanh, math_ops.tanh)208    self._compareBothSparse(y, np.sign, math_ops.sign)209    self._compareBothSparse(x, np.vectorize(math.erf), math_ops.erf)210  @test_util.run_deprecated_v1211  def testFloatTanhEdge(self):212    x = np.arange(40, 40 + 6).reshape(6).astype(np.float32)213    self._compareBoth(x, np.tanh, math_ops.tanh)214    x = np.arange(-40, -40 + 6).reshape(6).astype(np.float32)215    self._compareBoth(x, np.tanh, math_ops.tanh)216  @test_util.run_deprecated_v1217  def testFloatEmpty(self):218    x = np.empty((2, 0, 5), dtype=np.float32)219    self._compareBoth(x, np.abs, math_ops.abs)220    self._compareBoth(x, np.abs, _ABS)221    self._compareBoth(x, np.negative, math_ops.negative)222    self._compareBoth(x, np.negative, _NEG)223    self._compareBoth(x, self._inv, math_ops.reciprocal)224    self._compareBoth(x, np.square, math_ops.square)225    self._compareBoth(x, np.sqrt, math_ops.sqrt)226    self._compareBoth(x, self._rsqrt, math_ops.rsqrt)227    self._compareBoth(x, np.exp, math_ops.exp)228    self._compareBoth(x, np.expm1, math_ops.expm1)229    self._compareBoth(x, np.log, math_ops.log)230    self._compareBoth(x, np.log1p, math_ops.log1p)231    self._compareBoth(x, np.sinh, math_ops.sinh)232    self._compareBoth(x, np.arcsinh, math_ops.asinh)233    self._compareBoth(x, np.cosh, math_ops.cosh)234    self._compareBoth(x, np.tanh, math_ops.tanh)235    self._compareBoth(x, self._sigmoid, math_ops.sigmoid)236    self._compareBoth(x, np.sign, math_ops.sign)237    self._compareBoth(x, np.sin, math_ops.sin)238    self._compareBoth(x, np.cos, math_ops.cos)239    # Can't use vectorize below, so just use some arbitrary function240    self._compareBoth(x, np.sign, math_ops.lgamma)241    self._compareBoth(x, np.sign, math_ops.erf)242    self._compareBoth(x, np.sign, math_ops.erfc)243    self._compareBoth(x, np.tan, math_ops.tan)244    self._compareBoth(x, np.arcsin, math_ops.asin)245    self._compareBoth(x, np.arccos, math_ops.acos)246    self._compareBoth(x, np.arctan, math_ops.atan)247    try:248      from scipy import special  # pylint: disable=g-import-not-at-top249      self._compareBoth(x, special.i0e, math_ops.bessel_i0e)250      self._compareBoth(x, special.i1e, math_ops.bessel_i1e)251    except ImportError as e:252      tf_logging.warn("Cannot test special functions: %s" % str(e))253    self._compareBothSparse(x, np.abs, math_ops.abs)254    self._compareBothSparse(x, np.negative, math_ops.negative)255    self._compareBothSparse(x, np.square, math_ops.square)256    self._compareBothSparse(x, np.sqrt, math_ops.sqrt, tol=1e-3)257    self._compareBothSparse(x, np.tanh, math_ops.tanh)258    self._compareBothSparse(x, np.sign, math_ops.sign)259    self._compareBothSparse(x, np.sign, math_ops.erf)260  @test_util.run_deprecated_v1261  def testDoubleBasic(self):262    x = np.arange(-3, 3).reshape(1, 3, 2).astype(np.float64)263    w = x - x.min() + 1.02  # all greater than 1264    y = (x + .5).astype(np.float64)  # no zero265    z = (x + 15.5).astype(np.float64)  # all positive266    k = np.arange(-0.90, 0.90,267                  0.35).reshape(1, 3, 2).astype(np.float64)  # between -1 and 1268    self._compareBoth(x, np.abs, math_ops.abs)269    self._compareBoth(x, np.abs, _ABS)270    self._compareBoth(x, np.negative, math_ops.negative)271    self._compareBoth(x, np.negative, _NEG)272    self._compareBoth(y, self._inv, math_ops.reciprocal)273    self._compareBoth(x, np.square, math_ops.square)274    self._compareBoth(z, np.sqrt, math_ops.sqrt)275    self._compareBoth(z, self._rsqrt, math_ops.rsqrt)276    self._compareBoth(x, np.exp, math_ops.exp)277    self._compareBoth(x, np.expm1, math_ops.expm1)278    self._compareBoth(z, np.log, math_ops.log)279    self._compareBoth(z, np.log1p, math_ops.log1p)280    self._compareBoth(x, np.sinh, math_ops.sinh)281    self._compareBoth(x, np.cosh, math_ops.cosh)282    self._compareBoth(x, np.tanh, math_ops.tanh)283    self._compareBoth(x, np.arcsinh, math_ops.asinh)284    self._compareBoth(w, np.arccosh, math_ops.acosh)285    self._compareBoth(k, np.arctanh, math_ops.atanh)286    self._compareBoth(x, self._sigmoid, math_ops.sigmoid)287    self._compareBoth(y, np.sign, math_ops.sign)288    self._compareBoth(x, np.sin, math_ops.sin)289    self._compareBoth(x, np.cos, math_ops.cos)290    self._compareBoth(291        y, np.vectorize(self._replace_domain_error_with_inf(math.lgamma)),292        math_ops.lgamma)293    self._compareBoth(x, np.vectorize(math.erf), math_ops.erf)294    self._compareBoth(x, np.vectorize(math.erfc), math_ops.erfc)295    self._compareBoth(x, np.arctan, math_ops.atan)296    self._compareBoth(k, np.arcsin, math_ops.asin)297    self._compareBoth(k, np.arccos, math_ops.acos)298    self._compareBoth(k, np.tan, math_ops.tan)299    try:300      from scipy import special  # pylint: disable=g-import-not-at-top301      self._compareBoth(x, special.i0e, math_ops.bessel_i0e)302      self._compareBoth(x, special.i1e, math_ops.bessel_i1e)303    except ImportError as e:304      tf_logging.warn("Cannot test special functions: %s" % str(e))305    self._compareBothSparse(x, np.abs, math_ops.abs)306    self._compareBothSparse(x, np.negative, math_ops.negative)307    self._compareBothSparse(x, np.square, math_ops.square)308    self._compareBothSparse(z, np.sqrt, math_ops.sqrt, tol=1e-3)309    self._compareBothSparse(x, np.tanh, math_ops.tanh)310    self._compareBothSparse(y, np.sign, math_ops.sign)311    self._compareBothSparse(x, np.vectorize(math.erf), math_ops.erf)312  @test_util.run_deprecated_v1313  def testHalfBasic(self):314    x = np.arange(-3, 3).reshape(1, 3, 2).astype(np.float16)315    y = (x + .5).astype(np.float16)  # no zero316    z = (x + 15.5).astype(np.float16)  # all positive317    self._compareBoth(x, np.abs, math_ops.abs)318    self._compareBoth(x, np.abs, _ABS)319    self._compareBoth(x, np.negative, math_ops.negative)320    self._compareBoth(x, np.negative, _NEG)321    self._compareBoth(y, self._inv, math_ops.reciprocal)322    self._compareBoth(x, np.square, math_ops.square)323    self._compareBoth(z, np.sqrt, math_ops.sqrt)324    self._compareBoth(z, self._rsqrt, math_ops.rsqrt)325    self._compareBoth(x, np.exp, math_ops.exp)326    self._compareBoth(x, np.expm1, math_ops.expm1)327    self._compareBoth(z, np.log, math_ops.log)328    self._compareBoth(z, np.log1p, math_ops.log1p)329    self._compareBoth(x, np.tanh, math_ops.tanh)330    self._compareBoth(x, self._sigmoid, math_ops.sigmoid)331    self._compareBoth(y, np.sign, math_ops.sign)332    self._compareBoth(x, np.sin, math_ops.sin)333    self._compareBoth(x, np.cos, math_ops.cos)334    self._compareBoth(335        y, np.vectorize(self._replace_domain_error_with_inf(math.lgamma)),336        math_ops.lgamma)337    self._compareBoth(x, np.vectorize(math.erf), math_ops.erf)338    self._compareBoth(x, np.vectorize(math.erfc), math_ops.erfc)339    try:340      from scipy import special  # pylint: disable=g-import-not-at-top341      self._compareBoth(x, special.i0e, math_ops.bessel_i0e)342      self._compareBoth(x, special.i1e, math_ops.bessel_i1e)343    except ImportError as e:344      tf_logging.warn("Cannot test special functions: %s" % str(e))345    self._compareBothSparse(x, np.abs, math_ops.abs)346    self._compareBothSparse(x, np.negative, math_ops.negative)347    self._compareBothSparse(x, np.square, math_ops.square)348    self._compareBothSparse(z, np.sqrt, math_ops.sqrt, tol=1e-3)349    self._compareBothSparse(x, np.tanh, math_ops.tanh)350    self._compareBothSparse(y, np.sign, math_ops.sign)351    self._compareBothSparse(x, np.vectorize(math.erf), math_ops.erf, tol=1e-3)352  def testBFloat16Basic(self):353    x = np.arange(-6, 6,354                  2).reshape(1, 3, 2).astype(dtypes_lib.bfloat16.as_numpy_dtype)355    self._compareCpu(x, np.abs, math_ops.abs)356    self._compareCpu(x, np.abs, _ABS)357  def testInt8Basic(self):358    x = np.arange(-6, 6, 2).reshape(1, 3, 2).astype(np.int8)359    self._compareCpu(x, np.abs, math_ops.abs)360    self._compareCpu(x, np.abs, _ABS)361  def testInt16Basic(self):362    x = np.arange(-6, 6, 2).reshape(1, 3, 2).astype(np.int16)363    self._compareCpu(x, np.abs, math_ops.abs)364    self._compareCpu(x, np.abs, _ABS)365  def testInt32Basic(self):366    x = np.arange(-6, 6, 2).reshape(1, 3, 2).astype(np.int32)367    self._compareCpu(x, np.abs, math_ops.abs)368    self._compareCpu(x, np.abs, _ABS)369    self._compareBoth(x, np.negative, math_ops.negative)370    self._compareBoth(x, np.negative, _NEG)371    self._compareBoth(x, np.square, math_ops.square)372    self._compareCpu(x, np.sign, math_ops.sign)373    self._compareBothSparse(x, np.abs, math_ops.abs)374    self._compareBothSparse(x, np.negative, math_ops.negative)375    self._compareBothSparse(x, np.square, math_ops.square)376    self._compareBothSparse(x, np.sign, math_ops.sign)377  def testInt64Basic(self):378    x = np.arange(-6 << 40, 6 << 40, 2 << 40).reshape(1, 3, 2).astype(np.int64)379    self._compareCpu(x, np.abs, math_ops.abs)380    self._compareCpu(x, np.abs, _ABS)381    self._compareCpu(x, np.negative, math_ops.negative)382    self._compareCpu(x, np.negative, _NEG)383    self._compareCpu(x, np.sign, math_ops.sign)384    self._compareBothSparse(x, np.abs, math_ops.abs)385    self._compareBothSparse(x, np.negative, math_ops.negative)386    self._compareBothSparse(x, np.sign, math_ops.sign)387  def testInt64Square(self):388    x = np.arange(-6 << 20, 6 << 20, 2 << 20).reshape(1, 3, 2).astype(np.int64)389    self._compareCpu(x, np.square, math_ops.square)390    self._compareBothSparse(x, np.square, math_ops.square)391  @test_util.run_deprecated_v1392  def testComplex64Basic(self):393    x = np.complex(1, 1) * np.arange(-3, 3).reshape(1, 3, 2).astype(394        np.complex64)395    y = x + np.complex(0.5, 0.5)  # no zeros396    self._compareBoth(x, np.abs, math_ops.abs)397    self._compareBoth(x, np.abs, _ABS)398    self._compareBoth(x, np.negative, math_ops.negative)399    self._compareBoth(x, np.negative, _NEG)400    self._compareCpu(y, self._inv, math_ops.reciprocal)401    self._compareCpu(x, np.square, math_ops.square)402    self._compareCpu(y, np.sqrt, math_ops.sqrt)403    self._compareCpu(y, self._rsqrt, math_ops.rsqrt)404    self._compareBoth(x, np.exp, math_ops.exp)405    self._compareCpu(x, np.expm1, math_ops.expm1)406    self._compareCpu(y, np.log, math_ops.log)407    self._compareCpu(y, np.log1p, math_ops.log1p)408    self._compareCpu(x, np.sinh, math_ops.sinh)409    self._compareCpu(x, np.cosh, math_ops.cosh)410    self._compareCpu(x, np.tanh, math_ops.tanh)411    # Complex64 versions of asinh() and acosh() in libstdc++ only have 6 digits412    # of precision.413    # Small gradient values + low precision --> High relative error414    self._compareCpu(y, np.arcsinh, math_ops.asinh, grad_rtol=1e-2)415    self._compareCpu(y, np.arccosh, math_ops.acosh, grad_rtol=1e-2)416    self._compareCpu(y, np.arctanh, math_ops.atanh)417    self._compareCpu(x, self._sigmoid, math_ops.sigmoid)418    self._compareCpu(x, np.sin, math_ops.sin)419    self._compareCpu(x, np.cos, math_ops.cos)420    self._compareBothSparse(x, np.abs, math_ops.abs)421    self._compareBothSparse(x, np.negative, math_ops.negative)422    self._compareBothSparse(x, np.square, math_ops.square)423    self._compareBothSparse(x, np.sqrt, math_ops.sqrt, 1e-3)424    self._compareBothSparse(x, np.tanh, math_ops.tanh)425    # Numpy uses an incorrect definition of sign; use the right one instead.426    def complex_sign(x):427      return x / np.abs(x)428    self._compareBoth(y, complex_sign, math_ops.sign)429    self._compareBothSparse(y, complex_sign, math_ops.sign)430  @test_util.run_deprecated_v1431  def testComplex128Basic(self):432    x = np.complex(1, 1) * np.arange(-3, 3).reshape(1, 3, 2).astype(433        np.complex128)434    y = x + np.complex(0.5, 0.5)  # no zeros435    self._compareBoth(x, np.abs, math_ops.abs)436    self._compareBoth(x, np.abs, _ABS)437    self._compareBoth(x, np.negative, math_ops.negative)438    self._compareBoth(x, np.negative, _NEG)439    self._compareCpu(y, self._inv, math_ops.reciprocal)440    self._compareCpu(x, np.square, math_ops.square)441    self._compareCpu(y, np.sqrt, math_ops.sqrt)442    self._compareCpu(y, self._rsqrt, math_ops.rsqrt)443    self._compareBoth(x, np.exp, math_ops.exp)444    self._compareCpu(x, np.expm1, math_ops.expm1)445    self._compareCpu(y, np.log, math_ops.log)446    self._compareCpu(y, np.log1p, math_ops.log1p)447    self._compareCpu(x, np.sinh, math_ops.sinh)448    self._compareCpu(x, np.cosh, math_ops.cosh)449    self._compareCpu(x, np.tanh, math_ops.tanh)450    self._compareCpu(y, np.arcsinh, math_ops.asinh)451    self._compareCpu(y, np.arccosh, math_ops.acosh)452    self._compareCpu(y, np.arctanh, math_ops.atanh)453    self._compareCpu(x, self._sigmoid, math_ops.sigmoid)454    self._compareCpu(x, np.sin, math_ops.sin)455    self._compareCpu(x, np.cos, math_ops.cos)456    self._compareBothSparse(x, np.abs, math_ops.abs)457    self._compareBothSparse(x, np.negative, math_ops.negative)458    self._compareBothSparse(x, np.square, math_ops.square)459    self._compareBothSparse(x, np.sqrt, math_ops.sqrt, 1e-3)460    self._compareBothSparse(x, np.tanh, math_ops.tanh)461    # Numpy uses an incorrect definition of sign; use the right one instead.462    def complex_sign(x):463      return x / np.abs(x)464    self._compareBoth(y, complex_sign, math_ops.sign)465    self._compareBothSparse(y, complex_sign, math_ops.sign)466  @test_util.run_deprecated_v1467  def testGradGrad(self):468    np.random.seed(7)469    shape = (5,)470    dtype_tols = [(np.float32, 5e-4), (np.float64, 1e-6), (np.complex64, 5e-4),471                  (np.complex128, 1e-6)]472    op_range = [473        (gen_math_ops.reciprocal_grad, [-2, 2]),474        (gen_math_ops.rsqrt_grad, [0.1, 3]),475        (gen_math_ops.sigmoid_grad, [-2, 2]),476        (gen_math_ops.sqrt_grad, [0.1, 3]),477        (gen_math_ops.tanh_grad, [-2, 2]),478    ]479    def rand(dtype, real_range):480      x = np.random.uniform(481          real_range[0], real_range[1], size=shape[0]).astype(dtype)482      if dtype in (np.complex64, np.complex128):483        x += 1j * np.random.uniform(-2, 2, size=shape[0]).astype(dtype)484      return x485    for op, real_range in op_range:486      with self.cached_session():487        for dtype, tol in dtype_tols:488          x = constant_op.constant(rand(dtype, real_range))489          y = constant_op.constant(rand(dtype, real_range))490          z = op(x, y)491          grads = gradient_checker.compute_gradient(492              [x, y], [shape, shape],493              z,494              shape,495              x_init_value=[rand(dtype, real_range),496                            rand(dtype, real_range)])497          if isinstance(grads, tuple):498            grads = [grads]499          for analytical, numerical in grads:500            self.assertAllClose(analytical, numerical, rtol=tol, atol=tol)501  @test_util.run_in_graph_and_eager_modes502  def testComplexAbsGradGrad(self):503    def f(x):504      real = math_ops.cos(x)505      imag = ops.convert_to_tensor(1.)506      return math_ops.abs(math_ops.complex(real, imag))507    def g(x):508      with backprop.GradientTape() as t:509        t.watch(x)510        y = f(x)511      return t.gradient(y, x)512    err = gradient_checker_v2.max_error(513        *gradient_checker_v2.compute_gradient(g, [ops.convert_to_tensor(2.0)]))514    self.assertLess(err, 1e-3)515if __name__ == "__main__":...

buildTestData.py

Source:buildTestData.py

1#-******************************************************************************2#3# Copyright (c) 2012,4#  Sony Pictures Imageworks Inc. and5#  Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.6#7# All rights reserved.8#9# Redistribution and use in source and binary forms, with or without10# modification, are permitted provided that the following conditions are11# met:12# *       Redistributions of source code must retain the above copyright13# notice, this list of conditions and the following disclaimer.14# *       Redistributions in binary form must reproduce the above15# copyright notice, this list of conditions and the following disclaimer16# in the documentation and/or other materials provided with the17# distribution.18# *       Neither the name of Sony Pictures Imageworks, nor19# Industrial Light & Magic, nor the names of their contributors may be used20# to endorse or promote products derived from this software without specific21# prior written permission.22#23# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS24# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT25# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR26# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT27# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,28# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT29# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,30# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY31# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT32# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE33# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.34#35#-******************************************************************************36from imath import *37from alembic.AbcCoreAbstract import *38from alembic.Abc import *39from alembic.AbcGeom import *40from alembic.Util import *41C3c = Color3c42C3f = Color3f43C4c = Color4c44C4f = Color4f45# Test data for number type traits46ScalarTraitsData = {}47SmallArrayTraitsData = {}48ArrayTraitsData = {}49# Comparison measures for number type traits50TraitsComparison = {}51# -----------------------------------------------------------------52# Test helper functions53# -----------------------------------------------------------------54# Comparison functions for various data types55EPS = 0.01 56def compareExact (a0, a1):57    return a0 == a158def compareEPS (a0, a1):59    return abs (a0 - a1) <= EPS60def compareVec3Exact (a0, a1):61    return a0[0] == a1[0] and a0[1] == a1[1] and a0[2] == a1[2]62def compareVec4Exact (a0, a1):63    return a0[0] == a1[0] and a0[1] == a1[1] and a0[2] == a1[2] and \64           a0[3] == a1[3]65def compareVecEPS (a0, a1):66    return a0.equalWithRelError (a1, EPS)67def compareBoxExact (a0, a1):68    return compareExact (a0.min(), a1.min()) and \69           compareExact (a0.max(), a1.max())70def compareBoxEPS (a0, a1):71    return compareVecEPS (a0.min(), a1.min()) and \72           compareVecEPS (a0.max(), a1.max())73def compareQuatEPS (a0, a1):74    return compareEPS (a0.angle(), a1.angle()) and \75           compareVecEPS (a0.axis(), a1.axis())76def compareC3EPS (a0, a1):77    return compareEPS (a0[0], a1[0]) and compareEPS (a0[1], a1[1]) and \78           compareEPS (a0[2], a1[2])79def compareC4EPS (a0, a1):80    return compareEPS (a0[0], a1[0]) and compareEPS (a0[1], a1[1]) and \81           compareEPS (a0[2], a1[2]) and compareEPS (a0[3], a1[3])82def WRITES( *iArgs ):83    iTraits = iArgs[0];84    name = iTraits.__name__85    ScalarTraitsData[name] = iArgs86def WRITESA( iTraits, *iArgs ):87    name = iTraits.__name__88    SmallArrayTraitsData[name] = iTraits, createArray( iTraits.arrayType, iArgs )89def createArray( iArray, iList ):90    a = iArray( len( iList ) )91    for i in range( len( iList ) ):92        a[i] = iList[i]93    return a94def WRITEA( iTraits, *iArgs ):95    name = iTraits.__name__96    ArrayTraitsData[name] = iTraits, createArray( iTraits.arrayType, iArgs )97def buildTestScalarData():98    # Scalar DataType99    100    # POD types101    # extent 1102    WRITES (BooleanTPTraits, 0, 1, 0)103    WRITES (Uint8TPTraits, 3, 4)104    WRITES (Int8TPTraits, -5 )105    WRITES (Uint16TPTraits, 6 )106    WRITES (Int16TPTraits, -7, 8 )107    WRITES (Uint32TPTraits, 9, 10, 11, 12 )108    WRITES (Int32TPTraits, -13, 14, -15 )109    WRITES (Uint64TPTraits, 16 )110    WRITES (Float16TPTraits, 1.234, 6.789)111    WRITES (Float32TPTraits, -1234.5678)112    WRITES (Float64TPTraits, 1234.5678)113    WRITES (StringTPTraits, "abc", "def")114    WRITES (WstringTPTraits, u"asdf" )115    # Compound Types116    # extent 2117    # vector2118    WRITES (V2sTPTraits, V2s (1, 2), V2s (-1, 0))119    WRITES (V2iTPTraits, V2i (3, 4))120    WRITES (V2fTPTraits, V2f (1.2, 3.4), V2f (5.6, 0))121    WRITES (V2dTPTraits, V2d (5.6, 7.8))122    # point2123    WRITES (P2sTPTraits, V2s (10, 20), V2s (-10, 0))124    WRITES (P2iTPTraits, V2i (30, 40))125    WRITES (P2fTPTraits, V2f (1.02, 3.04), V2f (5.06, 0))126    WRITES (P2dTPTraits, V2d (5.06, 7.08))127    # normal2128    WRITES (N2fTPTraits, V2f (1.1, 1.2), V2f (-1.1, 0.1))129    WRITES (N2dTPTraits, V2d (3.4, 4.4))130    # extent 3131    # color3132    WRITES (C3cTPTraits, Color3c (1, 2, 3))133    # TODO: Color3h types are not wrapped. C3f is used instead.134    WRITES (C3hTPTraits, Color3f (0.1, 0.2, 0.3))135    WRITES (C3fTPTraits, Color3f (15.6, 7.8, 9.0))136    # vector3137    WRITES (V3sTPTraits, V3s (4, 5, 6))138    WRITES (V3iTPTraits, V3i (7, 8, 9))139    WRITES (V3fTPTraits, V3f (25.6, 7.8, 9.0))140    WRITES (V3dTPTraits, V3d (35.6, 7.8, 14.2))141    # point3142    WRITES (P3sTPTraits, V3s (40, 50, 60))143    WRITES (P3iTPTraits, V3i (70, 80, 90))144    WRITES (P3fTPTraits, V3f (25.06, 7.08, 90.0))145    WRITES (P3dTPTraits, V3d (35.06, 7.08, 14.02))146    # normal3147    WRITES (N3fTPTraits, V3f (11.1, 11.2, 11.3), V3f (-11.1, 0.11, 0.22))148    WRITES (N3dTPTraits, V3d (31.4, 41.4, 41.5))149    # extent 4150    # color4151    WRITES (C4cTPTraits, Color4c (1, 2, 3, 4) )152    # TODO: Color4h types are not wrapped. C4f is used instead.153    WRITES (C4hTPTraits, Color4f (5.6, 7.8, 1.2, 3.4) )154    WRITES (C4fTPTraits, Color4f (1.111, 2.222, 3.333, 4.444) )155    # box2156    WRITES (Box2sTPTraits, Box2s (V2s (0, 0), V2s (1, 1)));157    WRITES (Box2iTPTraits, Box2i (V2i (0, 0), V2i (2, 2)));158    WRITES (Box2fTPTraits, Box2f (V2f (0, 0), V2f (0.3, 0.3)));159    WRITES (Box2dTPTraits, Box2d (V2d (0, 0), V2d (0.4, 0.4)));160    # quat161    WRITES (QuatfTPTraits, Quatf (-1.0, 2.0, 3.0, -4.0))162    WRITES (QuatdTPTraits, Quatd (0.5, 0.6, -0.7, -0.8))163    # extent 6164    # box3165    WRITES (Box3sTPTraits, Box3s (V3s (-1, -1, -1), V3s (1, 1, 1)))166    WRITES (Box3iTPTraits, Box3i (V3i (0, 0, 0), V3i (1, 1, 1)))167    WRITES (Box3fTPTraits, Box3f (V3f(1.2, 3.4, 5.6), V3f(-1.2, 3.4, -5.6)))168    WRITES (Box3dTPTraits, Box3d (V3d(0, 0, 0), V3d(5.6, 7.8, 9.0)))169    # extent 9170    # matrix33171    WRITES (M33fTPTraits, M33f(1)*2)172    WRITES (M33dTPTraits, M33d(1)*3)173    # extent 16174    # matrix44175    WRITES (M44fTPTraits, M44f(1)*4)176    WRITES (M44dTPTraits, M44d(1)*5)177    178def buildTestSmallArrayData():179    # Scalar DataType180    181    # POD types182    # extent > 1183    WRITESA (BooleanTPTraits, 0, 0, 1)184    WRITESA (Uint8TPTraits, 1, 2, 3, 4, 5, 6)185    WRITESA (Int8TPTraits, -1, 2, -3, 4, -5, 6)186    WRITESA (Uint16TPTraits, 10, 20, 30, 40, 50, 60)187    WRITESA (Int16TPTraits, -10, 20, -30, 40, -50, 60)188    WRITESA (Uint32TPTraits, 11, 22, 33, 44, 55, 66)189    WRITESA (Int32TPTraits, -11, 22, -33, 44, -55, 66)190    WRITESA (Uint64TPTraits, 13, 23, 33, 43, 53)191    WRITESA (Int64TPTraits, -13, 23, -33, 43, -53)192    WRITESA (Float16TPTraits, 1.23, 2.34, 3.45, 4.56)193    WRITESA (Float32TPTraits, 1.234, 2.345, 3.456, 4.567)194    WRITESA (Float64TPTraits, 1.2345, 2.3456, 3.4567, 4.5678)195    WRITESA (StringTPTraits, "a", "b", "c", "d", "e")196    WRITESA (WstringTPTraits, u"A", u"B", u"C", u"D", u"E")197def buildTestArrayData():198    # POD types199    # extent 1200    WRITEA (BooleanTPTraits, 0, 0, 1)201    WRITEA (Uint8TPTraits, 1, 2, 3, 4, 5, 6)202    WRITEA (Int8TPTraits, -1, 2, -3, 4, -5, 6)203    WRITEA (Uint16TPTraits, 10, 20, 30, 40, 50, 60)204    WRITEA (Int16TPTraits, -10, 20, -30, 40, -50, 60)205    WRITEA (Uint32TPTraits, 11, 22, 33, 44, 55, 66)206    WRITEA (Int32TPTraits, -11, 22, -33, 44, -55, 66)207    WRITEA (Uint64TPTraits, 13, 23, 33, 43, 53)208    WRITEA (Int64TPTraits, -13, 23, -33, 43, -53)209    WRITEA (Float16TPTraits, 1.23, 2.34, 3.45, 4.56)210    WRITEA (Float32TPTraits, 1.234, 2.345, 3.456, 4.567)211    WRITEA (Float64TPTraits, 1.2345, 2.3456, 3.4567, 4.5678)212    WRITEA (StringTPTraits, "a", "b", "c", "d", "e");213    WRITEA (WstringTPTraits, u"A", u"B", u"C", u"D", u"E");214    # Compound Types215    # extent 2216    # vector2217    WRITEA (V2sTPTraits, V2s (1, 2), V2s (-1, 1))218    WRITEA (V2iTPTraits, V2i (3, 4), V2i (5, 6))219    WRITEA (V2fTPTraits, V2f (1.2, 3.4), V2f (5.6, 7.8))220    WRITEA (V2dTPTraits, V2d (5.6, 7.8), V2d (9.10, 10.11))221    # point2222    WRITEA (P2sTPTraits, V2s (10, 20), V2s (-10, 0))223    WRITEA (P2iTPTraits, V2i (30, 40), V2i (10, 20))224    WRITEA (P2fTPTraits, V2f (1.02, 3.04), V2f (5.06, 0.11))225    WRITEA (P2dTPTraits, V2d (5.06, 7.08), V2d (-102.4, -9.5))226    # normal2227    WRITEA (N2fTPTraits, V2f (1.1, 1.2), V2f (-1.1, 0.1))228    WRITEA (N2dTPTraits, V2d (3.4, 4.4), V2d (-104.2, 104.2))229    # extent 3230    # color3231    WRITEA (C3cTPTraits, C3c (1, 2, 3), C3c (4, 5, 6))232    # TODO: C3h types are not wrapped. C3f is used instead.233    WRITEA (C3hTPTraits, C3f (0.1, 0.2, 0.3), C3f(0.4, 0.5, 0.6))234    WRITEA (C3fTPTraits, C3f (15.6, 7.8, 9.0), C3f(-1.4, -235.2, 11.1))235    # vector3236    WRITEA (V3sTPTraits, V3s (4, 5, 6), V3s (14, 132, 13))237    WRITEA (V3iTPTraits, V3i (7, 8, 9), V3i (-1, -14, 32))238    WRITEA (V3fTPTraits, V3f (25.6, 7.8, 9.0), V3f (-0.2, -1.3, 1.5))239    WRITEA (V3dTPTraits, V3d (35.6, 7.8, 14.2), V3d (13.2, 1403, -12.3))240    # point3241    WRITEA (P3sTPTraits, V3s (40, 50, 60), V3s(1, 2, 3))242    WRITEA (P3iTPTraits, V3i (70, 80, 90), V3i(-1, -2, -3))243    WRITEA (P3fTPTraits, V3f (25.06, 7.08, 90.0), V3f(-0.1, -0.2, -0.3))244    WRITEA (P3dTPTraits, V3d (35.06, 7.08, 14.02), V3d(-0.3, -0.4, -0.5))245    # normal3246    WRITEA (N3fTPTraits, V3f (11.1, 11.2, 11.3), V3f (-11.1, 0.11, 0.22))247    WRITEA (N3dTPTraits, V3d (31.4, 41.4, 41.5), V3d (-0.1, -0.2, -0.4))248    # extent 4249    # color4250    WRITEA (C4cTPTraits, C4c (1, 2, 3, 4) )251    # TODO: C4h types are not wrapped. C4f is used instead.252    WRITEA (C4hTPTraits, C4f (5.6, 7.8, 1.2, 3.4) )253    WRITEA (C4fTPTraits, C4f (1.111, 2.222, 3.333, 4.444) )254    # box2255    WRITEA (Box2sTPTraits, Box2s (V2s (0, 0), V2s (1, 1)));256    WRITEA (Box2iTPTraits, Box2i (V2i (0, 0), V2i (2, 2)));257    WRITEA (Box2fTPTraits, Box2f (V2f (0, 0), V2f (0.3, 0.3)));258    WRITEA (Box2dTPTraits, Box2d (V2d (0, 0), V2d (0.4, 0.4)));259    # quat260    WRITEA (QuatfTPTraits, Quatf (-1.0, 2.0, 3.0, -4.0))261    WRITEA (QuatdTPTraits, Quatd (0.5, 0.6, -0.7, -0.8))262    # extent 6263    # box3264    WRITEA (Box3sTPTraits, Box3s (V3s (-1, -1, -1), V3s (1, 1, 1)))265    WRITEA (Box3iTPTraits, Box3i (V3i (0, 0, 0), V3i (1, 1, 1)))266    WRITEA (Box3fTPTraits, Box3f (V3f (1.2, 3.4, 5.6), V3f (1.2, 4.4, 5.6)))267    WRITEA (Box3dTPTraits, Box3d (V3d (0, 0, 0), V3d (5.6, 7.8, 9.0)))268    # extent 9269    # matrix33270    WRITEA (M33fTPTraits, M33f (1)*2, M33f (0.1))271    WRITEA (M33dTPTraits, M33d (1)*3, M33d (3.4))272    # extent 16273    # matrix44274    WRITEA (M44fTPTraits, M44f (1)*4, M44f (1.2))275    WRITEA (M44dTPTraits, M44d (1)*5, M44d (5.6))276def buildComparisonMeasure():277    # Assign the property name and proper comparison function278    # for each type279    TraitsComparison[BooleanTPTraits.__name__] = compareExact280    TraitsComparison[Uint8TPTraits.__name__] = compareExact281    TraitsComparison[Int8TPTraits.__name__] = compareExact282    TraitsComparison[Uint16TPTraits.__name__] = compareExact283    TraitsComparison[Int16TPTraits.__name__] = compareExact284    TraitsComparison[Uint32TPTraits.__name__] = compareExact285    TraitsComparison[Int32TPTraits.__name__] = compareExact286    TraitsComparison[Uint64TPTraits.__name__] = compareExact287    TraitsComparison[Int64TPTraits.__name__] = compareExact288    TraitsComparison[Float16TPTraits.__name__] = compareEPS289    TraitsComparison[Float32TPTraits.__name__] = compareEPS290    TraitsComparison[Float64TPTraits.__name__] = compareEPS291    TraitsComparison[StringTPTraits.__name__] = compareExact292    TraitsComparison[WstringTPTraits.__name__] = compareExact293    TraitsComparison[V2sTPTraits.__name__] = compareExact294    TraitsComparison[V2iTPTraits.__name__] = compareExact295    TraitsComparison[V2fTPTraits.__name__] = compareVecEPS296    TraitsComparison[V2dTPTraits.__name__] = compareVecEPS297    TraitsComparison[P2sTPTraits.__name__] = compareExact298    TraitsComparison[P2iTPTraits.__name__] = compareExact 299    TraitsComparison[P2fTPTraits.__name__] = compareVecEPS300    TraitsComparison[P2dTPTraits.__name__] = compareVecEPS301    TraitsComparison[N2fTPTraits.__name__] = compareVecEPS302    TraitsComparison[N2dTPTraits.__name__] = compareVecEPS303    TraitsComparison[C3cTPTraits.__name__] = compareVec3Exact304    TraitsComparison[C3hTPTraits.__name__] = compareVecEPS305    TraitsComparison[C3fTPTraits.__name__] = compareC3EPS306    TraitsComparison[V3sTPTraits.__name__] = compareExact307    TraitsComparison[V3iTPTraits.__name__] = compareExact308    TraitsComparison[V3fTPTraits.__name__] = compareVecEPS309    TraitsComparison[V3dTPTraits.__name__] = compareVecEPS310    TraitsComparison[P3sTPTraits.__name__] = compareExact311    TraitsComparison[P3iTPTraits.__name__] = compareExact312    TraitsComparison[P3fTPTraits.__name__] = compareVecEPS313    TraitsComparison[P3dTPTraits.__name__] = compareVecEPS314    TraitsComparison[N3fTPTraits.__name__] = compareVecEPS315    TraitsComparison[N3dTPTraits.__name__] = compareVecEPS316    TraitsComparison[C4cTPTraits.__name__] = compareVec4Exact317    TraitsComparison[C4hTPTraits.__name__] = compareC4EPS318    TraitsComparison[C4fTPTraits.__name__] = compareC4EPS319    TraitsComparison[Box2sTPTraits.__name__] = compareBoxExact320    TraitsComparison[Box2iTPTraits.__name__] = compareBoxExact321    TraitsComparison[Box2fTPTraits.__name__] = compareBoxEPS322    TraitsComparison[Box2dTPTraits.__name__] = compareBoxEPS323    TraitsComparison[QuatfTPTraits.__name__] = compareQuatEPS324    TraitsComparison[QuatdTPTraits.__name__] = compareQuatEPS325    TraitsComparison[Box3sTPTraits.__name__] = compareBoxExact326    TraitsComparison[Box3iTPTraits.__name__] = compareBoxExact327    TraitsComparison[Box3fTPTraits.__name__] = compareBoxEPS328    TraitsComparison[Box3dTPTraits.__name__] = compareBoxEPS329    TraitsComparison[M33fTPTraits.__name__] = compareVecEPS330    TraitsComparison[M33dTPTraits.__name__] = compareVecEPS331    TraitsComparison[M44fTPTraits.__name__] = compareVecEPS332    TraitsComparison[M44dTPTraits.__name__] = compareVecEPS333# -------------------------------------------------------------------------334# Main loop335buildTestScalarData()336buildTestSmallArrayData()337buildTestArrayData()...

basic_gpu_test.py

Source:basic_gpu_test.py

...74    self._compareGPU(x, y, np.subtract, math_ops.subtract)75    self._compareGPU(x, y, np.multiply, math_ops.multiply)76    self._compareGPU(x, y + 0.1, np.true_divide, math_ops.truediv)77class MathBuiltinUnaryTest(test.TestCase):78  def _compare(self, x, np_func, tf_func, use_gpu):79    np_out = np_func(x)80    with self.cached_session(use_gpu=use_gpu) as sess:81      inx = ops.convert_to_tensor(x)82      ofunc = tf_func(inx)83      tf_out = self.evaluate(ofunc)84    self.assertAllClose(np_out, tf_out)85  def _inv(self, x):86    return 1.0 / x87  def _rsqrt(self, x):88    return self._inv(np.sqrt(x))89  def _testDtype(self, dtype, use_gpu):90    data = (np.arange(-3, 3) / 4.).reshape([1, 3, 2]).astype(dtype)91    data_gt_1 = data + 2 # for x > 192    self._compare(data, np.abs, math_ops.abs, use_gpu)93    self._compare(data, np.arccos, math_ops.acos, use_gpu)94    self._compare(data, np.arcsin, math_ops.asin, use_gpu)95    self._compare(data, np.arcsinh, math_ops.asinh, use_gpu)96    self._compare(data_gt_1, np.arccosh, math_ops.acosh, use_gpu)97    self._compare(data, np.arctan, math_ops.atan, use_gpu)98    self._compare(data, np.ceil, math_ops.ceil, use_gpu)99    self._compare(data, np.cos, math_ops.cos, use_gpu)100    self._compare(data, np.cosh, math_ops.cosh, use_gpu)101    self._compare(data, np.exp, math_ops.exp, use_gpu)102    self._compare(data, np.floor, math_ops.floor, use_gpu)103    self._compare(data, np.log, math_ops.log, use_gpu)104    self._compare(data, np.log1p, math_ops.log1p, use_gpu)105    self._compare(data, np.negative, math_ops.negative, use_gpu)106    self._compare(data, self._rsqrt, math_ops.rsqrt, use_gpu)107    self._compare(data, np.sin, math_ops.sin, use_gpu)108    self._compare(data, np.sinh, math_ops.sinh, use_gpu)109    self._compare(data, np.sqrt, math_ops.sqrt, use_gpu)110    self._compare(data, np.square, math_ops.square, use_gpu)111    self._compare(data, np.tan, math_ops.tan, use_gpu)112    self._compare(data, np.tanh, math_ops.tanh, use_gpu)113    self._compare(data, np.arctanh, math_ops.atanh, use_gpu)114  def testTypes(self):115    for dtype in [np.float32]:116      self._testDtype(dtype, use_gpu=True)117  def testFloorDivide(self):118    x = (1 + np.linspace(0, 5, np.prod([1, 3, 2]))).astype(np.float32).reshape(119        [1, 3, 2])120    y = (1 + np.linspace(0, 5, np.prod([1, 3, 2]))).astype(np.float32).reshape(121        [1, 3, 2])122    np_out = np.floor_divide(x, y + 0.1)123    with self.session(use_gpu=True) as sess:124      inx = ops.convert_to_tensor(x)125      iny = ops.convert_to_tensor(y + 0.1)126      ofunc = inx / iny127      out_func2 = math_ops.floor(ofunc)...

li_std_containers_int_runme.py

Source:li_std_containers_int_runme.py

1# Check std::vector and std::list behaves the same as Python iterable2# types (list)3from li_std_containers_int import *4import sys5def failed(a, b, msg):6    raise RuntimeError, msg + " " + str(list(a)) + " " + str(list(b))7def compare_sequences(a, b):8    if len(a) != len(b):9        failed(a, b, "different sizes")10    for i in range(len(a)):11        if a[i] != b[i]:12            failed(a, b, "elements are different")13def compare_containers(pythonlist, swigvector, swiglist):14    compare_sequences(pythonlist, swigvector)15    compare_sequences(pythonlist, swiglist)16# Check std::vector and std::list assignment behaves same as Python list17# assignment including exceptions18def container_insert_step(i, j, step, newval):19    ps = range(6)20    iv = vector_int(ps)21    il = list_int(ps)22    # Python slice23    try:24        if step == None:25            if j == None:26                ps[i] = newval27            else:28                ps[i:j] = newval29        else:30            if j == None:31                ps[i::step] = newval32            else:33                ps[i:j:step] = newval34        ps_error = None35    except ValueError, e:36        ps_error = e37    except IndexError, e:38        ps_error = e39    # std::vector<int>40    try:41        if step == None:42            if j == None:43                iv[i] = newval44            else:45                iv[i:j] = newval46        else:47            if j == None:48                iv[i::step] = newval49            else:50                iv[i:j:step] = newval51        iv_error = None52    except ValueError, e:53        iv_error = e54    except IndexError, e:55        iv_error = e56    # std::list<int>57    try:58        if step == None:59            if j == None:60                il[i] = newval61            else:62                il[i:j] = newval63        else:64            if j == None:65                il[i::step] = newval66            else:67                il[i:j:step] = newval68        il_error = None69    except ValueError, e:70        il_error = e71    except IndexError, e:72        il_error = e73    # Python 2.6 contains bug fixes in extended slicing syntax:74    # http://docs.python.org/2/whatsnew/2.6.html75    skip_check = ps_error != None and(76        iv_error == il_error == None) and step > 0 and (sys.version_info[0:2] < (2, 6))77    if not(skip_check):78        if not((type(ps_error) == type(iv_error)) and (type(ps_error) == type(il_error))):79            raise RuntimeError, "ValueError exception not consistently thrown: " + \80                str(ps_error) + " " + str(iv_error) + " " + str(il_error)81        compare_containers(ps, iv, il)82# Check std::vector and std::list delete behaves same as Python list83# delete including exceptions84def container_delete_step(i, j, step):85    ps = range(6)86    iv = vector_int(ps)87    il = list_int(ps)88    # Python slice89    try:90        if step == None:91            if j == None:92                del ps[i]93            else:94                del ps[i:j]95        else:96            if j == None:97                del ps[i::step]98            else:99                del ps[i:j:step]100        ps_error = None101    except ValueError, e:102        ps_error = e103    except IndexError, e:104        ps_error = e105    # std::vector<int>106    try:107        if step == None:108            if j == None:109                del iv[i]110            else:111                del iv[i:j]112        else:113            if j == None:114                del iv[i::step]115            else:116                del iv[i:j:step]117        iv_error = None118    except ValueError, e:119        iv_error = e120    except IndexError, e:121        iv_error = e122    # std::list<int>123    try:124        if step == None:125            if j == None:126                del il[i]127            else:128                del il[i:j]129        else:130            if j == None:131                del il[i::step]132            else:133                del il[i:j:step]134        il_error = None135    except ValueError, e:136        il_error = e137    except IndexError, e:138        il_error = e139    if not((type(ps_error) == type(iv_error)) and (type(ps_error) == type(il_error))):140        raise RuntimeError, "ValueError exception not consistently thrown: " + \141            str(ps_error) + " " + str(iv_error) + " " + str(il_error)142    compare_containers(ps, iv, il)143ps = [0, 1, 2, 3, 4, 5]144iv = vector_int(ps)145il = list_int(ps)146# slices147compare_containers(ps[0:0], iv[0:0], il[0:0])148compare_containers(ps[1:1], iv[1:1], il[1:1])149compare_containers(ps[1:3], iv[1:3], il[1:3])150compare_containers(ps[2:4], iv[2:4], il[2:4])151compare_containers(ps[0:3], iv[0:3], il[0:3])152compare_containers(ps[3:6], iv[3:6], il[3:6])153compare_containers(ps[3:10], iv[3:10], il[3:10])  # beyond end of range154# before beginning of range (negative indexing)155compare_containers(ps[-1:7], iv[-1:7], il[-1:7])156compare_containers(ps[-2:7], iv[-2:7], il[-2:7])157compare_containers(ps[-5:7], iv[-5:7], il[-5:7])158compare_containers(ps[-6:7], iv[-6:7], il[-6:7])159# before beginning of range (negative indexing, negative index is >160# container size)161compare_containers(ps[-7:7], iv[-7:7], il[-7:7])162compare_containers(ps[-100:7], iv[-100:7], il[-100:7])163compare_containers(ps[3:], iv[3:], il[3:])164compare_containers(ps[:3], iv[:3], il[:3])165compare_containers(ps[:], iv[:], il[:])166compare_containers(ps[-3:], iv[-3:], il[-3:])167compare_containers(ps[-7:], iv[-7:], il[-7:])168compare_containers(ps[:-1], iv[:-1], il[:-1])169compare_containers(ps[:-7], iv[:-7], il[:-7])170# step slicing171compare_containers(ps[1:5:1], iv[1:5:1], il[1:5:1])172compare_containers(ps[1:5:2], iv[1:5:2], il[1:5:2])173compare_containers(ps[1:5:3], iv[1:5:3], il[1:5:3])174compare_containers(ps[1:5:4], iv[1:5:4], il[1:5:4])175compare_containers(ps[1:6:5], iv[1:6:5], il[1:6:5])176compare_containers(ps[1:7:5], iv[1:7:5], il[1:7:5])177compare_containers(ps[-1:7:1], iv[-1:7:1], il[-1:7:1])178compare_containers(ps[-1:7:2], iv[-1:7:2], il[-1:7:2])179compare_containers(ps[-6:7:2], iv[-6:7:2], il[-6:7:2])180compare_containers(ps[-100:7:2], iv[-100:7:2], il[-100:7:2])181compare_containers(ps[::1], iv[::1], il[::1])182compare_containers(ps[::2], iv[::2], il[::2])183compare_containers(ps[::-1], iv[::-1], il[::-1])184compare_containers(ps[6::-1], iv[6::-1], il[6::-1])185compare_containers(ps[:-3:-1], iv[:-3:-1], il[:-3:-1])186compare_containers(ps[:-6:-1], iv[:-6:-1], il[:-6:-1])187compare_containers(ps[:-7:-1], iv[:-7:-1], il[:-7:-1])188compare_containers(ps[:-8:-1], iv[:-8:-1], il[:-8:-1])189compare_containers(ps[:-100:-1], iv[:-100:-1], il[:-100:-1])190compare_containers(ps[4:6:-1], iv[4:6:-1], il[4:6:-1])191compare_containers(ps[4:5:-1], iv[4:5:-1], il[4:5:-1])192compare_containers(ps[4:4:-1], iv[4:4:-1], il[4:4:-1])193compare_containers(ps[4:3:-1], iv[4:3:-1], il[4:3:-1])194compare_containers(ps[4:2:-1], iv[4:2:-1], il[4:2:-1])195compare_containers(ps[100:104:-1], iv[100:104:-1], il[100:104:-1])196compare_containers(ps[104:100:-1], iv[104:100:-1], il[104:100:-1])197compare_containers(ps[-100:-104:-1], iv[-100:-104:-1], il[-100:-104:-1])198compare_containers(ps[-104:-100:-1], iv[-104:-100:-1], il[-104:-100:-1])199compare_containers(ps[::-2], iv[::-2], il[::-2])200compare_containers(ps[::-3], iv[::-3], il[::-3])201compare_containers(ps[::-4], iv[::-4], il[::-4])202compare_containers(ps[::-5], iv[::-5], il[::-5])203# insert sequences (growing, shrinking and staying same size)204for start in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:205    # single element set/replace206    container_insert_step(start, None, None, 111)207    for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:208        container_insert_step(209            start, end, None, [111, 222, 333, 444, 555, 666, 777])210        container_insert_step(start, end, None, [111, 222, 333, 444, 555, 666])211        container_insert_step(start, end, None, [111, 222, 333, 444, 555])212        container_insert_step(start, end, None, [111, 222, 333, 444])213        container_insert_step(start, end, None, [111, 222, 333])214        container_insert_step(start, end, None, [111, 222])215        container_insert_step(start, end, None, [111])216        container_insert_step(start, end, None, [])217# delete sequences (growing, shrinking and staying same size)218for start in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:219    # single element delete220    container_delete_step(start, None, None)221    for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:222        container_delete_step(start, end, None)223        for step in range(-7, 7):224            container_delete_step(start, end, step)225ps = range(6)226iv = vector_int(ps)227il = list_int(ps)228del ps[:]229del iv[:]230del il[:]231compare_containers(ps, iv, il)232for end in range(7):233    for step in range(-7, 7):234        for start in range(7):235            container_insert_step(236                start, end, step, [111, 222, 333, 444, 555, 666, 777])237            container_insert_step(238                start, end, step, [111, 222, 333, 444, 555, 666])239            container_insert_step(start, end, step, [111, 222, 333, 444, 555])240            container_insert_step(start, end, step, [111, 222, 333, 444])241            container_insert_step(start, end, step, [111, 222, 333])242            container_insert_step(start, end, step, [111, 222])243            container_insert_step(start, end, step, [111])244            container_insert_step(start, end, step, [])245try:246    x = iv[::0]247    raise RuntimeError("Zero step not caught")248except ValueError:...

cpp11_li_std_array_runme.py

Source:cpp11_li_std_array_runme.py

1from cpp11_li_std_array import *2import sys3def failed(a, b, msg):4    raise RuntimeError, msg + " " + str(list(a)) + " " + str(list(b))5def compare_sequences(a, b):6    if len(a) != len(b):7        failed(a, b, "different sizes")8    for i in range(len(a)):9        if a[i] != b[i]:10            failed(a, b, "elements are different")11def compare_containers(pythonlist, swigarray):12    compare_sequences(pythonlist, swigarray)13def steps_exception(swigarray, i, j, step):14    try:15        if i == None and j == None:16            a = swigarray[::step]17        elif i == None:18            a = swigarray[:j:step]19        elif j == None:20            a = swigarray[i::step]21        else:22            a = swigarray[i:j:step]23        raise RuntimeError, "swigarray[" + str(i) + ":" + str(j) + ":" + str(step) + "] missed steps exception for " + str(list(swigarray))24    except ValueError, e:25#        print("exception: {}".format(e))26        pass27def del_exception(swigarray, i, j, step):28    try:29        if i == None and j == None:30            del swigarray[::step]31        elif j == None and step == None:32            del swigarray[i]33        elif i == None:34            del swigarray[:j:step]35        elif j == None:36            del swigarray[i::step]37        else:38            del swigarray[i:j:step]39        raise RuntimeError, "swigarray[" + str(i) + ":" + str(j) + ":" + str(step) + "] missed del exception for " + str(list(swigarray))40    except ValueError, e:41#        print("exception: {}".format(e))42        pass43def setslice_exception(swigarray, newval):44    try:45        swigarray[::] = newval46        raise RuntimeError, "swigarray[::] = " + str(newval) + " missed set exception for swigarray:" + str(list(swigarray))47    except TypeError, e:48#        print("exception: {}".format(e))49        pass50# Check std::array has similar behaviour to a Python list51# except it is not resizable52ps = [0, 1, 2, 3, 4, 5]53ai = ArrayInt6(ps)54compare_containers(ps, ai)55# slices56compare_containers(ps[0:6], ai[0:6])57compare_containers(ps[0:10], ai[0:10])58compare_containers(ps[-10:6], ai[-10:6])59compare_containers(ps[-10:10], ai[-10:10])60compare_containers(ps[0:6:1], ai[0:6:1])61compare_containers(ps[::], ai[::])62compare_containers(ps[::1], ai[::1])63compare_containers([x for x in ps], [x for x in ai])64# Reverse65compare_containers(ps[::-1], ai[::-1])66compare_containers(ps[5::-1], ai[5::-1])67compare_containers(ps[10::-1], ai[10::-1])68# Steps other than +1 and -1 not supported69steps_exception(ai, 0, 6, 3)70steps_exception(ai, None, None, 0)71steps_exception(ai, None, None, 2)72steps_exception(ai, None, None, -2)73steps_exception(ai, 1, 3, 1)74steps_exception(ai, 3, 1, -1)75# Modify content76for i in range(len(ps)):77    ps[i] = (ps[i] + 1) * 1078    ai[i] = (ai[i] + 1) * 1079compare_containers(ps, ai)80# Delete81del_exception(ai, 0, 6, 3)82del_exception(ai, None, None, 0)83del_exception(ai, None, None, 2)84del_exception(ai, None, None, -2)85del_exception(ai, 1, 3, 1)86del_exception(ai, 3, 1, -1)87del_exception(ai, 0, None, None)88del_exception(ai, 5, None, None)89# Empty90ai = ArrayInt6()91compare_containers([0, 0, 0, 0, 0, 0], ai)92# Set slice93newvals = [10, 20, 30, 40, 50, 60]94ai[::] = newvals95compare_containers(ai, newvals)96newvals = [100, 200, 300, 400, 500, 600]97ai[0:6:1] = newvals98compare_containers(ai, newvals)99newvals = [1000, 2000, 3000, 4000, 5000, 6000]100ai[::-1] = newvals101compare_containers(ai, newvals[::-1])102newvals = [10000, 20000, 30000, 40000, 50000, 60000]103ai[-10:100:1] = newvals104compare_containers(ai, newvals[-10:100:1])105setslice_exception(ai, [1, 2, 3, 4, 5, 6, 7])106setslice_exception(ai, [1, 2, 3, 4, 5])107setslice_exception(ai, [1, 2, 3, 4])108setslice_exception(ai, [1, 2, 3])109setslice_exception(ai, [1, 2])110setslice_exception(ai, [1])111setslice_exception(ai, [])112# Check return113compare_containers(arrayOutVal(), [-2, -1, 0, 0, 1, 2])114compare_containers(arrayOutConstRef(), [-2, -1, 0, 0, 1, 2])115compare_containers(arrayOutRef(), [-2, -1, 0, 0, 1, 2])116compare_containers(arrayOutPtr(), [-2, -1, 0, 0, 1, 2])117# Check passing arguments118ai = arrayInVal([9, 8, 7, 6, 5, 4])119compare_containers(ai, [90, 80, 70, 60, 50, 40])120ai = arrayInConstRef([9, 8, 7, 6, 5, 4])121compare_containers(ai, [90, 80, 70, 60, 50, 40])122ai = ArrayInt6([9, 8, 7, 6, 5, 4])123arrayInRef(ai)124compare_containers(ai, [90, 80, 70, 60, 50, 40])125ai = ArrayInt6([9, 8, 7, 6, 5, 4])126arrayInPtr(ai)127compare_containers(ai, [90, 80, 70, 60, 50, 40])128# fill129ai.fill(111)...

test_util.py

Source:test_util.py

1"""2Tests capa util3"""4import unittest5import textwrap6from . import test_capa_system7from capa.util import compare_with_tolerance, sanitize_html8class UtilTest(unittest.TestCase):9    """Tests for util"""10    def setUp(self):11        super(UtilTest, self).setUp()12        self.system = test_capa_system()13    def test_compare_with_tolerance(self):14        # Test default tolerance '0.001%' (it is relative)15        result = compare_with_tolerance(100.0, 100.0)16        self.assertTrue(result)17        result = compare_with_tolerance(100.001, 100.0)18        self.assertTrue(result)19        result = compare_with_tolerance(101.0, 100.0)20        self.assertFalse(result)21        # Test absolute percentage tolerance22        result = compare_with_tolerance(109.9, 100.0, '10%', False)23        self.assertTrue(result)24        result = compare_with_tolerance(110.1, 100.0, '10%', False)25        self.assertFalse(result)26        # Test relative percentage tolerance27        result = compare_with_tolerance(111.0, 100.0, '10%', True)28        self.assertTrue(result)29        result = compare_with_tolerance(112.0, 100.0, '10%', True)30        self.assertFalse(result)31        # Test absolute tolerance (string)32        result = compare_with_tolerance(109.9, 100.0, '10.0', False)33        self.assertTrue(result)34        result = compare_with_tolerance(110.1, 100.0, '10.0', False)35        self.assertFalse(result)36         # Test relative tolerance (string)37        result = compare_with_tolerance(111.0, 100.0, '0.1', True)38        self.assertTrue(result)39        result = compare_with_tolerance(112.0, 100.0, '0.1', True)40        self.assertFalse(result)41        # Test absolute tolerance (float)42        result = compare_with_tolerance(109.9, 100.0, 10.0, False)43        self.assertTrue(result)44        result = compare_with_tolerance(110.1, 100.0, 10.0, False)45        self.assertFalse(result)46         # Test relative tolerance (float)47        result = compare_with_tolerance(111.0, 100.0, 0.1, True)48        self.assertTrue(result)49        result = compare_with_tolerance(112.0, 100.0, 0.1, True)50        self.assertFalse(result)51        ##### Infinite values #####52        infinity = float('Inf')53        # Test relative tolerance (float)54        result = compare_with_tolerance(infinity, 100.0, 1.0, True)55        self.assertFalse(result)56        result = compare_with_tolerance(100.0, infinity, 1.0, True)57        self.assertFalse(result)58        result = compare_with_tolerance(infinity, infinity, 1.0, True)59        self.assertTrue(result)60        # Test absolute tolerance (float)61        result = compare_with_tolerance(infinity, 100.0, 1.0, False)62        self.assertFalse(result)63        result = compare_with_tolerance(100.0, infinity, 1.0, False)64        self.assertFalse(result)65        result = compare_with_tolerance(infinity, infinity, 1.0, False)66        self.assertTrue(result)67        # Test relative tolerance (string)68        result = compare_with_tolerance(infinity, 100.0, '1.0', True)69        self.assertFalse(result)70        result = compare_with_tolerance(100.0, infinity, '1.0', True)71        self.assertFalse(result)72        result = compare_with_tolerance(infinity, infinity, '1.0', True)73        self.assertTrue(result)74        # Test absolute tolerance (string)75        result = compare_with_tolerance(infinity, 100.0, '1.0', False)76        self.assertFalse(result)77        result = compare_with_tolerance(100.0, infinity, '1.0', False)78        self.assertFalse(result)79        result = compare_with_tolerance(infinity, infinity, '1.0', False)80        self.assertTrue(result)81    def test_sanitize_html(self):82        """83        Test for html sanitization with bleach.84        """85        allowed_tags = ['div', 'p', 'audio', 'pre', 'span']86        for tag in allowed_tags:87            queue_msg = "<{0}>Test message</{0}>".format(tag)88            self.assertEqual(sanitize_html(queue_msg), queue_msg)89        not_allowed_tag = 'script'90        queue_msg = "<{0}>Test message</{0}>".format(not_allowed_tag)91        expected = "&lt;script&gt;Test message&lt;/script&gt;"...

Using AI Code Generation

1import test from 'ava';2test('foo', t => {3    t.true('foo' === 'foo');4});5test('bar', async t => {6    const bar = Promise.resolve('bar');7    t.is(await bar, 'bar');8});9import { expect } from 'chai';10describe('test', () => {11    it('foo', () => {12        expect('foo').to.be.equal('foo');13    });14    it('bar', async () => {15        const bar = Promise.resolve('bar');16        expect(await bar).to.be.equal('bar');17    });18});

Using AI Code Generation

1import test from 'ava';2test('foo', t => {3	t.pass();4});5test('bar', async t => {6	const bar = Promise.resolve('bar');7	t.is(await bar, 'bar');8});9{10	"scripts": {11	},12	"devDependencies": {13	}14}15import test from 'ava';16test.cb('foo', t => {17	setTimeout(() => {18		t.pass();19		t.end();20	}, 500);21});22import test from 'ava';23test('foo', t => {24	return new Promise(resolve => {25		setTimeout(() => {26			t.pass();27			resolve();28		}, 500);29	});30});31import test from 'ava';32test('foo', t => {33	return new Promise(resolve => {34		t.pass();35		resolve();36	});37});38import test from 'ava';39test('foo

Using AI Code Generation

1import test from 'ava';2import compare from './compare';3test('compare', t => {4  t.true(compare(1, 1));5  t.true(compare(2, 2));6  t.true(compare(3, 3));7  t.true(compare(4, 4));8  t.true(compare(5, 5));9  t.true(compare(6, 6));10  t.true(compare(7, 7));11  t.true(compare(8, 8));12  t.true(compare(9, 9));13  t.true(compare(10, 10));14});15export default function compare(a, b) {16  return a === b;17}18### test([title], implementation)19### test.serial([title], implementation)20### test.cb([title], implementation)21### test.only([title], implementation)22### test.skip([title], implementation)23### test.before([title], implementation)24### test.before.cb([title], implementation)25### test.after([title], implementation)26### test.after.cb([title], implementation)27### test.beforeEach([title], implementation)28### test.beforeEach.cb([title], implementation)29### test.afterEach([title], implementation)

Using AI Code Generation

1var fs = require('fs');2var path = require('path');3var dir = process.argv[2];4var ext = '.' + process.argv[3];5fs.readdir(dir, function(err, list) {6	if(err) {7		return console.log(err);8	}9	list.forEach(function(file) {10		if(path.extname(file) === ext) {11			console.log(file);12		}13	});14});15var fs = require('fs');16var path = require('path');17var dir = process.argv[2];18var ext = '.' + process.argv[3];19fs.readdir(dir, function(err, list) {20	if(err) {21		return console.log(err);22	}23	list.forEach(function(file) {24		if(path.extname(file) === ext) {25			console.log(file);26		}27	});28});29var fs = require('fs');30var path = require('path');31var dir = process.argv[2];32var ext = '.' + process.argv[3];33fs.readdir(dir, function(err, list) {34	if(err) {35		return console.log(err);36	}37	list.forEach(function(file) {38		if(path.extname(file) === ext) {39			console.log(file);40		}41	});42});43var fs = require('fs');44var path = require('path');45var dir = process.argv[2];46var ext = '.' + process.argv[3];47fs.readdir(dir, function(err, list) {48	if(err) {49		return console.log(err);50	}51	list.forEach(function(file) {52		if(path.extname(file) === ext) {53			console.log(file);54		}55	});56});57var fs = require('fs');58var path = require('path');59var dir = process.argv[2];60var ext = '.' + process.argv[3];61fs.readdir(dir, function(err, list) {62	if(err) {63		return console.log(err);64	}65	list.forEach(function(file) {66		if(path.extname(file) === ext) {67			console.log(file);68		}69	});70});

Using AI Code Generation

1var x = 10;2var y = 20;3var z = 30;4var a = 10;5var b = 20;6var c = 30;7console.log(x == a);8console.log(y == b);9console.log(z == c);10console.log(x == y);11console.log(y == z);12console.log(x == z);13console.log(x != y);14console.log(y != z);15console.log(x != z);16console.log(x < y);17console.log(y < z);18console.log(x < z);19console.log(x > y);20console.log(y > z);21console.log(x > z);22console.log(x <= y);23console.log(y <= z);24console.log(x <= z);25console.log(x >= y);26console.log(y >= z);27console.log(x >= z);28console.log(x === a);29console.log(y === b);30console.log(z === c);31console.log(x === y);32console.log(y === z);33console.log(x === z);34console.log(x !== y);35console.log(y !== z);36console.log(x !== z);

Using AI Code Generation

1var compare = require('./compare');2var a = 10;3var b = 20;4compare.compare(a,b);5compare.add(a,b);6compare.subtract(a,b);7compare.multiply(a,b);8compare.divide(a,b);9compare.modulus(a,b);10compare.power(a,b);11module.exports = {12    compare: function(a,b) {13        if(a > b) {14            console.log('a is greater than b');15        } else if(a < b) {16            console.log('a is less than b');17        } else {18            console.log('a is equal to b');19        }20    },21    add: function(a,b) {22        console.log('a + b = ' + (a+b));23    },24    subtract: function(a,b) {25        console.log('a - b = ' + (a-b));26    },27    multiply: function(a,b) {28        console.log('a * b = ' + (a*b));29    },30    divide: function(a,b) {31        console.log('a / b = ' + (a/b));32    },33    modulus: function(a,b) {34        console.log('a % b = ' + (a%b));35    },36    power: function(a,b) {37        console.log('a ^ b = ' + (Math.pow(a,b)));38    }39};40var compare = require('./compare');41var a = 10;42var b = 20;43compare.compare(a,b);44compare.add(a,b);45compare.subtract(a,b);46compare.multiply(a,b);47compare.divide(a,b);48compare.modulus(a,b);49compare.power(a,b);50module.exports = {51    compare: function(a,b) {52        if(a > b) {53            console.log('a is greater than b');54        } else if(a < b) {55            console.log('a is less than b');56        } else {57            console.log('a is equal to b');58        }59    },60    add: function(a,b) {61        console.log('a + b = ' + (a+b));62    },63    subtract: function(a,b) {64        console.log('a - b = ' + (a-b));65    },66    multiply: function(a,b) {67        console.log('a * b = '

Using AI Code Generation

1var compare = require('compare');2var a = 3;3var b = 5;4var c = compare(a,b);5console.log(c);6var compare = require('compare');7var a = 3;8var b = 5;9var c = compare(a,b);10var compare = function(a,b){11    if(a>b){12        return 1;13    }else if(a<b){14        return -1;15    }else{16        return 0;17    }18}19module.exports = compare;20var compare = function(a,b){21    if(a>b){22        return 1;23    }else if(a<b){24        return -1;25    }else{26        return 0;27    }28}29module.exports = compare;30var compare = require('compare');31var a = 3;32var b = 5;33var c = compare(a,b);34console.log(c);35var compare = require('compare');36var a = 3;37var b = 5;38var c = compare(a,b);39var compare = function(a,b){40    if(a>b){41        return 1;42    }else if(a<b){43        return -1;44    }else{45        return 0;46    }47}48module.exports = compare;49var compare = function(a,b){50    if(a>b){51        return 1;52    }else if(a<b){53        return -1;54    }else{55        return 0;56    }57}58module.exports = compare;59var compare = require('compare');60var a = 3;61var b = 5;62var c = compare(a,b);63console.log(c);64var compare = require('compare');65var a = 3;66var b = 5;67var c = compare(a,b);

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.