keras-nightly 3.12.0.dev2025083103__py3-none-any.whl → 3.14.0.dev2026011604__py3-none-any.whl

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/preprocessing/string_lookup.py

@@ -26,9 +26,9 @@ class StringLookup(IndexLookup):
     tokens will be used to create the vocabulary and all others will be treated
     as out-of-vocabulary (OOV).
 
-    There are two possible output modes for the layer.
-    When `output_mode` is `"int"`,
-    input strings are converted to their index in the vocabulary (an integer).
+    There are two possible output modes for the layer. When `output_mode` is
+    `"int"`, input strings are converted to their index in the vocabulary (an
+    integer).
     When `output_mode` is `"multi_hot"`, `"count"`, or `"tf_idf"`, input strings
     are encoded into an array where each dimension corresponds to an element in
     the vocabulary.
@@ -48,7 +48,7 @@ class StringLookup(IndexLookup):
     It can however be used with any backend when running eagerly.
     It can also always be used as part of an input preprocessing pipeline
     with any backend (outside the model itself), which is how we recommend
-    to use this layer.
+    using this layer.
 
     **Note:** This layer is safe to use inside a `tf.data` pipeline
     (independently of which backend you're using).
@@ -65,28 +65,26 @@ class StringLookup(IndexLookup):
             If this value is 0, OOV inputs will cause an error when calling
             the layer. Defaults to `1`.
         mask_token: A token that represents masked inputs. When `output_mode` is
-            `"int"`, the token is included in vocabulary and mapped to index 0.
-            In other output modes, the token will not appear
-            in the vocabulary and instances of the mask token
-            in the input will be dropped. If set to `None`,
-            no mask term will be added. Defaults to `None`.
+            `"int"`, the token is included in the vocabulary and mapped to index
+            0.
+            In other output modes, the token will not appear in the vocabulary
+            and instances of the mask token in the input will be dropped.
+            If set to `None`, no mask term will be added. Defaults to `None`.
         oov_token: Only used when `invert` is True. The token to return for OOV
             indices. Defaults to `"[UNK]"`.
-        vocabulary: Optional. Either an array of integers or a string path to a
-            text file. If passing an array, can pass a tuple, list,
-            1D NumPy array, or 1D tensor containing the integer vocbulary terms.
-            If passing a file path, the file should contain one line per term
-            in the vocabulary. If this argument is set,
-            there is no need to `adapt()` the layer.
-        vocabulary_dtype: The dtype of the vocabulary terms, for example
-            `"int64"` or `"int32"`. Defaults to `"int64"`.
+        vocabulary: Optional. Either an array of strings or a string path to a
+            text file. If passing an array, you can pass a tuple, list, 1D NumPy
+            array, or 1D tensor containing the string vocabulary terms.
+            If passing a file path, the file should contain one line per term in
+            the vocabulary. If this argument is set, there is no need to
+            `adapt()` the layer.
         idf_weights: Only valid when `output_mode` is `"tf_idf"`.
             A tuple, list, 1D NumPy array, or 1D tensor or the same length
             as the vocabulary, containing the floating point inverse document
             frequency weights, which will be multiplied by per sample term
             counts for the final TF-IDF weight.
-            If the `vocabulary` argument is set, and `output_mode` is
-            `"tf_idf"`, this argument must be supplied.
+            If the `vocabulary` argument is set and `output_mode` is `"tf_idf"`,
+            this argument must be supplied.
         invert: Only valid when `output_mode` is `"int"`.
             If `True`, this layer will map indices to vocabulary items
             instead of mapping vocabulary items to indices.
@@ -102,11 +100,11 @@ class StringLookup(IndexLookup):
                 If the last dimension is not size 1, will append a new
                 dimension for the encoded output.
             - `"multi_hot"`: Encodes each sample in the input into a single
-                array the same size as the vocabulary,
-                containing a 1 for each vocabulary term present in the sample.
-                Treats the last dimension as the sample dimension,
-                if input shape is `(..., sample_length)`,
-                output shape will be `(..., num_tokens)`.
+                array the same size as the vocabulary containing a 1 for each
+                vocabulary term present in the sample.
+                Treats the last dimension as the sample dimension, if the input
+                shape is `(..., sample_length)`, the output shape will be
+                `(..., num_tokens)`.
             - `"count"`: As `"multi_hot"`, but the int array contains
                 a count of the number of times the token at that index
                 appeared in the sample.
@@ -240,8 +238,8 @@ class StringLookup(IndexLookup):
     array([[0.  , 0.25, 0.  , 0.6 , 0.8 ],
            [1.0 , 0.  , 0.75, 0.  , 0.4 ]], dtype=float32)
 
-    To specify the idf weights for oov values, you will need to pass the entire
-    vocabulary including the leading oov token.
+    To specify the idf weights for OOV values, you will need to pass the entire
+    vocabulary including the leading OOV token.
 
     >>> vocab = ["[UNK]", "a", "b", "c", "d"]
     >>> idf_weights = [0.9, 0.25, 0.75, 0.6, 0.4]
@@ -269,7 +267,7 @@ class StringLookup(IndexLookup):
     array([[b'a', b'c', b'd'],
            [b'd', b'[UNK]', b'b']], dtype=object)
 
-    Note that the first index correspond to the oov token by default.
+    Note that the first index corresponds to the OOV token by default.
 
 
     **Forward and inverse lookup pairs**
@@ -340,7 +338,7 @@ class StringLookup(IndexLookup):
         self.supports_jit = False
 
     def adapt(self, data, steps=None):
-        """Computes a vocabulary of integer terms from tokens in a dataset.
+        """Computes a vocabulary of terms from tokens in a dataset.
 
         Calling `adapt()` on a `StringLookup` layer is an alternative to passing
         in a precomputed vocabulary on construction via the `vocabulary`

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/legacy/preprocessing/image.py

@@ -30,11 +30,14 @@ class Iterator(PyDataset):
         batch_size: Integer, size of a batch.
         shuffle: Boolean, whether to shuffle the data between epochs.
         seed: Random seeding for data shuffling.
+        **kwargs: Additional keyword arguments for the `PyDataset` base class,
+            such as `workers`, `use_multiprocessing`, and `max_queue_size`.
     """
 
     white_list_formats = ("png", "jpg", "jpeg", "bmp", "ppm", "tif", "tiff")
 
-    def __init__(self, n, batch_size, shuffle, seed):
+    def __init__(self, n, batch_size, shuffle, seed, **kwargs):
+        super().__init__(**kwargs)
         self.n = n
         self.batch_size = batch_size
         self.seed = seed

keras/src/legacy/preprocessing/sequence.py

@@ -47,6 +47,8 @@ class TimeseriesGenerator(PyDataset):
             in reverse chronological order.
         batch_size: Number of timeseries samples in each batch
             (except maybe the last one).
+        **kwargs: Additional keyword arguments for the `PyDataset` base class,
+            such as `workers`, `use_multiprocessing`, and `max_queue_size`.
 
     Returns:
         A PyDataset instance.
@@ -64,7 +66,9 @@ class TimeseriesGenerator(PyDataset):
         shuffle=False,
         reverse=False,
         batch_size=128,
+        **kwargs,
     ):
+        super().__init__(**kwargs)
         if len(data) != len(targets):
             raise ValueError(
                 "Data and targets have to be "
@@ -145,18 +149,22 @@ class TimeseriesGenerator(PyDataset):
         except TypeError as e:
             raise TypeError(f"Targets not JSON Serializable: {targets}") from e
 
-        return {
-            "data": json_data,
-            "targets": json_targets,
-            "length": self.length,
-            "sampling_rate": self.sampling_rate,
-            "stride": self.stride,
-            "start_index": self.start_index,
-            "end_index": self.end_index,
-            "shuffle": self.shuffle,
-            "reverse": self.reverse,
-            "batch_size": self.batch_size,
-        }
+        config = super().get_config()
+        config.update(
+            {
+                "data": json_data,
+                "targets": json_targets,
+                "length": self.length,
+                "sampling_rate": self.sampling_rate,
+                "stride": self.stride,
+                "start_index": self.start_index,
+                "end_index": self.end_index,
+                "shuffle": self.shuffle,
+                "reverse": self.reverse,
+                "batch_size": self.batch_size,
+            }
+        )
+        return config
 
     def to_json(self, **kwargs):
         """Returns a JSON string containing the generator's configuration.

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)

keras/src/losses/losses.py

@@ -73,6 +73,14 @@ class MeanSquaredError(LossFunctionWrapper):
             `"float32"` unless set to different value
             (via `keras.backend.set_floatx()`). If a `keras.DTypePolicy` is
             provided, then the `compute_dtype` will be utilized.
+
+    Examples:
+
+    >>> y_true = keras.ops.array([1.0, 0.0, 1.0])
+    >>> y_pred = keras.ops.array([0.9, 0.1, 0.8])
+    >>> loss = keras.losses.MeanSquaredError()
+    >>> loss(y_true, y_pred)
+    0.02
     """
 
     def __init__(
@@ -114,6 +122,14 @@ class MeanAbsoluteError(LossFunctionWrapper):
             `"float32"` unless set to different value
             (via `keras.backend.set_floatx()`). If a `keras.DTypePolicy` is
             provided, then the `compute_dtype` will be utilized.
+
+    Examples:
+
+    >>> y_true = keras.ops.array([1.0, 0.3, 1.0])
+    >>> y_pred = keras.ops.array([1.9, 0.3, 1.8])
+    >>> loss = keras.losses.MeanAbsoluteError()
+    >>> loss(y_true, y_pred)
+    0.5666667
     """
 
     def __init__(
@@ -155,6 +171,14 @@ class MeanAbsolutePercentageError(LossFunctionWrapper):
             `"float32"` unless set to different value
             (via `keras.backend.set_floatx()`). If a `keras.DTypePolicy` is
             provided, then the `compute_dtype` will be utilized.
+
+    Examples:
+
+    >>> y_true = keras.ops.array([100.0, 200.0, 300.0])
+    >>> y_pred = keras.ops.array([90.0, 210.0, 310.0])
+    >>> loss = keras.losses.MeanAbsolutePercentageError()
+    >>> loss(y_true, y_pred)
+    6.111111
     """
 
     def __init__(

keras/src/metrics/confusion_metrics.py

@@ -654,7 +654,7 @@ class SensitivitySpecificityBase(Metric):
         Args:
             constrained: Over these values the constraint is specified. A rank-1
                 tensor.
-            dependent: From these values the maximum that satiesfies the
+            dependent: From these values the maximum that satisfies the
                 constraint is selected. Values in this tensor and in
                 `constrained` are linked by having the same threshold at each
                 position, hence this tensor must have the same shape.
@@ -664,11 +664,12 @@ class SensitivitySpecificityBase(Metric):
         Returns:
             maximal dependent value, if no value satisfies the constraint 0.0.
         """
-        feasible = ops.nonzero(predicate(constrained, self.value))
-        feasible_exists = ops.greater(ops.size(feasible), 0)
-        max_dependent = ops.max(ops.take(dependent, feasible), initial=0)
-
-        return ops.where(feasible_exists, max_dependent, 0.0)
+        feasible = predicate(constrained, self.value)
+        # Mask values based on whether they satisfy the constraint and take max.
+        return ops.max(
+            ops.multiply(dependent, ops.cast(feasible, dependent.dtype)),
+            initial=0,
+        )
 
 
 @keras_export("keras.metrics.SensitivityAtSpecificity")

keras/src/models/cloning.py

@@ -293,10 +293,12 @@ def _clone_sequential_model(model, clone_function, input_tensors=None):
         input_name = ref_input_layer.name
         input_batch_shape = ref_input_layer.batch_shape
         input_dtype = ref_input_layer._dtype
+        input_optional = ref_input_layer.optional
     else:
         input_name = None
         input_dtype = None
         input_batch_shape = None
+        input_optional = False
 
     if input_tensors is not None:
         if isinstance(input_tensors, (list, tuple)):
@@ -313,6 +315,7 @@ def _clone_sequential_model(model, clone_function, input_tensors=None):
         inputs = Input(
             tensor=input_tensors,
             name=input_name,
+            optional=input_optional,
         )
         new_layers = [inputs] + new_layers
     else:
@@ -321,6 +324,7 @@ def _clone_sequential_model(model, clone_function, input_tensors=None):
                 batch_shape=input_batch_shape,
                 dtype=input_dtype,
                 name=input_name,
+                optional=input_optional,
             )
             new_layers = [inputs] + new_layers
     cloned_model = Sequential(

keras/src/models/functional.py

@@ -254,9 +254,9 @@ class Functional(Function, Model):
         return converted
 
     def _adjust_input_rank(self, flat_inputs):
-        flat_ref_shapes = [x.shape for x in self._inputs]
         adjusted = []
-        for x, ref_shape in zip(flat_inputs, flat_ref_shapes):
+        for i, x in enumerate(flat_inputs):
+            ref_shape = self._inputs[i].shape
             if x is None:
                 adjusted.append(x)
                 continue
@@ -273,8 +273,11 @@ class Functional(Function, Model):
                 if ref_shape[-1] == 1:
                     adjusted.append(ops.expand_dims(x, axis=-1))
                     continue
+            flat_paths_and_inputs = tree.flatten_with_path(self._inputs_struct)
+            path = ".".join(str(p) for p in flat_paths_and_inputs[i][0])
             raise ValueError(
-                f"Invalid input shape for input {x}. Expected shape "
+                f"Invalid input shape for input {x} with name "
+                f"'{self._inputs[i].name}' and path '{path}'. Expected shape "
                 f"{ref_shape}, but input has incompatible shape {x.shape}"
             )
         # Add back metadata.
@@ -832,11 +835,16 @@ def clone_graph_nodes(inputs, outputs):
             kt_id_mapping[id(kt_input)] = kt_input
         else:
             # We need to create a new Keras tensor for any intermediate tensor
+            original_op = kt_input._keras_history.operation
+            optional = False
+            if isinstance(original_op, InputLayer):
+                optional = original_op.optional
             cloned_input = Input(
                 batch_shape=kt_input.shape,
                 dtype=kt_input.dtype,
                 sparse=kt_input.sparse,
                 name=f"{kt_input.name}CLONE",
+                optional=optional,
             )
             cloned_inputs.append(cloned_input)
             kt_id_mapping[id(kt_input)] = cloned_input