Fixes for reference before assignment…

examples/demo_jax_distributed.py

@@ -287,6 +287,7 @@ def train_step(train_state, x, y):
 print("\nTraining:")
 data_iter = iter(train_data)
 for epoch in range(EPOCHS):
+    loss_value = None  # default
     for i in tqdm(range(STEPS_PER_EPOCH)):
         x, y = next(data_iter)
         sharded_x = jax.device_put(x.numpy(), data_sharding)

guides/custom_train_step_in_jax.py

@@ -124,7 +124,7 @@ def train_step(self, state, data):
         )
 
         # Update metrics.
-        new_metrics_vars = []
+        new_metrics_vars, logs = [], []
         for metric in self.metrics:
             this_metric_vars = metrics_variables[
                 len(new_metrics_vars) : len(new_metrics_vars)
@@ -314,7 +314,7 @@ def test_step(self, state, data):
         loss = self.compute_loss(x, y, y_pred)
 
         # Update metrics.
-        new_metrics_vars = []
+        new_metrics_vars, logs = [], []
         for metric in self.metrics:
             this_metric_vars = metrics_variables[
                 len(new_metrics_vars) : len(new_metrics_vars)

guides/distributed_training_with_jax.py

@@ -252,6 +252,7 @@ def get_replicated_train_state(devices):
 # Custom training loop
 for epoch in range(num_epochs):
     data_iter = iter(train_data)
+    loss_value = None  # default
     for data in data_iter:
         x, y = data
         sharded_x = jax.device_put(x.numpy(), data_sharding)

keras/src/activations/activations.py

@@ -83,6 +83,8 @@ def static_call(x, negative_slope=0.0, max_value=None, threshold=0.0):
                 negative_part = backend.nn.relu(-x + threshold)
             else:
                 negative_part = backend.nn.relu(-x)
+        else:
+            negative_part = 1
 
         clip_max = max_value is not None
         if threshold != 0:

keras/src/applications/densenet.py

@@ -289,6 +289,8 @@ def DenseNet(
                     cache_subdir="models",
                     file_hash="1ceb130c1ea1b78c3bf6114dbdfd8807",
                 )
+            else:
+                raise ValueError("weights_path undefined")
         else:
             if blocks == [6, 12, 24, 16]:
                 weights_path = file_utils.get_file(
@@ -311,6 +313,8 @@ def DenseNet(
                     cache_subdir="models",
                     file_hash="c13680b51ded0fb44dff2d8f86ac8bb1",
                 )
+            else:
+                raise ValueError("weights_path undefined")
         model.load_weights(weights_path)
     elif weights is not None:
         model.load_weights(weights)

keras/src/backend/jax/trainer.py

@@ -397,6 +397,7 @@ def fit(
 
         self.make_train_function()
         self.stop_training = False
+        training_logs = {}
         callbacks.on_train_begin()
         initial_epoch = self._initial_epoch or initial_epoch
         for epoch in range(initial_epoch, epochs):

keras/src/backend/torch/trainer.py

@@ -236,6 +236,7 @@ def fit(
             )
 
         self.stop_training = False
+        training_logs = {}
         self.make_train_function()
         callbacks.on_train_begin()
         initial_epoch = self._initial_epoch or initial_epoch

keras/src/callbacks/reduce_lr_on_plateau.py

@@ -138,7 +138,7 @@ def on_epoch_end(self, epoch, logs=None):
                         self.model.optimizer.learning_rate = new_lr
                         if self.verbose > 0:
                             io_utils.print_msg(
-                                f"\nEpoch {epoch +1}: "
+                                f"\nEpoch {epoch + 1}: "
                                 "ReduceLROnPlateau reducing "
                                 f"learning rate to {new_lr}."
                             )

keras/src/layers/attention/attention.py

@@ -134,6 +134,8 @@ def _calculate_scores(self, query, key):
                 scores = self.concat_score_weight * ops.sum(
                     ops.tanh(q_reshaped + k_reshaped), axis=-1
                 )
+        else:
+            raise ValueError("scores not computed")
 
         return scores
 

keras/src/layers/preprocessing/center_crop_test.py

@@ -164,16 +164,13 @@ def test_input_smaller_than_crop_box(self, size, data_format):
     def test_tf_data_compatibility(self):
         if backend.config.image_data_format() == "channels_last":
             input_shape = (2, 10, 12, 3)
-            output_shape = (2, 8, 9, 3)
         else:
             input_shape = (2, 3, 10, 12)
-            output_shape = (2, 3, 8, 9)
         layer = layers.CenterCrop(8, 9)
         input_data = np.random.random(input_shape)
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
-        self.assertEqual(tuple(output.shape), output_shape)
+        output = next(iter(ds)).numpy()
+        self.assertEqual(list(output.shape), [2, 8, 9, 3])
 
     def test_list_compatibility(self):
         if backend.config.image_data_format() == "channels_last":

keras/src/layers/preprocessing/feature_space.py

@@ -513,8 +513,7 @@ def adapt(self, dataset):
             preprocessor = self.preprocessors[name]
             # TODO: consider adding an adapt progress bar.
             # Sample 1 element to check the rank
-            for x in feature_dataset.take(1):
-                pass
+            x = next(iter(feature_dataset))
             if len(x.shape) == 0:
                 # The dataset yields unbatched scalars; batch it.
                 feature_dataset = feature_dataset.batch(32)

keras/src/layers/preprocessing/hashed_crossing_test.py

@@ -86,8 +86,7 @@ def test_tf_data_compatibility(self):
             .batch(5)
             .map(lambda x1, x2: layer((x1, x2)))
         )
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(np.array([1, 4, 1, 1, 3]), output)
 
     def test_upsupported_shape_input_fails(self):

keras/src/layers/preprocessing/hashing_test.py

@@ -60,8 +60,7 @@ def test_tf_data_compatibility(self):
         layer = layers.Hashing(num_bins=3)
         inp = [["A"], ["B"], ["C"], ["D"], ["E"]]
         ds = tf.data.Dataset.from_tensor_slices(inp).batch(5).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(output, np.array([[1], [0], [1], [1], [2]]))
 
     @parameterized.named_parameters(
@@ -306,6 +305,8 @@ def test_count_output(self, input_value, expected_output, output_shape):
             symbolic_sample_shape = ()
         elif input_array.ndim == 2:
             symbolic_sample_shape = (None,)
+        else:
+            raise TypeError("Unknown `symbolic_sample_shape`")
         inputs = layers.Input(shape=symbolic_sample_shape, dtype="int32")
         layer = layers.Hashing(num_bins=3, output_mode="count")
         outputs = layer(inputs)

keras/src/layers/preprocessing/integer_lookup_test.py

@@ -102,6 +102,5 @@ def test_tf_data_compatibility(self):
         )
         input_data = [2, 3, 4, 5]
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(4).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(output, np.array([2, 3, 4, 0]))

keras/src/layers/preprocessing/normalization.py

@@ -277,6 +277,8 @@ def adapt(self, data):
                     batch_var + (batch_mean - new_total_mean) ** 2
                 ) * batch_weight
                 total_mean = new_total_mean
+        else:
+            raise NotImplementedError(type(data))
 
         self.adapt_mean.assign(total_mean)
         self.adapt_variance.assign(total_var)

keras/src/layers/preprocessing/normalization_test.py

@@ -65,6 +65,8 @@ def test_normalization_adapt(self, input_type):
             data = backend.convert_to_tensor(x)
         elif input_type == "tf.data":
             data = tf_data.Dataset.from_tensor_slices(x).batch(8)
+        else:
+            raise NotImplementedError(input_type)
 
         layer = layers.Normalization()
         layer.adapt(data)

keras/src/layers/preprocessing/random_contrast_test.py

@@ -43,5 +43,4 @@ def test_tf_data_compatibility(self):
         layer = layers.RandomContrast(factor=0.5, seed=1337)
         input_data = np.random.random((2, 8, 8, 3))
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output.numpy()
+        next(iter(ds)).numpy()

keras/src/layers/preprocessing/random_crop_test.py

@@ -92,12 +92,9 @@ def test_tf_data_compatibility(self):
         layer = layers.RandomCrop(8, 9)
         if backend.config.image_data_format() == "channels_last":
             input_shape = (2, 10, 12, 3)
-            output_shape = (2, 8, 9, 3)
         else:
             input_shape = (2, 3, 10, 12)
-            output_shape = (2, 3, 8, 9)
         input_data = np.random.random(input_shape)
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
-        self.assertEqual(tuple(output.shape), output_shape)
+        output = next(iter(ds)).numpy()
+        self.assertEqual(list(output.shape), [2, 8, 9, 3])

keras/src/layers/preprocessing/random_flip_test.py

@@ -135,8 +135,7 @@ def test_tf_data_compatibility(self):
         input_data = np.array([[[2, 3, 4]], [[5, 6, 7]]])
         expected_output = np.array([[[5, 6, 7]], [[2, 3, 4]]])
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(output, expected_output)
         # Test 4D input: shape (2, 2, 1, 3)
         layer = layers.RandomFlip("vertical", seed=42)
@@ -159,6 +158,5 @@ def test_tf_data_compatibility(self):
             ]
         )
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(output, expected_output)

keras/src/layers/preprocessing/random_rotation_test.py

@@ -73,6 +73,5 @@ def test_tf_data_compatibility(self):
                 [4, 3, 2, 1, 0],
             ]
         ).reshape(input_shape[1:])
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(expected_output, output)

keras/src/layers/preprocessing/random_translation_test.py

@@ -327,5 +327,4 @@ def test_tf_data_compatibility(self):
         layer = layers.RandomTranslation(0.2, 0.1)
         input_data = np.random.random((1, 4, 4, 3))
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(1).map(layer)
-        for output in ds.take(1):
-            output.numpy()
+        next(iter(ds)).numpy()

keras/src/layers/preprocessing/random_zoom_test.py

@@ -119,8 +119,7 @@ def test_tf_data_compatibility(self):
                 [0, 0, 0, 0, 0],
             ]
         ).reshape(input_shape)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(expected_output, output)
 
     def test_dynamic_shape(self):

keras/src/layers/preprocessing/rescaling_test.py

@@ -72,8 +72,7 @@ def test_tf_data_compatibility(self):
         layer = layers.Rescaling(scale=1.0 / 255, offset=0.5)
         x = np.random.random((3, 10, 10, 3)) * 255
         ds = tf_data.Dataset.from_tensor_slices(x).batch(3).map(layer)
-        for output in ds.take(1):
-            output.numpy()
+        next(iter(ds)).numpy()
 
     def test_rescaling_with_channels_first_and_vector_scale(self):
         config = backend.image_data_format()

keras/src/layers/preprocessing/resizing_test.py

@@ -186,8 +186,7 @@ def test_tf_data_compatibility(self):
         layer = layers.Resizing(8, 9)
         input_data = np.random.random(input_shape)
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertEqual(tuple(output.shape), output_shape)
 
     @pytest.mark.skipif(
@@ -210,6 +209,5 @@ def test_tf_data_compatibility_sequential(self):
             .batch(2)
             .map(Sequential([layer]))
         )
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertEqual(tuple(output.shape), output_shape)

keras/src/layers/preprocessing/string_lookup_test.py

@@ -77,8 +77,7 @@ def test_tf_data_compatibility(self):
         )
         input_data = ["b", "c", "d"]
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(3).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(output, np.array([2, 3, 0]))
 
     @pytest.mark.skipif(not backend.backend() == "tensorflow", reason="tf only")

keras/src/layers/preprocessing/text_vectorization_test.py

@@ -95,8 +95,7 @@ def test_tf_data_compatibility(self):
         )
         input_data = [["foo qux bar"], ["qux baz"]]
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output = output.numpy()
+        output = next(iter(ds)).numpy()
         self.assertAllClose(output, np.array([[4, 1, 3, 0], [1, 2, 0, 0]]))
 
         # Test adapt flow
@@ -107,8 +106,7 @@ def test_tf_data_compatibility(self):
         )
         layer.adapt(input_data)
         ds = tf_data.Dataset.from_tensor_slices(input_data).batch(2).map(layer)
-        for output in ds.take(1):
-            output.numpy()
+        next(iter(ds)).numpy()
 
     @pytest.mark.skipif(
         backend.backend() != "tensorflow", reason="Requires string tensors."

keras/src/legacy/backend.py

@@ -1279,6 +1279,8 @@ def relu(x, alpha=0.0, max_value=None, threshold=0.0):
             negative_part = tf.nn.relu(-x + threshold)
         else:
             negative_part = tf.nn.relu(-x)
+    else:
+        negative_part = 1
 
     clip_max = max_value is not None
 

keras/src/models/model.py

@@ -393,6 +393,7 @@ def quantize(self, mode):
     def build_from_config(self, config):
         if not config:
             return
+        status = False
         if "input_shape" in config:
             # Case: all inputs are in the first arg (possibly nested).
             if utils.is_default(self.build):
@@ -404,7 +405,7 @@ def build_from_config(self, config):
                     self.build(config["input_shape"])
                     status = True
                 except:
-                    status = False
+                    pass
             self._build_shapes_dict = config
 
         elif "shapes_dict" in config:
@@ -416,7 +417,7 @@ def build_from_config(self, config):
                     self.build(**config["shapes_dict"])
                     status = True
                 except:
-                    status = False
+                    pass
             self._build_shapes_dict = config["shapes_dict"]
 
         if not status:

keras/src/models/sequential.py

@@ -351,6 +351,7 @@ def from_config(cls, config, custom_objects=None):
             model.add(layer)
         if (
             not model._functional
+            and "build_input_shape" in locals()
             and build_input_shape
             and isinstance(build_input_shape, (tuple, list))
         ):

keras/src/ops/function.py

@@ -318,7 +318,7 @@ def map_graph(inputs, outputs):
                         "The following previous operations were accessed "
                         f"without issue: {operations_with_complete_input}"
                     )
-                operations_with_complete_input.append(operation.name)
+                operations_with_complete_input.append(node.operation.name)
 
             for x in tree.flatten(node.outputs):
                 computable_tensors.add(x)

keras/src/optimizers/base_optimizer.py

@@ -847,6 +847,8 @@ def get_config(self):
             learning_rate = serialization_lib.serialize_keras_object(
                 self._learning_rate
             )
+        else:
+            learning_rate = 0.5
 
         config = {
             "name": self.name,

keras/src/trainers/compile_utils.py

@@ -170,6 +170,7 @@ def variables(self):
         return vars
 
     def build(self, y_true, y_pred):
+        num_outputs = 1  # default
         if self.output_names:
             output_names = self.output_names
         elif isinstance(y_pred, dict):
@@ -182,7 +183,6 @@ def build(self, y_true, y_pred):
                 output_names = None
         else:
             output_names = None
-            num_outputs = 1
         if output_names:
             num_outputs = len(output_names)
 
@@ -430,6 +430,7 @@ def __init__(
         super().__init__(name="compile_loss", reduction=reduction)
 
     def build(self, y_true, y_pred):
+        num_outputs = 1  # default
         if self.output_names:
             output_names = self.output_names
         elif isinstance(y_pred, dict):
@@ -442,7 +443,6 @@ def build(self, y_true, y_pred):
                 output_names = None
         else:
             output_names = None
-            num_outputs = 1
         if output_names:
             num_outputs = len(output_names)