Increase coverage in optimizers (#21337)

* Update .gitignore

* Add tests for invalid parameters in optimizers: AdamW, Ftrl, Lion, Nadam, and SGD

* Ran formatting

* Revert "Update .gitignore"

This reverts commit ae56fe7.

Author: Frightera

keras/src/optimizers/adamw_test.py

@@ -52,6 +52,14 @@ def test_weight_decay(self):
         self.assertAlmostEqual(var2.numpy(), 2.0, decimal=6)
         self.assertAlmostEqual(var3.numpy(), 2.0, decimal=6)
 
+    def test_weight_decay_is_none(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            "Argument `weight_decay` must be a float. "
+            "Received: weight_decay=None",
+        ):
+            AdamW(learning_rate=1.0, weight_decay=None)
+
     def test_correctness_with_golden(self):
         optimizer = AdamW(learning_rate=1.0, weight_decay=0.5, epsilon=2)
 

keras/src/optimizers/ftrl_test.py

@@ -2,6 +2,7 @@
 
 
 import numpy as np
+from unittest import mock
 
 from keras.src import backend
 from keras.src import testing
@@ -71,3 +72,43 @@ def test_clip_value(self):
         grad = [np.array([100.0, 100.0])]
         clipped_grad = optimizer._clip_gradients(grad)
         self.assertAllClose(clipped_grad[0], [1.0, 1.0])
+
+    def test_invalid_initial_accumulator_value(self):
+        invalid_value = -0.1
+        with self.assertRaisesRegex(
+            ValueError,
+            f"^`initial_accumulator_value` needs to be positive or zero. Received: initial_accumulator_value={invalid_value}.$",
+        ):
+            Ftrl(initial_accumulator_value=invalid_value)
+
+    def test_invalid_learning_rate_power(self):
+        invalid_value = 0.1
+        with self.assertRaisesRegex(
+            ValueError,
+            f"^`learning_rate_power` needs to be negative or zero. Received: learning_rate_power={invalid_value}.$",
+        ):
+            Ftrl(learning_rate_power=invalid_value)
+
+    def test_invalid_l1_regularization_strength(self):
+        invalid_value = -0.1
+        with self.assertRaisesRegex(
+            ValueError,
+            f"^`l1_regularization_strength` needs to be positive or zero. Received: l1_regularization_strength={invalid_value}.$",
+        ):
+            Ftrl(l1_regularization_strength=invalid_value)
+
+    def test_invalid_l2_regularization_strength(self):
+        invalid_value = -0.1
+        with self.assertRaisesRegex(
+            ValueError,
+            f"^`l2_regularization_strength` needs to be positive or zero. Received: l2_regularization_strength={invalid_value}.$",
+        ):
+            Ftrl(l2_regularization_strength=invalid_value)
+
+    def test_invalid_l2_shrinkage_regularization_strength(self):
+        invalid_value = -0.1
+        with self.assertRaisesRegex(
+            ValueError,
+            f"^`l2_shrinkage_regularization_strength` needs to be positive or zero. Received: l2_shrinkage_regularization_strength={invalid_value}.$",
+        ):
+            Ftrl(l2_shrinkage_regularization_strength=invalid_value)

keras/src/optimizers/lion_test.py

@@ -9,6 +9,26 @@
 
 
 class LionTest(testing.TestCase):
+    def test_invalid_beta_1(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            "Argument `beta_1` must be in the \\[0, 1\\] range. Otherwise, the "
+            "optimizer degenerates to SignSGD. Received: beta_1=-0.1.",
+        ):
+            Lion(beta_1=-0.1)
+        with self.assertRaisesRegex(
+            ValueError,
+            "Argument `beta_1` must be in the \\[0, 1\\] range. Otherwise, the "
+            "optimizer degenerates to SignSGD. Received: beta_1=0.0.",
+        ):
+            Lion(beta_1=0.0)
+        with self.assertRaisesRegex(
+            ValueError,
+            "Argument `beta_1` must be in the \\[0, 1\\] range. Otherwise, the "
+            "optimizer degenerates to SignSGD. Received: beta_1=1.1.",
+        ):
+            Lion(beta_1=1.1)
+
     def test_config(self):
         optimizer = Lion(
             learning_rate=0.5,

keras/src/optimizers/nadam_test.py

@@ -19,6 +19,11 @@ def test_config(self):
         )
         self.run_class_serialization_test(optimizer)
 
+    def test_build_with_empty_var_list(self):
+        optimizer = Nadam()
+        optimizer.build([])
+        self.assertEqual(optimizer._u_product.dtype, backend.floatx())
+
     def test_single_step(self):
         optimizer = Nadam(learning_rate=0.5)
         grads = ops.array([1.0, 6.0, 7.0, 2.0])

keras/src/optimizers/sgd_test.py

@@ -30,6 +30,17 @@ def test_single_step(self):
         self.assertEqual(optimizer.variables[0], 1)
         self.assertEqual(optimizer.variables[1], 0.5)
 
+    def test_invalid_momentum(self):
+        with self.assertRaisesRegex(
+            ValueError, "`momentum` must be a float between \\[0, 1\\]."
+        ):
+            SGD(momentum=-1.0)
+
+        with self.assertRaisesRegex(
+            ValueError, "`momentum` must be a float between \\[0, 1\\]."
+        ):
+            SGD(momentum=2.0)
+
     def test_weight_decay(self):
         grads, var1, var2, var3 = (
             ops.zeros(()),