Replace deprecated assert calls

tensor2tensor/models/revnet_test.py

@@ -24,94 +24,94 @@ class RevnetTest(tf.test.TestCase):
   def testH(self):
     rev_block_input = tf.random_uniform([1, 299, 299, 3])
     rev_block_output = revnet.downsample_bottleneck(rev_block_input, 256)
-    self.assertEquals(rev_block_output.get_shape().as_list(),
+    self.assertEqual(rev_block_output.get_shape().as_list(),
                       [1, 299, 299, 256])
 
   def testHStride(self):
     rev_block_input = tf.random_uniform([2, 299, 299, 256])
     rev_block_output = revnet.downsample_bottleneck(
         rev_block_input, 512, stride=2, scope='HStride')
-    self.assertEquals(rev_block_output.get_shape().as_list(),
+    self.assertEqual(rev_block_output.get_shape().as_list(),
                       [2, 150, 150, 512])
 
   def testInit(self):
     images = tf.random_uniform([1, 299, 299, 3])
     x1, x2 = revnet.init(images, 32)
-    self.assertEquals(x1.get_shape().as_list(), [1, 74, 74, 16])
-    self.assertEquals(x2.get_shape().as_list(), [1, 74, 74, 16])
+    self.assertEqual(x1.get_shape().as_list(), [1, 74, 74, 16])
+    self.assertEqual(x2.get_shape().as_list(), [1, 74, 74, 16])
 
   def testInit3D(self):
     images = tf.random_uniform([1, 299, 299, 299, 3])
     x1, x2 = revnet.init(images, 32, dim='3d', scope='init3d')
-    self.assertEquals(x1.get_shape().as_list(), [1, 74, 74, 74, 16])
-    self.assertEquals(x2.get_shape().as_list(), [1, 74, 74, 74, 16])
+    self.assertEqual(x1.get_shape().as_list(), [1, 74, 74, 74, 16])
+    self.assertEqual(x2.get_shape().as_list(), [1, 74, 74, 74, 16])
 
   def testUnit1(self):
     x1 = tf.random_uniform([4, 74, 74, 256])
     x2 = tf.random_uniform([4, 74, 74, 256])
     x1, x2 = revnet.unit(x1, x2, block_num=1, depth=64,
                          first_batch_norm=True, num_layers=1)
-    self.assertEquals(x1.get_shape().as_list(), [4, 74, 74, 256])
-    self.assertEquals(x2.get_shape().as_list(), [4, 74, 74, 256])
+    self.assertEqual(x1.get_shape().as_list(), [4, 74, 74, 256])
+    self.assertEqual(x2.get_shape().as_list(), [4, 74, 74, 256])
 
   def testUnit2(self):
     x1 = tf.random_uniform([4, 74, 74, 256])
     x2 = tf.random_uniform([4, 74, 74, 256])
     x1, x2 = revnet.unit(x1, x2, block_num=2, depth=128,
                          num_layers=1, stride=2)
-    self.assertEquals(x1.get_shape().as_list(), [4, 37, 37, 512])
-    self.assertEquals(x2.get_shape().as_list(), [4, 37, 37, 512])
+    self.assertEqual(x1.get_shape().as_list(), [4, 37, 37, 512])
+    self.assertEqual(x2.get_shape().as_list(), [4, 37, 37, 512])
 
   def testUnit3(self):
     x1 = tf.random_uniform([1, 37, 37, 512])
     x2 = tf.random_uniform([1, 37, 37, 512])
     x1, x2 = revnet.unit(x1, x2, block_num=3, depth=256,
                          num_layers=10, stride=2)
-    self.assertEquals(x1.get_shape().as_list(), [1, 19, 19, 1024])
-    self.assertEquals(x2.get_shape().as_list(), [1, 19, 19, 1024])
+    self.assertEqual(x1.get_shape().as_list(), [1, 19, 19, 1024])
+    self.assertEqual(x2.get_shape().as_list(), [1, 19, 19, 1024])
 
   def testUnit4(self):
     x1 = tf.random_uniform([1, 19, 19, 1024])
     x2 = tf.random_uniform([1, 19, 19, 1024])
     x1, x2 = revnet.unit(x1, x2, block_num=4, depth=416,
                          num_layers=1, stride=2)
-    self.assertEquals(x1.get_shape().as_list(), [1, 10, 10, 1664])
-    self.assertEquals(x2.get_shape().as_list(), [1, 10, 10, 1664])
+    self.assertEqual(x1.get_shape().as_list(), [1, 10, 10, 1664])
+    self.assertEqual(x2.get_shape().as_list(), [1, 10, 10, 1664])
 
   def testUnit3D(self):
     x1 = tf.random_uniform([4, 74, 74, 74, 256])
     x2 = tf.random_uniform([4, 74, 74, 74, 256])
     x1, x2 = revnet.unit(x1, x2, block_num=5, depth=128,
                          num_layers=1, dim='3d', stride=2)
-    self.assertEquals(x1.get_shape().as_list(), [4, 37, 37, 37, 512])
-    self.assertEquals(x2.get_shape().as_list(), [4, 37, 37, 37, 512])
+    self.assertEqual(x1.get_shape().as_list(), [4, 37, 37, 37, 512])
+    self.assertEqual(x2.get_shape().as_list(), [4, 37, 37, 37, 512])
 
   def testFinalBlock(self):
     x1 = tf.random_uniform([5, 10, 10, 1024])
     x2 = tf.random_uniform([5, 10, 10, 1024])
     logits = revnet.final_block(x1, x2)
-    self.assertEquals(logits.shape, [5, 1, 1, 2048])
+    self.assertEqual(logits.shape, [5, 1, 1, 2048])
 
   def testFinalBlock3D(self):
     x1 = tf.random_uniform([5, 10, 10, 10, 1024])
     x2 = tf.random_uniform([5, 10, 10, 10, 1024])
     logits = revnet.final_block(x1, x2, dim='3d', scope='FinalBlock3D')
-    self.assertEquals(logits.shape, [5, 1, 1, 1, 2048])
+    self.assertEqual(logits.shape, [5, 1, 1, 1, 2048])
 
   def testEndToEnd(self):
     images = tf.random_uniform([1, 299, 299, 3])
     hparams = revnet.revnet_base()
     hparams.mode = tf.estimator.ModeKeys.TRAIN
     logits = revnet.revnet(images, hparams)
-    self.assertEquals(logits.shape, [1, 1, 1, 3328])
+    self.assertEqual(logits.shape, [1, 1, 1, 3328])
 
   def testEndToEnd3D(self):
     images = tf.random_uniform([1, 299, 299, 299, 3])
     hparams = revnet.revnet_base()
     hparams.dim = '3d'
     hparams.mode = tf.estimator.ModeKeys.TRAIN
     logits = revnet.revnet(images, hparams)
-    self.assertEquals(logits.shape, [1, 1, 1, 1, 3328])
+    self.assertEqual(logits.shape, [1, 1, 1, 1, 3328])
 
 if __name__ == '__main__':
   tf.test.main()

tensor2tensor/rl/gym_utils_test.py

@@ -56,7 +56,7 @@ def test_making_timewrapped_env(self):
     env = gym_utils.make_gym_env("CartPole-v0", rl_env_max_episode_steps=1000)
     self.assertTrue(isinstance(env, gym.Env))
     self.assertTrue(isinstance(env, gym.wrappers.TimeLimit))
-    self.assertEquals(1000, env._max_episode_steps)
+    self.assertEqual(1000, env._max_episode_steps)
 
   # Make a time-wrapped environment with unlimited limit.
   def test_unlimited_env(self):

tensor2tensor/utils/t2t_model_test.py

@@ -35,7 +35,7 @@ def testSummarizeLosses(self):
                 "extra": tf.random_normal([])}
       outputs = model._summarize_losses(losses)
       self.assertIsNone(outputs, None)
-      self.assertEquals(
+      self.assertEqual(
           len(tf.get_collection(tf.GraphKeys.SUMMARIES, scope="losses")),
           len(losses))