From 00fbbd90369a1dcf28794a25e2c210e8f35d43af Mon Sep 17 00:00:00 2001 From: Scott Zhu Date: Wed, 11 Mar 2020 16:41:41 -0700 Subject: [PATCH] Update Keras tests under engine package to use combinations. 1. Change all test_util.run_all_in_graph_and_eager_modes to combination. 2. Replace import tensorflow.python.keras with explicit module import. 3. Update BUILD file to not rely on the overall Keras target. PiperOrigin-RevId: 300434594 Change-Id: I7ca776f66ac3097ba1343a5c58969ec2e6e0df3d --- tensorflow/python/keras/engine/BUILD | 57 +- .../python/keras/engine/base_layer_test.py | 440 +++++------ .../keras/engine/base_layer_utils_test.py | 14 +- .../python/keras/engine/network_test.py | 699 +++++++++--------- 4 files changed, 633 insertions(+), 577 deletions(-) diff --git a/tensorflow/python/keras/engine/BUILD b/tensorflow/python/keras/engine/BUILD index 47765190ff6..86223028543 100644 --- a/tensorflow/python/keras/engine/BUILD +++ b/tensorflow/python/keras/engine/BUILD @@ -183,7 +183,10 @@ tf_py_test( deps = [ ":base_layer_utils", "//tensorflow/python:client_testlib", - "@absl_py//absl/testing:parameterized", + "//tensorflow/python:dtypes", + "//tensorflow/python:lookup_ops", + "//tensorflow/python/keras:backend", + "//tensorflow/python/keras:combinations", ], ) @@ -437,10 +440,28 @@ tf_py_test( "nomac", # TODO(mihaimaruseac): b/127695564 ], deps = [ + ":base_layer", + ":engine", + "//tensorflow/python:array_ops", "//tensorflow/python:client_testlib", - "//tensorflow/python/keras", + "//tensorflow/python:constant_op", + "//tensorflow/python:dtypes", + "//tensorflow/python:framework_ops", + "//tensorflow/python:math_ops", + "//tensorflow/python:state_ops", + "//tensorflow/python:tensor_shape", + "//tensorflow/python/eager:context", + "//tensorflow/python/keras:backend", + "//tensorflow/python/keras:combinations", + "//tensorflow/python/keras:initializers", + "//tensorflow/python/keras:models", + "//tensorflow/python/keras:testing_utils", + "//tensorflow/python/keras/layers", + "//tensorflow/python/keras/utils:layer_utils", + "//tensorflow/python/keras/utils:tf_utils", + "//tensorflow/python/ops/ragged:ragged_factory_ops", + "//tensorflow/python/training/tracking:util", "//third_party/py/numpy", - "@absl_py//absl/testing:parameterized", ], ) @@ -455,10 +476,36 @@ tf_py_test( "nomac", # TODO(mihaimaruseac): b/127695564 ], deps = [ + ":base_layer", + ":engine", + "//tensorflow/python:array_ops", "//tensorflow/python:client_testlib", - "//tensorflow/python/keras", + "//tensorflow/python:constant_op", + "//tensorflow/python:control_flow_ops", + "//tensorflow/python:dtypes", + "//tensorflow/python:framework_ops", + "//tensorflow/python:math_ops", + "//tensorflow/python:platform", + "//tensorflow/python:sparse_tensor", + "//tensorflow/python:state_ops", + "//tensorflow/python:summary", + "//tensorflow/python:summary_ops_v2", + "//tensorflow/python:tensor_array_ops", + "//tensorflow/python:tensor_spec", + "//tensorflow/python:util", + "//tensorflow/python:variables", + "//tensorflow/python/eager:context", + "//tensorflow/python/eager:def_function", + "//tensorflow/python/keras:backend", + "//tensorflow/python/keras:combinations", + "//tensorflow/python/keras:regularizers", + "//tensorflow/python/keras:testing_utils", + "//tensorflow/python/keras/layers", + "//tensorflow/python/keras/mixed_precision/experimental:policy", + "//tensorflow/python/keras/optimizer_v2", + "//tensorflow/python/keras/utils:tf_utils", + "//tensorflow/python/ops/ragged:ragged_tensor", "//third_party/py/numpy", - "@absl_py//absl/testing:parameterized", ], ) diff --git a/tensorflow/python/keras/engine/base_layer_test.py b/tensorflow/python/keras/engine/base_layer_test.py index dd53f20b98d..94766fe177a 100644 --- a/tensorflow/python/keras/engine/base_layer_test.py +++ b/tensorflow/python/keras/engine/base_layer_test.py @@ -25,7 +25,6 @@ import traceback import numpy as np -from tensorflow.python import keras from tensorflow.python.eager import context from tensorflow.python.eager import def_function from tensorflow.python.framework import constant_op @@ -33,11 +32,16 @@ from tensorflow.python.framework import dtypes from tensorflow.python.framework import ops from tensorflow.python.framework import sparse_tensor from tensorflow.python.framework import tensor_spec -from tensorflow.python.framework import test_util from tensorflow.python.keras import backend +from tensorflow.python.keras import combinations from tensorflow.python.keras import keras_parameterized +from tensorflow.python.keras import layers +from tensorflow.python.keras import regularizers from tensorflow.python.keras import testing_utils from tensorflow.python.keras.engine import base_layer +from tensorflow.python.keras.engine import input_layer +from tensorflow.python.keras.engine import sequential +from tensorflow.python.keras.engine import training as training_lib from tensorflow.python.keras.mixed_precision.experimental import policy from tensorflow.python.keras.optimizer_v2 import rmsprop from tensorflow.python.keras.utils import tf_utils @@ -81,7 +85,7 @@ class InvalidLayer(base_layer.Layer): class BaseLayerTest(keras_parameterized.TestCase): - @keras_parameterized.run_with_all_model_types + @combinations.generate(combinations.keras_model_type_combinations()) def test_dynamic_layer(self): model = testing_utils.get_model_from_layers([DynamicLayer(dynamic=True)], input_shape=(3,)) @@ -90,7 +94,7 @@ class BaseLayerTest(keras_parameterized.TestCase): self.assertEqual(model.run_eagerly, True) model.train_on_batch(np.random.random((2, 3)), np.random.random((2, 3))) - @keras_parameterized.run_with_all_model_types + @combinations.generate(combinations.keras_model_type_combinations()) def test_dynamic_layer_error(self): with self.assertRaisesRegexp(TypeError, 'attempting to use Python control flow'): @@ -99,7 +103,7 @@ class BaseLayerTest(keras_parameterized.TestCase): model.compile(rmsprop.RMSprop(0.001), loss='mse') model.train_on_batch(np.random.random((2, 3)), np.random.random((2, 3))) - @keras_parameterized.run_with_all_model_types + @combinations.generate(combinations.keras_model_type_combinations()) def test_dynamic_layer_error_running_in_graph_mode(self): with ops.get_default_graph().as_default(): model = testing_utils.get_model_from_layers([DynamicLayer(dynamic=True)], @@ -111,7 +115,8 @@ class BaseLayerTest(keras_parameterized.TestCase): model.compile(rmsprop.RMSprop(0.001), loss='mse') def test_manual_compute_output_shape(self): - class BuildCounter(keras.layers.Layer): + + class BuildCounter(base_layer.Layer): def __init__(self, *args, **kwargs): # pylint: disable=redefined-outer-name super(BuildCounter, self).__init__(*args, **kwargs) @@ -123,45 +128,41 @@ class BaseLayerTest(keras_parameterized.TestCase): def call(self, inputs): return inputs - with context.eager_mode(): - layer = BuildCounter(dtype=dtypes.float64) - output_shape = layer.compute_output_shape((None, 10)) - self.assertEqual(layer.build_counter, 1) - self.assertEqual(output_shape.as_list(), [None, 10]) - output_signature = layer.compute_output_signature( - tensor_spec.TensorSpec(dtype=dtypes.float64, shape=[None, 10])) - self.assertEqual(layer.build_counter, 1) - self.assertEqual(output_signature.dtype, dtypes.float64) - self.assertEqual(output_signature.shape.as_list(), [None, 10]) - layer(np.ones((5, 10))) - self.assertEqual(layer.build_counter, 1) + layer = BuildCounter(dtype=dtypes.float64) + output_shape = layer.compute_output_shape((None, 10)) + self.assertEqual(layer.build_counter, 1) + self.assertEqual(output_shape.as_list(), [None, 10]) + output_signature = layer.compute_output_signature( + tensor_spec.TensorSpec(dtype=dtypes.float64, shape=[None, 10])) + self.assertEqual(layer.build_counter, 1) + self.assertEqual(output_signature.dtype, dtypes.float64) + self.assertEqual(output_signature.shape.as_list(), [None, 10]) + layer(np.ones((5, 10))) + self.assertEqual(layer.build_counter, 1) def test_eager_switch_case_input(self): - with context.eager_mode(): - task = keras.Input(shape=(), dtype=dtypes.int32) - control_flow_ops.switch_case( - task[0], [lambda: constant_op.constant(1.0) for _ in range(10)]) + task = input_layer.Input(shape=(), dtype=dtypes.int32) + control_flow_ops.switch_case( + task[0], [lambda: constant_op.constant(1.0) for _ in range(10)]) def test_dynamic_layer_with_deferred_sequential_model(self): - model = keras.Sequential( - [DynamicLayer(dynamic=True), - keras.layers.Dense(3)]) + model = sequential.Sequential([DynamicLayer(dynamic=True), layers.Dense(3)]) self.assertEqual(model.dynamic, True) model.compile(rmsprop.RMSprop(0.001), loss='mse') self.assertEqual(model.run_eagerly, True) model.train_on_batch(np.random.random((2, 3)), np.random.random((2, 3))) def test_nested_dynamic_layers_in_eager_mode(self): - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) outputs = DynamicLayer(dynamic=True)(inputs) - inner_model = keras.Model(inputs, outputs) + inner_model = training_lib.Model(inputs, outputs) self.assertEqual(inner_model.dynamic, True) - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) x = DynamicLayer(dynamic=True)(inputs) outputs = inner_model(x) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) self.assertEqual(model.dynamic, True) model.compile(rmsprop.RMSprop(0.001), loss='mse') self.assertEqual(model.run_eagerly, True) @@ -169,12 +170,12 @@ class BaseLayerTest(keras_parameterized.TestCase): def test_dynamic_subclassed_model_no_shape_inference(self): - class MyModel(keras.Model): + class MyModel(training_lib.Model): def __init__(self): super(MyModel, self).__init__(dynamic=True) - self.layer1 = keras.layers.Dense(3) - self.layer2 = keras.layers.Dense(3) + self.layer1 = layers.Dense(3) + self.layer2 = layers.Dense(3) def call(self, inputs): if math_ops.reduce_sum(inputs) > 0: @@ -191,12 +192,12 @@ class BaseLayerTest(keras_parameterized.TestCase): def test_dynamic_subclassed_model_with_shape_inference(self): - class MyModel(keras.Model): + class MyModel(training_lib.Model): def __init__(self): super(MyModel, self).__init__(dynamic=True) - self.layer1 = keras.layers.Dense(3) - self.layer2 = keras.layers.Dense(3) + self.layer1 = layers.Dense(3) + self.layer2 = layers.Dense(3) def call(self, inputs): if math_ops.reduce_sum(inputs) > 0: @@ -216,74 +217,72 @@ class BaseLayerTest(keras_parameterized.TestCase): self.assertEqual(outputs.shape.as_list(), [2, 3]) def test_deepcopy(self): - with context.eager_mode(): - bias_reg = lambda x: 1e-3 * math_ops.reduce_sum(x) - layer = keras.layers.Conv2D(32, (3, 3), bias_regularizer=bias_reg) - # Call the Layer on data to generate regularize losses. - layer(array_ops.ones((1, 10, 10, 3))) - self.assertLen(layer.losses, 1) - new_layer = copy.deepcopy(layer) - self.assertEqual(new_layer.bias_regularizer, bias_reg) - self.assertEqual(layer.get_config(), new_layer.get_config()) + bias_reg = lambda x: 1e-3 * math_ops.reduce_sum(x) + layer = layers.Conv2D(32, (3, 3), bias_regularizer=bias_reg) + # Call the Layer on data to generate regularize losses. + layer(array_ops.ones((1, 10, 10, 3))) + self.assertLen(layer.losses, 1) + new_layer = copy.deepcopy(layer) + self.assertEqual(new_layer.bias_regularizer, bias_reg) + self.assertEqual(layer.get_config(), new_layer.get_config()) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_invalid_forward_pass(self): - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) with self.assertRaisesRegexp(ValueError, 'You did something wrong!'): _ = InvalidLayer()(inputs) def test_no_legacy_model(self): - inputs = keras.Input((1,)) + inputs = input_layer.Input((1,)) legacy_dense_0 = legacy_core.Dense(1, name='legacy_dense_0') legacy_dense_1 = legacy_core.Dense(1, name='legacy_dense_1') layer = legacy_dense_0(inputs) - layer = keras.layers.Dense(1)(layer) + layer = layers.Dense(1)(layer) layer = legacy_dense_1(layer) expected_regex = (r'The following are legacy tf\.layers\.Layers:\n ' '{}\n {}'.format(legacy_dense_0, legacy_dense_1)) with self.assertRaisesRegexp(TypeError, expected_regex): - _ = keras.models.Model(inputs=[inputs], outputs=[layer]) + _ = training_lib.Model(inputs=[inputs], outputs=[layer]) - model = keras.models.Model(inputs=[inputs], outputs=[inputs]) + model = training_lib.Model(inputs=[inputs], outputs=[inputs]) with self.assertRaisesRegexp(TypeError, expected_regex): model._insert_layers([legacy_dense_0, legacy_dense_1]) def test_no_legacy_sequential(self): - layers = [ - keras.layers.Dense(1), - legacy_core.Dense(1, name='legacy_dense_0') - ] + layer = [layers.Dense(1), legacy_core.Dense(1, name='legacy_dense_0')] - expected_regex = r'legacy tf\.layers\.Layers:\n {}'.format(layers[1]) + expected_regex = r'legacy tf\.layers\.Layers:\n {}'.format(layer[1]) with self.assertRaisesRegexp(TypeError, expected_regex): - _ = keras.models.Sequential(layers) + _ = sequential.Sequential(layer) with self.assertRaisesRegexp(TypeError, expected_regex): - _ = keras.models.Sequential([keras.layers.Input(shape=(4,))] + layers) + _ = sequential.Sequential([input_layer.Input(shape=(4,))] + layer) - model = keras.models.Sequential() + model = sequential.Sequential() with self.assertRaisesRegexp(TypeError, expected_regex): - for l in layers: + for l in layer: model.add(l) - @keras_parameterized.run_with_all_model_types - @test_util.run_in_graph_and_eager_modes + @combinations.generate( + combinations.times( + combinations.keras_model_type_combinations(), + combinations.combine(mode=['graph', 'eager']))) def test_build_with_numpy_data(self): model_layers = [ - keras.layers.Dense(3, activation='relu', kernel_initializer='ones'), - keras.layers.Dense(1, activation='sigmoid', kernel_initializer='ones') + layers.Dense(3, activation='relu', kernel_initializer='ones'), + layers.Dense(1, activation='sigmoid', kernel_initializer='ones') ] model = testing_utils.get_model_from_layers(model_layers, input_shape=(4,)) model(np.zeros((2, 4), dtype='float32')) self.assertTrue(model.built) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_default_add_weight(self): - class TestLayer(keras.layers.Layer): + class TestLayer(base_layer.Layer): def __init__(self): super(TestLayer, self).__init__() @@ -300,76 +299,77 @@ class BaseLayerTest(keras_parameterized.TestCase): self.assertEqual(len(layer.losses), 1) if not context.executing_eagerly(): # Cannot access tensor.name in eager execution. - self.assertTrue('Variable_2/Regularizer' in layer.losses[0].name) + self.assertIn('Variable_2/Regularizer', layer.losses[0].name) - @keras_parameterized.run_all_keras_modes(always_skip_v1=True) + @combinations.generate(combinations.keras_mode_combinations(mode=['eager'])) def test_learning_phase_freezing_for_layers(self): - class LearningPhaseLayer(keras.layers.Layer): + + class LearningPhaseLayer(base_layer.Layer): def call(self, inputs): - return keras.backend.in_train_phase( - lambda: array_ops.ones_like(inputs), - lambda: array_ops.zeros_like(inputs)) + return backend.in_train_phase(lambda: array_ops.ones_like(inputs), + lambda: array_ops.zeros_like(inputs)) def get_learning_phase_value(): - model = keras.models.Sequential([LearningPhaseLayer(input_shape=(1,))]) + model = sequential.Sequential([LearningPhaseLayer(input_shape=(1,))]) model._run_eagerly = testing_utils.should_run_eagerly() return np.sum(model(np.ones((1, 1)))) self.assertEqual(get_learning_phase_value(), 0) # Test scope. - with keras.backend.learning_phase_scope(1): + with backend.learning_phase_scope(1): self.assertEqual(get_learning_phase_value(), 1) # The effects of the scope end after exiting it. self.assertEqual(get_learning_phase_value(), 0) # Test setting. - keras.backend.set_learning_phase(1) + backend.set_learning_phase(1) self.assertEqual(get_learning_phase_value(), 1) - keras.backend.set_learning_phase(0) + backend.set_learning_phase(0) self.assertEqual(get_learning_phase_value(), 0) # Cannot be enabled with `run_eagerly=True`, see b/123904578 - @test_util.run_all_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_layer_can_return_variable(self): - class ComputeSum(keras.layers.Layer): + class ComputeSum(base_layer.Layer): def __init__(self): super(ComputeSum, self).__init__() self.total = variables.Variable( initial_value=array_ops.zeros((1, 1)), trainable=False) if not context.executing_eagerly(): - keras.backend.get_session().run(self.total.initializer) + backend.get_session().run(self.total.initializer) def call(self, inputs): self.total.assign_add(inputs) return self.total - inputs = keras.Input(shape=(1,)) - model = keras.Model(inputs, ComputeSum()(inputs)) + inputs = input_layer.Input(shape=(1,)) + model = training_lib.Model(inputs, ComputeSum()(inputs)) model.predict(np.ones((1, 1))) def _get_layer_with_training_arg(self): - class TrainingLayer(keras.layers.Layer): + class TrainingLayer(base_layer.Layer): """A layer with a `training` argument in a defuned `call`.""" @def_function.function def call(self, inputs, training=None): if training is None: - training = keras.backend.learning_phase() + training = backend.learning_phase() return tf_utils.smart_cond(training, lambda: array_ops.ones_like(inputs), lambda: array_ops.zeros_like(inputs)) return TrainingLayer() - @keras_parameterized.run_with_all_model_types # b/124459427: can't test with `run_eagerly=True` for now. - @test_util.run_in_graph_and_eager_modes + @combinations.generate( + combinations.times(combinations.keras_mode_combinations(), + combinations.keras_model_type_combinations())) def test_training_arg_in_defun(self): layer = self._get_layer_with_training_arg() model = testing_utils.get_model_from_layers([layer], input_shape=(1,)) @@ -383,20 +383,21 @@ class BaseLayerTest(keras_parameterized.TestCase): # Test that the argument injection performed in `call` is not active # when the argument is passed explicitly. layer = self._get_layer_with_training_arg() - inputs = keras.Input(shape=(1,)) + inputs = input_layer.Input(shape=(1,)) # Pass `training` by name outputs = layer(inputs, training=False) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile(rmsprop.RMSprop(0.), loss='mae') history = model.fit(np.zeros((1, 1)), np.zeros((1, 1))) self.assertEqual(history.history['loss'][0], 0.) - @keras_parameterized.run_with_all_model_types - @keras_parameterized.run_all_keras_modes + @combinations.generate( + combinations.times(combinations.keras_mode_combinations(), + combinations.keras_model_type_combinations())) def test_raw_variable_assignment(self): - class RawVariableLayer(keras.layers.Layer): + class RawVariableLayer(base_layer.Layer): def __init__(self, **kwargs): super(RawVariableLayer, self).__init__(**kwargs) @@ -416,15 +417,15 @@ class BaseLayerTest(keras_parameterized.TestCase): # Checks that variables get initialized. model.fit(x, y, batch_size=2, epochs=2) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_layer_names(self): - inputs = keras.layers.Input(shape=[2]) + inputs = input_layer.Input(shape=[2]) add1 = inputs + inputs - add2 = keras.layers.Add()([inputs, inputs]) + add2 = layers.Add()([inputs, inputs]) add3 = inputs + inputs - add4 = keras.layers.Add()([inputs, inputs]) - model = keras.models.Model( - inputs=[inputs], outputs=[add1, add2, add3, add4]) + add4 = layers.Add()([inputs, inputs]) + model = training_lib.Model(inputs=[inputs], + outputs=[add1, add2, add3, add4]) actual_names = [l.name for l in model.layers] graph_names = [ 'input_1', 'tf_op_layer_AddV2', 'add', 'tf_op_layer_AddV2_1', 'add_1' @@ -437,7 +438,7 @@ class BaseLayerTest(keras_parameterized.TestCase): def test_add_trainable_weight_on_frozen_layer(self): - class TestLayer(keras.layers.Layer): + class TestLayer(base_layer.Layer): def build(self, input_shape): self.w = self.add_weight(shape=(), trainable=True) @@ -451,12 +452,12 @@ class BaseLayerTest(keras_parameterized.TestCase): layer.trainable = True self.assertListEqual(layer.trainable_weights, [layer.w]) - @keras_parameterized.run_with_all_model_types - @keras_parameterized.run_all_keras_modes + @combinations.generate( + combinations.times(combinations.keras_mode_combinations(), + combinations.keras_model_type_combinations())) def test_passing_initial_weights_values(self): kernel_value = np.random.random((10, 2)) - layer_with_weights = keras.layers.Dense( - 2, use_bias=False, weights=[kernel_value]) + layer_with_weights = layers.Dense(2, use_bias=False, weights=[kernel_value]) model = testing_utils.get_model_from_layers([layer_with_weights], input_shape=(10,)) @@ -469,9 +470,9 @@ class BaseLayerTest(keras_parameterized.TestCase): self.assertAllClose(model.layers[-1].get_weights()[0], kernel_value) self.assertAllClose(out, np.dot(inputs, kernel_value)) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_set_weights_and_get_weights(self): - layer = keras.layers.Dense(2) + layer = layers.Dense(2) layer.build((None, 10)) kernel = np.random.random((10, 2)) bias = np.random.random((2,)) @@ -489,7 +490,7 @@ class BaseLayerTest(keras_parameterized.TestCase): def test_get_config_error(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def __init__(self, my_kwarg='default', **kwargs): super(MyLayer, self).__init__(**kwargs) @@ -500,7 +501,7 @@ class BaseLayerTest(keras_parameterized.TestCase): with self.assertRaisesRegexp(NotImplementedError, 'Layer MyLayer has'): MyLayer('custom').get_config() - class MyLayerNew(keras.layers.Layer): + class MyLayerNew(base_layer.Layer): def __init__(self, my_kwarg='default', **kwargs): super(MyLayerNew, self).__init__(**kwargs) @@ -515,7 +516,7 @@ class BaseLayerTest(keras_parameterized.TestCase): # from an overridden `get_config`: self.assertEqual(MyLayerNew('custom').get_config()['my_kwarg'], 'custom') - class MyLayerNew2(keras.layers.Layer): + class MyLayerNew2(base_layer.Layer): def __init__(self, name='MyLayerName', dtype=None, **kwargs): # pylint:disable=redefined-outer-name super(MyLayerNew2, self).__init__(name=name, dtype=dtype, **kwargs) @@ -524,27 +525,27 @@ class BaseLayerTest(keras_parameterized.TestCase): # arguments, no error is thrown: self.assertEqual(MyLayerNew2(name='New').get_config()['name'], 'New') - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_count_params(self): - dense = keras.layers.Dense(16) + dense = layers.Dense(16) dense.build((None, 4)) self.assertEqual(dense.count_params(), 16 * 4 + 16) - dense = keras.layers.Dense(16) + dense = layers.Dense(16) with self.assertRaisesRegexp(ValueError, 'call `count_params`'): dense.count_params() - model = keras.Sequential(keras.layers.Dense(16)) + model = sequential.Sequential(layers.Dense(16)) with self.assertRaisesRegexp(ValueError, 'call `count_params`'): model.count_params() - dense = keras.layers.Dense(16, input_dim=4) - model = keras.Sequential(dense) + dense = layers.Dense(16, input_dim=4) + model = sequential.Sequential(dense) self.assertEqual(model.count_params(), 16 * 4 + 16) def test_super_not_called(self): - class CustomLayerNotCallingSuper(keras.layers.Layer): + class CustomLayerNotCallingSuper(base_layer.Layer): def __init__(self): pass @@ -553,11 +554,11 @@ class BaseLayerTest(keras_parameterized.TestCase): with self.assertRaisesRegexp(RuntimeError, 'You must call `super()'): layer(np.random.random((10, 2))) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_first_arg_not_called_inputs(self): x, y = array_ops.ones((10, 1)), array_ops.ones((10, 1)) - class ArgLayer(keras.layers.Layer): + class ArgLayer(base_layer.Layer): def call(self, x, y): return x + y @@ -566,7 +567,7 @@ class BaseLayerTest(keras_parameterized.TestCase): out = self.evaluate(layer(x=x, y=y)) self.assertAllClose(out, 2 * np.ones((10, 1))) - class KwargLayer(keras.layers.Layer): + class KwargLayer(base_layer.Layer): def call(self, x=None, y=None): return x + y @@ -578,7 +579,7 @@ class BaseLayerTest(keras_parameterized.TestCase): with self.assertRaisesRegexp(ValueError, 'must always be passed'): layer(y=y) - class TFFunctionLayer(keras.layers.Layer): + class TFFunctionLayer(base_layer.Layer): @def_function.function def call(self, x, y=None): @@ -591,7 +592,8 @@ class BaseLayerTest(keras_parameterized.TestCase): self.assertAllClose(out, 2 * np.ones((10, 1))) def test_build_input_shape(self): - class CustomLayer(keras.layers.Layer): + + class CustomLayer(base_layer.Layer): def build(self, input_shape): self.add_weight('w', shape=input_shape[1:]) @@ -605,36 +607,36 @@ class BaseLayerTest(keras_parameterized.TestCase): self.assertEqual([None, 1, 2, 3], layer._build_input_shape) layer = CustomLayer() - layer(keras.Input((3,))) + layer(input_layer.Input((3,))) self.assertTrue(layer.built) self.assertEqual([None, 3], layer._build_input_shape.as_list()) -class SymbolicSupportTest(test.TestCase): +class SymbolicSupportTest(keras_parameterized.TestCase): def test_using_symbolic_tensors_with_tf_ops(self): # Single-input. - x = keras.Input((3,)) + x = input_layer.Input((3,)) y = math_ops.square(x) - self.assertEqual(y.graph, keras.backend.get_graph()) + self.assertEqual(y.graph, backend.get_graph()) # Multi-inputs. - x1, x2 = keras.Input((3,)), keras.Input((3,)) + x1, x2 = input_layer.Input((3,)), input_layer.Input((3,)) y = array_ops.concat([x1, x2], axis=1) - self.assertEqual(y.graph, keras.backend.get_graph()) + self.assertEqual(y.graph, backend.get_graph()) # Mixing Keras symbolic tensors and graph tensors from the same graph works. - with keras.backend.get_graph().as_default(): - x1 = keras.Input((3,)) - x2 = keras.Input((3,)) + with backend.get_graph().as_default(): + x1 = input_layer.Input((3,)) + x2 = input_layer.Input((3,)) y = math_ops.matmul(x1, x2) - self.assertEqual(y.graph, keras.backend.get_graph()) + self.assertEqual(y.graph, backend.get_graph()) # Creating same op type (matmul) multiple times in the Keras graph works. - x1 = keras.Input((3,)) - x2 = keras.Input((3,)) + x1 = input_layer.Input((3,)) + x2 = input_layer.Input((3,)) y = math_ops.matmul(x1, x2) - self.assertEqual(y.graph, keras.backend.get_graph()) + self.assertEqual(y.graph, backend.get_graph()) def test_mixing_eager_and_graph_tensors(self): with ops.Graph().as_default(): @@ -651,33 +653,33 @@ class SymbolicSupportTest(test.TestCase): with self.assertRaisesRegexp(TypeError, 'Graph tensors'): math_ops.matmul(x1, x2) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_mixing_keras_symbolic_tensors_and_eager_tensors(self): - x1 = keras.Input((3,)) + x1 = input_layer.Input((3,)) x2 = array_ops.ones((3, 3)) y = math_ops.matmul(x1, x2) - self.assertEqual(y.graph, keras.backend.get_graph()) - fn = keras.backend.function(inputs=[x1], outputs=[y]) + self.assertEqual(y.graph, backend.get_graph()) + fn = backend.function(inputs=[x1], outputs=[y]) x_val = np.random.random((3, 3)) y_val = np.ones((3, 3)) self.assertAllClose(fn([x_val])[0], np.matmul(x_val, y_val), atol=1e-5) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_mixing_keras_symbolic_tensors_and_numpy_arrays(self): - x1 = keras.Input((3,)) + x1 = input_layer.Input((3,)) x2 = np.ones((3, 3), dtype='float32') y = math_ops.matmul(x1, x2) - self.assertEqual(y.graph, keras.backend.get_graph()) - fn = keras.backend.function(inputs=[x1], outputs=[y]) + self.assertEqual(y.graph, backend.get_graph()) + fn = backend.function(inputs=[x1], outputs=[y]) x_val = np.random.random((3, 3)) y_val = np.ones((3, 3)) self.assertAllClose(fn([x_val])[0], np.matmul(x_val, y_val), atol=1e-5) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_reraising_exception(self): # When layer is not dynamic, we have some pattern matching during exception # handling to detect when the user is trying to use python control flow. @@ -692,7 +694,7 @@ class SymbolicSupportTest(test.TestCase): raise TypeError('Non-matching TypeError message.') easily_identifiable_name() - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) try: _ = TypeErrorLayer()(inputs) @@ -707,12 +709,12 @@ class SymbolicSupportTest(test.TestCase): function_name = last_entry[2] self.assertEqual(function_name, 'easily_identifiable_name') - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_summaries_in_tf_function(self): if not context.executing_eagerly(): return - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def call(self, inputs): summary_ops_v2.scalar('mean', math_ops.reduce_mean(inputs)) @@ -739,19 +741,19 @@ class SymbolicSupportTest(test.TestCase): self.assertEqual(set(['my_layer/mean']), tags) -@test_util.run_all_in_graph_and_eager_modes +@combinations.generate(combinations.combine(mode=['graph', 'eager'])) class NestedTrackingTest(test.TestCase): def test_nested_layer_variable_tracking(self): # Test that variables from nested sublayers are # being tracked by subclassed layers. - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def __init__(self): super(MyLayer, self).__init__() - self.dense1 = keras.layers.Dense(1) - self.dense2 = keras.layers.BatchNormalization() + self.dense1 = layers.Dense(1) + self.dense2 = layers.BatchNormalization() def build(self, input_shape): self.v1 = self.add_weight('v1', shape=input_shape[1:].as_list()) @@ -765,7 +767,7 @@ class NestedTrackingTest(test.TestCase): return x + self.v1 + self.v2 layer = MyLayer() - inputs = keras.Input((1,)) + inputs = input_layer.Input((1,)) _ = layer(inputs) self.assertEqual(len(layer.weights), 8) @@ -789,7 +791,7 @@ class NestedTrackingTest(test.TestCase): # Test that updates and losses from nested sublayers are # being tracked by subclassed layers. - class UpdateAndLossLayer(keras.layers.Layer): + class UpdateAndLossLayer(base_layer.Layer): def build(self, _): self.v1 = self.add_weight('v1', shape=()) @@ -799,7 +801,7 @@ class NestedTrackingTest(test.TestCase): self.add_update(state_ops.assign_add(self.v1, 1)) return inputs + 1 - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def build(self, _): self.v1 = self.add_weight('v1', shape=()) @@ -823,23 +825,23 @@ class NestedTrackingTest(test.TestCase): self.assertEqual(len(layer.losses), 3) self.assertLen(layer.get_losses_for(None), 3) else: - inputs = keras.Input((1,)) + inputs = input_layer.Input((1,)) _ = layer(inputs) self.assertEqual(len(layer.losses), 3) self.assertEqual(len(layer.updates), 3) self.assertLen(layer.get_losses_for(None), 3) def test_attribute_reassignment(self): - l = keras.layers.Layer() - l.a = keras.layers.Layer() + l = base_layer.Layer() + l.a = base_layer.Layer() l.a = [] l.a = variables.Variable(1.) - l.a = keras.layers.Layer() - last_assignment = keras.layers.Layer() + l.a = base_layer.Layer() + last_assignment = base_layer.Layer() l.a = last_assignment l.b = variables.Variable(1.) del l.b - l.c = keras.layers.Layer() + l.c = base_layer.Layer() del l.c l.d = last_assignment del l.d @@ -852,7 +854,7 @@ class NestedTrackingTest(test.TestCase): def test_assign_op_not_tracked_as_variable(self): - class LayerWithAssignAttr(keras.layers.Layer): + class LayerWithAssignAttr(base_layer.Layer): def build(self, input_shape): self.v = variables.Variable(1.) @@ -866,11 +868,11 @@ class NestedTrackingTest(test.TestCase): def test_layer_class_not_tracked_as_sublayer(self): # See https://github.com/tensorflow/tensorflow/issues/27431 for details. - class LayerWithClassAttribute(keras.layers.Layer): + class LayerWithClassAttribute(base_layer.Layer): def __init__(self): super(LayerWithClassAttribute, self).__init__() - self.layer_fn = keras.layers.Dense + self.layer_fn = layers.Dense layer = LayerWithClassAttribute() self.assertEmpty(layer.variables) @@ -878,12 +880,12 @@ class NestedTrackingTest(test.TestCase): def test_layer_call_fn_args(self): - class NonDefunLayer(keras.layers.Layer): + class NonDefunLayer(base_layer.Layer): def call(self, inputs, a, mask, b=None, training=None): return inputs - class DefunLayer(keras.layers.Layer): + class DefunLayer(base_layer.Layer): @def_function.function def call(self, x, mask, a, training=None, b=None): @@ -897,18 +899,18 @@ class NestedTrackingTest(test.TestCase): ['x', 'mask', 'a', 'training', 'b']) def test_sequential_model(self): - model = keras.Sequential([keras.layers.Dense(10, input_shape=(10,)), - keras.layers.Dense(5)]) + model = sequential.Sequential( + [layers.Dense(10, input_shape=(10,)), + layers.Dense(5)]) self.assertLen(model.layers, 2) self.assertLen(model.weights, 4) # Make sure a subclass model also works when it is called 'Sequential'. - class Sequential(keras.Model): + class Sequential(training_lib.Model): def __init__(self): super(Sequential, self).__init__() - self.dense_layers = [keras.layers.Dense(10), - keras.layers.Dense(5)] + self.dense_layers = [layers.Dense(10), layers.Dense(5)] def call(self, inputs): x = inputs @@ -920,31 +922,31 @@ class NestedTrackingTest(test.TestCase): self.assertLen(s.layers, 2) self.assertLen(s.weights, 0) - s(keras.Input((10,))) + s(input_layer.Input((10,))) self.assertLen(s.weights, 4) -@test_util.run_all_in_graph_and_eager_modes +@combinations.generate(combinations.combine(mode=['graph', 'eager'])) class NameScopingTest(keras_parameterized.TestCase): def test_name_scope_layer(self): - x = keras.backend.placeholder(shape=(10, 10)) - layer = keras.layers.Dense(10, name='MyName') + x = backend.placeholder(shape=(10, 10)) + layer = layers.Dense(10, name='MyName') layer(x) self.assertEqual(layer.bias.name, 'MyName/bias:0') self.assertEqual(layer.kernel.name, 'MyName/kernel:0') def test_name_scope_sublayer(self): - class NameScopeTracker(keras.layers.Layer): + class NameScopeTracker(base_layer.Layer): def call(self, inputs): self.active_name_scope = ops.get_name_scope() return inputs - x = keras.backend.placeholder(shape=(10, 10)) + x = backend.placeholder(shape=(10, 10)) sublayer = NameScopeTracker(name='Sublayer') - layer = keras.layers.Dense(10, activation=sublayer, name='MyName2') + layer = layers.Dense(10, activation=sublayer, name='MyName2') layer(x) self.assertEqual(layer.bias.name, 'MyName2/bias:0') self.assertEqual(layer.kernel.name, 'MyName2/kernel:0') @@ -952,21 +954,21 @@ class NameScopingTest(keras_parameterized.TestCase): def test_name_scope_tf_tensor(self): x = ops.convert_to_tensor_v2(np.ones((10, 10))) - layer = keras.layers.Dense( - 10, activation=keras.layers.ReLU(name='MyAct'), name='MyName3') + layer = layers.Dense( + 10, activation=layers.ReLU(name='MyAct'), name='MyName3') layer(x) self.assertEqual(layer.bias.name, 'MyName3/bias:0') self.assertEqual(layer.kernel.name, 'MyName3/kernel:0') -@keras_parameterized.run_all_keras_modes(always_skip_v1=True) +@combinations.generate(combinations.keras_mode_combinations(mode=['eager'])) class AutographControlFlowTest(keras_parameterized.TestCase): def test_disabling_in_context_is_matched(self): test_obj = self - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def call(self, inputs, training=None): with test_obj.assertRaisesRegex(TypeError, 'Tensor.*as.*bool'): @@ -982,16 +984,16 @@ class AutographControlFlowTest(keras_parameterized.TestCase): def test_if_training_pattern_output(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def call(self, inputs, training=None): if training: return inputs * 1. return inputs * 0. - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) outputs = MyLayer()(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile( 'sgd', 'mse', @@ -1003,7 +1005,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase): def test_if_training_pattern_loss(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def call(self, inputs, training=None): if training: @@ -1013,9 +1015,9 @@ class AutographControlFlowTest(keras_parameterized.TestCase): self.add_loss(loss) return inputs - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) outputs = MyLayer()(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile( 'sgd', 'mse', @@ -1027,7 +1029,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase): def test_if_training_pattern_metric(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def call(self, inputs, training=None): if training: @@ -1037,9 +1039,9 @@ class AutographControlFlowTest(keras_parameterized.TestCase): self.add_metric(metric, name='my_metric', aggregation='mean') return inputs - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) outputs = MyLayer()(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile( 'sgd', 'mse', @@ -1055,7 +1057,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase): def test_if_training_pattern_update(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def build(self, input_shape): self.counter = self.add_weight( @@ -1069,20 +1071,20 @@ class AutographControlFlowTest(keras_parameterized.TestCase): self.counter.assign_add(increment) return inputs - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) layer = MyLayer() outputs = layer(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile( 'sgd', 'mse', run_eagerly=testing_utils.should_run_eagerly()) model.train_on_batch(np.ones((2, 3)), np.ones((2, 3))) - self.assertEqual(keras.backend.get_value(layer.counter), 1.) + self.assertEqual(backend.get_value(layer.counter), 1.) def test_conditional_updates_in_call(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def __init__(self): super(MyLayer, @@ -1102,27 +1104,27 @@ class AutographControlFlowTest(keras_parameterized.TestCase): return input_shape if testing_utils.should_run_eagerly(): - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) layer = MyLayer() outputs = layer(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile( 'sgd', 'mse', run_eagerly=testing_utils.should_run_eagerly()) model.train_on_batch(np.ones((2, 3)), np.ones((2, 3))) - self.assertEqual(keras.backend.get_value(layer.counter), 6.) + self.assertEqual(backend.get_value(layer.counter), 6.) else: # TODO(fchollet): support the same workflow in graph mode. with self.assertRaisesRegexp(RuntimeError, '`add_update` in a control flow branch'): layer = MyLayer() - layer(keras.Input((3,))) + layer(input_layer.Input((3,))) _ = layer.updates def test_conditional_losses_in_call(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def __init__(self): super(MyLayer, @@ -1137,10 +1139,10 @@ class AutographControlFlowTest(keras_parameterized.TestCase): return input_shape if testing_utils.should_run_eagerly(): - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) layer = MyLayer() outputs = layer(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile( 'sgd', 'mse', @@ -1150,12 +1152,12 @@ class AutographControlFlowTest(keras_parameterized.TestCase): else: with self.assertRaisesRegexp(RuntimeError, '`add_loss` in a control flow branch'): - layer = MyLayer()(keras.Input((3,))) + layer = MyLayer()(input_layer.Input((3,))) def test_conditional_callable_losses(self): - model = keras.Sequential([ - keras.layers.Dense( - 1, kernel_regularizer=keras.regularizers.l2(1e-4), input_shape=(1,)) + model = sequential.Sequential([ + layers.Dense( + 1, kernel_regularizer=regularizers.l2(1e-4), input_shape=(1,)) ]) model._run_eagerly = testing_utils.should_run_eagerly() @@ -1175,7 +1177,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase): def test_conditional_metrics_in_call(self): - class MyLayer(keras.layers.Layer): + class MyLayer(base_layer.Layer): def __init__(self): super(MyLayer, @@ -1192,10 +1194,10 @@ class AutographControlFlowTest(keras_parameterized.TestCase): return input_shape if testing_utils.should_run_eagerly(): - inputs = keras.Input((3,)) + inputs = input_layer.Input((3,)) layer = MyLayer() outputs = layer(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) model.compile( 'sgd', 'mse', @@ -1206,16 +1208,16 @@ class AutographControlFlowTest(keras_parameterized.TestCase): # TODO(fchollet): support the same workflow in graph mode. with self.assertRaisesRegexp(RuntimeError, '`add_metric` in a control flow branch'): - layer = MyLayer()(keras.Input((3,))) + layer = MyLayer()(input_layer.Input((3,))) def test_conditional_activity_regularizer_in_call(self): - class TestModel(keras.Model): + class TestModel(training_lib.Model): def __init__(self): super(TestModel, self).__init__( name='test_model', dynamic=testing_utils.should_run_eagerly()) - self.layer = keras.layers.Dense(2, activity_regularizer='l2') + self.layer = layers.Dense(2, activity_regularizer='l2') def call(self, x, training=None): if math_ops.greater(math_ops.reduce_sum(x), 0.0): @@ -1241,14 +1243,13 @@ class AutographControlFlowTest(keras_parameterized.TestCase): def test_conditional_activity_regularizer_with_wrappers_in_call(self): - class TestModel(keras.Model): + class TestModel(training_lib.Model): def __init__(self): super(TestModel, self).__init__( name='test_model', dynamic=testing_utils.should_run_eagerly()) - self.layer = keras.layers.TimeDistributed( - keras.layers.Dense(2, activity_regularizer='l2'), - input_shape=(3, 4)) + self.layer = layers.TimeDistributed( + layers.Dense(2, activity_regularizer='l2'), input_shape=(3, 4)) def call(self, x, training=None): if math_ops.greater(math_ops.reduce_sum(x), 0.0): @@ -1273,7 +1274,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase): model.fit(x, y, epochs=2, batch_size=5) -class AddLayer(keras.layers.Layer): +class AddLayer(base_layer.Layer): """A layer which adds its input to a variable. Useful for testing a layer with a variable @@ -1287,7 +1288,7 @@ class AddLayer(keras.layers.Layer): return inputs + self.v -class IdentityLayer(keras.layers.Layer): +class IdentityLayer(base_layer.Layer): """A layer that returns its input. Useful for testing a layer without a variable. @@ -1297,7 +1298,7 @@ class IdentityLayer(keras.layers.Layer): return inputs -@test_util.run_all_in_graph_and_eager_modes +@combinations.generate(combinations.combine(mode=['graph', 'eager'])) class DTypeTest(keras_parameterized.TestCase): # This class only have tests relating to layer.dtype. Tests for dtype policies @@ -1365,7 +1366,7 @@ class DTypeTest(keras_parameterized.TestCase): @testing_utils.enable_v2_dtype_behavior def multiple_inputs_cast_to_dtype(self): - class MultiIdentityLayer(keras.layers.Layer): + class MultiIdentityLayer(base_layer.Layer): def call(self, inputs): return [array_ops.identity(x) for x in inputs] @@ -1394,7 +1395,7 @@ class DTypeTest(keras_parameterized.TestCase): @testing_utils.enable_v2_dtype_behavior def test_extra_args_and_kwargs_not_casted(self): - class IdentityLayerWithArgs(keras.layers.Layer): + class IdentityLayerWithArgs(base_layer.Layer): def call(self, inputs, *args, **kwargs): return nest.flatten([inputs, args, kwargs]) @@ -1495,9 +1496,10 @@ class DTypeTest(keras_parameterized.TestCase): ragged = ragged_tensor.RaggedTensor.from_row_splits( values=array_ops.constant([1., 2., 3.], dtype='float32'), row_splits=array_ops.constant([0, 2, 2, 3], dtype='int64')) - model = keras.Sequential([ - keras.layers.InputLayer(input_shape=(None,), ragged=True), - IdentityLayer()]) + model = sequential.Sequential([ + input_layer.InputLayer(input_shape=(None,), ragged=True), + IdentityLayer() + ]) model.compile(rmsprop.RMSprop(0.001), loss='mse') model.train_on_batch(ragged) diff --git a/tensorflow/python/keras/engine/base_layer_utils_test.py b/tensorflow/python/keras/engine/base_layer_utils_test.py index 8bb1d39b4c9..21f539d89c5 100644 --- a/tensorflow/python/keras/engine/base_layer_utils_test.py +++ b/tensorflow/python/keras/engine/base_layer_utils_test.py @@ -1,13 +1,13 @@ # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # -# Licensed under the Apache License, Version 2.0 (the "License"); +# Licensed under the Apache License, Version 2.0 (the 'License'); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, +# distributed under the License is distributed on an 'AS IS' BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. @@ -17,15 +17,15 @@ from __future__ import division from __future__ import print_function from tensorflow.python.framework import dtypes -from tensorflow.python.framework import test_util from tensorflow.python.keras import backend +from tensorflow.python.keras import combinations from tensorflow.python.keras import keras_parameterized from tensorflow.python.keras.engine import base_layer_utils from tensorflow.python.ops import lookup_ops from tensorflow.python.platform import test -@test_util.run_all_in_graph_and_eager_modes +@combinations.generate(combinations.combine(mode=['graph', 'eager'])) class TrackableWeightHandlerTest(keras_parameterized.TestCase): def get_table_handler(self): @@ -44,7 +44,7 @@ class TrackableWeightHandlerTest(keras_parameterized.TestCase): def test_get_and_set_weights(self): table_handler = self.get_table_handler() - table_data = {b"a": 1, b"b": 2, b"c": 3} + table_data = {b'a': 1, b'b': 2, b'c': 3} table_handler.set_weights( [list(table_data.keys()), list(table_data.values())]) @@ -54,7 +54,7 @@ class TrackableWeightHandlerTest(keras_parameterized.TestCase): def test_get_and_set_weights_does_not_add_ops(self): table_handler = self.get_table_handler() - table_data = {b"a": 1, b"b": 2, b"c": 3} + table_data = {b'a': 1, b'b': 2, b'c': 3} table_handler.set_weights( [list(table_data.keys()), list(table_data.values())]) @@ -66,5 +66,5 @@ class TrackableWeightHandlerTest(keras_parameterized.TestCase): _ = backend.batch_get_value(table_handler.get_tensors()) -if __name__ == "__main__": +if __name__ == '__main__': test.main() diff --git a/tensorflow/python/keras/engine/network_test.py b/tensorflow/python/keras/engine/network_test.py index 5aa7d6ae16e..46f4d951407 100644 --- a/tensorflow/python/keras/engine/network_test.py +++ b/tensorflow/python/keras/engine/network_test.py @@ -20,20 +20,25 @@ from __future__ import print_function import numpy as np -from tensorflow.python import keras from tensorflow.python.eager import context from tensorflow.python.framework import constant_op from tensorflow.python.framework import dtypes from tensorflow.python.framework import ops from tensorflow.python.framework import tensor_shape -from tensorflow.python.framework import test_util +from tensorflow.python.keras import backend +from tensorflow.python.keras import combinations +from tensorflow.python.keras import initializers from tensorflow.python.keras import keras_parameterized +from tensorflow.python.keras import layers +from tensorflow.python.keras import models from tensorflow.python.keras import testing_utils from tensorflow.python.keras.engine import base_layer from tensorflow.python.keras.engine import input_layer as input_layer_lib from tensorflow.python.keras.engine import network as network_lib +from tensorflow.python.keras.engine import sequential from tensorflow.python.keras.engine import training as training_lib from tensorflow.python.keras.utils import layer_utils +from tensorflow.python.keras.utils import tf_utils from tensorflow.python.ops import array_ops from tensorflow.python.ops import math_ops from tensorflow.python.ops import state_ops @@ -51,7 +56,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): def test_get_updates(self): - class MyLayer(keras.layers.Layer): + class MyLayer(layers.Layer): def build(self, input_shape): self.a = self.add_variable('a', @@ -113,24 +118,24 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual(len(network.updates), 7) self.assertEqual(len(network.get_updates_for(x4)), 2) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_get_updates_bn(self): x1 = input_layer_lib.Input(shape=(1,)) - layer = keras.layers.BatchNormalization() + layer = layers.BatchNormalization() _ = layer(x1) self.assertEqual(len(layer.updates), 2) self.assertEqual(len(layer.get_updates_for(x1)), 2) self.assertEqual(len(layer.get_updates_for(None)), 0) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testTopologicalAttributes(self): # test layer attributes / methods related to cross-layer connectivity. a = input_layer_lib.Input(shape=(32,), name='input_a') b = input_layer_lib.Input(shape=(32,), name='input_b') # test input, output, input_shape, output_shape - test_layer = keras.layers.Dense(16, name='test_layer') + test_layer = layers.Dense(16, name='test_layer') a_test = test_layer(a) self.assertIs(test_layer.input, a) self.assertIs(test_layer.output, a_test) @@ -138,7 +143,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual(test_layer.output_shape, (None, 16)) # test `get_*_at` methods - dense = keras.layers.Dense(16, name='dense_1') + dense = layers.Dense(16, name='dense_1') a_2 = dense(a) b_2 = dense(b) @@ -155,26 +160,26 @@ class NetworkConstructionTest(keras_parameterized.TestCase): with self.assertRaises(ValueError): dense.get_input_at(2) with self.assertRaises(AttributeError): - new_dense = keras.layers.Dense(16) + new_dense = layers.Dense(16) _ = new_dense.input with self.assertRaises(AttributeError): - new_dense = keras.layers.Dense(16) + new_dense = layers.Dense(16) _ = new_dense.output with self.assertRaises(AttributeError): - new_dense = keras.layers.Dense(16) + new_dense = layers.Dense(16) _ = new_dense.output_shape with self.assertRaises(AttributeError): - new_dense = keras.layers.Dense(16) + new_dense = layers.Dense(16) _ = new_dense.input_shape with self.assertRaises(AttributeError): - new_dense = keras.layers.Dense(16) + new_dense = layers.Dense(16) a = input_layer_lib.Input(shape=(3, 32)) a = input_layer_lib.Input(shape=(5, 32)) a_2 = dense(a) b_2 = dense(b) _ = new_dense.input_shape with self.assertRaises(AttributeError): - new_dense = keras.layers.Dense(16) + new_dense = layers.Dense(16) a = input_layer_lib.Input(shape=(3, 32)) a = input_layer_lib.Input(shape=(5, 32)) a_2 = dense(a) @@ -184,10 +189,10 @@ class NetworkConstructionTest(keras_parameterized.TestCase): def _assertAllIs(self, a, b): self.assertTrue(all(x is y for x, y in zip(a, b))) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testTopologicalAttributesMultiOutputLayer(self): - class PowersLayer(keras.layers.Layer): + class PowersLayer(layers.Layer): def call(self, inputs): return [inputs**2, inputs**3] @@ -201,10 +206,10 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual(test_layer.input_shape, (None, 32)) self.assertEqual(test_layer.output_shape, [(None, 32), (None, 32)]) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testTopologicalAttributesMultiInputLayer(self): - class AddLayer(keras.layers.Layer): + class AddLayer(layers.Layer): def call(self, inputs): assert len(inputs) == 2 @@ -224,7 +229,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): with ops.Graph().as_default(): # minimum viable network x = input_layer_lib.Input(shape=(32,)) - dense = keras.layers.Dense(2) + dense = layers.Dense(2) y = dense(x) network = network_lib.Network(x, y, name='dense_network') @@ -254,11 +259,11 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self._assertAllIs(network.non_trainable_weights, dense.trainable_weights + dense.non_trainable_weights) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_trainable_weights(self): - a = keras.layers.Input(shape=(2,)) - b = keras.layers.Dense(1)(a) - model = keras.models.Model(a, b) + a = layers.Input(shape=(2,)) + b = layers.Dense(1)(a) + model = training_lib.Model(a, b) weights = model.weights self._assertAllIs(model.trainable_weights, weights) @@ -277,8 +282,8 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self._assertAllIs(model.non_trainable_weights, weights) # sequential model - model = keras.models.Sequential() - model.add(keras.layers.Dense(1, input_dim=2)) + model = sequential.Sequential() + model.add(layers.Dense(1, input_dim=2)) weights = model.weights self._assertAllIs(model.trainable_weights, weights) @@ -299,32 +304,32 @@ class NetworkConstructionTest(keras_parameterized.TestCase): def test_layer_call_arguments(self): with ops.Graph().as_default(): # Test the ability to pass and serialize arguments to `call`. - inp = keras.layers.Input(shape=(2,)) - x = keras.layers.Dense(3)(inp) - x = keras.layers.Dropout(0.5)(x, training=True) - model = keras.models.Model(inp, x) + inp = layers.Input(shape=(2,)) + x = layers.Dense(3)(inp) + x = layers.Dropout(0.5)(x, training=True) + model = training_lib.Model(inp, x) # Would be `dropout/cond/Merge` by default self.assertIn('dropout', model.output.op.name) # Test that argument is kept when applying the model - inp2 = keras.layers.Input(shape=(2,)) + inp2 = layers.Input(shape=(2,)) out2 = model(inp2) self.assertIn('dropout', out2.op.name) # Test that argument is kept after loading a model config = model.get_config() - model = keras.models.Model.from_config(config) + model = training_lib.Model.from_config(config) self.assertIn('dropout', model.output.op.name) def test_node_construction(self): # test basics - a = keras.layers.Input(shape=(32,), name='input_a') - b = keras.layers.Input(shape=(32,), name='input_b') + a = layers.Input(shape=(32,), name='input_a') + b = layers.Input(shape=(32,), name='input_b') with self.assertRaises(ValueError): - _ = keras.layers.Input(shape=(32,), batch_shape=(10, 32)) + _ = layers.Input(shape=(32,), batch_shape=(10, 32)) with self.assertRaises(ValueError): - _ = keras.layers.Input(shape=(32,), unknown_kwarg=None) + _ = layers.Input(shape=(32,), unknown_kwarg=None) self.assertListEqual(a.shape.as_list(), [None, 32]) a_layer, a_node_index, a_tensor_index = a._keras_history @@ -340,7 +345,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertListEqual(node.output_tensors, [a]) self.assertListEqual(node.output_shapes, [(None, 32)]) - dense = keras.layers.Dense(16, name='dense_1') + dense = layers.Dense(16, name='dense_1') a_2 = dense(a) b_2 = dense(b) @@ -354,7 +359,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertIs(dense._inbound_nodes[1].input_tensors, b) # test layer properties - test_layer = keras.layers.Dense(16, name='test_layer') + test_layer = layers.Dense(16, name='test_layer') a_test = test_layer(a) self.assertListEqual(test_layer.kernel.shape.as_list(), [32, 16]) self.assertIs(test_layer.input, a) @@ -375,18 +380,18 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual(dense.get_output_mask_at(0), None) self.assertEqual(dense.get_output_mask_at(1), None) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_multi_input_layer(self): with self.cached_session(): # test multi-input layer - a = keras.layers.Input(shape=(32,), name='input_a') - b = keras.layers.Input(shape=(32,), name='input_b') + a = layers.Input(shape=(32,), name='input_a') + b = layers.Input(shape=(32,), name='input_b') - dense = keras.layers.Dense(16, name='dense_1') + dense = layers.Dense(16, name='dense_1') a_2 = dense(a) b_2 = dense(b) - merged = keras.layers.concatenate([a_2, b_2], name='merge') + merged = layers.concatenate([a_2, b_2], name='merge') self.assertListEqual(merged.shape.as_list(), [None, 16 * 2]) merge_layer, merge_node_index, merge_tensor_index = merged._keras_history @@ -399,10 +404,10 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual(len(merge_layer._inbound_nodes[0].input_tensors), 2) self.assertEqual(len(merge_layer._inbound_nodes[0].inbound_layers), 2) - c = keras.layers.Dense(64, name='dense_2')(merged) - d = keras.layers.Dense(5, name='dense_3')(c) + c = layers.Dense(64, name='dense_2')(merged) + d = layers.Dense(5, name='dense_3')(c) - model = keras.models.Model(inputs=[a, b], outputs=[c, d], name='model') + model = training_lib.Model(inputs=[a, b], outputs=[c, d], name='model') self.assertEqual(len(model.layers), 6) output_shapes = model.compute_output_shape([(None, 32), (None, 32)]) self.assertListEqual(output_shapes[0].as_list(), [None, 64]) @@ -420,7 +425,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): ['dense_2', 'dense_3']) # actually run model - fn = keras.backend.function(model.inputs, model.outputs) + fn = backend.function(model.inputs, model.outputs) input_a_np = np.random.random((10, 32)) input_b_np = np.random.random((10, 32)) fn_outputs = fn([input_a_np, input_b_np]) @@ -431,7 +436,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # serialization / deserialization json_config = model.to_json() - recreated_model = keras.models.model_from_json(json_config) + recreated_model = models.model_from_json(json_config) recreated_model.compile('rmsprop', 'mse') self.assertListEqual([l.name for l in recreated_model.layers][2:], @@ -441,42 +446,41 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertListEqual([l.name for l in recreated_model._output_layers], ['dense_2', 'dense_3']) - fn = keras.backend.function(recreated_model.inputs, - recreated_model.outputs) + fn = backend.function(recreated_model.inputs, recreated_model.outputs) input_a_np = np.random.random((10, 32)) input_b_np = np.random.random((10, 32)) fn_outputs = fn([input_a_np, input_b_np]) self.assertListEqual([x.shape for x in fn_outputs], [(10, 64), (10, 5)]) def test_multi_output_layer_output_names(self): - inp = keras.layers.Input(name='inp', shape=(None,), dtype=dtypes.float32) + inp = layers.Input(name='inp', shape=(None,), dtype=dtypes.float32) - class _MultiOutput(keras.layers.Layer): + class _MultiOutput(layers.Layer): def call(self, x): return x + 1., x + 2. out = _MultiOutput(name='out')(inp) - model = keras.models.Model(inp, out) + model = training_lib.Model(inp, out) self.assertEqual(['out', 'out_1'], model.output_names) self.assertAllClose([2., 3.], model(1.)) def test_recursion(self): with ops.Graph().as_default(), self.cached_session(): - a = keras.layers.Input(shape=(32,), name='input_a') - b = keras.layers.Input(shape=(32,), name='input_b') + a = layers.Input(shape=(32,), name='input_a') + b = layers.Input(shape=(32,), name='input_b') - dense = keras.layers.Dense(16, name='dense_1') + dense = layers.Dense(16, name='dense_1') a_2 = dense(a) b_2 = dense(b) - merged = keras.layers.concatenate([a_2, b_2], name='merge') - c = keras.layers.Dense(64, name='dense_2')(merged) - d = keras.layers.Dense(5, name='dense_3')(c) + merged = layers.concatenate([a_2, b_2], name='merge') + c = layers.Dense(64, name='dense_2')(merged) + d = layers.Dense(5, name='dense_3')(c) - model = keras.models.Model(inputs=[a, b], outputs=[c, d], name='model') + model = training_lib.Model(inputs=[a, b], outputs=[c, d], name='model') - e = keras.layers.Input(shape=(32,), name='input_e') - f = keras.layers.Input(shape=(32,), name='input_f') + e = layers.Input(shape=(32,), name='input_e') + f = layers.Input(shape=(32,), name='input_f') self.assertEqual(len(model.inputs), 2) g, h = model([e, f]) self.assertEqual(len(model.inputs), 2) @@ -486,9 +490,9 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertListEqual(h.shape.as_list(), d.shape.as_list()) # test separate manipulation of different layer outputs - i = keras.layers.Dense(7, name='dense_4')(h) + i = layers.Dense(7, name='dense_4')(h) - final_model = keras.models.Model( + final_model = training_lib.Model( inputs=[e, f], outputs=[i, g], name='final') self.assertEqual(len(final_model.inputs), 2) self.assertEqual(len(final_model.outputs), 2) @@ -505,7 +509,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): (10, 64)]) # run recursive model - fn = keras.backend.function(final_model.inputs, final_model.outputs) + fn = backend.function(final_model.inputs, final_model.outputs) input_a_np = np.random.random((10, 32)) input_b_np = np.random.random((10, 32)) fn_outputs = fn([input_a_np, input_b_np]) @@ -513,48 +517,47 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # test serialization model_config = final_model.get_config() - recreated_model = keras.models.Model.from_config(model_config) + recreated_model = models.Model.from_config(model_config) - fn = keras.backend.function(recreated_model.inputs, - recreated_model.outputs) + fn = backend.function(recreated_model.inputs, recreated_model.outputs) input_a_np = np.random.random((10, 32)) input_b_np = np.random.random((10, 32)) fn_outputs = fn([input_a_np, input_b_np]) self.assertListEqual([x.shape for x in fn_outputs], [(10, 7), (10, 64)]) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_multi_input_multi_output_recursion(self): with self.cached_session(): # test multi-input multi-output - a = keras.layers.Input(shape=(32,), name='input_a') - b = keras.layers.Input(shape=(32,), name='input_b') + a = layers.Input(shape=(32,), name='input_a') + b = layers.Input(shape=(32,), name='input_b') - dense = keras.layers.Dense(16, name='dense_1') + dense = layers.Dense(16, name='dense_1') a_2 = dense(a) b_2 = dense(b) - merged = keras.layers.concatenate([a_2, b_2], name='merge') - c = keras.layers.Dense(64, name='dense_2')(merged) - d = keras.layers.Dense(5, name='dense_3')(c) + merged = layers.concatenate([a_2, b_2], name='merge') + c = layers.Dense(64, name='dense_2')(merged) + d = layers.Dense(5, name='dense_3')(c) - model = keras.models.Model(inputs=[a, b], outputs=[c, d], name='model') + model = training_lib.Model(inputs=[a, b], outputs=[c, d], name='model') - j = keras.layers.Input(shape=(32,), name='input_j') - k = keras.layers.Input(shape=(32,), name='input_k') + j = layers.Input(shape=(32,), name='input_j') + k = layers.Input(shape=(32,), name='input_k') _, n = model([j, k]) - o = keras.layers.Input(shape=(32,), name='input_o') - p = keras.layers.Input(shape=(32,), name='input_p') + o = layers.Input(shape=(32,), name='input_o') + p = layers.Input(shape=(32,), name='input_p') q, _ = model([o, p]) self.assertListEqual(n.shape.as_list(), [None, 5]) self.assertListEqual(q.shape.as_list(), [None, 64]) - s = keras.layers.concatenate([n, q], name='merge_nq') + s = layers.concatenate([n, q], name='merge_nq') self.assertListEqual(s.shape.as_list(), [None, 64 + 5]) # test with single output as 1-elem list - multi_io_model = keras.models.Model([j, k, o, p], [s]) + multi_io_model = training_lib.Model([j, k, o, p], [s]) - fn = keras.backend.function(multi_io_model.inputs, multi_io_model.outputs) + fn = backend.function(multi_io_model.inputs, multi_io_model.outputs) fn_outputs = fn([ np.random.random((10, 32)), np.random.random((10, 32)), np.random.random((10, 32)), np.random.random((10, 32)) @@ -562,9 +565,9 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertListEqual([x.shape for x in fn_outputs], [(10, 69)]) # test with single output as tensor - multi_io_model = keras.models.Model([j, k, o, p], s) + multi_io_model = training_lib.Model([j, k, o, p], s) - fn = keras.backend.function(multi_io_model.inputs, multi_io_model.outputs) + fn = backend.function(multi_io_model.inputs, multi_io_model.outputs) fn_outputs = fn([ np.random.random((10, 32)), np.random.random((10, 32)), np.random.random((10, 32)), np.random.random((10, 32)) @@ -574,10 +577,9 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # test serialization model_config = multi_io_model.get_config() - recreated_model = keras.models.Model.from_config(model_config) + recreated_model = models.Model.from_config(model_config) - fn = keras.backend.function(recreated_model.inputs, - recreated_model.outputs) + fn = backend.function(recreated_model.inputs, recreated_model.outputs) fn_outputs = fn([ np.random.random((10, 32)), np.random.random((10, 32)), np.random.random((10, 32)), np.random.random((10, 32)) @@ -586,88 +588,88 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertListEqual([x.shape for x in fn_outputs], [(10, 69)]) config = model.get_config() - keras.models.Model.from_config(config) + models.Model.from_config(config) model.summary() json_str = model.to_json() - keras.models.model_from_json(json_str) + models.model_from_json(json_str) if yaml is not None: yaml_str = model.to_yaml() - keras.models.model_from_yaml(yaml_str) + models.model_from_yaml(yaml_str) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_invalid_graphs(self): - a = keras.layers.Input(shape=(32,), name='input_a') - b = keras.layers.Input(shape=(32,), name='input_b') + a = layers.Input(shape=(32,), name='input_a') + b = layers.Input(shape=(32,), name='input_b') - dense = keras.layers.Dense(16, name='dense_1') + dense = layers.Dense(16, name='dense_1') a_2 = dense(a) b_2 = dense(b) - merged = keras.layers.concatenate([a_2, b_2], name='merge') - c = keras.layers.Dense(64, name='dense_2')(merged) - d = keras.layers.Dense(5, name='dense_3')(c) + merged = layers.concatenate([a_2, b_2], name='merge') + c = layers.Dense(64, name='dense_2')(merged) + d = layers.Dense(5, name='dense_3')(c) - model = keras.models.Model(inputs=[a, b], outputs=[c, d], name='model') + model = training_lib.Model(inputs=[a, b], outputs=[c, d], name='model') # input is not an Input tensor - j = keras.layers.Input(shape=(32,), name='input_j') - j = keras.layers.Dense(32)(j) - k = keras.layers.Input(shape=(32,), name='input_k') + j = layers.Input(shape=(32,), name='input_j') + j = layers.Dense(32)(j) + k = layers.Input(shape=(32,), name='input_k') m, n = model([j, k]) with self.assertRaises(Exception): - keras.models.Model([j, k], [m, n]) + training_lib.Model([j, k], [m, n]) # disconnected graph - j = keras.layers.Input(shape=(32,), name='input_j') - k = keras.layers.Input(shape=(32,), name='input_k') + j = layers.Input(shape=(32,), name='input_j') + k = layers.Input(shape=(32,), name='input_k') m, n = model([j, k]) with self.assertRaises(Exception): - keras.models.Model([j], [m, n]) + training_lib.Model([j], [m, n]) # redundant outputs - j = keras.layers.Input(shape=(32,), name='input_j') - k = keras.layers.Input(shape=(32,), name='input_k') + j = layers.Input(shape=(32,), name='input_j') + k = layers.Input(shape=(32,), name='input_k') m, n = model([j, k]) - keras.models.Model([j, k], [m, n, n]) + training_lib.Model([j, k], [m, n, n]) # redundant inputs - j = keras.layers.Input(shape=(32,), name='input_j') - k = keras.layers.Input(shape=(32,), name='input_k') + j = layers.Input(shape=(32,), name='input_j') + k = layers.Input(shape=(32,), name='input_k') m, n = model([j, k]) with self.assertRaises(Exception): - keras.models.Model([j, k, j], [m, n]) + training_lib.Model([j, k, j], [m, n]) # i have not idea what I'm doing: garbage as inputs/outputs - j = keras.layers.Input(shape=(32,), name='input_j') - k = keras.layers.Input(shape=(32,), name='input_k') + j = layers.Input(shape=(32,), name='input_j') + k = layers.Input(shape=(32,), name='input_k') m, n = model([j, k]) with self.assertRaises(Exception): - keras.models.Model([j, k], [m, n, 0]) + training_lib.Model([j, k], [m, n, 0]) def test_raw_tf_compatibility(self): with ops.Graph().as_default(): # test calling layers/models on TF tensors - a = keras.layers.Input(shape=(32,), name='input_a') - b = keras.layers.Input(shape=(32,), name='input_b') + a = layers.Input(shape=(32,), name='input_a') + b = layers.Input(shape=(32,), name='input_b') - dense = keras.layers.Dense(16, name='dense_1') + dense = layers.Dense(16, name='dense_1') a_2 = dense(a) b_2 = dense(b) - merged = keras.layers.concatenate([a_2, b_2], name='merge') - c = keras.layers.Dense(64, name='dense_2')(merged) - d = keras.layers.Dense(5, name='dense_3')(c) + merged = layers.concatenate([a_2, b_2], name='merge') + c = layers.Dense(64, name='dense_2')(merged) + d = layers.Dense(5, name='dense_3')(c) - model = keras.models.Model(inputs=[a, b], outputs=[c, d], name='model') + model = training_lib.Model(inputs=[a, b], outputs=[c, d], name='model') - j = keras.layers.Input(shape=(32,), name='input_j') - k = keras.layers.Input(shape=(32,), name='input_k') + j = layers.Input(shape=(32,), name='input_j') + k = layers.Input(shape=(32,), name='input_k') self.assertEqual(len(model.inputs), 2) m, n = model([j, k]) self.assertEqual(len(model.inputs), 2) - tf_model = keras.models.Model([j, k], [m, n]) + tf_model = training_lib.Model([j, k], [m, n]) j_tf = array_ops.placeholder(dtype=dtypes.float32, shape=(None, 32)) k_tf = array_ops.placeholder(dtype=dtypes.float32, shape=(None, 32)) @@ -676,26 +678,26 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertListEqual(n_tf.shape.as_list(), [None, 5]) # test merge - keras.layers.concatenate([j_tf, k_tf], axis=1) - keras.layers.add([j_tf, k_tf]) + layers.concatenate([j_tf, k_tf], axis=1) + layers.add([j_tf, k_tf]) # test tensor input x = array_ops.placeholder(shape=(None, 2), dtype=dtypes.float32) - keras.layers.InputLayer(input_tensor=x) + layers.InputLayer(input_tensor=x) - x = keras.layers.Input(tensor=x) - keras.layers.Dense(2)(x) + x = layers.Input(tensor=x) + layers.Dense(2)(x) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_basic_masking(self): - a = keras.layers.Input(shape=(10, 32), name='input_a') - b = keras.layers.Masking()(a) - model = keras.models.Model(a, b) + a = layers.Input(shape=(10, 32), name='input_a') + b = layers.Masking()(a) + model = training_lib.Model(a, b) self.assertEqual(model.output_mask.shape.as_list(), [None, 10]) def testMaskingSingleInput(self): - class MaskedLayer(keras.layers.Layer): + class MaskedLayer(layers.Layer): def call(self, inputs, mask=None): if mask is not None: @@ -737,29 +739,29 @@ class NetworkConstructionTest(keras_parameterized.TestCase): net_a_input = input_layer_lib.Input((2,)) net_a = net_a_input - net_a = keras.layers.Dense(2, kernel_initializer='ones', - use_bias=False, - activity_regularizer=reg)(net_a) - model_a = keras.Model([net_a_input], [net_a]) + net_a = layers.Dense( + 2, kernel_initializer='ones', use_bias=False, activity_regularizer=reg)( + net_a) + model_a = training_lib.Model([net_a_input], [net_a]) net_b_input = input_layer_lib.Input((2,)) net_b = model_a(net_b_input) - model_b = keras.Model([net_b_input], [net_b]) + model_b = training_lib.Model([net_b_input], [net_b]) model_b.compile(optimizer='sgd', loss=None) x = np.ones((1, 2)) loss = model_b.evaluate(x) self.assertEqual(loss, 4.) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_layer_sharing_at_heterogenous_depth(self): x_val = np.random.random((10, 5)) x = input_layer_lib.Input(shape=(5,)) - a = keras.layers.Dense(5, name='A') - b = keras.layers.Dense(5, name='B') + a = layers.Dense(5, name='A') + b = layers.Dense(5, name='B') output = a(b(a(b(x)))) - m = keras.models.Model(x, output) + m = training_lib.Model(x, output) m.run_eagerly = testing_utils.should_run_eagerly() output_val = m.predict(x_val) @@ -767,26 +769,26 @@ class NetworkConstructionTest(keras_parameterized.TestCase): config = m.get_config() weights = m.get_weights() - m2 = keras.models.Model.from_config(config) + m2 = models.Model.from_config(config) m2.set_weights(weights) output_val_2 = m2.predict(x_val) self.assertAllClose(output_val, output_val_2, atol=1e-6) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_layer_sharing_at_heterogenous_depth_with_concat(self): input_shape = (16, 9, 3) input_layer = input_layer_lib.Input(shape=input_shape) - a = keras.layers.Dense(3, name='dense_A') - b = keras.layers.Dense(3, name='dense_B') - c = keras.layers.Dense(3, name='dense_C') + a = layers.Dense(3, name='dense_A') + b = layers.Dense(3, name='dense_B') + c = layers.Dense(3, name='dense_C') x1 = b(a(input_layer)) x2 = a(c(input_layer)) - output = keras.layers.concatenate([x1, x2]) + output = layers.concatenate([x1, x2]) - m = keras.models.Model(inputs=input_layer, outputs=output) + m = training_lib.Model(inputs=input_layer, outputs=output) m.run_eagerly = testing_utils.should_run_eagerly() x_val = np.random.random((10, 16, 9, 3)) @@ -795,21 +797,21 @@ class NetworkConstructionTest(keras_parameterized.TestCase): config = m.get_config() weights = m.get_weights() - m2 = keras.models.Model.from_config(config) + m2 = models.Model.from_config(config) m2.set_weights(weights) output_val_2 = m2.predict(x_val) self.assertAllClose(output_val, output_val_2, atol=1e-6) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_explicit_training_argument(self): - a = keras.layers.Input(shape=(2,)) - b = keras.layers.Dropout(0.5)(a) - base_model = keras.models.Model(a, b) + a = layers.Input(shape=(2,)) + b = layers.Dropout(0.5)(a) + base_model = training_lib.Model(a, b) - a = keras.layers.Input(shape=(2,)) + a = layers.Input(shape=(2,)) b = base_model(a, training=False) - model = keras.models.Model(a, b) + model = training_lib.Model(a, b) x = np.ones((100, 2)) y = np.ones((100, 2)) @@ -820,18 +822,18 @@ class NetworkConstructionTest(keras_parameterized.TestCase): loss = model.train_on_batch(x, y) self.assertEqual(loss, 0) # In inference mode, output is equal to input. - a = keras.layers.Input(shape=(2,)) + a = layers.Input(shape=(2,)) b = base_model(a, training=True) - model = keras.models.Model(a, b) + model = training_lib.Model(a, b) preds = model.predict(x) self.assertEqual(np.min(preds), 0.) # At least one unit was dropped. - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_mask_derived_from_keras_layer(self): - inputs = keras.Input((5, 10)) - mask = keras.Input((5,)) - outputs = keras.layers.RNN(keras.layers.LSTMCell(100))(inputs, mask=mask) - model = keras.Model([inputs, mask], outputs) + inputs = input_layer_lib.Input((5, 10)) + mask = input_layer_lib.Input((5,)) + outputs = layers.RNN(layers.LSTMCell(100))(inputs, mask=mask) + model = training_lib.Model([inputs, mask], outputs) model.compile( 'sgd', 'mse', @@ -849,7 +851,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Data is not masked, returned values are random. self.assertGreater(history.history['loss'][0], 0.0) - model = keras.Model.from_config(model.get_config()) + model = training_lib.Model.from_config(model.get_config()) model.compile( 'sgd', 'mse', @@ -867,18 +869,18 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Data is not masked, returned values are random. self.assertGreater(history.history['loss'][0], 0.0) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_call_arg_derived_from_keras_layer(self): - class MyAdd(keras.layers.Layer): + class MyAdd(layers.Layer): def call(self, x1, x2): return x1 + x2 - input1 = keras.Input(10) - input2 = keras.Input(10) + input1 = input_layer_lib.Input(10) + input2 = input_layer_lib.Input(10) outputs = MyAdd()(input1, input2) - model = keras.Model([input1, input2], outputs) + model = training_lib.Model([input1, input2], outputs) model.compile( 'sgd', 'mse', @@ -891,7 +893,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual(history.history['loss'][0], 0.0) # Check serialization. - model = keras.Model.from_config( + model = training_lib.Model.from_config( model.get_config(), custom_objects={'MyAdd': MyAdd}) model.compile( 'sgd', @@ -904,20 +906,20 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Check that second input was correctly added to first. self.assertEqual(history.history['loss'][0], 0.0) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_call_kwarg_derived_from_keras_layer(self): - class MaybeAdd(keras.layers.Layer): + class MaybeAdd(layers.Layer): def call(self, x1, x2=None): if x2 is not None: return x1 + x2 return x1 - input1 = keras.Input(10) - input2 = keras.Input(10) + input1 = input_layer_lib.Input(10) + input2 = input_layer_lib.Input(10) outputs = MaybeAdd()(input1, x2=input2) - model = keras.Model([input1, input2], outputs) + model = training_lib.Model([input1, input2], outputs) model.compile( 'sgd', 'mse', @@ -929,7 +931,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Check that second input was correctly added to first. self.assertEqual(history.history['loss'][0], 0.0) - model = keras.Model.from_config( + model = training_lib.Model.from_config( model.get_config(), custom_objects={'MaybeAdd': MaybeAdd}) model.compile( 'sgd', @@ -942,12 +944,12 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Check that second input was correctly added to first. self.assertEqual(history.history['loss'][0], 0.0) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_composite_call_kwarg_derived_from_keras_layer(self): # Create a test layer that accepts composite tensor inputs (note the # 'supports_ragged_inputs = True' in the init method.) - class MaybeAdd(keras.layers.Layer): + class MaybeAdd(layers.Layer): def __init__(self, **kwargs): super(MaybeAdd, self).__init__(**kwargs) @@ -960,10 +962,10 @@ class NetworkConstructionTest(keras_parameterized.TestCase): return (x1 + x2).to_tensor(default_value=0) return x1.to_tensor(default_value=0) - input1 = keras.Input((None,), ragged=True) - input2 = keras.Input((None,), ragged=True) + input1 = input_layer_lib.Input((None,), ragged=True) + input2 = input_layer_lib.Input((None,), ragged=True) outputs = MaybeAdd()(input1, x2=input2) - model = keras.Model([input1, input2], outputs) + model = training_lib.Model([input1, input2], outputs) model.compile( 'sgd', 'mse', @@ -978,7 +980,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Check that second input was correctly added to first. self.assertEqual(history.history['loss'][0], 0.0) - model = keras.Model.from_config( + model = training_lib.Model.from_config( model.get_config(), custom_objects={'MaybeAdd': MaybeAdd}) model.compile( 'sgd', @@ -988,10 +990,10 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Check that second input was correctly added to first. self.assertEqual(history.history['loss'][0], 0.0) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_call_nested_arg_derived_from_keras_layer(self): - class AddAll(keras.layers.Layer): + class AddAll(layers.Layer): def call(self, x1, x2, x3=None): out = x1 + x2 @@ -1000,9 +1002,9 @@ class NetworkConstructionTest(keras_parameterized.TestCase): out += t return out - input1 = keras.Input(10) - input2 = keras.Input(10) - input3 = keras.Input(10) + input1 = input_layer_lib.Input(10) + input2 = input_layer_lib.Input(10) + input3 = input_layer_lib.Input(10) outputs = AddAll()( input1, 4 * array_ops.ones((1, 10)), @@ -1011,7 +1013,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): 'b': input3, 'c': 5 * array_ops.ones((1, 10)) }) - model = keras.Model([input1, input2, input3], outputs) + model = training_lib.Model([input1, input2, input3], outputs) model.compile( 'sgd', 'mse', @@ -1023,7 +1025,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Check that all inputs were correctly added. self.assertEqual(history.history['loss'][0], 0.0) - model = keras.Model.from_config( + model = training_lib.Model.from_config( model.get_config(), custom_objects={'AddAll': AddAll}) model.compile( 'sgd', @@ -1036,7 +1038,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase): # Check that all inputs were correctly added. self.assertEqual(history.history['loss'][0], 0.0) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_multi_output_model_with_none_masking(self): def func(x): return [x * 0.2, x * 0.3] @@ -1044,19 +1046,19 @@ class NetworkConstructionTest(keras_parameterized.TestCase): def output_shape(input_shape): return [input_shape, input_shape] - i = keras.layers.Input(shape=(3, 2, 1)) - o = keras.layers.Lambda(function=func, output_shape=output_shape)(i) + i = layers.Input(shape=(3, 2, 1)) + o = layers.Lambda(function=func, output_shape=output_shape)(i) - self.assertEqual(keras.backend.int_shape(o[0]), (None, 3, 2, 1)) - self.assertEqual(keras.backend.int_shape(o[1]), (None, 3, 2, 1)) + self.assertEqual(backend.int_shape(o[0]), (None, 3, 2, 1)) + self.assertEqual(backend.int_shape(o[1]), (None, 3, 2, 1)) - o = keras.layers.add(o) - model = keras.Model(i, o) + o = layers.add(o) + model = training_lib.Model(i, o) model.run_eagerly = testing_utils.should_run_eagerly() - i2 = keras.layers.Input(shape=(3, 2, 1)) + i2 = layers.Input(shape=(3, 2, 1)) o2 = model(i2) - model2 = keras.Model(i2, o2) + model2 = training_lib.Model(i2, o2) model2.run_eagerly = testing_utils.should_run_eagerly() x = np.random.random((4, 3, 2, 1)) @@ -1064,13 +1066,12 @@ class NetworkConstructionTest(keras_parameterized.TestCase): assert out.shape == (4, 3, 2, 1) self.assertAllClose(out, x * 0.2 + x * 0.3, atol=1e-4) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_constant_initializer_with_numpy(self): - initializer = keras.initializers.Constant(np.ones((3, 2))) - model = keras.models.Sequential() - model.add( - keras.layers.Dense(2, input_shape=(3,), kernel_initializer=initializer)) - model.add(keras.layers.Dense(3)) + initializer = initializers.Constant(np.ones((3, 2))) + model = sequential.Sequential() + model.add(layers.Dense(2, input_shape=(3,), kernel_initializer=initializer)) + model.add(layers.Dense(3)) model.compile( loss='mse', optimizer='sgd', @@ -1078,35 +1079,35 @@ class NetworkConstructionTest(keras_parameterized.TestCase): run_eagerly=testing_utils.should_run_eagerly()) json_str = model.to_json() - keras.models.model_from_json(json_str) + models.model_from_json(json_str) if yaml is not None: yaml_str = model.to_yaml() - keras.models.model_from_yaml(yaml_str) + models.model_from_yaml(yaml_str) def test_subclassed_error_if_init_not_called(self): class MyNetwork(network_lib.Network): def __init__(self): - self._foo = [keras.layers.Dense(10), keras.layers.Dense(10)] + self._foo = [layers.Dense(10), layers.Dense(10)] with self.assertRaisesRegexp(RuntimeError, 'forgot to call'): MyNetwork() - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_int_input_shape(self): - inputs = keras.Input(10) + inputs = input_layer_lib.Input(10) self.assertEqual([None, 10], inputs.shape.as_list()) - inputs_with_batch = keras.Input(batch_size=20, shape=5) + inputs_with_batch = input_layer_lib.Input(batch_size=20, shape=5) self.assertEqual([20, 5], inputs_with_batch.shape.as_list()) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_model_initialization(self): # Functional model inputs = input_layer_lib.Input(shape=(32,)) - outputs = keras.layers.Dense(4)(inputs) + outputs = layers.Dense(4)(inputs) with self.assertRaisesRegexp(TypeError, 'unexpected argument'): model = training_lib.Model( @@ -1126,22 +1127,22 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual('subclassed', model.name) self.assertTrue(model.dynamic) self.assertTrue(model.trainable) - w = model.add_weight('w', [], initializer=keras.initializers.Constant(1)) + w = model.add_weight('w', [], initializer=initializers.Constant(1)) self.assertEqual(dtypes.int64, w.dtype) def test_disconnected_inputs(self): input_tensor1 = input_layer_lib.Input(shape=[200], name='a') input_tensor2 = input_layer_lib.Input(shape=[10], name='b') - output_tensor1 = keras.layers.Dense(units=10)(input_tensor1) + output_tensor1 = layers.Dense(units=10)(input_tensor1) - net = keras.engine.network.Network( + net = network_lib.Network( inputs=[input_tensor1, input_tensor2], outputs=[output_tensor1]) - net2 = keras.engine.network.Network.from_config(net.get_config()) + net2 = network_lib.Network.from_config(net.get_config()) self.assertLen(net2.inputs, 2) self.assertEqual('a', net2.layers[0].name) self.assertEqual('b', net2.layers[1].name) - @keras_parameterized.run_with_all_model_types + @combinations.generate(combinations.keras_model_type_combinations()) def test_dependency_tracking(self): model = testing_utils.get_small_mlp(1, 4, input_dim=3) model.trackable = Checkpoint() @@ -1149,21 +1150,21 @@ class NetworkConstructionTest(keras_parameterized.TestCase): self.assertEqual(model.trackable, model._lookup_dependency('trackable')) -class DeferredModeTest(test.TestCase): +class DeferredModeTest(keras_parameterized.TestCase): - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testSimpleNetworkBuilding(self): inputs = input_layer_lib.Input(shape=(32,)) if context.executing_eagerly(): self.assertEqual(inputs.dtype.name, 'float32') self.assertEqual(inputs.shape.as_list(), [None, 32]) - x = keras.layers.Dense(2)(inputs) + x = layers.Dense(2)(inputs) if context.executing_eagerly(): self.assertEqual(x.dtype.name, 'float32') self.assertEqual(x.shape.as_list(), [None, 2]) - outputs = keras.layers.Dense(4)(x) + outputs = layers.Dense(4)(x) network = network_lib.Network(inputs, outputs) self.assertIsInstance(network, network_lib.Network) @@ -1174,19 +1175,19 @@ class DeferredModeTest(test.TestCase): outputs = network(inputs) self.assertEqual(outputs.shape.as_list(), [10, 4]) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testMultiIONetworkBuilding(self): input_a = input_layer_lib.Input(shape=(32,)) input_b = input_layer_lib.Input(shape=(16,)) - a = keras.layers.Dense(16)(input_a) + a = layers.Dense(16)(input_a) - class AddLayer(keras.layers.Layer): + class AddLayer(layers.Layer): def call(self, inputs): return inputs[0] + inputs[1] c = AddLayer()([a, input_b]) # pylint: disable=not-callable - c = keras.layers.Dense(2)(c) + c = layers.Dense(2)(c) network = network_lib.Network([input_a, input_b], [a, c]) if context.executing_eagerly(): @@ -1207,16 +1208,16 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): output_value = model.predict(input_value) self.assertEqual(output_value.shape, expected_output_shape) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testSingleInputCase(self): - class LayerWithOneInput(keras.layers.Layer): + class LayerWithOneInput(layers.Layer): def build(self, input_shape): self.w = array_ops.ones(shape=(3, 4)) def call(self, inputs): - return keras.backend.dot(inputs, self.w) + return backend.dot(inputs, self.w) inputs = input_layer_lib.Input(shape=(3,)) layer = LayerWithOneInput() @@ -1232,57 +1233,57 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): layer.compute_output_shape((6, 3)).as_list(), [6, 4]) outputs = layer(inputs) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) self._testShapeInference(model, (2, 3), (2, 4)) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testMultiInputOutputCase(self): - class MultiInputOutputLayer(keras.layers.Layer): + class MultiInputOutputLayer(layers.Layer): def build(self, input_shape): self.w = array_ops.ones(shape=(3, 4)) def call(self, inputs): - a = keras.backend.dot(inputs[0], self.w) + a = backend.dot(inputs[0], self.w) b = a + inputs[1] return [a, b] input_a = input_layer_lib.Input(shape=(3,)) input_b = input_layer_lib.Input(shape=(4,)) output_a, output_b = MultiInputOutputLayer()([input_a, input_b]) - model = keras.Model([input_a, input_b], [output_a, output_b]) + model = training_lib.Model([input_a, input_b], [output_a, output_b]) output_a_val, output_b_val = model.predict( [np.random.random((2, 3)), np.random.random((2, 4))]) self.assertEqual(output_a_val.shape, (2, 4)) self.assertEqual(output_b_val.shape, (2, 4)) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testTrainingArgument(self): - class LayerWithTrainingArg(keras.layers.Layer): + class LayerWithTrainingArg(layers.Layer): def build(self, input_shape): self.w = array_ops.ones(shape=(3, 4)) def call(self, inputs, training): - return keras.backend.dot(inputs, self.w) + return backend.dot(inputs, self.w) inputs = input_layer_lib.Input(shape=(3,)) outputs = LayerWithTrainingArg()(inputs, training=False) - model = keras.Model(inputs, outputs) + model = training_lib.Model(inputs, outputs) self._testShapeInference(model, (2, 3), (2, 4)) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testNoneInShape(self): - class Model(keras.Model): + class Model(training_lib.Model): def __init__(self): super(Model, self).__init__() - self.conv1 = keras.layers.Conv2D(8, 3) - self.pool = keras.layers.GlobalAveragePooling2D() - self.fc = keras.layers.Dense(3) + self.conv1 = layers.Conv2D(8, 3) + self.pool = layers.GlobalAveragePooling2D() + self.fc = layers.Dense(3) def call(self, x): x = self.conv1(x) @@ -1300,16 +1301,16 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): output = model(sample_input) self.assertEqual(output.shape, (1, 3)) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testNoneInShapeWithCompoundModel(self): - class BasicBlock(keras.Model): + class BasicBlock(training_lib.Model): def __init__(self): super(BasicBlock, self).__init__() - self.conv1 = keras.layers.Conv2D(8, 3) - self.pool = keras.layers.GlobalAveragePooling2D() - self.dense = keras.layers.Dense(3) + self.conv1 = layers.Conv2D(8, 3) + self.pool = layers.GlobalAveragePooling2D() + self.dense = layers.Dense(3) def call(self, x): x = self.conv1(x) @@ -1317,7 +1318,7 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): x = self.dense(x) return x - class CompoundModel(keras.Model): + class CompoundModel(training_lib.Model): def __init__(self): super(CompoundModel, self).__init__() @@ -1337,27 +1338,27 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): output = model(sample_input) # pylint: disable=not-callable self.assertEqual(output.shape, (1, 3)) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testNoneInShapeWithFunctionalAPI(self): - class BasicBlock(keras.Model): - # Inheriting from keras.layers.Layer since we are calling this layer + class BasicBlock(training_lib.Model): + # Inheriting from layers.Layer since we are calling this layer # inside a model created using functional API. def __init__(self): super(BasicBlock, self).__init__() - self.conv1 = keras.layers.Conv2D(8, 3) + self.conv1 = layers.Conv2D(8, 3) def call(self, x): x = self.conv1(x) return x - input_layer = keras.layers.Input(shape=(None, None, 1)) + input_layer = layers.Input(shape=(None, None, 1)) x = BasicBlock()(input_layer) - x = keras.layers.GlobalAveragePooling2D()(x) - output_layer = keras.layers.Dense(3)(x) + x = layers.GlobalAveragePooling2D()(x) + output_layer = layers.Dense(3)(x) - model = keras.Model(inputs=input_layer, outputs=output_layer) + model = training_lib.Model(inputs=input_layer, outputs=output_layer) model.build(tensor_shape.TensorShape((None, None, None, 1))) self.assertTrue(model.built, 'Model should be built') @@ -1368,16 +1369,16 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): output = model(sample_input) self.assertEqual(output.shape, (1, 3)) - @keras_parameterized.run_all_keras_modes + @combinations.generate(combinations.keras_mode_combinations()) def test_sequential_as_downstream_of_masking_layer(self): - inputs = keras.layers.Input(shape=(3, 4)) - x = keras.layers.Masking(mask_value=0., input_shape=(3, 4))(inputs) + inputs = layers.Input(shape=(3, 4)) + x = layers.Masking(mask_value=0., input_shape=(3, 4))(inputs) - s = keras.Sequential() - s.add(keras.layers.Dense(5, input_shape=(4,))) + s = sequential.Sequential() + s.add(layers.Dense(5, input_shape=(4,))) - x = keras.layers.wrappers.TimeDistributed(s)(x) - model = keras.Model(inputs=inputs, outputs=x) + x = layers.wrappers.TimeDistributed(s)(x) + model = training_lib.Model(inputs=inputs, outputs=x) model.compile( optimizer='rmsprop', loss='mse', @@ -1396,16 +1397,16 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): mask_outputs = [model.layers[1].compute_mask(model.layers[1].input)] mask_outputs += [model.layers[2].compute_mask( model.layers[2].input, mask_outputs[-1])] - func = keras.backend.function([model.input], mask_outputs) + func = backend.function([model.input], mask_outputs) mask_outputs_val = func([model_input]) self.assertAllClose(mask_outputs_val[0], np.any(model_input, axis=-1)) self.assertAllClose(mask_outputs_val[1], np.any(model_input, axis=-1)) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_external_keras_serialization_compat_input_layers(self): - inputs = keras.Input(shape=(10,)) - outputs = keras.layers.Dense(1)(inputs) - model = keras.Model(inputs, outputs) + inputs = input_layer_lib.Input(shape=(10,)) + outputs = layers.Dense(1)(inputs) + model = training_lib.Model(inputs, outputs) config = model.get_config() # Checks that single inputs and outputs are still saved as 1-element lists. # Saving as 1-element lists or not is equivalent in TF Keras, but only the @@ -1413,20 +1414,20 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase): self.assertLen(config['input_layers'], 1) self.assertLen(config['output_layers'], 1) - @test_util.run_in_graph_and_eager_modes() + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_external_keras_serialization_compat_inbound_nodes(self): # Check single Tensor input. - inputs = keras.Input(shape=(10,), name='in') - outputs = keras.layers.Dense(1)(inputs) - model = keras.Model(inputs, outputs) + inputs = input_layer_lib.Input(shape=(10,), name='in') + outputs = layers.Dense(1)(inputs) + model = training_lib.Model(inputs, outputs) config = model.get_config() self.assertEqual(config['layers'][1]['inbound_nodes'], [[['in', 0, 0, {}]]]) # Check multiple Tensor input. - inputs1 = keras.Input(shape=(10,), name='in1') - inputs2 = keras.Input(shape=(10,), name='in2') - outputs = keras.layers.Add()([inputs1, inputs2]) - model = keras.Model([inputs1, inputs2], outputs) + inputs1 = input_layer_lib.Input(shape=(10,), name='in1') + inputs2 = input_layer_lib.Input(shape=(10,), name='in2') + outputs = layers.Add()([inputs1, inputs2]) + model = training_lib.Model([inputs1, inputs2], outputs) config = model.get_config() self.assertEqual(config['layers'][2]['inbound_nodes'], [[['in1', 0, 0, {}], ['in2', 0, 0, {}]]]) @@ -1447,28 +1448,30 @@ class GraphUtilsTest(test.TestCase): x_5 = x_3 * pl_1 self.assertEqual( - keras.utils.tf_utils.get_reachable_from_inputs([pl_1]), + tf_utils.get_reachable_from_inputs([pl_1]), {pl_1, x_1, x_4, x_5, x_1.op, x_4.op, x_5.op}) self.assertEqual( - keras.utils.tf_utils.get_reachable_from_inputs([pl_1, pl_2]), + tf_utils.get_reachable_from_inputs([pl_1, pl_2]), {pl_1, pl_2, x_1, x_2, x_4, x_5, x_1.op, x_2.op, x_4.op, x_5.op}) self.assertEqual( - keras.utils.tf_utils.get_reachable_from_inputs([pl_3]), + tf_utils.get_reachable_from_inputs([pl_3]), {pl_3, x_3, x_5, x_3.op, x_5.op}) self.assertEqual( - keras.utils.tf_utils.get_reachable_from_inputs([x_3]), - {x_3, x_5, x_5.op}) + tf_utils.get_reachable_from_inputs([x_3]), {x_3, x_5, x_5.op}) -@test_util.run_all_in_graph_and_eager_modes -class NestedNetworkTest(test.TestCase): +@combinations.generate(combinations.combine(mode=['graph', 'eager'])) +class NestedNetworkTest(keras_parameterized.TestCase): def test_nested_inputs_network(self): - inputs = {'x1': keras.Input(shape=(1,)), 'x2': keras.Input(shape=(1,))} - outputs = keras.layers.Add()([inputs['x1'], inputs['x2']]) - network = keras.engine.network.Network(inputs, outputs) + inputs = { + 'x1': input_layer_lib.Input(shape=(1,)), + 'x2': input_layer_lib.Input(shape=(1,)) + } + outputs = layers.Add()([inputs['x1'], inputs['x2']]) + network = network_lib.Network(inputs, outputs) - network = keras.engine.network.Network.from_config(network.get_config()) + network = network_lib.Network.from_config(network.get_config()) result_tensor = network({ 'x': array_ops.ones((1, 1), 'float32'), @@ -1485,15 +1488,15 @@ class NestedNetworkTest(test.TestCase): self.assertListEqual(output_shape.as_list(), [None, 1]) def test_nested_outputs_network(self): - inputs = keras.Input(shape=(1,)) + inputs = input_layer_lib.Input(shape=(1,)) outputs = { - 'x+x': keras.layers.Add()([inputs, inputs]), - 'x*x': keras.layers.Multiply()([inputs, inputs]) + 'x+x': layers.Add()([inputs, inputs]), + 'x*x': layers.Multiply()([inputs, inputs]) } - network = keras.engine.network.Network(inputs, outputs) + network = network_lib.Network(inputs, outputs) - network = keras.engine.network.Network.from_config(network.get_config()) + network = network_lib.Network.from_config(network.get_config()) result_tensor = network(array_ops.ones((1, 1), 'float32')) result = self.evaluate(result_tensor) @@ -1506,23 +1509,24 @@ class NestedNetworkTest(test.TestCase): def test_nested_network_inside_network(self): inner_inputs = { - 'x1': keras.Input(shape=(1,)), - 'x2': keras.Input(shape=(1,)) + 'x1': input_layer_lib.Input(shape=(1,)), + 'x2': input_layer_lib.Input(shape=(1,)) } inner_outputs = { - 'x1+x2': - keras.layers.Add()([inner_inputs['x1'], inner_inputs['x2']]), - 'x1*x2': - keras.layers.Multiply()([inner_inputs['x1'], inner_inputs['x2']]) + 'x1+x2': layers.Add()([inner_inputs['x1'], inner_inputs['x2']]), + 'x1*x2': layers.Multiply()([inner_inputs['x1'], inner_inputs['x2']]) } - inner_network = keras.engine.network.Network(inner_inputs, inner_outputs) + inner_network = network_lib.Network(inner_inputs, inner_outputs) - inputs = [keras.Input(shape=(1,)), keras.Input(shape=(1,))] + inputs = [ + input_layer_lib.Input(shape=(1,)), + input_layer_lib.Input(shape=(1,)) + ] middle = inner_network({'x1': inputs[0], 'x2': inputs[1]}) - outputs = keras.layers.Add()([middle['x1+x2'], middle['x1*x2']]) - network = keras.engine.network.Network(inputs, outputs) + outputs = layers.Add()([middle['x1+x2'], middle['x1*x2']]) + network = network_lib.Network(inputs, outputs) - network = keras.engine.network.Network.from_config(network.get_config()) + network = network_lib.Network.from_config(network.get_config()) # Computes: `(x1+x2) + (x1*x2)` result_tensor = network( @@ -1534,14 +1538,14 @@ class NestedNetworkTest(test.TestCase): output_shape = network.compute_output_shape([(None, 1), (None, 1)]) self.assertListEqual(output_shape.as_list(), [None, 1]) - @test_util.run_in_graph_and_eager_modes + @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def test_updates_with_direct_call(self): - inputs = keras.Input(shape=(10,)) - x = keras.layers.BatchNormalization()(inputs) - x = keras.layers.Dense(10)(x) - model = keras.Model(inputs, x) + inputs = input_layer_lib.Input(shape=(10,)) + x = layers.BatchNormalization()(inputs) + x = layers.Dense(10)(x) + model = training_lib.Model(inputs, x) - ph = keras.backend.placeholder(shape=(10, 10)) + ph = backend.placeholder(shape=(10, 10)) model(ph) self.assertLen(model.get_updates_for(ph), 2) @@ -1549,7 +1553,7 @@ class NestedNetworkTest(test.TestCase): def test_dict_mapping_input(self): - class ReturnFirst(keras.layers.Layer): + class ReturnFirst(layers.Layer): def call(self, inputs): b, _ = inputs @@ -1557,30 +1561,30 @@ class NestedNetworkTest(test.TestCase): # Checks that inputs are put in same order as the # Model was constructed with. - b = keras.Input(shape=(10,), name='b') - a = keras.Input(shape=(10,), name='a') + b = input_layer_lib.Input(shape=(10,), name='b') + a = input_layer_lib.Input(shape=(10,), name='a') outputs = ReturnFirst()([b, a]) b_val = array_ops.ones((10, 10)) a_val = array_ops.zeros((10, 10)) - model = keras.Model([b, a], outputs) + model = training_lib.Model([b, a], outputs) res = model({'a': a_val, 'b': b_val}) self.assertAllClose(self.evaluate(res), self.evaluate(b_val)) - reversed_model = keras.Model([a, b], outputs) + reversed_model = training_lib.Model([a, b], outputs) res = reversed_model({'a': a_val, 'b': b_val}) self.assertAllClose(self.evaluate(res), self.evaluate(b_val)) -@keras_parameterized.run_all_keras_modes +@combinations.generate(combinations.keras_mode_combinations()) class AddLossTest(keras_parameterized.TestCase): def test_add_loss_outside_call_only_loss(self): - inputs = keras.Input((10,)) - mid = keras.layers.Dense(10)(inputs) - outputs = keras.layers.Dense(1)(mid) - model = keras.Model(inputs, outputs) + inputs = input_layer_lib.Input((10,)) + mid = layers.Dense(10)(inputs) + outputs = layers.Dense(1)(mid) + model = training_lib.Model(inputs, outputs) model.add_loss(math_ops.reduce_mean(outputs)) self.assertLen(model.losses, 1) @@ -1604,11 +1608,11 @@ class AddLossTest(keras_parameterized.TestCase): self.assertAllClose(model.get_weights(), model2.get_weights()) def test_add_loss_outside_call_multiple_losses(self): - inputs = keras.Input((10,)) - x1 = keras.layers.Dense(10)(inputs) - x2 = keras.layers.Dense(10)(x1) - outputs = keras.layers.Dense(1)(x2) - model = keras.Model(inputs, outputs) + inputs = input_layer_lib.Input((10,)) + x1 = layers.Dense(10)(inputs) + x2 = layers.Dense(10)(x1) + outputs = layers.Dense(1)(x2) + model = training_lib.Model(inputs, outputs) model.add_loss(math_ops.reduce_sum(x1 * x2)) model.add_loss(math_ops.reduce_mean(outputs)) self.assertLen(model.losses, 2) @@ -1633,38 +1637,39 @@ class AddLossTest(keras_parameterized.TestCase): self.assertAllClose(model.get_weights(), model2.get_weights()) -@keras_parameterized.run_all_keras_modes +@combinations.generate(combinations.keras_mode_combinations()) class WeightAccessTest(keras_parameterized.TestCase): def test_functional_model(self): - inputs = keras.Input((10,)) - x1 = keras.layers.Dense(10)(inputs) - x2 = keras.layers.Dense(10)(x1) - outputs = keras.layers.Dense(1)(x2) - model = keras.Model(inputs, outputs) + inputs = input_layer_lib.Input((10,)) + x1 = layers.Dense(10)(inputs) + x2 = layers.Dense(10)(x1) + outputs = layers.Dense(1)(x2) + model = training_lib.Model(inputs, outputs) self.assertEqual(len(model.weights), 6) def test_sequential_model_with_input_shape(self): - x1 = keras.layers.Dense(10, input_shape=(10,)) - x2 = keras.layers.Dense(10) - x3 = keras.layers.Dense(1) - model = keras.models.Sequential([x1, x2, x3]) + x1 = layers.Dense(10, input_shape=(10,)) + x2 = layers.Dense(10) + x3 = layers.Dense(1) + model = sequential.Sequential([x1, x2, x3]) self.assertEqual(len(model.weights), 6) def test_sequential_model_without_input_shape(self): - x1 = keras.layers.Dense(10) - x2 = keras.layers.Dense(10) - x3 = keras.layers.Dense(1) - model = keras.models.Sequential([x1, x2, x3]) + x1 = layers.Dense(10) + x2 = layers.Dense(10) + x3 = layers.Dense(1) + model = sequential.Sequential([x1, x2, x3]) with self.assertRaisesRegexp( ValueError, 'Weights for model .* have not yet been created'): _ = model.weights def test_subclass_model_with_build_method(self): - class SubclassModel(keras.models.Model): + + class SubclassModel(models.Model): def build(self, input_shape): self.w = self.add_weight(shape=input_shape[-1], initializer='ones') @@ -1678,11 +1683,12 @@ class WeightAccessTest(keras_parameterized.TestCase): ValueError, 'Weights for model .* have not yet been created'): _ = model.weights - model(keras.Input((10,))) + model(input_layer_lib.Input((10,))) self.assertEqual(len(model.weights), 1) def test_subclass_model_without_build_method(self): - class SubclassModel(keras.models.Model): + + class SubclassModel(models.Model): def __init__(self): super(SubclassModel, self).__init__() @@ -1695,13 +1701,13 @@ class WeightAccessTest(keras_parameterized.TestCase): self.assertEqual(len(model.weights), 1) -@test_util.run_all_in_graph_and_eager_modes +@combinations.generate(combinations.combine(mode=['graph', 'eager'])) class DTypeTest(keras_parameterized.TestCase): @testing_utils.enable_v2_dtype_behavior def test_graph_network_dtype(self): - inputs = keras.Input((10,)) - outputs = keras.layers.Dense(10)(inputs) + inputs = input_layer_lib.Input((10,)) + outputs = layers.Dense(10)(inputs) network = network_lib.Network(inputs, outputs) self.assertEqual(network.dtype, 'float32') @@ -1748,6 +1754,7 @@ class AttrTrackingLayer(base_layer.Layer): class CacheCorrectnessTest(keras_parameterized.TestCase): + def layer_and_network_test(self): # Top level layer network = network_lib.Network() @@ -1850,7 +1857,7 @@ class CacheCorrectnessTest(keras_parameterized.TestCase): def test_compute_output_shape_cache(self): # See https://github.com/tensorflow/tensorflow/issues/32029. x = input_layer_lib.Input(shape=(None, 32)) - dense = keras.layers.Dense(2) + dense = layers.Dense(2) y = dense(x) network = network_lib.Network(x, y, name='dense_network')