keras-nightly 3.12.0.dev2025092403__py3-none-any.whl → 3.14.0.dev2026010104__py3-none-any.whl

keras/src/layers/pooling/adaptive_average_pooling2d.py

@@ -0,0 +1,62 @@
+"""Adaptive Average Pooling 2D layer."""
+
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_adaptive_pooling import (
+    BaseAdaptiveAveragePooling,
+)
+
+
+@keras_export("keras.layers.AdaptiveAveragePooling2D")
+class AdaptiveAveragePooling2D(BaseAdaptiveAveragePooling):
+    """Adaptive average pooling operation for 2D spatial data.
+
+    This layer applies an adaptive average pooling operation, which pools the
+    input such that the output has a target spatial size specified by
+    `output_size`, regardless of the input spatial size. The kernel size
+    and stride are automatically computed to achieve the target output size.
+
+    Args:
+        output_size: Integer or tuple of 2 integers specifying the
+            target output size.
+            If an integer, the same value is used for both height and width.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            `"channels_last"` corresponds to inputs with shape
+            `(batch, height, width, channels)`.
+            `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, height, width)`.
+            Defaults to the value found in your Keras config file at
+            `~/.keras/keras.json`. If never set, `"channels_last"` is used.
+
+    Input shape:
+        - If `data_format="channels_last"`: 4D tensor
+            `(batch_size, height, width, channels)`
+        - If `data_format="channels_first"`: 4D tensor
+            `(batch_size, channels, height, width)`
+
+    Output shape:
+        - If `data_format="channels_last"`:
+            `(batch_size, output_height, output_width, channels)`
+        - If `data_format="channels_first"`:
+            `(batch_size, channels, output_height, output_width)`
+
+    Examples:
+        >>> import numpy as np
+        >>> input_img = np.random.rand(1, 64, 64, 3)
+        >>> layer = AdaptiveAveragePooling2D(output_size=32)
+        >>> output_img = layer(input_img)
+        >>> output_img.shape
+        (1, 32, 32, 3)
+    """
+
+    def __init__(self, output_size, data_format=None, **kwargs):
+        if isinstance(output_size, int):
+            output_size_tuple = (output_size, output_size)
+        elif isinstance(output_size, (tuple, list)) and len(output_size) == 2:
+            output_size_tuple = tuple(output_size)
+        else:
+            raise TypeError(
+                f"`output_size` must be an integer or (height, width) tuple. "
+                f"Received: {output_size} of type {type(output_size)}"
+            )
+
+        super().__init__(output_size_tuple, data_format, **kwargs)

keras/src/layers/pooling/adaptive_average_pooling3d.py

@@ -0,0 +1,63 @@
+"""Adaptive Average Pooling 3D layer."""
+
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_adaptive_pooling import (
+    BaseAdaptiveAveragePooling,
+)
+
+
+@keras_export("keras.layers.AdaptiveAveragePooling3D")
+class AdaptiveAveragePooling3D(BaseAdaptiveAveragePooling):
+    """Adaptive average pooling operation for 3D volumetric data.
+
+    This layer applies an adaptive average pooling operation, which pools the
+    input such that the output has a target spatial size specified by
+    `output_size`, regardless of the input spatial size. The kernel size
+    and stride are automatically computed to achieve the target output size.
+
+    Args:
+        output_size: Integer or tuple of 3 integers specifying the
+            target output size.
+            If an integer, the same value is used for depth, height, and width.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            `"channels_last"` corresponds to inputs with shape
+            `(batch, depth, height, width, channels)`.
+            `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, depth, height, width)`.
+            Defaults to the value found in your Keras config file at
+            `~/.keras/keras.json`. If never set, `"channels_last"` is used.
+
+    Input shape:
+        - If `data_format="channels_last"`: 5D tensor
+            `(batch_size, depth, height, width, channels)`
+        - If `data_format="channels_first"`: 5D tensor
+            `(batch_size, channels, depth, height, width)`
+
+    Output shape:
+        - If `data_format="channels_last"`:
+            `(batch_size, output_depth, output_height, output_width, channels)`
+        - If `data_format="channels_first"`:
+            `(batch_size, channels, output_depth, output_height, output_width)`
+
+    Examples:
+        >>> import numpy as np
+        >>> input_vol = np.random.rand(1, 32, 32, 32, 3)
+        >>> layer = AdaptiveAveragePooling3D(output_size=16)
+        >>> output_vol = layer(input_vol)
+        >>> output_vol.shape
+        (1, 16, 16, 16, 3)
+    """
+
+    def __init__(self, output_size, data_format=None, **kwargs):
+        if isinstance(output_size, int):
+            output_size_tuple = (output_size, output_size, output_size)
+        elif isinstance(output_size, (tuple, list)) and len(output_size) == 3:
+            output_size_tuple = tuple(output_size)
+        else:
+            raise TypeError(
+                f"`output_size` must be an integer or "
+                f"(depth, height, width) tuple. "
+                f"Received: {output_size} of type {type(output_size)}"
+            )
+
+        super().__init__(output_size_tuple, data_format, **kwargs)

keras/src/layers/pooling/adaptive_max_pooling1d.py

@@ -0,0 +1,65 @@
+"""Adaptive Max Pooling 1D layer."""
+
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_adaptive_pooling import (
+    BaseAdaptiveMaxPooling,
+)
+
+
+@keras_export("keras.layers.AdaptiveMaxPooling1D")
+class AdaptiveMaxPooling1D(BaseAdaptiveMaxPooling):
+    """Adaptive max pooling operation for 1D temporal or spatial data.
+
+    This layer applies an adaptive max pooling operation, which pools the
+    input such that the output has a target length specified by `output_size`,
+    regardless of the input length. The kernel size and stride are automatically
+    computed to achieve the target output size.
+
+    Args:
+        output_size: Integer specifying the target output length.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            `"channels_last"` corresponds to inputs with shape
+            `(batch, length, channels)`.
+            `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, length)`.
+            Defaults to the value found in your Keras config file at
+            `~/.keras/keras.json`. If never set, `"channels_last"` is used.
+
+    Input shape:
+        - If `data_format="channels_last"`: 3D tensor
+            `(batch_size, length, channels)`
+        - If `data_format="channels_first"`: 3D tensor
+            `(batch_size, channels, length)`
+
+    Output shape:
+        - If `data_format="channels_last"`:
+            `(batch_size, output_length, channels)`
+        - If `data_format="channels_first"`:
+            `(batch_size, channels, output_length)`
+
+    Examples:
+        >>> import numpy as np
+        >>> input_seq = np.random.rand(1, 64, 3)
+        >>> layer = AdaptiveMaxPooling1D(output_size=32)
+        >>> output_seq = layer(input_seq)
+        >>> output_seq.shape
+        (1, 32, 3)
+    """
+
+    def __init__(self, output_size, data_format=None, **kwargs):
+        if isinstance(output_size, int):
+            output_size = (output_size,)
+        elif isinstance(output_size, (tuple, list)):
+            if len(output_size) != 1:
+                raise ValueError(
+                    f"For 1D input, `output_size` tuple must have length 1. "
+                    f"Received: {output_size}"
+                )
+            output_size = tuple(output_size)
+        else:
+            raise TypeError(
+                f"`output_size` must be an integer or tuple of 1 integer. "
+                f"Received: {output_size} of type {type(output_size)}"
+            )
+
+        super().__init__(output_size, data_format, **kwargs)

keras/src/layers/pooling/adaptive_max_pooling2d.py

@@ -0,0 +1,62 @@
+"""Adaptive Max Pooling 2D layer."""
+
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_adaptive_pooling import (
+    BaseAdaptiveMaxPooling,
+)
+
+
+@keras_export("keras.layers.AdaptiveMaxPooling2D")
+class AdaptiveMaxPooling2D(BaseAdaptiveMaxPooling):
+    """Adaptive max pooling operation for 2D spatial data.
+
+    This layer applies an adaptive max pooling operation, which pools the
+    input such that the output has a target spatial size specified by
+    `output_size`, regardless of the input spatial size. The kernel size
+    and stride are automatically computed to achieve the target output size.
+
+    Args:
+        output_size: Integer or tuple of 2 integers specifying the
+            target output size.
+            If an integer, the same value is used for both height and width.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            `"channels_last"` corresponds to inputs with shape
+            `(batch, height, width, channels)`.
+            `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, height, width)`.
+            Defaults to the value found in your Keras config file at
+            `~/.keras/keras.json`. If never set, `"channels_last"` is used.
+
+    Input shape:
+        - If `data_format="channels_last"`: 4D tensor
+            `(batch_size, height, width, channels)`
+        - If `data_format="channels_first"`: 4D tensor
+            `(batch_size, channels, height, width)`
+
+    Output shape:
+        - If `data_format="channels_last"`:
+            `(batch_size, output_height, output_width, channels)`
+        - If `data_format="channels_first"`:
+            `(batch_size, channels, output_height, output_width)`
+
+    Examples:
+        >>> import numpy as np
+        >>> input_img = np.random.rand(1, 64, 64, 3)
+        >>> layer = AdaptiveMaxPooling2D(output_size=32)
+        >>> output_img = layer(input_img)
+        >>> output_img.shape
+        (1, 32, 32, 3)
+    """
+
+    def __init__(self, output_size, data_format=None, **kwargs):
+        if isinstance(output_size, int):
+            output_size_tuple = (output_size, output_size)
+        elif isinstance(output_size, (tuple, list)) and len(output_size) == 2:
+            output_size_tuple = tuple(output_size)
+        else:
+            raise TypeError(
+                f"`output_size` must be an integer or (height, width) tuple. "
+                f"Received: {output_size} of type {type(output_size)}"
+            )
+
+        super().__init__(output_size_tuple, data_format, **kwargs)

keras/src/layers/pooling/adaptive_max_pooling3d.py

@@ -0,0 +1,63 @@
+"""Adaptive Max Pooling 3D layer."""
+
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_adaptive_pooling import (
+    BaseAdaptiveMaxPooling,
+)
+
+
+@keras_export("keras.layers.AdaptiveMaxPooling3D")
+class AdaptiveMaxPooling3D(BaseAdaptiveMaxPooling):
+    """Adaptive max pooling operation for 3D volumetric data.
+
+    This layer applies an adaptive max pooling operation, which pools the
+    input such that the output has a target spatial size specified by
+    `output_size`, regardless of the input spatial size. The kernel size
+    and stride are automatically computed to achieve the target output size.
+
+    Args:
+        output_size: Integer or tuple of 3 integers specifying the
+            target output size.
+            If an integer, the same value is used for depth, height, and width.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            `"channels_last"` corresponds to inputs with shape
+            `(batch, depth, height, width, channels)`.
+            `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, depth, height, width)`.
+            Defaults to the value found in your Keras config file at
+            `~/.keras/keras.json`. If never set, `"channels_last"` is used.
+
+    Input shape:
+        - If `data_format="channels_last"`: 5D tensor
+            `(batch_size, depth, height, width, channels)`
+        - If `data_format="channels_first"`: 5D tensor
+            `(batch_size, channels, depth, height, width)`
+
+    Output shape:
+        - If `data_format="channels_last"`:
+            `(batch_size, output_depth, output_height, output_width, channels)`
+        - If `data_format="channels_first"`:
+            `(batch_size, channels, output_depth, output_height, output_width)`
+
+    Examples:
+        >>> import numpy as np
+        >>> input_vol = np.random.rand(1, 32, 32, 32, 3)
+        >>> layer = AdaptiveMaxPooling3D(output_size=16)
+        >>> output_vol = layer(input_vol)
+        >>> output_vol.shape
+        (1, 16, 16, 16, 3)
+    """
+
+    def __init__(self, output_size, data_format=None, **kwargs):
+        if isinstance(output_size, int):
+            output_size_tuple = (output_size, output_size, output_size)
+        elif isinstance(output_size, (tuple, list)) and len(output_size) == 3:
+            output_size_tuple = tuple(output_size)
+        else:
+            raise TypeError(
+                f"`output_size` must be an integer or "
+                f"(depth, height, width) tuple. "
+                f"Received: {output_size} of type {type(output_size)}"
+            )
+
+        super().__init__(output_size_tuple, data_format, **kwargs)

keras/src/layers/pooling/base_adaptive_pooling.py

@@ -0,0 +1,63 @@
+"""Base classes for adaptive pooling layers."""
+
+from keras.src import ops
+from keras.src.backend import config
+from keras.src.layers.layer import Layer
+
+
+class BaseAdaptivePooling(Layer):
+    """Base class shared by all adaptive pooling layers."""
+
+    def __init__(self, output_size, data_format=None, **kwargs):
+        """Initialize base adaptive pooling layer.
+
+        Args:
+            output_size: Normalized spatial output size as a tuple
+                (for example, (32,), (32, 32), or (32, 32, 32)).
+            data_format: Either "channels_last" or "channels_first".
+            **kwargs: Additional layer keyword arguments.
+        """
+        super().__init__(**kwargs)
+        self.output_size = output_size
+        self.data_format = data_format or config.image_data_format()
+        if self.data_format not in {"channels_first", "channels_last"}:
+            raise ValueError(
+                f"Invalid data_format: {self.data_format}. "
+                "Expected 'channels_first' or 'channels_last'."
+            )
+
+    def compute_output_shape(self, input_shape):
+        """Return the output shape tensor after pooling."""
+        batch_size = input_shape[0]
+        if self.data_format == "channels_last":
+            channels = input_shape[-1]
+            return (batch_size, *self.output_size, channels)
+        else:
+            channels = input_shape[1]
+            return (batch_size, channels, *self.output_size)
+
+    def get_config(self):
+        config_dict = {
+            "output_size": self.output_size,
+            "data_format": self.data_format,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config_dict}
+
+
+class BaseAdaptiveAveragePooling(BaseAdaptivePooling):
+    """Base class for adaptive average pooling in 1D, 2D, and 3D."""
+
+    def call(self, inputs):
+        return ops.adaptive_average_pool(
+            inputs, output_size=self.output_size, data_format=self.data_format
+        )
+
+
+class BaseAdaptiveMaxPooling(BaseAdaptivePooling):
+    """Base class for adaptive max pooling in 1D, 2D, and 3D."""
+
+    def call(self, inputs):
+        return ops.adaptive_max_pool(
+            inputs, output_size=self.output_size, data_format=self.data_format
+        )

keras/src/layers/preprocessing/discretization.py

@@ -95,9 +95,6 @@ class Discretization(DataLayer):
         dtype=None,
         name=None,
     ):
-        if dtype is None:
-            dtype = "int64" if output_mode == "int" else backend.floatx()
-
         super().__init__(name=name, dtype=dtype)
 
         if sparse and not backend.SUPPORTS_SPARSE_TENSORS:
@@ -155,6 +152,10 @@ class Discretization(DataLayer):
     def input_dtype(self):
         return backend.floatx()
 
+    @property
+    def output_dtype(self):
+        return self.compute_dtype if self.output_mode != "int" else "int32"
+
     def adapt(self, data, steps=None):
         """Computes bin boundaries from quantiles in a input dataset.
 
@@ -213,7 +214,7 @@ class Discretization(DataLayer):
         self.summary = np.array([[], []], dtype="float32")
 
     def compute_output_spec(self, inputs):
-        return backend.KerasTensor(shape=inputs.shape, dtype=self.compute_dtype)
+        return backend.KerasTensor(shape=inputs.shape, dtype=self.output_dtype)
 
     def load_own_variables(self, store):
         if len(store) == 1:
@@ -234,7 +235,7 @@ class Discretization(DataLayer):
             indices,
             output_mode=self.output_mode,
             depth=len(self.bin_boundaries) + 1,
-            dtype=self.compute_dtype,
+            dtype=self.output_dtype,
             sparse=self.sparse,
             backend_module=self.backend,
         )

keras/src/layers/preprocessing/index_lookup.py

@@ -4,6 +4,7 @@ import numpy as np
 
 from keras.src import backend
 from keras.src.layers.layer import Layer
+from keras.src.saving import serialization_lib
 from keras.src.utils import argument_validation
 from keras.src.utils import numerical_utils
 from keras.src.utils import tf_utils
@@ -178,7 +179,12 @@ class IndexLookup(Layer):
         self.vocabulary_dtype = tf.as_dtype(vocabulary_dtype).name
         self._frozen_vocab_size = kwargs.pop("vocabulary_size", None)
 
-        self.input_vocabulary = vocabulary
+        # Remember original `vocabulary` as `input_vocabulary` for serialization
+        # via `get_config`. However, if `vocabulary` is a file path or a URL, we
+        # serialize the vocabulary as an asset and clear the original path/URL.
+        self.input_vocabulary = (
+            vocabulary if not isinstance(vocabulary, str) else None
+        )
         self.input_idf_weights = idf_weights
 
         # We set this hidden attr to
@@ -382,6 +388,18 @@ class IndexLookup(Layer):
             )
 
         if isinstance(vocabulary, str):
+            if serialization_lib.in_safe_mode():
+                raise ValueError(
+                    "Requested the loading of a vocabulary file outside of the "
+                    "model archive. This carries a potential risk of loading "
+                    "arbitrary and sensitive files and thus it is disallowed "
+                    "by default. If you trust the source of the artifact, you "
+                    "can override this error by passing `safe_mode=False` to "
+                    "the loading function, or calling "
+                    "`keras.config.enable_unsafe_deserialization(). "
+                    f"Vocabulary file: '{vocabulary}'"
+                )
+
             if not tf.io.gfile.exists(vocabulary):
                 raise ValueError(
                     f"Vocabulary file {vocabulary} does not exist."

keras/src/layers/preprocessing/normalization.py

@@ -6,6 +6,7 @@ from keras.src import backend
 from keras.src import ops
 from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.data_layer import DataLayer
+from keras.src.trainers.data_adapters.py_dataset_adapter import PyDataset
 from keras.src.utils.module_utils import tensorflow as tf
 
 
@@ -43,10 +44,12 @@ class Normalization(DataLayer):
             will be broadcast to the shape of the kept axes above;
             if the value(s) cannot be broadcast, an error will be raised when
             this layer's `build()` method is called.
+            `mean` and `variance` must be specified together.
         variance: The variance value(s) to use during normalization. The passed
             value(s) will be broadcast to the shape of the kept axes above;
             if the value(s) cannot be broadcast, an error will be raised when
             this layer's `build()` method is called.
+            `mean` and `variance` must be specified together.
         invert: If `True`, this layer will apply the inverse transformation
             to its inputs: it would turn a normalized input back into its
             original form.
@@ -227,6 +230,18 @@ class Normalization(DataLayer):
                 # Batch dataset if it isn't batched
                 data = data.batch(128)
             input_shape = tuple(data.element_spec.shape)
+        elif isinstance(data, PyDataset):
+            data = data[0]
+            if isinstance(data, tuple):
+                # handling (x, y) or (x, y, sample_weight)
+                data = data[0]
+            input_shape = data.shape
+        else:
+            raise TypeError(
+                f"Unsupported data type: {type(data)}. `adapt` supports "
+                f"`np.ndarray`, backend tensors, `tf.data.Dataset`, and "
+                f"`keras.utils.PyDataset`."
+            )
 
         if not self.built:
             self.build(input_shape)
@@ -246,7 +261,7 @@ class Normalization(DataLayer):
         elif backend.is_tensor(data):
             total_mean = ops.mean(data, axis=self._reduce_axis)
             total_var = ops.var(data, axis=self._reduce_axis)
-        elif isinstance(data, tf.data.Dataset):
+        elif isinstance(data, (tf.data.Dataset, PyDataset)):
             total_mean = ops.zeros(self._mean_and_var_shape)
             total_var = ops.zeros(self._mean_and_var_shape)
             total_count = 0

keras/src/layers/regularization/dropout.py

@@ -48,13 +48,55 @@ class Dropout(Layer):
             )
         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/rnn/gru.py

@@ -261,7 +261,7 @@ class GRUCell(Layer, DropoutRNNCell):
             matrix_x = ops.matmul(inputs, self.kernel)
             if self.use_bias:
                 # biases: bias_z_i, bias_r_i, bias_h_i
-                matrix_x += input_bias
+                matrix_x = ops.add(matrix_x, input_bias)
 
             x_z, x_r, x_h = ops.split(matrix_x, 3, axis=-1)
 

keras/src/layers/rnn/lstm.py

@@ -276,9 +276,9 @@ class LSTMCell(Layer, DropoutRNNCell):
 
             z = ops.matmul(inputs, self.kernel)
 
-            z += ops.matmul(h_tm1, self.recurrent_kernel)
+            z = ops.add(z, ops.matmul(h_tm1, self.recurrent_kernel))
             if self.use_bias:
-                z += self.bias
+                z = ops.add(z, self.bias)
 
             z = ops.split(z, 4, axis=1)
             c, o = self._compute_carry_and_output_fused(z, c_tm1)

keras/src/layers/rnn/rnn.py

@@ -212,6 +212,7 @@ class RNN(Layer):
         self.supports_masking = True
         self.input_spec = None
         self.states = None
+        self._expected_batch_size = None
 
         state_size = getattr(self.cell, "state_size", None)
         if state_size is None:
@@ -283,6 +284,9 @@ class RNN(Layer):
                         f"batch size: sequence.shape={sequences_shape}"
                     )
                 self._create_state_variables(sequences_shape[0])
+                self._expected_batch_size = ops.shape(
+                    tree.flatten(self.states)[0]
+                )[0]
 
     @tracking.no_automatic_dependency_tracking
     def _create_state_variables(self, batch_size):
@@ -382,6 +386,21 @@ class RNN(Layer):
                 initial_state = self.get_initial_state(
                     batch_size=ops.shape(sequences)[0]
                 )
+        if self.stateful:
+            actual_batch_size = sequences.shape[0]
+            if (
+                self._expected_batch_size is not None
+                and actual_batch_size is not None
+                and actual_batch_size != self._expected_batch_size
+            ):
+                raise ValueError(
+                    f"If an RNN is stateful, the batch size of the "
+                    f"input sequences must be the same as the batch "
+                    f"size of the initial state. \n"
+                    f"- Expected batch size: {self._expected_batch_size}\n"
+                    f"- Received batch size: {actual_batch_size}"
+                )
+
         # RNN expect the states in a list, even if single state.
         if not tree.is_nested(initial_state):
             initial_state = [initial_state]

keras/src/layers/rnn/simple_rnn.py

@@ -160,7 +160,7 @@ class SimpleRNNCell(Layer, DropoutRNNCell):
             sequence = sequence * dp_mask
         h = ops.matmul(sequence, self.kernel)
         if self.bias is not None:
-            h += self.bias
+            h = ops.add(h, self.bias)
 
         if training and rec_dp_mask is not None:
             prev_output = prev_output * rec_dp_mask

keras/src/losses/loss.py

@@ -211,7 +211,7 @@ def apply_mask(sample_weight, mask, dtype, reduction):
                 dtype,
             )
             valid = ops.sum(mask)  # May be 0!
-            mask *= total / (valid + backend.epsilon())
+            mask *= ops.divide_no_nan(total, valid)
 
         if sample_weight is not None:
             sample_weight = ops.cast(sample_weight, dtype=dtype)