Used black on other unused files. (#1032)

Author: gabrieldemarmiesse

pyproject.toml

@@ -27,19 +27,13 @@ exclude = '''
   | tensorflow_addons/losses/giou_loss.py
   | tensorflow_addons/losses/giou_loss_test.py
   | tensorflow_addons/metrics/cohens_kappa.py
-  | tensorflow_addons/metrics/cohens_kappa_test.py
   | tensorflow_addons/metrics/matthews_correlation_coefficient.py
   | tensorflow_addons/metrics/multilabel_confusion_matrix.py
   | tensorflow_addons/metrics/r_square.py
   | tensorflow_addons/optimizers/__init__.py
   | tensorflow_addons/optimizers/lookahead.py
-  | tensorflow_addons/optimizers/lookahead_test.py
   | tensorflow_addons/optimizers/moving_average.py
-  | tensorflow_addons/optimizers/moving_average_test.py
   | tensorflow_addons/optimizers/weight_decay_optimizers.py
-  | tensorflow_addons/optimizers/weight_decay_optimizers_test.py
-  | tensorflow_addons/rnn/cell.py
-  | tensorflow_addons/rnn/cell_test.py
   | tensorflow_addons/seq2seq/attention_wrapper_test.py
   | tensorflow_addons/text/__init__.py
   | tensorflow_addons/text/crf.py

tensorflow_addons/metrics/cohens_kappa_test.py

@@ -22,21 +22,21 @@
 @test_utils.run_all_in_graph_and_eager_modes
 class CohenKappaTest(tf.test.TestCase):
     def test_config(self):
-        kp_obj = CohenKappa(name='cohen_kappa', num_classes=5)
-        self.assertEqual(kp_obj.name, 'cohen_kappa')
+        kp_obj = CohenKappa(name="cohen_kappa", num_classes=5)
+        self.assertEqual(kp_obj.name, "cohen_kappa")
         self.assertEqual(kp_obj.dtype, tf.float32)
         self.assertEqual(kp_obj.num_classes, 5)
 
         # Check save and restore config
         kb_obj2 = CohenKappa.from_config(kp_obj.get_config())
-        self.assertEqual(kb_obj2.name, 'cohen_kappa')
+        self.assertEqual(kb_obj2.name, "cohen_kappa")
         self.assertEqual(kb_obj2.dtype, tf.float32)
         self.assertEqual(kp_obj.num_classes, 5)
 
     def initialize_vars(self):
         kp_obj1 = CohenKappa(num_classes=5)
-        kp_obj2 = CohenKappa(num_classes=5, weightage='linear')
-        kp_obj3 = CohenKappa(num_classes=5, weightage='quadratic')
+        kp_obj2 = CohenKappa(num_classes=5, weightage="linear")
+        kp_obj3 = CohenKappa(num_classes=5, weightage="quadratic")
 
         self.evaluate(tf.compat.v1.variables_initializer(kp_obj1.variables))
         self.evaluate(tf.compat.v1.variables_initializer(kp_obj2.variables))
@@ -78,8 +78,9 @@ def test_kappa_random_score(self):
         self.update_obj_states(kp_obj1, kp_obj2, kp_obj3, actuals, preds, None)
 
         # Check results
-        self.check_results([kp_obj1, kp_obj2, kp_obj3],
-                           [0.61904761, 0.62790697, 0.68932038])
+        self.check_results(
+            [kp_obj1, kp_obj2, kp_obj3], [0.61904761, 0.62790697, 0.68932038]
+        )
 
     def test_kappa_perfect_score(self):
         actuals = [4, 4, 3, 3, 2, 2, 1, 1]
@@ -109,8 +110,9 @@ def test_kappa_worse_than_random(self):
         self.update_obj_states(kp_obj1, kp_obj2, kp_obj3, actuals, preds, None)
 
         # check results
-        self.check_results([kp_obj1, kp_obj2, kp_obj3],
-                           [-0.3333333, -0.52380952, -0.72727272])
+        self.check_results(
+            [kp_obj1, kp_obj2, kp_obj3], [-0.3333333, -0.52380952, -0.72727272]
+        )
 
     def test_kappa_with_sample_weights(self):
         actuals = [4, 4, 3, 3, 2, 2, 1, 1]
@@ -124,12 +126,12 @@ def test_kappa_with_sample_weights(self):
         kp_obj1, kp_obj2, kp_obj3 = self.initialize_vars()
 
         # Update
-        self.update_obj_states(kp_obj1, kp_obj2, kp_obj3, actuals, preds,
-                               weights)
+        self.update_obj_states(kp_obj1, kp_obj2, kp_obj3, actuals, preds, weights)
 
         # check results
-        self.check_results([kp_obj1, kp_obj2, kp_obj3],
-                           [-0.25473321, -0.38992332, -0.60695344])
+        self.check_results(
+            [kp_obj1, kp_obj2, kp_obj3], [-0.25473321, -0.38992332, -0.60695344]
+        )
 
     def test_kappa_reset_states(self):
         # Initialize
@@ -152,5 +154,5 @@ def test_large_values(self):
         self.assertAllClose(0.166666666, obj.result())
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     tf.test.main()

tensorflow_addons/optimizers/lookahead_test.py

@@ -33,10 +33,8 @@ def run_dense_sample(self, iterations, optimizer, seed=0x2019):
         var_0 = tf.Variable(val_0, dtype=tf.dtypes.float32)
         var_1 = tf.Variable(val_1, dtype=tf.dtypes.float32)
 
-        grad_0 = tf.constant(
-            np.random.standard_normal((2,)), dtype=tf.dtypes.float32)
-        grad_1 = tf.constant(
-            np.random.standard_normal((2,)), dtype=tf.dtypes.float32)
+        grad_0 = tf.constant(np.random.standard_normal((2,)), dtype=tf.dtypes.float32)
+        grad_1 = tf.constant(np.random.standard_normal((2,)), dtype=tf.dtypes.float32)
 
         grads_and_vars = list(zip([grad_0, grad_1], [var_0, var_1]))
 
@@ -62,11 +60,15 @@ def run_sparse_sample(self, iterations, optimizer, seed=0x2019):
         var_1 = tf.Variable(val_1, dtype=tf.dtypes.float32)
 
         grad_0 = tf.IndexedSlices(
-            tf.constant([np.random.standard_normal()]), tf.constant([0]),
-            tf.constant([2]))
+            tf.constant([np.random.standard_normal()]),
+            tf.constant([0]),
+            tf.constant([2]),
+        )
         grad_1 = tf.IndexedSlices(
-            tf.constant([np.random.standard_normal()]), tf.constant([1]),
-            tf.constant([2]))
+            tf.constant([np.random.standard_normal()]),
+            tf.constant([1]),
+            tf.constant([2]),
+        )
 
         grads_and_vars = list(zip([grad_0, grad_1], [var_0, var_1]))
 
@@ -84,10 +86,9 @@ def run_sparse_sample(self, iterations, optimizer, seed=0x2019):
     def test_dense_exact_ratio(self):
         for k in [5, 10, 100]:
             for alpha in [0.3, 0.7]:
-                optimizer = tf.keras.optimizers.get('adam')
+                optimizer = tf.keras.optimizers.get("adam")
                 vals, quick_vars = self.run_dense_sample(k, optimizer)
-                optimizer = Lookahead(
-                    'adam', sync_period=k, slow_step_size=alpha)
+                optimizer = Lookahead("adam", sync_period=k, slow_step_size=alpha)
                 _, slow_vars = self.run_dense_sample(k, optimizer)
                 for val, quick, slow in zip(vals, quick_vars, slow_vars):
                     expected = val + (quick - val) * alpha
@@ -96,10 +97,9 @@ def test_dense_exact_ratio(self):
     def test_sparse_exact_ratio(self):
         for k in [5, 10, 100]:
             for alpha in [0.3, 0.7]:
-                optimizer = tf.keras.optimizers.get('adam')
+                optimizer = tf.keras.optimizers.get("adam")
                 vals, quick_vars = self.run_sparse_sample(k, optimizer)
-                optimizer = Lookahead(
-                    'adam', sync_period=k, slow_step_size=alpha)
+                optimizer = Lookahead("adam", sync_period=k, slow_step_size=alpha)
                 _, slow_vars = self.run_sparse_sample(k, optimizer)
                 for val, quick, slow in zip(vals, quick_vars, slow_vars):
                     expected = val + (quick - val) * alpha
@@ -115,7 +115,7 @@ def test_fit_simple_linear_model(self):
 
         model = tf.keras.models.Sequential()
         model.add(tf.keras.layers.Dense(input_shape=(3,), units=1))
-        model.compile(Lookahead('adam'), loss='mse')
+        model.compile(Lookahead("adam"), loss="mse")
 
         model.fit(x, y, epochs=3)
 
@@ -128,15 +128,18 @@ def test_fit_simple_linear_model(self):
 
     def test_model_dynamic_lr(self):
         grad = tf.Variable([[0.1]])
-        model = tf.keras.Sequential([
-            tf.keras.layers.Dense(
-                1,
-                kernel_initializer=tf.keras.initializers.Constant([[1.0]]),
-                use_bias=False)
-        ])
+        model = tf.keras.Sequential(
+            [
+                tf.keras.layers.Dense(
+                    1,
+                    kernel_initializer=tf.keras.initializers.Constant([[1.0]]),
+                    use_bias=False,
+                )
+            ]
+        )
         model.build(input_shape=[1, 1])
 
-        opt = Lookahead('adam', sync_period=10, slow_step_size=0.4)
+        opt = Lookahead("adam", sync_period=10, slow_step_size=0.4)
         update = opt.apply_gradients(list(zip([grad], model.variables)))
 
         self.evaluate(tf.compat.v1.global_variables_initializer())
@@ -147,13 +150,12 @@ def test_model_dynamic_lr(self):
         self.assertAllClose(opt.lr.read_value(), 1e-4)
 
     def test_get_config(self):
-        opt = Lookahead('adam', sync_period=10, slow_step_size=0.4)
-        opt = tf.keras.optimizers.deserialize(
-            tf.keras.optimizers.serialize(opt))
+        opt = Lookahead("adam", sync_period=10, slow_step_size=0.4)
+        opt = tf.keras.optimizers.deserialize(tf.keras.optimizers.serialize(opt))
         config = opt.get_config()
-        self.assertEqual(config['sync_period'], 10)
-        self.assertEqual(config['slow_step_size'], 0.4)
+        self.assertEqual(config["sync_period"], 10)
+        self.assertEqual(config["slow_step_size"], 0.4)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     tf.test.main()

tensorflow_addons/optimizers/moving_average_test.py

@@ -37,7 +37,8 @@ def test_run(self):
             opt = MovingAverage(
                 tf.keras.optimizers.SGD(lr=2.0),
                 sequential_update=sequential_update,
-                average_decay=0.5)
+                average_decay=0.5,
+            )
 
             if not tf.executing_eagerly():
                 update = opt.apply_gradients(grads_and_vars)
@@ -51,8 +52,8 @@ def test_run(self):
             self.assertAllClose(var0.read_value(), [0.6, 1.6])
             self.assertAllClose(var1.read_value(), [2.96, 3.96])
 
-            ema_var0 = opt.get_slot(var0, 'average')
-            ema_var1 = opt.get_slot(var1, 'average')
+            ema_var0 = opt.get_slot(var0, "average")
+            ema_var1 = opt.get_slot(var1, "average")
 
             if sequential_update:
                 self.assertAllClose(ema_var0.read_value(), [0.75, 1.75])
@@ -65,12 +66,14 @@ def test_run(self):
                 self.assertAllClose(var0.read_value(), [0.75, 1.75])
                 self.assertAllClose(var1.read_value(), [2.975, 3.975])
 
-            perturb = tf.group([
-                var0.assign_add([1.0, 1.0]),
-                var1.assign_add([2.0, 2.0]),
-                ema_var0.assign_add([3.0, 3.0]),
-                ema_var1.assign_add([4.0, 4.0])
-            ])
+            perturb = tf.group(
+                [
+                    var0.assign_add([1.0, 1.0]),
+                    var1.assign_add([2.0, 2.0]),
+                    ema_var0.assign_add([3.0, 3.0]),
+                    ema_var1.assign_add([4.0, 4.0]),
+                ]
+            )
             self.evaluate(perturb)
 
             if sequential_update:
@@ -87,12 +90,15 @@ def test_opt_failure(self):
 
     def test_model_weights_update(self):
         grad = tf.Variable([[0.1]])
-        model = tf.keras.Sequential([
-            tf.keras.layers.Dense(
-                1,
-                kernel_initializer=tf.keras.initializers.Constant([[1.0]]),
-                use_bias=False)
-        ])
+        model = tf.keras.Sequential(
+            [
+                tf.keras.layers.Dense(
+                    1,
+                    kernel_initializer=tf.keras.initializers.Constant([[1.0]]),
+                    use_bias=False,
+                )
+            ]
+        )
         model.build(input_shape=[1, 1])
         self.evaluate(tf.compat.v1.global_variables_initializer())
 
@@ -109,17 +115,19 @@ def test_model_weights_update(self):
 
     def test_model_dynamic_lr(self):
         grad = tf.Variable([[0.1]])
-        model = tf.keras.Sequential([
-            tf.keras.layers.Dense(
-                1,
-                kernel_initializer=tf.keras.initializers.Constant([[1.0]]),
-                use_bias=False)
-        ])
+        model = tf.keras.Sequential(
+            [
+                tf.keras.layers.Dense(
+                    1,
+                    kernel_initializer=tf.keras.initializers.Constant([[1.0]]),
+                    use_bias=False,
+                )
+            ]
+        )
         model.build(input_shape=[1, 1])
         self.evaluate(tf.compat.v1.global_variables_initializer())
 
-        opt = MovingAverage(
-            tf.keras.optimizers.SGD(lr=1e-3), average_decay=0.5)
+        opt = MovingAverage(tf.keras.optimizers.SGD(lr=1e-3), average_decay=0.5)
         update = opt.apply_gradients(list(zip([grad], model.variables)))
 
         self.evaluate(tf.compat.v1.global_variables_initializer())
@@ -130,21 +138,20 @@ def test_model_dynamic_lr(self):
         self.assertAllClose(opt.lr.read_value(), 1e-4)
 
     def test_optimizer_string(self):
-        _ = MovingAverage('adam')
+        _ = MovingAverage("adam")
 
     def test_config(self):
         sgd_opt = tf.keras.optimizers.SGD(
-            lr=2.0, nesterov=True, momentum=0.3, decay=0.1)
+            lr=2.0, nesterov=True, momentum=0.3, decay=0.1
+        )
         opt = MovingAverage(
-            sgd_opt,
-            average_decay=0.5,
-            num_updates=None,
-            sequential_update=False)
+            sgd_opt, average_decay=0.5, num_updates=None, sequential_update=False
+        )
         config = opt.get_config()
 
-        self.assertEqual(config['average_decay'], 0.5)
-        self.assertEqual(config['num_updates'], None)
-        self.assertEqual(config['sequential_update'], False)
+        self.assertEqual(config["average_decay"], 0.5)
+        self.assertEqual(config["num_updates"], None)
+        self.assertEqual(config["sequential_update"], False)
 
         new_opt = MovingAverage.from_config(config)
         old_sgd_config = opt._optimizer.get_config()
@@ -166,8 +173,8 @@ def test_fit_simple_linear_model(self):
         model.add(tf.keras.layers.Dense(input_shape=(3,), units=1))
         self.evaluate(tf.compat.v1.global_variables_initializer())
 
-        opt = MovingAverage('adam')
-        model.compile(opt, loss='mse')
+        opt = MovingAverage("adam")
+        model.compile(opt, loss="mse")
 
         model.fit(x, y, epochs=10)
         opt.assign_average_vars(model.variables)
@@ -181,5 +188,5 @@ def test_fit_simple_linear_model(self):
         self.assertLess(max_abs_diff, 1e-3)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     tf.test.main()