Merge branch 'keras-team:master' into master

Author: utsab345

keras/src/layers/regularization/dropout.py

@@ -48,13 +48,55 @@ def __init__(self, rate, noise_shape=None, seed=None, **kwargs):
             )
         self.rate = rate
         self.seed = seed
-        self.noise_shape = noise_shape
+        self.noise_shape = self._validate_noise_shape(noise_shape)
         if rate > 0:
             self.seed_generator = backend.random.SeedGenerator(seed)
         self.supports_masking = True
 
         self._build_at_init()
 
+    def _validate_noise_shape(self, noise_shape):
+        if noise_shape is None:
+            return None
+
+        if isinstance(noise_shape, str):
+            raise ValueError(
+                f"Invalid value received for argument `noise_shape`. "
+                f"Expected a tuple or list of integers. "
+                f"Received: noise_shape={noise_shape}"
+            )
+
+        if not isinstance(noise_shape, tuple):
+            try:
+                noise_shape = tuple(noise_shape)
+            except TypeError:
+                raise ValueError(
+                    f"Invalid value received for argument `noise_shape`. "
+                    f"Expected an iterable of integers "
+                    f"(e.g., a tuple or list). "
+                    f"Received: noise_shape={noise_shape}"
+                )
+
+        for i, dim in enumerate(noise_shape):
+            if dim is not None:
+                if not isinstance(dim, int):
+                    raise ValueError(
+                        f"Invalid value received for argument `noise_shape`. "
+                        f"Expected all elements to be integers or None. "
+                        f"Received element at index {i}: {dim} "
+                        f"(type: {type(dim).__name__})"
+                    )
+
+                if dim <= 0:
+                    raise ValueError(
+                        f"Invalid value received for argument `noise_shape`. "
+                        f"Expected all dimensions to be positive integers "
+                        f"or None. "
+                        f"Received negative or zero value at index {i}: {dim}"
+                    )
+
+        return noise_shape
+
     def call(self, inputs, training=False):
         if training and self.rate > 0:
             return backend.random.dropout(

keras/src/layers/regularization/dropout_test.py

@@ -60,3 +60,52 @@ def test_dropout_rate_greater_than_one(self):
             "Expected a float value between 0 and 1.",
         ):
             _ = layers.Dropout(rate=1.5)
+
+    def test_validate_noise_shape_none(self):
+        layer = layers.Dropout(0.5, noise_shape=None)
+        self.assertIsNone(layer.noise_shape)
+
+    def test_validate_noise_shape_integer_tuple(self):
+        layer = layers.Dropout(0.5, noise_shape=(20, 1, 10))
+        self.assertEqual(layer.noise_shape, (20, 1, 10))
+
+    def test_validate_noise_shape_none_values(self):
+        layer = layers.Dropout(0.5, noise_shape=(None, 1, None))
+        self.assertEqual(layer.noise_shape, (None, 1, None))
+
+    def test_validate_noise_shape_cast_to_a_tuple(self):
+        layer = layers.Dropout(0.5, noise_shape=[20, 1, 10])
+        self.assertEqual(layer.noise_shape, (20, 1, 10))
+        self.assertIsInstance(layer.noise_shape, tuple)
+
+    def test_validate_noise_shape_non_iterable(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            "Invalid value received for argument `noise_shape`. "
+            "Expected a tuple or list of integers.",
+        ):
+            layers.Dropout(0.5, noise_shape="Invalid")
+
+    def test_validate_noise_shape_invalid_type(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            "Invalid value received for argument `noise_shape`. "
+            "Expected all elements to be integers or None.",
+        ):
+            layers.Dropout(0.5, noise_shape=(20, 1.5, 10))
+
+    def test_validate_noise_shape_negative_value(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            "Invalid value received for argument `noise_shape`. "
+            "Expected all dimensions to be positive integers or None.",
+        ):
+            layers.Dropout(0.5, noise_shape=(20, -1, 10))
+
+    def test_validate_noise_shape_zero_value(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            "Invalid value received for argument `noise_shape`. "
+            "Expected all dimensions to be positive integers or None.",
+        ):
+            layers.Dropout(0.5, noise_shape=(20, 0, 10))

keras/src/optimizers/schedules/learning_rate_schedule.py

@@ -584,9 +584,10 @@ class CosineDecay(LearningRateSchedule):
     schedule applies a linear increase per optimizer step to our learning rate
     from `initial_learning_rate` to `warmup_target` for a duration of
     `warmup_steps`. Afterwards, it applies a cosine decay function taking our
-    learning rate from `warmup_target` to `alpha` for a duration of
-    `decay_steps`. If `warmup_target` is None we skip warmup and our decay
-    will take our learning rate from `initial_learning_rate` to `alpha`.
+    learning rate from `warmup_target` to `warmup_target * alpha` for a
+    duration of `decay_steps`. If `warmup_target` is None we skip warmup and
+    our decay will take our learning rate from `initial_learning_rate` to
+    `initial_learning_rate * alpha`.
     It requires a `step` value to  compute the learning rate. You can
     just pass a backend variable that you increment at each training step.
 

keras/src/utils/progbar.py

@@ -3,6 +3,8 @@
 import sys
 import time
 
+import numpy as np
+
 from keras.src.api_export import keras_export
 from keras.src.utils import io_utils
 
@@ -161,7 +163,10 @@ def update(self, current, values=None, finalize=None):
             for k in self._values_order:
                 info += f" - {k}:"
                 if isinstance(self._values[k], list):
-                    avg = self._values[k][0] / max(1, self._values[k][1])
+                    values, count = self._values[k]
+                    if not isinstance(values, float):
+                        values = np.mean(values)
+                    avg = values / max(1, count)
                     if abs(avg) > 1e-3:
                         info += f" {avg:.4f}"
                     else:
@@ -188,7 +193,10 @@ def update(self, current, values=None, finalize=None):
                 info += f" -{self._format_time(time_per_unit, self.unit_name)}"
                 for k in self._values_order:
                     info += f" - {k}:"
-                    avg = self._values[k][0] / max(1, self._values[k][1])
+                    values, count = self._values[k]
+                    if not isinstance(values, float):
+                        values = np.mean(values)
+                    avg = values / max(1, count)
                     if avg > 1e-3:
                         info += f" {avg:.4f}"
                     else:

keras/src/utils/progbar_test.py

@@ -0,0 +1,27 @@
+import numpy as np
+from absl.testing import parameterized
+
+from keras.src import testing
+from keras.src.utils import progbar
+
+
+class ProgbarTest(testing.TestCase):
+    @parameterized.named_parameters(
+        [
+            ("float", "float"),
+            ("np", "np"),
+            ("list", "list"),
+        ]
+    )
+    def test_update(self, value_type):
+        if value_type == "float":
+            values = 1.0
+        elif value_type == "np":
+            values = np.array(1.0)
+        elif value_type == "list":
+            values = [0.0, 1.0, 2.0]
+        else:
+            raise ValueError("Unknown value_type")
+        pb = progbar.Progbar(target=1, verbose=1)
+
+        pb.update(1, values=[("values", values)], finalize=True)

keras/src/wrappers/sklearn_test.py

@@ -1,5 +1,6 @@
 """Tests using Scikit-Learn's bundled estimator_checks."""
 
+import unittest
 from contextlib import contextmanager
 
 import pytest
@@ -59,7 +60,7 @@ def patched_more_tags(self):
 
 def dynamic_model(X, y, loss, layers=[10]):
     """Creates a basic MLP classifier dynamically choosing binary/multiclass
-    classification loss and ouput activations.
+    classification loss and output activations.
     """
     n_features_in = X.shape[1]
     inp = Input(shape=(n_features_in,))
@@ -156,5 +157,8 @@ def test_sklearn_estimator_checks(estimator, check):
             or "NotImplementedError" in str(exc)
         ):
             pytest.xfail("Backend not implemented")
+        elif isinstance(exc, unittest.SkipTest):
+            # Workaround for https://github.com/pytest-dev/pytest/issues/13895
+            pytest.skip(str(exc))
         else:
             raise