experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove passing experimental_run_tf_function in most tests.

Browse Source 
The experimental_run_tf_function parameter no longer has any effect.

I didn't remove the functionality from testing_util.py and keras_parameterized.py to run with experimental_run_tf_function being True and False. I will remove that functionality in a future change.

PiperOrigin-RevId: 297674422
Change-Id: I5b1e67f78b4c3b60242241fb4dc2018f0ace6013
This commit is contained in:
Reed Wanderman-Milne 2020-02-27 13:31:01 -08:00 committed by TensorFlower Gardener
parent 9ca4b6f117
commit b7014702fd
65 changed files with 564 additions and 1192 deletions
tensorflow/python
distribute
keras_save_load_test.py
model_collection
simple_models.py
saved_model_mixed_api_test.pysaved_model_save_load_test.pysaved_model_test_base.py
keras
callbacks_test.py
distribute
distribute_strategy_test.pykeras_correctness_test_base.pykeras_dnn_correctness_test.pykeras_embedding_model_correctness_test.pykeras_image_model_correctness_test.pykeras_optimizer_v2_test.pykeras_premade_models_test.pykeras_rnn_model_correctness_test.pykeras_stateful_lstm_model_correctness_test.pykeras_utils_test.py
engine
base_layer_test.pybase_preprocessing_layer_test.pycorrectness_test.pyfeature_columns_integration_test.pynetwork_test.pysequential_test.pytraining_arrays_test.pytraining_dataset_test.pytraining_eager_test.pytraining_generator_test.pytraining_integration_test.pytraining_test.py
layers
advanced_activations_test.pyconvolutional_recurrent_test.pycore_test.pycudnn_recurrent_test.pyembeddings_test.pygru_test.pygru_v2_test.pylstm_test.pylstm_v2_test.pymerge_test.pynormalization_test.py
preprocessing
normalization_test.py
recurrent_test.pyrecurrent_v2_test.pysimplernn_test.pytensorflow_op_layer_test.pywrappers_test.py
metrics_correctness_test.pymetrics_test.py
mixed_precision/experimental
BUILDkeras_test.py
models_test.py
optimizer_v2
optimizer_v2_test.py
optimizers_test.py
premade
wide_deep_test.py
regularizers_test.py
saving
losses_serialization_test.pymetrics_serialization_test.pysaving_utils_test.py
tests
add_loss_correctness_test.pyintegration_test.pymodel_subclassing_compiled_test.pymodel_subclassing_test.pytemporal_sample_weights_correctness_test.py
utils
composite_tensor_support_test.pyio_utils_test.py
saved_model
load_test.py

20
tensorflow/python/distribute/keras_save_load_test.py
View File

@ -37,30 +37,24 @@ class KerasSaveLoadTest(test_base.TestSavedModelBase):
distribution,
saved_dir,
predict_dataset,
experimental_run_tf_function,
output_name='output_1'):
restored_keras_model = save.load_model(saved_dir)
restored_keras_model._experimental_run_tf_function = (
experimental_run_tf_function)
return restored_keras_model.predict(
predict_dataset, steps=test_base.PREDICT_STEPS)
@combinations.generate(test_base.simple_models_with_strategies())
def test_save_no_strategy_restore_strategy(self, model_and_input,
distribution,
experimental_run_tf_function):
distribution):
self.run_test_save_no_strategy_restore_strategy(
model_and_input, distribution, experimental_run_tf_function)
model_and_input, distribution)
@combinations.generate(
combinations.times(test_base.simple_models_with_strategies(),
combinations.combine(save_in_scope=[True, False])))
def test_save_strategy_restore_no_strategy(self, model_and_input,
distribution, save_in_scope,
experimental_run_tf_function):
distribution, save_in_scope):
self.run_test_save_strategy_restore_no_strategy(
model_and_input, distribution, save_in_scope,
experimental_run_tf_function)
model_and_input, distribution, save_in_scope)
@combinations.generate(
combinations.times(test_base.simple_models_with_strategy_pairs(),
@ -68,13 +62,11 @@ class KerasSaveLoadTest(test_base.TestSavedModelBase):
def test_save_strategy_restore_strategy(self, model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function):
save_in_scope):
self.run_test_save_strategy_restore_strategy(model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function)
save_in_scope)
if __name__ == '__main__':

18
tensorflow/python/distribute/model_collection/simple_models.py
View File

@ -52,14 +52,10 @@ class SimpleFunctionalModel(model_collection_base.ModelAndInput):
model = keras.Model(inputs=x, outputs=y)
optimizer = gradient_descent.SGD(learning_rate=0.001)
experimental_run_tf_function = kwargs.pop('experimental_run_tf_function',
None)
assert experimental_run_tf_function is not None
model.compile(
loss='mse',
metrics=['mae'],
optimizer=optimizer,
experimental_run_tf_function=experimental_run_tf_function)
optimizer=optimizer)
return model
@ -81,14 +77,10 @@ class SimpleSequentialModel(model_collection_base.ModelAndInput):
5, dtype=dtypes.float32, name=output_name, input_dim=3)
model.add(y)
optimizer = gradient_descent.SGD(learning_rate=0.001)
experimental_run_tf_function = kwargs.pop('experimental_run_tf_function',
None)
assert experimental_run_tf_function is not None
model.compile(
loss='mse',
metrics=['mae'],
optimizer=optimizer,
experimental_run_tf_function=experimental_run_tf_function)
optimizer=optimizer)
return model
@ -115,15 +107,11 @@ class SimpleSubclassModel(model_collection_base.ModelAndInput):
def get_model(self, **kwargs):
model = _SimpleModel()
optimizer = gradient_descent.SGD(learning_rate=0.001)
experimental_run_tf_function = kwargs.pop('experimental_run_tf_function',
None)
assert experimental_run_tf_function is not None
model.compile(
loss='mse',
metrics=['mae'],
cloning=False,
optimizer=optimizer,
experimental_run_tf_function=experimental_run_tf_function)
optimizer=optimizer)
return model

18
tensorflow/python/distribute/saved_model_mixed_api_test.py
View File

@ -45,7 +45,6 @@ class SavedModelSaveAndLoadTest(test_base.TestSavedModelBase):
distribution,
saved_dir,
predict_dataset,
experimental_run_tf_function,
output_name='output_1'):
return test_base.load_and_run_with_saved_model_api(distribution, saved_dir,
predict_dataset,
@ -53,20 +52,17 @@ class SavedModelSaveAndLoadTest(test_base.TestSavedModelBase):
@combinations.generate(test_base.simple_models_with_strategies())
def test_save_no_strategy_restore_strategy(self, model_and_input,
distribution,
experimental_run_tf_function):
distribution):
self.run_test_save_no_strategy_restore_strategy(
model_and_input, distribution, experimental_run_tf_function)
model_and_input, distribution)
@combinations.generate(
combinations.times(test_base.simple_models_with_strategies(),
combinations.combine(save_in_scope=[True, False])))
def test_save_strategy_restore_no_strategy(self, model_and_input,
distribution, save_in_scope,
experimental_run_tf_function):
distribution, save_in_scope):
self.run_test_save_strategy_restore_no_strategy(
model_and_input, distribution, save_in_scope,
experimental_run_tf_function)
model_and_input, distribution, save_in_scope)
@combinations.generate(
combinations.times(test_base.simple_models_with_strategy_pairs(),
@ -74,13 +70,11 @@ class SavedModelSaveAndLoadTest(test_base.TestSavedModelBase):
def test_save_strategy_restore_strategy(self, model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function):
save_in_scope):
self.run_test_save_strategy_restore_strategy(model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function)
save_in_scope)
if __name__ == '__main__':

38
tensorflow/python/distribute/saved_model_save_load_test.py
View File

@ -39,7 +39,6 @@ class SavedModelKerasModelTest(test_base.TestSavedModelBase):
distribution,
saved_dir,
predict_dataset,
experimental_run_tf_function,
output_name='output_1'):
return test_base.load_and_run_with_saved_model_api(distribution, saved_dir,
predict_dataset,
@ -47,20 +46,17 @@ class SavedModelKerasModelTest(test_base.TestSavedModelBase):
@combinations.generate(test_base.simple_models_with_strategies())
def test_save_no_strategy_restore_strategy(self, model_and_input,
distribution,
experimental_run_tf_function):
distribution):
self.run_test_save_no_strategy_restore_strategy(
model_and_input, distribution, experimental_run_tf_function)
model_and_input, distribution)
@combinations.generate(
combinations.times(test_base.simple_models_with_strategies(),
combinations.combine(save_in_scope=[True, False])))
def test_save_strategy_restore_no_strategy(self, model_and_input,
distribution, save_in_scope,
experimental_run_tf_function):
distribution, save_in_scope):
self.run_test_save_strategy_restore_no_strategy(
model_and_input, distribution, save_in_scope,
experimental_run_tf_function)
model_and_input, distribution, save_in_scope)
@combinations.generate(
combinations.times(test_base.simple_models_with_strategy_pairs(),
@ -68,13 +64,11 @@ class SavedModelKerasModelTest(test_base.TestSavedModelBase):
def test_save_strategy_restore_strategy(self, model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function):
save_in_scope):
self.run_test_save_strategy_restore_strategy(model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function)
save_in_scope)
class SavedModelTFModuleTest(test_base.TestSavedModelBase):
@ -108,28 +102,24 @@ class SavedModelTFModuleTest(test_base.TestSavedModelBase):
distribution,
saved_dir,
predict_dataset,
experimental_run_tf_function,
output_name='output_1'):
del output_name, experimental_run_tf_function
del output_name
model = saved_model.load(saved_dir)
return self._predict_with_model(distribution, model, predict_dataset)
@combinations.generate(test_base.tfmodule_models_with_strategies())
def test_save_no_strategy_restore_strategy(self, model_and_input,
distribution,
experimental_run_tf_function):
distribution):
self.run_test_save_no_strategy_restore_strategy(
model_and_input, distribution, experimental_run_tf_function)
model_and_input, distribution)
@combinations.generate(
combinations.times(test_base.tfmodule_models_with_strategies(),
combinations.combine(save_in_scope=[True, False])))
def test_save_strategy_restore_no_strategy(
self, model_and_input, distribution, save_in_scope,
experimental_run_tf_function):
self, model_and_input, distribution, save_in_scope):
self.run_test_save_strategy_restore_no_strategy(
model_and_input, distribution, save_in_scope,
experimental_run_tf_function)
model_and_input, distribution, save_in_scope)
@combinations.generate(
combinations.times(test_base.tfmodule_models_with_strategy_pairs(),
@ -137,13 +127,11 @@ class SavedModelTFModuleTest(test_base.TestSavedModelBase):
def test_save_strategy_restore_strategy(self, model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function):
save_in_scope):
self.run_test_save_strategy_restore_strategy(model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function)
save_in_scope)
if __name__ == '__main__':

42
tensorflow/python/distribute/saved_model_test_base.py
View File

@ -78,8 +78,7 @@ def simple_models_with_strategies():
return combinations.combine(
model_and_input=simple_models,
distribution=strategies,
mode=['eager'],
experimental_run_tf_function=[True, False])
mode=['eager'])
def simple_models_with_strategy_pairs():
@ -87,16 +86,14 @@ def simple_models_with_strategy_pairs():
model_and_input=simple_models,
distribution_for_saving=strategies,
distribution_for_restoring=strategies,
mode=['eager'],
experimental_run_tf_function=[True, False])
mode=['eager'])
def tfmodule_models_with_strategies():
return combinations.combine(
model_and_input=[model_combinations.simple_tfmodule_model],
distribution=strategies,
mode=['eager'],
experimental_run_tf_function=[True])
mode=['eager'])
def tfmodule_models_with_strategy_pairs():
@ -104,8 +101,7 @@ def tfmodule_models_with_strategy_pairs():
model_and_input=[model_combinations.simple_tfmodule_model],
distribution_for_saving=strategies,
distribution_for_restoring=strategies,
mode=['eager'],
experimental_run_tf_function=[True])
mode=['eager'])
def load_and_run_with_saved_model_api(distribution, saved_dir, predict_dataset,
@ -154,7 +150,6 @@ class TestSavedModelBase(test.TestCase, parameterized.TestCase):
distribution,
saved_dir,
predict_dataset,
experimental_run_tf_function,
output_name='output_1'):
"""Load the model and run 1 step of predict with it.
@ -166,8 +161,6 @@ class TestSavedModelBase(test.TestCase, parameterized.TestCase):
saved_dir: the string representing the path where the model is saved.
predict_dataset: the data used to do the predict on the model for
cross_replica context.
experimental_run_tf_function: Whether to use the single execution path
for models.
output_name: the string representing the name of the output layer of the
model.
"""
@ -193,14 +186,12 @@ class TestSavedModelBase(test.TestCase, parameterized.TestCase):
return predict_dataset
def run_test_save_no_strategy_restore_strategy(self, model_and_input,
distribution,
experimental_run_tf_function):
distribution):
"""Save a model without DS, and restore it with DS."""
saved_dir = os.path.join(self.get_temp_dir(), '0')
model = model_and_input.get_model(
experimental_run_tf_function=experimental_run_tf_function)
model = model_and_input.get_model()
x_train, y_train, x_predict = model_and_input.get_data()
batch_size = model_and_input.get_batch_size()
predict_dataset = self._get_predict_dataset(x_predict, batch_size)
@ -214,22 +205,19 @@ class TestSavedModelBase(test.TestCase, parameterized.TestCase):
result_after_save = self._load_and_run_model(
distribution=distribution,
saved_dir=saved_dir,
predict_dataset=predict_dataset,
experimental_run_tf_function=experimental_run_tf_function)
predict_dataset=predict_dataset)
tolerance = get_tolerance(None, distribution)
self.assertAllClose(result_before_save, result_after_save, atol=tolerance)
def run_test_save_strategy_restore_no_strategy(self, model_and_input,
distribution, save_in_scope,
experimental_run_tf_function):
distribution, save_in_scope):
"""Save a model with DS, and restore it without DS."""
saved_dir = os.path.join(self.get_temp_dir(), '1')
with distribution.scope():
model = model_and_input.get_model(
experimental_run_tf_function=experimental_run_tf_function)
model = model_and_input.get_model()
x_train, y_train, x_predict = model_and_input.get_data()
batch_size = model_and_input.get_batch_size()
@ -247,8 +235,7 @@ class TestSavedModelBase(test.TestCase, parameterized.TestCase):
load_result = self._load_and_run_model(
distribution=None,
saved_dir=saved_dir,
predict_dataset=predict_dataset,
experimental_run_tf_function=experimental_run_tf_function)
predict_dataset=predict_dataset)
tolerance = get_tolerance(distribution, None)
self.assertAllClose(result_before_save, load_result, atol=tolerance)
@ -256,14 +243,12 @@ class TestSavedModelBase(test.TestCase, parameterized.TestCase):
def run_test_save_strategy_restore_strategy(self, model_and_input,
distribution_for_saving,
distribution_for_restoring,
save_in_scope,
experimental_run_tf_function):
save_in_scope):
"""Save a model with DS, and restore it with potentially different DS."""
saved_dir = os.path.join(self.get_temp_dir(), '2')
with distribution_for_saving.scope():
model = model_and_input.get_model(
experimental_run_tf_function=experimental_run_tf_function)
model = model_and_input.get_model()
x_train, y_train, x_predict = model_and_input.get_data()
batch_size = model_and_input.get_batch_size()
@ -283,8 +268,7 @@ class TestSavedModelBase(test.TestCase, parameterized.TestCase):
load_result = self._load_and_run_model(
distribution=distribution_for_restoring,
saved_dir=saved_dir,
predict_dataset=predict_dataset,
experimental_run_tf_function=experimental_run_tf_function)
predict_dataset=predict_dataset)
tolerance = get_tolerance(distribution_for_saving,
distribution_for_restoring)

17
tensorflow/python/keras/callbacks_test.py
View File

@ -140,8 +140,7 @@ class CallbackCountsTest(keras_parameterized.TestCase):
model.compile(
adam.AdamOptimizer(0.001),
'binary_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
@parameterized.named_parameters(('with_numpy', _get_numpy()),
@ -257,8 +256,7 @@ class KerasCallbacksTest(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=[keras.metrics.CategoricalAccuracy(name='my_acc')],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
@keras_parameterized.run_with_all_model_types
@ -1516,8 +1514,7 @@ class TestTensorBoardV2(keras_parameterized.TestCase):
model.compile(
opt,
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
def test_TensorBoard_default_logdir(self):
@ -1703,7 +1700,7 @@ class TestTensorBoardV2(keras_parameterized.TestCase):
)
def test_custom_summary(self):
if not testing_utils.should_run_tf_function():
if not context.executing_eagerly():
self.skipTest('Custom summaries only supported in V2 code path.')
def scalar_v2_mock(name, data, step=None):
@ -1732,8 +1729,7 @@ class TestTensorBoardV2(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
tb_cbk = keras.callbacks.TensorBoard(self.logdir, update_freq=1)
x, y = np.ones((10, 5)), np.ones((10, 5))
model.fit(x, y, batch_size=2, validation_data=(x, y), callbacks=[tb_cbk])
@ -1801,8 +1797,7 @@ class TestTensorBoardV2NonParameterizedTest(keras_parameterized.TestCase):
model.compile(
opt,
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
def _get_trace_file(self, logdir):

257
tensorflow/python/keras/distribute/distribute_strategy_test.py
View File

@ -254,11 +254,9 @@ def all_strategy_combinations():
def all_strategy_combinations_plus_run_distributed():
return (combinations.combine(
distribution=strategies_minus_tpu,
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]) + combinations.combine(
mode=['graph', 'eager']) + combinations.combine(
distribution=tpu_strategies,
mode=['graph', 'eager'],
experimental_run_tf_function=[False]))
mode=['graph', 'eager']))
def all_strategy_minus_default_and_tpu_combinations():
@ -294,12 +292,10 @@ def strategy_and_optimizer_combinations():
strategy_combinations.nadam_optimizer_keras_v2_fn,
strategy_combinations.rmsprop_optimizer_keras_v2_fn,
strategy_combinations.ftrl_optimizer_keras_v2_fn
],
experimental_run_tf_function=[True, False]))
]))
tpu_strategies_graph = combinations.combine(
distribution=tpu_strategies,
mode=['graph'],
experimental_run_tf_function=[True],
optimizer=[
strategy_combinations.adagrad_optimizer_v1_fn,
strategy_combinations.adam_optimizer_v1_fn,
@ -313,7 +309,6 @@ def strategy_and_optimizer_combinations():
tpu_strategies_eager = combinations.combine(
distribution=tpu_strategies,
mode=['eager'],
experimental_run_tf_function=[False],
optimizer=[
strategy_combinations.adagrad_optimizer_keras_v2_fn,
strategy_combinations.adam_optimizer_keras_v2_fn,
@ -428,8 +423,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
distribution, 64, steps=10, batch_size=13)
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_calling_model_with_numpy_arrays(self, distribution,
experimental_run_tf_function):
def test_calling_model_with_numpy_arrays(self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -440,8 +434,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
inputs = np.zeros((64, 3), dtype=np.float32)
targets = np.zeros((64, 4), dtype=np.float32)
@ -464,8 +457,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
model.predict(inputs, batch_size=8)
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_calling_model_with_mixed_precision(self, distribution,
experimental_run_tf_function):
def test_calling_model_with_mixed_precision(self, distribution):
if isinstance(distribution,
(tpu_strategy.TPUStrategy, tpu_strategy.TPUStrategyV1)):
policy_name = 'mixed_bfloat16'
@ -485,8 +477,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
# We need to pass float32 since TPUs do not support float64, even though
# these arrays will immediately be casted to bfloat16 on TPUs. We also
@ -509,8 +500,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
model.predict(inputs, batch_size=8)
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_operator_overload_mixed_precision(self, distribution,
experimental_run_tf_function):
def test_operator_overload_mixed_precision(self, distribution):
# Regression test that tests a fixed bug does not reoccur. Adding an
# AutoCastVariable to a tensor on a TPU, where the variable was the LHS of
# the '+' operator, used to cause the gradient w.r.t. the variable to be
@ -565,8 +555,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_calling_model_with_nested_numpy_arrays(self, distribution,
experimental_run_tf_function):
def test_calling_model_with_nested_numpy_arrays(self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -575,8 +564,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
input_a_np = np.asarray(np.random.random((64, 3)), dtype=np.float32)
input_b_np = np.asarray(np.random.random((64, 5)), dtype=np.float32)
@ -600,18 +588,15 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
@combinations.generate(
combinations.combine(
distribution=strategies_minus_tpu,
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
def test_numpy_with_sample_weights(self, distribution,
experimental_run_tf_function):
mode=['graph', 'eager']))
def test_numpy_with_sample_weights(self, distribution):
with self.cached_session(), distribution.scope():
model = get_sample_weights_model()
optimizer = rmsprop.RMSPropOptimizer(learning_rate=0.001)
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
inputs = np.array([[0], [1], [2], [3]], np.float32)
targets = np.array([[2], [4], [6], [8]], np.float32)
@ -642,8 +627,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
self.assertAllClose(result, 13.5)
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_flatten_predict_outputs(self, distribution,
experimental_run_tf_function):
def test_flatten_predict_outputs(self, distribution):
with self.cached_session():
with distribution.scope():
model = multi_input_output_model()
@ -652,8 +636,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
# We take 6 input samples with each input having a dimension of 3 or 5.
input_a_np = np.asarray(np.random.random((6, 3)), dtype=np.float32)
@ -715,10 +698,8 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
@combinations.generate(
combinations.times(
tpu_strategy_combinations_graph_only(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_predict_with_partial_batch(self, distribution,
experimental_run_tf_function):
tpu_strategy_combinations_graph_only()))
def test_predict_with_partial_batch(self, distribution):
with self.cached_session():
optimizer = gradient_descent.GradientDescentOptimizer(0.001)
loss = 'mse'
@ -727,8 +708,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
model_with_ds_strategy = get_model()
model_with_ds_strategy.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
cpu_model = get_model()
cpu_model.compile(optimizer, loss)
@ -780,10 +760,9 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
@combinations.generate(
combinations.times(
tpu_strategy_combinations_graph_only(),
combinations.combine(experimental_run_tf_function=[True, False])))
tpu_strategy_combinations_graph_only()))
def test_predict_multi_output_model_with_partial_batch(
self, distribution, experimental_run_tf_function):
self, distribution):
with self.cached_session():
optimizer = gradient_descent.GradientDescentOptimizer(0.001)
loss = 'mse'
@ -792,8 +771,7 @@ class TestDistributionStrategyWithNumpyArrays(test.TestCase,
model_with_ds_strategy = simple_multi_inputs_multi_outputs_model()
model_with_ds_strategy.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
cpu_model = simple_multi_inputs_multi_outputs_model()
cpu_model.compile(optimizer, loss)
@ -820,8 +798,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
parameterized.TestCase):
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_calling_model_on_same_dataset(self, distribution,
experimental_run_tf_function):
def test_calling_model_on_same_dataset(self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -832,8 +809,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
dataset = get_dataset(distribution)
@ -856,7 +832,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_model_interleaved_eval_same_as_direct_eval(
self, distribution, experimental_run_tf_function):
self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -864,16 +840,14 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
user_controlled_model.compile(
optimizer_fn(0.001),
loss='mse',
metrics=['mae', keras.metrics.CategoricalAccuracy()],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['mae', keras.metrics.CategoricalAccuracy()])
interleaved_model = get_model()
interleaved_model.set_weights(user_controlled_model.get_weights())
interleaved_model.compile(
optimizer_fn(0.001),
loss='mse',
metrics=['mae', keras.metrics.CategoricalAccuracy()],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['mae', keras.metrics.CategoricalAccuracy()])
dataset = get_dataset(distribution)
@ -908,8 +882,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
[x[2] for x in user_controlled_output])
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_fit_with_tuple_and_dict_dataset_inputs(self, distribution,
experimental_run_tf_function):
def test_fit_with_tuple_and_dict_dataset_inputs(self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -920,8 +893,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
input_a_np = np.random.random((10, 3)).astype('float32')
input_b_np = np.random.random((10, 5)).astype('float32')
@ -948,7 +920,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_fit_with_dictionary_in_the_dataset_b135161171(
self, distribution, experimental_run_tf_function):
self, distribution):
def custom_loss(predict, label, weight):
bce = keras.losses.binary_crossentropy(label, predict)
@ -968,8 +940,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
outputs=[predict, my_loss])
model.add_loss(model.get_layer('my_loss').output)
model.compile(
optimizer='adam',
experimental_run_tf_function=experimental_run_tf_function)
optimizer='adam')
if context.executing_eagerly():
@ -993,7 +964,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_fit_eval_and_predict_methods_on_dataset_without_steps(
self, distribution, experimental_run_tf_function):
self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -1004,8 +975,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
inputs = np.zeros((1000, 3), dtype=np.float32)
targets = np.zeros((1000, 4), dtype=np.float32)
@ -1030,10 +1000,9 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(
combinations.times(
strategy_minus_tpu_combinations(),
combinations.combine(experimental_run_tf_function=[True, False])))
strategy_minus_tpu_combinations()))
def test_on_dataset_with_unknown_cardinality_without_steps(
self, distribution, experimental_run_tf_function, mode):
self, distribution, mode):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -1044,8 +1013,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
inputs = np.zeros((1000, 3), dtype=np.float32)
targets = np.zeros((1000, 4), dtype=np.float32)
@ -1087,10 +1055,8 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(
combinations.times(
tpu_strategy_combinations(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_on_dataset_with_unknown_cardinality(self, distribution,
experimental_run_tf_function):
tpu_strategy_combinations()))
def test_on_dataset_with_unknown_cardinality(self, distribution):
with self.cached_session():
with distribution.scope():
model = get_model()
@ -1099,8 +1065,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.compile(
gradient_descent.GradientDescentOptimizer(0.001),
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
inputs = np.zeros((1000, 3), dtype=np.float32)
targets = np.zeros((1000, 4), dtype=np.float32)
@ -1133,7 +1098,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_fit_eval_and_predict_methods_on_dataset(
self, distribution, experimental_run_tf_function):
self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -1144,8 +1109,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
dataset = get_dataset(distribution)
@ -1154,8 +1118,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.predict(get_predict_dataset(distribution), steps=2)
@combinations.generate(strategy_and_optimizer_combinations())
def test_fit_eval_and_predict_with_optimizer(self, distribution, optimizer,
experimental_run_tf_function):
def test_fit_eval_and_predict_with_optimizer(self, distribution, optimizer):
with self.cached_session():
with distribution.scope():
@ -1164,8 +1127,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
loss = 'mse'
model.compile(
optimizer(),
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
dataset = get_dataset(distribution)
@ -1179,10 +1141,8 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
strategy_combinations.one_device_strategy
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
def test_dataset_wrong_input_shape(self, distribution,
experimental_run_tf_function, mode):
mode=['graph', 'eager']))
def test_dataset_wrong_input_shape(self, distribution, mode):
if mode == 'graph':
self.skipTest(
'TODO(b/120943676, b/120957836): Re-enable for graph once the '
@ -1195,8 +1155,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
# Wrong input shape
inputs = np.zeros((10, 5), dtype=np.float32)
@ -1213,10 +1172,9 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
distribution=[
strategy_combinations.mirrored_strategy_with_gpu_and_cpu
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
mode=['graph', 'eager']))
def test_dataset_external_batch_input_validation(
self, distribution, experimental_run_tf_function):
self, distribution):
with self.cached_session():
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
@ -1225,8 +1183,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
# Batching is done outside tf.data's `batch`
inputs = np.zeros((100, 10, 3), dtype=np.float32)
@ -1242,10 +1199,8 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
strategy_combinations.mirrored_strategy_with_two_gpus
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
def test_learning_phase_value(self, distribution,
experimental_run_tf_function):
mode=['graph', 'eager']))
def test_learning_phase_value(self, distribution):
# TODO(anjalisridhar): Modify this test to use Lambdas since we can compare
# meaningful values. Currently we don't pass the learning phase if the
# Lambda layer uses the learning phase.
@ -1264,8 +1219,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
batch_size = 8
if isinstance(distribution, mirrored_strategy.MirroredStrategy):
@ -1295,8 +1249,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
self.assertArrayNear(output, ref_output, 1e-1)
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def testOptimizerWithCallbacks(self, distribution,
experimental_run_tf_function):
def testOptimizerWithCallbacks(self, distribution):
with self.cached_session():
with distribution.scope():
model = get_model()
@ -1304,8 +1257,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
dataset = get_dataset(distribution)
@ -1363,10 +1315,9 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(
combinations.times(
tpu_strategy_combinations_graph_only(),
combinations.combine(experimental_run_tf_function=[True, False])))
tpu_strategy_combinations_graph_only()))
def test_predict_with_dataset_with_partial_batch(
self, distribution, experimental_run_tf_function):
self, distribution):
with self.cached_session():
optimizer = gradient_descent.GradientDescentOptimizer(0.001)
loss = 'mse'
@ -1375,8 +1326,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model_with_ds_strategy = get_model()
model_with_ds_strategy.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
cpu_model = get_model()
cpu_model.compile(optimizer, loss)
@ -1397,10 +1347,9 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(
combinations.times(
tpu_strategy_combinations_graph_only(),
combinations.combine(experimental_run_tf_function=[True, False])))
tpu_strategy_combinations_graph_only()))
def test_predict_multi_output_model_with_dataset_with_partial_batch(
self, distribution, experimental_run_tf_function):
self, distribution):
with self.cached_session():
optimizer = gradient_descent.GradientDescentOptimizer(0.001)
loss = 'mse'
@ -1409,8 +1358,7 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
model_with_ds_strategy = simple_multi_inputs_multi_outputs_model()
model_with_ds_strategy.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
cpu_model = simple_multi_inputs_multi_outputs_model()
cpu_model.compile(optimizer, loss)
@ -1490,18 +1438,15 @@ class TestDistributionStrategyWithDatasets(test.TestCase,
@combinations.generate(
combinations.combine(
distribution=strategies_minus_tpu,
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
def test_dataset_with_sample_weights(self, distribution,
experimental_run_tf_function):
mode=['graph', 'eager']))
def test_dataset_with_sample_weights(self, distribution):
with self.cached_session(), distribution.scope():
model = get_sample_weights_model()
optimizer = rmsprop.RMSPropOptimizer(learning_rate=0.001)
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
inputs = np.array([[0], [1], [2], [3]], np.float32)
targets = np.array([[2], [4], [6], [8]], np.float32)
@ -1553,9 +1498,8 @@ class TestRegularizerLoss(test.TestCase, parameterized.TestCase):
@combinations.generate(
combinations.times(
strategy_combinations.all_strategy_combinations_minus_default(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_regularizer_loss(self, distribution, experimental_run_tf_function):
strategy_combinations.all_strategy_combinations_minus_default()))
def test_regularizer_loss(self, distribution):
batch_size = 2
if not distributed_training_utils.global_batch_size_supported(distribution):
batch_size //= distribution.num_replicas_in_sync
@ -1576,8 +1520,7 @@ class TestRegularizerLoss(test.TestCase, parameterized.TestCase):
opt = gradient_descent_keras.SGD(1.)
model.compile(
opt,
loss=TestRegularizerLoss.loss_fn,
experimental_run_tf_function=experimental_run_tf_function)
loss=TestRegularizerLoss.loss_fn)
model.fit(
x=np.array([[1.], [1.]], dtype=np.float32),
y=np.array([[1.], [1.]], dtype=np.float32),
@ -1591,7 +1534,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_distribution_strategy_on_sequential_model(
self, distribution, experimental_run_tf_function):
self, distribution):
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
optimizer = optimizer_fn(learning_rate=0.001)
@ -1599,8 +1542,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
inputs = np.zeros((20, 10), np.float32)
targets = np.zeros((20, 2), np.float32)
@ -1611,7 +1553,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(all_strategy_combinations_plus_run_distributed())
def test_distribution_strategy_on_functional_model(
self, distribution, experimental_run_tf_function):
self, distribution):
with distribution.scope():
optimizer_fn = gradient_descent_keras.SGD
optimizer = optimizer_fn(learning_rate=0.001)
@ -1619,8 +1561,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
loss = 'mse'
model.compile(
optimizer,
loss,
experimental_run_tf_function=experimental_run_tf_function)
loss)
inputs = np.zeros((64, 3), dtype=np.float32)
targets = np.zeros((64, 4), dtype=np.float32)
@ -1631,10 +1572,8 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(
combinations.times(
all_strategy_combinations_minus_default(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_distribution_strategy_one_dimensional(self, distribution,
experimental_run_tf_function):
all_strategy_combinations_minus_default()))
def test_distribution_strategy_one_dimensional(self, distribution):
with distribution.scope():
inp = keras.layers.Input(shape=(10,))
out = keras.layers.Dense(3, activation='softmax')(inp)
@ -1642,8 +1581,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
model.compile(
optimizer='rmsprop',
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['sparse_categorical_accuracy'])
x = np.random.random((64, 10)).astype('float32')
y = np.random.randint(3, size=64)
@ -1657,14 +1595,13 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
strategy_combinations.mirrored_strategy_with_two_gpus
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False],
reduction=[
loss_reduction.ReductionV2.AUTO,
loss_reduction.ReductionV2.SUM_OVER_BATCH_SIZE,
loss_reduction.ReductionV2.SUM
]))
def test_distribution_strategy_with_loss_reduction_types(
self, distribution, experimental_run_tf_function, reduction):
self, distribution, reduction):
np.random.seed(_RANDOM_SEED)
def _get_model():
@ -1689,8 +1626,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
ds_model = _get_model()
ds_model.compile(
'sgd',
loss=keras.losses.MeanSquaredError(reduction=reduction),
experimental_run_tf_function=experimental_run_tf_function)
loss=keras.losses.MeanSquaredError(reduction=reduction))
ds_history = ds_model.fit(
dataset, steps_per_epoch=2, epochs=1, shuffle=False)
self.assertArrayNear(history.history['loss'], ds_history.history['loss'],
@ -1698,10 +1634,9 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(
combinations.times(
all_strategy_combinations_minus_default(),
combinations.combine(experimental_run_tf_function=[True, False])))
all_strategy_combinations_minus_default()))
def test_distribution_strategy_with_symbolic_add_loss(
self, mode, distribution, experimental_run_tf_function):
self, mode, distribution):
def _make_model_with_add_loss():
inputs = keras.Input((10,))
@ -1722,7 +1657,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
with distribution.scope():
ds_model = _make_model_with_add_loss()
ds_model.compile(
'sgd', experimental_run_tf_function=experimental_run_tf_function)
'sgd')
ds_history = ds_model.fit(x, epochs=1)
self.assertAllClose(history.history, ds_history.history)
@ -1761,10 +1696,9 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(
combinations.times(
all_strategy_minus_default_and_tpu_combinations(),
combinations.combine(experimental_run_tf_function=[True, False])))
all_strategy_minus_default_and_tpu_combinations()))
def test_distribution_strategy_with_add_metric_in_call(
self, distribution, experimental_run_tf_function):
self, distribution):
class Bias(keras.layers.Layer):
@ -1799,8 +1733,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
self.assertLen(ds_model.metrics, 1)
ds_model.compile(
'sgd',
'mse',
experimental_run_tf_function=experimental_run_tf_function)
'mse')
ds_history = ds_model.fit(
x, y, validation_data=(x, y), validation_steps=2, epochs=2)
# includes stateful loss metric in eager.
@ -1817,10 +1750,9 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
strategy_combinations.mirrored_strategy_with_two_gpus,
],
mode=['eager'],
experimental_run_tf_function=[False]))
mode=['eager']))
def test_distribution_strategy_with_add_metric_object(
self, distribution, experimental_run_tf_function):
self, distribution):
class Bias(keras.layers.Layer):
@ -1855,8 +1787,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
self.assertLen(ds_model.metrics, 1)
ds_model.compile(
'sgd',
'mse',
experimental_run_tf_function=experimental_run_tf_function)
'mse')
ds_history = ds_model.fit(
x, y, validation_data=(x, y), validation_steps=2, epochs=2)
# includes stateful loss metric in eager.
@ -1868,10 +1799,9 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(
# TODO(phillypham): Why does validation_steps > 1 not work on TPUs?
combinations.times(
all_strategy_minus_default_and_tpu_combinations(),
combinations.combine(experimental_run_tf_function=[True, False])))
all_strategy_minus_default_and_tpu_combinations()))
def test_distribution_strategy_with_add_metric_outside_call(
self, distribution, experimental_run_tf_function):
self, distribution):
def _make_model_with_add_metric():
inputs = keras.Input((10,))
@ -1897,8 +1827,7 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
self.assertLen(ds_model.metrics, 1)
ds_model.compile(
'sgd',
'mse',
experimental_run_tf_function=experimental_run_tf_function)
'mse')
ds_history = ds_model.fit(
x, y, validation_data=(x, y), validation_steps=2, epochs=2)
# includes stateful loss metric in eager.
@ -1910,10 +1839,8 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(
combinations.combine(
distribution=strategies_minus_tpu,
mode=['eager'],
experimental_run_tf_function=[True]))
def test_sparse_tensor_outputs(self, distribution,
experimental_run_tf_function):
mode=['eager']))
def test_sparse_tensor_outputs(self, distribution):
class ToSparse(keras.layers.Layer):
"""Create a sparse tensor based on a given dense tensor."""
@ -1925,7 +1852,6 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
return sparse_tensor.SparseTensor(indices, values, dense_shape=shape)
model = keras.Sequential([ToSparse()])
model._experimental_run_tf_function = experimental_run_tf_function
# Define some input data with additional padding.
input_data = np.array([[1, 0, 0], [2, 3, 0]])
@ -1942,10 +1868,8 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
@combinations.generate(
combinations.combine(
distribution=strategies_minus_tpu,
mode=['eager'],
experimental_run_tf_function=[True]))
def test_ragged_tensor_outputs(self, distribution,
experimental_run_tf_function):
mode=['eager']))
def test_ragged_tensor_outputs(self, distribution):
class ToRagged(keras.layers.Layer):
"""Create a ragged tensor based on a given dense tensor."""
@ -1960,7 +1884,6 @@ class TestDistributionStrategyWithKerasModels(test.TestCase,
inputs, padding=self._padding, ragged_rank=self._ragged_rank)
model = keras.Sequential([ToRagged(padding=0)])
model._experimental_run_tf_function = experimental_run_tf_function
# Define some input data with additional padding.
input_data = np.array([[1, 0, 0], [2, 3, 0]])

22
tensorflow/python/keras/distribute/keras_correctness_test_base.py
View File

@ -67,8 +67,7 @@ def graph_mode_test_configuration():
def all_strategy_and_input_config_combinations():
return (combinations.times(
combinations.combine(
distribution=all_strategies,
experimental_run_tf_function=[True, False]),
distribution=all_strategies),
eager_mode_test_configuration() + graph_mode_test_configuration()))
@ -100,12 +99,10 @@ def test_combinations_for_embedding_model():
return (combinations.times(
combinations.combine(
distribution=strategies_for_embedding_models(),
experimental_run_tf_function=[True, False]),
distribution=strategies_for_embedding_models()),
(graph_mode_test_configuration())) + combinations.times(
combinations.combine(
distribution=eager_mode_strategies,
experimental_run_tf_function=[False]),
distribution=eager_mode_strategies),
(eager_mode_test_configuration())))
@ -249,13 +246,11 @@ def get_correctness_test_inputs(use_numpy, use_validation_data,
def fit_eval_and_predict(initial_weights,
input_fn,
model_fn,
experimental_run_tf_function=None,
distribution=None,
is_stateful_model=False):
"""Generates results for fit/predict/evaluate for given model."""
training_inputs, eval_inputs, predict_inputs = input_fn()
model = model_fn(
experimental_run_tf_function=experimental_run_tf_function,
initial_weights=initial_weights,
distribution=distribution,
input_shapes=get_shapes(training_inputs['x']))
@ -426,7 +421,6 @@ class TestDistributionStrategyCorrectnessBase(test.TestCase,
def get_model(self,
distribution=None,
experimental_run_tf_function=None,
input_shapes=None):
raise NotImplementedError
@ -434,7 +428,6 @@ class TestDistributionStrategyCorrectnessBase(test.TestCase,
distribution,
use_numpy,
use_validation_data,
experimental_run_tf_function=None,
with_batch_norm=None,
is_stateful_model=False,
partial_last_batch=None,
@ -457,7 +450,6 @@ class TestDistributionStrategyCorrectnessBase(test.TestCase,
# This is used to initialize the model for both the distribution and
# non-distribution run.
model = self.get_model(
experimental_run_tf_function=experimental_run_tf_function,
input_shapes=get_shapes(x_train))
initial_weights = model.get_weights()
@ -489,14 +481,12 @@ class TestDistributionStrategyCorrectnessBase(test.TestCase,
initial_weights,
input_fn=ds_input_fn,
model_fn=self.get_model,
experimental_run_tf_function=experimental_run_tf_function,
distribution=distribution,
is_stateful_model=is_stateful_model)
results_without_ds = fit_eval_and_predict(
initial_weights,
input_fn=nods_input_fn,
model_fn=self.get_model,
experimental_run_tf_function=experimental_run_tf_function,
distribution=None,
is_stateful_model=is_stateful_model)
@ -538,14 +528,12 @@ class TestDistributionStrategyCorrectnessBase(test.TestCase,
return training_input, None, None
def run_dynamic_lr_test(self,
distribution,
experimental_run_tf_function=None):
distribution):
with self.cached_session():
self.set_up_test_config()
x_train, y_train, _ = self.get_data()
model = self.get_model(
experimental_run_tf_function=experimental_run_tf_function,
input_shapes=get_shapes(x_train))
initial_weights = model.get_weights()
update_freq = None
@ -587,13 +575,11 @@ class TestDistributionStrategyCorrectnessBase(test.TestCase,
initial_weights,
input_fn=ds_input_fn,
model_fn=self.get_model,
experimental_run_tf_function=experimental_run_tf_function,
distribution=distribution)
results_without_ds = fit_eval_and_predict(
initial_weights,
input_fn=nods_input_fn,
model_fn=self.get_model,
experimental_run_tf_function=experimental_run_tf_function,
distribution=None)
compare_results(
results_with_ds, results_without_ds, distribution, testcase=self)

78
tensorflow/python/keras/distribute/keras_dnn_correctness_test.py
View File

@ -33,15 +33,13 @@ from tensorflow.python.training import gradient_descent
def all_strategy_combinations_with_eager_and_graph_modes():
return (combinations.combine(
distribution=keras_correctness_test_base.all_strategies,
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
mode=['graph', 'eager']))
def all_strategy_combinations_with_graph_mode():
return (combinations.combine(
distribution=keras_correctness_test_base.all_strategies,
mode=['graph'],
experimental_run_tf_function=[True, False]))
mode=['graph']))
def is_default_strategy(strategy):
@ -53,7 +51,6 @@ class TestDistributionStrategyDnnCorrectness(
keras_correctness_test_base.TestDistributionStrategyCorrectnessBase):
def get_model(self,
experimental_run_tf_function,
initial_weights=None,
distribution=None,
input_shapes=None):
@ -75,8 +72,7 @@ class TestDistributionStrategyDnnCorrectness(
model.compile(
loss=keras.losses.mean_squared_error,
optimizer=gradient_descent_keras.SGD(0.05),
metrics=['mse'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['mse'])
return model
def get_data(self):
@ -103,10 +99,8 @@ class TestDistributionStrategyDnnCorrectness(
@combinations.generate(
keras_correctness_test_base.all_strategy_and_input_config_combinations())
def test_dnn_correctness(self, distribution, use_numpy, use_validation_data,
experimental_run_tf_function):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
def test_dnn_correctness(self, distribution, use_numpy, use_validation_data):
self.run_correctness_test(distribution, use_numpy, use_validation_data)
@combinations.generate(
keras_correctness_test_base.test_combinations_with_tpu_strategies())
@ -131,16 +125,14 @@ class TestDistributionStrategyDnnCorrectness(
training_epochs=1)
@combinations.generate(all_strategy_combinations_with_graph_mode())
def test_dnn_with_dynamic_learning_rate(self, distribution,
experimental_run_tf_function):
self.run_dynamic_lr_test(distribution, experimental_run_tf_function)
def test_dnn_with_dynamic_learning_rate(self, distribution):
self.run_dynamic_lr_test(distribution)
class TestDistributionStrategyDnnMetricCorrectness(
keras_correctness_test_base.TestDistributionStrategyCorrectnessBase):
def get_model(self,
experimental_run_tf_function,
distribution=None,
input_shapes=None):
with distribution.scope():
@ -150,18 +142,16 @@ class TestDistributionStrategyDnnMetricCorrectness(
model.compile(
loss=keras.losses.mean_squared_error,
optimizer=gradient_descent_keras.SGD(0.05),
metrics=[keras.metrics.BinaryAccuracy()],
experimental_run_tf_function=experimental_run_tf_function)
metrics=[keras.metrics.BinaryAccuracy()])
return model
def run_metric_correctness_test(self, distribution,
experimental_run_tf_function):
def run_metric_correctness_test(self, distribution):
with self.cached_session():
self.set_up_test_config()
x_train, y_train, _ = self.get_data()
model = self.get_model(
experimental_run_tf_function, distribution=distribution)
distribution=distribution)
batch_size = 64
batch_size = (
@ -174,16 +164,14 @@ class TestDistributionStrategyDnnMetricCorrectness(
self.assertEqual(history.history['binary_accuracy'], [1.0, 1.0])
@combinations.generate(all_strategy_combinations_with_eager_and_graph_modes())
def test_simple_dnn_metric_correctness(self, distribution,
experimental_run_tf_function):
self.run_metric_correctness_test(distribution, experimental_run_tf_function)
def test_simple_dnn_metric_correctness(self, distribution):
self.run_metric_correctness_test(distribution)
class TestDistributionStrategyDnnMetricEvalCorrectness(
keras_correctness_test_base.TestDistributionStrategyCorrectnessBase):
def get_model(self,
experimental_run_tf_function,
distribution=None,
input_shapes=None):
with distribution.scope():
@ -197,17 +185,15 @@ class TestDistributionStrategyDnnMetricEvalCorrectness(
model.compile(
loss='mae',
metrics=['accuracy', keras.metrics.BinaryAccuracy()],
optimizer=gradient_descent.GradientDescentOptimizer(0.001),
experimental_run_tf_function=experimental_run_tf_function)
optimizer=gradient_descent.GradientDescentOptimizer(0.001))
return model
def run_eval_metrics_correctness_test(self, distribution,
experimental_run_tf_function):
def run_eval_metrics_correctness_test(self, distribution):
with self.cached_session():
self.set_up_test_config()
model = self.get_model(
experimental_run_tf_function, distribution=distribution)
distribution=distribution)
# verify correctness of stateful and stateless metrics.
x = np.ones((100, 4)).astype('float32')
@ -226,10 +212,8 @@ class TestDistributionStrategyDnnMetricEvalCorrectness(
self.assertEqual(outs[2], 0.)
@combinations.generate(all_strategy_combinations_with_eager_and_graph_modes())
def test_identity_model_metric_eval_correctness(self, distribution,
experimental_run_tf_function):
self.run_eval_metrics_correctness_test(distribution,
experimental_run_tf_function)
def test_identity_model_metric_eval_correctness(self, distribution):
self.run_eval_metrics_correctness_test(distribution)
class SubclassedModel(keras.Model):
@ -260,7 +244,6 @@ class TestDistributionStrategyDnnCorrectnessWithSubclassedModel(
TestDistributionStrategyDnnCorrectness):
def get_model(self,
experimental_run_tf_function,
initial_weights=None,
distribution=None,
input_shapes=None):
@ -270,53 +253,46 @@ class TestDistributionStrategyDnnCorrectnessWithSubclassedModel(
model.compile(
loss=keras.losses.mean_squared_error,
optimizer=gradient_descent_keras.SGD(0.05),
metrics=['mse'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['mse'])
return model
@combinations.generate(
keras_correctness_test_base.all_strategy_and_input_config_combinations())
def test_dnn_correctness(self, distribution, use_numpy, use_validation_data,
experimental_run_tf_function):
def test_dnn_correctness(self, distribution, use_numpy, use_validation_data):
if (context.executing_eagerly()) or is_default_strategy(distribution):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
self.run_correctness_test(distribution, use_numpy, use_validation_data)
elif K.is_tpu_strategy(distribution) and not context.executing_eagerly():
with self.assertRaisesRegexp(
ValueError,
'Expected `model` argument to be a functional `Model` instance, '
'but got a subclass model instead.'):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
self.run_correctness_test(distribution, use_numpy, use_validation_data)
else:
with self.assertRaisesRegexp(
ValueError,
'We currently do not support distribution strategy with a '
'`Sequential` model that is created without `input_shape`/'
'`input_dim` set in its first layer or a subclassed model.'):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
self.run_correctness_test(distribution, use_numpy, use_validation_data)
@combinations.generate(all_strategy_combinations_with_graph_mode())
def test_dnn_with_dynamic_learning_rate(self, distribution,
experimental_run_tf_function):
if ((not experimental_run_tf_function and context.executing_eagerly() and
not K.is_tpu_strategy(distribution)) or
def test_dnn_with_dynamic_learning_rate(self, distribution):
if ((context.executing_eagerly() and not K.is_tpu_strategy(distribution)) or
is_default_strategy(distribution)):
self.run_dynamic_lr_test(distribution, experimental_run_tf_function)
self.run_dynamic_lr_test(distribution)
elif K.is_tpu_strategy(distribution):
with self.assertRaisesRegexp(
ValueError,
'Expected `model` argument to be a functional `Model` instance, '
'but got a subclass model instead.'):
self.run_dynamic_lr_test(distribution, experimental_run_tf_function)
self.run_dynamic_lr_test(distribution)
else:
with self.assertRaisesRegexp(
ValueError,
'We currently do not support distribution strategy with a '
'`Sequential` model that is created without `input_shape`/'
'`input_dim` set in its first layer or a subclassed model.'):
self.run_dynamic_lr_test(distribution, experimental_run_tf_function)
self.run_dynamic_lr_test(distribution)
@combinations.generate(
keras_correctness_test_base.test_combinations_with_tpu_strategies())

24
tensorflow/python/keras/distribute/keras_embedding_model_correctness_test.py
View File

@ -33,7 +33,6 @@ class DistributionStrategyEmbeddingModelCorrectnessTest(
max_words=10,
initial_weights=None,
distribution=None,
experimental_run_tf_function=None,
input_shapes=None):
del input_shapes
with keras_correctness_test_base.MaybeDistributionScope(distribution):
@ -53,28 +52,23 @@ class DistributionStrategyEmbeddingModelCorrectnessTest(
model.compile(
optimizer=gradient_descent_keras.SGD(learning_rate=0.1),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['sparse_categorical_accuracy'])
return model
@combinations.generate(
keras_correctness_test_base.test_combinations_for_embedding_model())
def test_embedding_model_correctness(self, distribution, use_numpy,
use_validation_data,
experimental_run_tf_function):
use_validation_data):
self.use_distributed_dense = False
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
self.run_correctness_test(distribution, use_numpy, use_validation_data)
@combinations.generate(
keras_correctness_test_base.test_combinations_for_embedding_model())
def test_embedding_time_distributed_model_correctness(
self, distribution, use_numpy, use_validation_data,
experimental_run_tf_function):
self, distribution, use_numpy, use_validation_data):
self.use_distributed_dense = True
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
self.run_correctness_test(distribution, use_numpy, use_validation_data)
class DistributionStrategySiameseEmbeddingModelCorrectnessTest(
@ -85,7 +79,6 @@ class DistributionStrategySiameseEmbeddingModelCorrectnessTest(
max_words=10,
initial_weights=None,
distribution=None,
experimental_run_tf_function=None,
input_shapes=None):
del input_shapes
with keras_correctness_test_base.MaybeDistributionScope(distribution):
@ -119,7 +112,6 @@ class DistributionStrategySiameseEmbeddingModelCorrectnessTest(
model.compile(
optimizer=gradient_descent_keras.SGD(learning_rate=0.1),
loss='mse',
experimental_run_tf_function=experimental_run_tf_function,
metrics=['mse'])
return model
@ -156,10 +148,8 @@ class DistributionStrategySiameseEmbeddingModelCorrectnessTest(
@combinations.generate(
keras_correctness_test_base.test_combinations_for_embedding_model())
def test_siamese_embedding_model_correctness(self, distribution, use_numpy,
use_validation_data,
experimental_run_tf_function):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
use_validation_data):
self.run_correctness_test(distribution, use_numpy, use_validation_data)
if __name__ == '__main__':

24
tensorflow/python/keras/distribute/keras_image_model_correctness_test.py
View File

@ -32,7 +32,6 @@ class DistributionStrategyCnnCorrectnessTest(
def get_model(self,
initial_weights=None,
distribution=None,
experimental_run_tf_function=None,
input_shapes=None):
del input_shapes
with keras_correctness_test_base.MaybeDistributionScope(distribution):
@ -60,8 +59,7 @@ class DistributionStrategyCnnCorrectnessTest(
model.compile(
optimizer=gradient_descent.SGD(learning_rate=0.1),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['sparse_categorical_accuracy'])
return model
@ -95,38 +93,32 @@ class DistributionStrategyCnnCorrectnessTest(
@combinations.generate(
keras_correctness_test_base.all_strategy_and_input_config_combinations())
def test_cnn_correctness(self, distribution, use_numpy, use_validation_data,
experimental_run_tf_function):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
def test_cnn_correctness(self, distribution, use_numpy, use_validation_data):
self.run_correctness_test(distribution, use_numpy, use_validation_data)
@combinations.generate(
keras_correctness_test_base.all_strategy_and_input_config_combinations())
def test_cnn_with_batch_norm_correctness(self, distribution, use_numpy,
use_validation_data,
experimental_run_tf_function):
use_validation_data):
self.skipTest('Flakily times out, b/134670856')
self.run_correctness_test(
distribution,
use_numpy,
use_validation_data,
with_batch_norm='regular',
experimental_run_tf_function=experimental_run_tf_function)
with_batch_norm='regular')
@combinations.generate(
keras_correctness_test_base.all_strategy_and_input_config_combinations())
def test_cnn_with_sync_batch_norm_correctness(self, distribution, use_numpy,
use_validation_data,
experimental_run_tf_function):
if not context.executing_eagerly() or not experimental_run_tf_function:
use_validation_data):
if not context.executing_eagerly():
self.skipTest('SyncBatchNorm is not enabled in graph mode.')
self.run_correctness_test(
distribution,
use_numpy,
use_validation_data,
with_batch_norm='sync',
experimental_run_tf_function=experimental_run_tf_function)
with_batch_norm='sync')
@combinations.generate(
keras_correctness_test_base.test_combinations_with_tpu_strategies() +

9
tensorflow/python/keras/distribute/keras_optimizer_v2_test.py
View File

@ -107,10 +107,8 @@ class MirroredStrategyOptimizerV2Test(test.TestCase, parameterized.TestCase):
distribution=[
strategy_combinations.central_storage_strategy_with_two_gpus,
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
def testOptimizerWithKerasModelAndNumpyArrays(self, distribution,
experimental_run_tf_function):
mode=['graph', 'eager']))
def testOptimizerWithKerasModelAndNumpyArrays(self, distribution):
self.skipTest('b/130309197')
with self.cached_session():
with distribution.scope():
@ -121,8 +119,7 @@ class MirroredStrategyOptimizerV2Test(test.TestCase, parameterized.TestCase):
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
inputs = np.zeros((64, 3), dtype=np.float32)
targets = np.zeros((64, 4), dtype=np.float32)

5
tensorflow/python/keras/distribute/keras_premade_models_test.py
View File

@ -64,7 +64,7 @@ class KerasPremadeModelsTest(test.TestCase, parameterized.TestCase):
with distribution.scope():
model = linear.LinearModel()
opt = gradient_descent.SGD(learning_rate=0.1)
model.compile(opt, 'mse', experimental_run_tf_function=True)
model.compile(opt, 'mse')
if data_fn == get_numpy:
inputs, output = get_numpy()
hist = model.fit(inputs, output, epochs=5)
@ -82,8 +82,7 @@ class KerasPremadeModelsTest(test.TestCase, parameterized.TestCase):
dnn_opt = adagrad.Adagrad(learning_rate=0.1)
wide_deep_model.compile(
optimizer=[linear_opt, dnn_opt],
loss='mse',
experimental_run_tf_function=True)
loss='mse')
if data_fn == get_numpy:
inputs, output = get_numpy()
hist = wide_deep_model.fit(inputs, output, epochs=5)

22
tensorflow/python/keras/distribute/keras_rnn_model_correctness_test.py
View File

@ -43,7 +43,6 @@ class _DistributionStrategyRnnModelCorrectnessTest(
max_words=10,
initial_weights=None,
distribution=None,
experimental_run_tf_function=None,
input_shapes=None):
del input_shapes
rnn_cls = self._get_layer_class()
@ -66,8 +65,7 @@ class _DistributionStrategyRnnModelCorrectnessTest(
model.compile(
optimizer=optimizer_fn(learning_rate=0.1),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['sparse_categorical_accuracy'])
return model
@ -85,11 +83,9 @@ class DistributionStrategyGruModelCorrectnessTest(
@combinations.generate(
keras_correctness_test_base.test_combinations_for_embedding_model())
def test_gru_model_correctness(self, distribution, use_numpy,
use_validation_data,
experimental_run_tf_function):
use_validation_data):
self.skipTest('Test is sensitive to TF random seed, b/TBD')
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
self.run_correctness_test(distribution, use_numpy, use_validation_data)
class DistributionStrategyLstmModelCorrectnessTest(
@ -106,17 +102,14 @@ class DistributionStrategyLstmModelCorrectnessTest(
@combinations.generate(
keras_correctness_test_base.test_combinations_for_embedding_model())
def test_lstm_model_correctness(self, distribution, use_numpy,
use_validation_data,
experimental_run_tf_function):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
use_validation_data):
self.run_correctness_test(distribution, use_numpy, use_validation_data)
@combinations.generate(
keras_correctness_test_base.test_combinations_for_embedding_model())
@testing_utils.enable_v2_dtype_behavior
def test_lstm_model_correctness_mixed_precision(self, distribution, use_numpy,
use_validation_data,
experimental_run_tf_function):
use_validation_data):
if isinstance(distribution,
(tpu_strategy.TPUStrategy, tpu_strategy.TPUStrategyV1)):
policy_name = 'mixed_bfloat16'
@ -124,8 +117,7 @@ class DistributionStrategyLstmModelCorrectnessTest(
policy_name = 'mixed_float16'
with policy.policy_scope(policy_name):
self.run_correctness_test(distribution, use_numpy, use_validation_data,
experimental_run_tf_function)
self.run_correctness_test(distribution, use_numpy, use_validation_data)
if __name__ == '__main__':

19
tensorflow/python/keras/distribute/keras_stateful_lstm_model_correctness_test.py
View File

@ -40,8 +40,7 @@ def test_combinations_for_stateful_embedding_model():
distribution=strategies_for_stateful_embedding_model(),
mode='graph',
use_numpy=False,
use_validation_data=False,
experimental_run_tf_function=[True, False]))
use_validation_data=False))
class DistributionStrategyStatefulLstmModelCorrectnessTest(
@ -52,7 +51,6 @@ class DistributionStrategyStatefulLstmModelCorrectnessTest(
max_words=10,
initial_weights=None,
distribution=None,
experimental_run_tf_function=None,
input_shapes=None):
del input_shapes
batch_size = keras_correctness_test_base._GLOBAL_BATCH_SIZE
@ -86,22 +84,18 @@ class DistributionStrategyStatefulLstmModelCorrectnessTest(
# doesn't work and enable for DistributionStrategy more generally.
@combinations.generate(test_combinations_for_stateful_embedding_model())
def disabled_test_stateful_lstm_model_correctness(
self, distribution, use_numpy, use_validation_data,
experimental_run_tf_function):
self, distribution, use_numpy, use_validation_data):
self.run_correctness_test(
distribution,
use_numpy,
use_validation_data,
is_stateful_model=True,
experimental_run_tf_function=experimental_run_tf_function)
is_stateful_model=True)
@combinations.generate(
combinations.times(
keras_correctness_test_base.test_combinations_with_tpu_strategies(),
combinations.combine(experimental_run_tf_function=[True, False])))
keras_correctness_test_base.test_combinations_with_tpu_strategies()))
def test_incorrectly_use_multiple_cores_for_stateful_lstm_model(
self, distribution, use_numpy, use_validation_data,
experimental_run_tf_function):
self, distribution, use_numpy, use_validation_data):
with self.assertRaisesRegexp(
ValueError,
'RNNs with stateful=True not yet supported with '
@ -110,8 +104,7 @@ class DistributionStrategyStatefulLstmModelCorrectnessTest(
distribution,
use_numpy,
use_validation_data,
is_stateful_model=True,
experimental_run_tf_function=experimental_run_tf_function)
is_stateful_model=True)
if __name__ == '__main__':

94
tensorflow/python/keras/distribute/keras_utils_test.py
View File

@ -74,16 +74,14 @@ class TestDistributionStrategyWithCallbacks(test.TestCase,
@combinations.generate(
combinations.times(
keras_test_lib.all_strategy_combinations(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_callbacks_in_fit(self, distribution, experimental_run_tf_function):
keras_test_lib.all_strategy_combinations()))
def test_callbacks_in_fit(self, distribution):
with distribution.scope():
model = keras_test_lib.get_model()
model.compile(
optimizer='sgd',
loss='mse',
metrics=['mae'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['mae'])
dataset = keras_test_lib.get_dataset(distribution)
counter = Counter()
@ -130,16 +128,14 @@ class TestDistributionStrategyWithCallbacks(test.TestCase,
@combinations.generate(
combinations.times(
keras_test_lib.all_strategy_combinations(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_callbacks_in_eval(self, distribution, experimental_run_tf_function):
keras_test_lib.all_strategy_combinations()))
def test_callbacks_in_eval(self, distribution):
with distribution.scope():
model = keras_test_lib.get_model()
model.compile(
optimizer='sgd',
loss='mse',
metrics=['mae'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['mae'])
dataset = keras_test_lib.get_dataset(distribution)
counter = Counter()
@ -156,17 +152,14 @@ class TestDistributionStrategyWithCallbacks(test.TestCase,
@combinations.generate(
combinations.times(
keras_test_lib.all_strategy_combinations(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_callbacks_in_predict(self, distribution,
experimental_run_tf_function):
keras_test_lib.all_strategy_combinations()))
def test_callbacks_in_predict(self, distribution):
with distribution.scope():
model = keras_test_lib.get_model()
model.compile(
optimizer='sgd',
loss='mse',
metrics=['mae'],
experimental_run_tf_function=experimental_run_tf_function)
metrics=['mae'])
dataset = keras_test_lib.get_dataset(distribution)
counter = Counter()
@ -240,10 +233,8 @@ class TestDistributionStrategyErrorCases(test.TestCase, parameterized.TestCase):
distribution=[
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
def test_unsupported_features(self, distribution,
experimental_run_tf_function, mode):
mode=['graph', 'eager']))
def test_unsupported_features(self, distribution, mode):
with self.cached_session():
with distribution.scope():
model = keras_test_lib.get_model()
@ -253,8 +244,7 @@ class TestDistributionStrategyErrorCases(test.TestCase, parameterized.TestCase):
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
dataset = keras_test_lib.get_dataset(distribution)
# Test with validation split
@ -294,10 +284,9 @@ class TestDistributionStrategyErrorCases(test.TestCase, parameterized.TestCase):
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
strategy_combinations.one_device_strategy,
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
mode=['graph', 'eager']))
def test_distribution_strategy_on_subclassed_model(
self, distribution, experimental_run_tf_function):
self, distribution):
with distribution.scope():
class _SimpleMLP(keras.Model):
@ -318,10 +307,10 @@ class TestDistributionStrategyErrorCases(test.TestCase, parameterized.TestCase):
'`Sequential` model that is created without `input_shape`/'
'`input_dim` set in its first layer or a subclassed model.'):
model.compile(
'sgd', experimental_run_tf_function=experimental_run_tf_function)
'sgd')
else:
model.compile(
'sgd', experimental_run_tf_function=experimental_run_tf_function)
'sgd')
@combinations.generate(
combinations.combine(
@ -329,10 +318,9 @@ class TestDistributionStrategyErrorCases(test.TestCase, parameterized.TestCase):
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
strategy_combinations.one_device_strategy,
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False]))
mode=['graph', 'eager']))
def test_distribution_strategy_on_deferred_sequential_model(
self, distribution, experimental_run_tf_function):
self, distribution):
with distribution.scope():
model = keras.models.Sequential()
model.add(keras.layers.Dense(16, activation='relu'))
@ -340,7 +328,7 @@ class TestDistributionStrategyErrorCases(test.TestCase, parameterized.TestCase):
if context.executing_eagerly():
model.compile(
'sgd', experimental_run_tf_function=experimental_run_tf_function)
'sgd')
else:
with self.assertRaisesRegexp(
ValueError,
@ -349,7 +337,7 @@ class TestDistributionStrategyErrorCases(test.TestCase, parameterized.TestCase):
'`input_shape`/`input_dim` set in its first layer or '
'a subclassed model.'):
model.compile(
'sgd', experimental_run_tf_function=experimental_run_tf_function)
'sgd')
@combinations.generate(
keras_test_lib.all_strategy_combinations_minus_default())
@ -375,10 +363,9 @@ class TestDistributionStrategyWithLossMasking(test.TestCase,
strategy_combinations.mirrored_strategy_with_gpu_and_cpu,
],
mode=['graph', 'eager'],
experimental_run_tf_function=[True, False],
optimizer=strategy_combinations.gradient_descent_optimizer_keras_v2_fn
))
def test_masking(self, distribution, experimental_run_tf_function, optimizer):
def test_masking(self, distribution, optimizer):
with self.cached_session():
np.random.seed(1337)
x = np.array([[[1], [1]], [[0], [0]]])
@ -390,8 +377,7 @@ class TestDistributionStrategyWithLossMasking(test.TestCase,
keras.layers.Dense(1, kernel_initializer='one')))
model.compile(
loss='mse',
optimizer=optimizer(),
experimental_run_tf_function=experimental_run_tf_function)
optimizer=optimizer())
y = np.array([[[1], [1]], [[1], [1]]])
dataset = dataset_ops.Dataset.from_tensor_slices((x, y))
dataset = dataset.repeat(100)
@ -408,11 +394,9 @@ class TestDistributionStrategyWithNormalizationLayer(test.TestCase,
keras_test_lib.all_strategy_combinations(),
combinations.combine(
fused=[True, False],
experimental_run_tf_function=[True, False],
optimizer=strategy_combinations
.gradient_descent_optimizer_keras_v2_fn)))
def test_batchnorm_correctness(self, distribution, fused, optimizer,
experimental_run_tf_function):
def test_batchnorm_correctness(self, distribution, fused, optimizer):
with self.cached_session():
with distribution.scope():
model = keras.models.Sequential()
@ -425,8 +409,7 @@ class TestDistributionStrategyWithNormalizationLayer(test.TestCase,
model.add(norm)
model.compile(
loss='mse',
optimizer=optimizer(),
experimental_run_tf_function=experimental_run_tf_function)
optimizer=optimizer())
# centered on 5.0, variance 10.0
x = np.random.normal(loc=5.0, scale=10.0, size=(1000, 10, 20, 30))
@ -455,18 +438,15 @@ class TestDistributionStrategySaveLoadWeights(test.TestCase,
combinations.times(
keras_test_lib.all_strategy_combinations_minus_default(),
combinations.combine(
experimental_run_tf_function=[True, False],
optimizer=strategy_combinations.rmsprop_optimizer_keras_v2_fn)))
def test_save_load_h5(self, distribution, optimizer,
experimental_run_tf_function):
def test_save_load_h5(self, distribution, optimizer):
with self.cached_session():
dataset = keras_test_lib.get_dataset(distribution)
with distribution.scope():
model = keras_test_lib.get_model()
model.compile(
optimizer(),
'mse',
experimental_run_tf_function=experimental_run_tf_function)
'mse')
model.fit(dataset, epochs=1, steps_per_epoch=1)
weights_file = tempfile.mktemp('.h5')
@ -475,8 +455,7 @@ class TestDistributionStrategySaveLoadWeights(test.TestCase,
model_2 = keras_test_lib.get_model()
model_2.compile(
optimizer(),
'mse',
experimental_run_tf_function=experimental_run_tf_function)
'mse')
model_2.load_weights(weights_file)
model_2.predict(
keras_test_lib.get_predict_dataset(distribution), steps=2)
@ -486,10 +465,8 @@ class TestDistributionStrategySaveLoadWeights(test.TestCase,
combinations.times(
keras_test_lib.all_strategy_combinations_minus_default(),
combinations.combine(
experimental_run_tf_function=[True, False],
optimizer=strategy_combinations.rmsprop_optimizer_keras_v2_fn)))
def test_save_load_trackable(self, distribution, optimizer,
experimental_run_tf_function):
def test_save_load_trackable(self, distribution, optimizer):
# TODO(b/123533246): Enable the test for TPU once bug is fixed
if (isinstance(distribution,
(tpu_strategy.TPUStrategy, tpu_strategy.TPUStrategyV1)) and
@ -501,8 +478,7 @@ class TestDistributionStrategySaveLoadWeights(test.TestCase,
model = keras_test_lib.get_model()
model.compile(
optimizer(),
'mse',
experimental_run_tf_function=experimental_run_tf_function)
'mse')
model.fit(dataset, epochs=1, steps_per_epoch=1)
weights_file = tempfile.mktemp()
@ -511,8 +487,7 @@ class TestDistributionStrategySaveLoadWeights(test.TestCase,
model_2 = keras_test_lib.get_model()
model_2.compile(
optimizer(),
'mse',
experimental_run_tf_function=experimental_run_tf_function)
'mse')
model_2.load_weights(weights_file)
model_2.predict(
keras_test_lib.get_predict_dataset(distribution), steps=2)
@ -523,10 +498,8 @@ class TestDistributionStrategyValidation(test.TestCase, parameterized.TestCase):
@combinations.generate(
combinations.times(
keras_test_lib.all_strategy_combinations_minus_default(),
combinations.combine(experimental_run_tf_function=[True, False])))
def test_layer_outside_scope(self, distribution,
experimental_run_tf_function):
keras_test_lib.all_strategy_combinations_minus_default()))
def test_layer_outside_scope(self, distribution):
with self.cached_session():
with self.assertRaisesRegexp(
ValueError, 'was not created in the distribution strategy'):
@ -540,8 +513,7 @@ class TestDistributionStrategyValidation(test.TestCase, parameterized.TestCase):
model.compile(
optimizer,
loss,
metrics=metrics,
experimental_run_tf_function=experimental_run_tf_function)
metrics=metrics)
@combinations.generate(
keras_test_lib.all_strategy_combinations_minus_default())

36
tensorflow/python/keras/engine/base_layer_test.py
View File

@ -314,8 +314,6 @@ class BaseLayerTest(keras_parameterized.TestCase):
def get_learning_phase_value():
model = keras.models.Sequential([LearningPhaseLayer(input_shape=(1,))])
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = (
testing_utils.should_run_tf_function())
return np.sum(model(np.ones((1, 1))))
self.assertEqual(get_learning_phase_value(), 0)
@ -413,8 +411,7 @@ class BaseLayerTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x, y = np.ones((10, 10)), np.ones((10, 10))
# Checks that variables get initialized.
model.fit(x, y, batch_size=2, epochs=2)
@ -466,8 +463,7 @@ class BaseLayerTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.random.random((3, 10))
out = model.predict(inputs)
self.assertAllClose(model.layers[-1].get_weights()[0], kernel_value)
@ -999,8 +995,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
train_loss = model.train_on_batch(np.ones((2, 3)), np.ones((2, 3)))
self.assertEqual(train_loss, 0.)
test_loss = model.test_on_batch(np.ones((2, 3)), np.ones((2, 3)))
@ -1024,8 +1019,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
train_loss = model.train_on_batch(np.ones((2, 3)), np.ones((2, 3)))
self.assertEqual(train_loss, 2 * 3)
test_loss = model.test_on_batch(np.ones((2, 3)), np.ones((2, 3)))
@ -1049,8 +1043,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
for _ in range(3):
_, train_metric = model.train_on_batch(np.ones((2, 3)),
np.ones((2, 3)))
@ -1083,8 +1076,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
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.)
@ -1117,8 +1109,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
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.)
else:
@ -1153,8 +1144,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
loss = model.train_on_batch(np.ones((2, 3)), np.ones((2, 3)))
self.assertEqual(loss, 2 * 3)
else:
@ -1168,7 +1158,6 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
1, kernel_regularizer=keras.regularizers.l2(1e-4), input_shape=(1,))
])
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
def assert_graph(t):
if not context.executing_eagerly():
@ -1210,8 +1199,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(np.ones((2, 3)), np.ones((2, 3)))
self.assertEqual(history.history['sum'][-1], 2 * 3)
else:
@ -1239,8 +1227,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 1))
y = np.ones(shape=(10, 2))
@ -1273,8 +1260,7 @@ class AutographControlFlowTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 3, 4))
y = np.ones(shape=(10, 3, 2))

13
tensorflow/python/keras/engine/base_preprocessing_layer_test.py
View File

@ -165,7 +165,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
layer.set_total(15)
@ -182,7 +181,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
self.assertAllEqual([[16], [17], [18]], model.predict([1., 2., 3.]))
@ -195,7 +193,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
layer.adapt(input_dataset)
@ -216,7 +213,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
self.assertAllEqual([[16], [17], [18]], model.predict([1., 2., 3.]))
@ -228,7 +224,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
combiner = layer._combiner
updates = combiner.extract(combiner.compute(input_dataset))
@ -248,7 +243,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
self.assertAllEqual([[16], [17], [18]], model.predict([1., 2., 3.]))
@ -262,7 +256,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
layer.adapt(input_dataset)
@ -280,7 +273,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
self.assertAllEqual([[16], [17], [18]], model.predict([1., 2., 3.]))
@ -298,7 +290,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
combiner = layer._combiner
updates = combiner.extract(combiner.compute(input_dataset))
@ -317,8 +308,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = (
testing_utils.should_run_tf_function())
return (model, layer)
input_dataset = np.array([1, 2, 3, 4, 5])
@ -344,8 +333,6 @@ class PreprocessingLayerTest(keras_parameterized.TestCase):
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = (
testing_utils.should_run_tf_function())
return (model, layer)
input_dataset = np.array([1, 2, 3, 4, 5])

6
tensorflow/python/keras/engine/correctness_test.py
View File

@ -60,8 +60,7 @@ class SimpleBiasTest(keras_parameterized.TestCase):
model.compile(
keras.optimizer_v2.gradient_descent.SGD(0.1),
'mae',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
def test_simple_bias_fit(self):
@ -99,8 +98,7 @@ class MultipleInputTest(keras_parameterized.TestCase):
model.compile(
keras.optimizer_v2.gradient_descent.SGD(0.1),
'mae',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
@parameterized.named_parameters(('subclassed', True), ('functional', False))

12
tensorflow/python/keras/engine/feature_columns_integration_test.py
View File

@ -60,8 +60,7 @@ class FeatureColumnsIntegrationTest(keras_parameterized.TestCase):
optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = {'a': np.random.random((10, 1))}
y = np.random.randint(20, size=(10, 1))
@ -83,8 +82,7 @@ class FeatureColumnsIntegrationTest(keras_parameterized.TestCase):
optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
y = np.random.randint(20, size=(100, 1))
y = np_utils.to_categorical(y, num_classes=20)
@ -147,8 +145,7 @@ class FeatureColumnsIntegrationTest(keras_parameterized.TestCase):
optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = {'a': np.random.random((10, 1)), 'b': np.random.random((10, 1))}
y = np.random.randint(20, size=(10, 1))
@ -169,8 +166,7 @@ class FeatureColumnsIntegrationTest(keras_parameterized.TestCase):
optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
y = np.random.randint(20, size=(100, 1))
y = np_utils.to_categorical(y, num_classes=20)

56
tensorflow/python/keras/engine/network_test.py
View File

@ -761,7 +761,6 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
output = a(b(a(b(x))))
m = keras.models.Model(x, output)
m.run_eagerly = testing_utils.should_run_eagerly()
m._experimental_run_tf_function = testing_utils.should_run_tf_function()
output_val = m.predict(x_val)
@ -789,7 +788,6 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
m = keras.models.Model(inputs=input_layer, outputs=output)
m.run_eagerly = testing_utils.should_run_eagerly()
m._experimental_run_tf_function = testing_utils.should_run_tf_function()
x_val = np.random.random((10, 16, 9, 3))
output_val = m.predict(x_val)
@ -818,8 +816,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
loss = model.train_on_batch(x, y)
self.assertEqual(loss, 0) # In inference mode, output is equal to input.
@ -838,8 +835,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[np.ones((10, 5, 10)), np.zeros((10, 5))],
y=np.zeros((10, 100)),
@ -857,8 +853,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[np.ones((10, 5, 10)), np.zeros((10, 5))],
y=np.zeros((10, 100)),
@ -887,8 +882,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[3 * np.ones((10, 10)), 7 * np.ones((10, 10))],
y=10 * np.ones((10, 10)),
@ -902,8 +896,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[3 * np.ones((10, 10)), 7 * np.ones((10, 10))],
y=10 * np.ones((10, 10)),
@ -928,8 +921,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[3 * np.ones((10, 10)), 7 * np.ones((10, 10))],
y=10 * np.ones((10, 10)),
@ -942,8 +934,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[3 * np.ones((10, 10)), 7 * np.ones((10, 10))],
y=10 * np.ones((10, 10)),
@ -976,8 +967,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
input_data = [
ragged_factory_ops.constant([[3.0, 3.0], [3.0, 3.0], [3.0]]),
ragged_factory_ops.constant([[7.0, 7.0], [7.0, 7.0], [7.0]])
@ -993,8 +983,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(x=input_data, y=expected_data)
# Check that second input was correctly added to first.
self.assertEqual(history.history['loss'][0], 0.0)
@ -1026,8 +1015,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[np.ones((10, 10)), 2 * np.ones((10, 10)), 3 * np.ones((10, 10))],
y=15 * np.ones((10, 10)),
@ -1040,8 +1028,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(
x=[np.ones((10, 10)), 2 * np.ones((10, 10)), 3 * np.ones((10, 10))],
y=15 * np.ones((10, 10)),
@ -1066,14 +1053,11 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
o = keras.layers.add(o)
model = keras.Model(i, o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
i2 = keras.layers.Input(shape=(3, 2, 1))
o2 = model(i2)
model2 = keras.Model(i2, o2)
model2.run_eagerly = testing_utils.should_run_eagerly()
model2._experimental_run_tf_function = testing_utils.should_run_tf_function(
)
x = np.random.random((4, 3, 2, 1))
out = model2.predict(x)
@ -1091,8 +1075,7 @@ class NetworkConstructionTest(keras_parameterized.TestCase):
loss='mse',
optimizer='sgd',
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
json_str = model.to_json()
keras.models.model_from_json(json_str)
@ -1398,8 +1381,7 @@ class DefaultShapeInferenceBehaviorTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model_input = np.random.randint(
low=1, high=5, size=(10, 3, 4)).astype('float32')
@ -1607,15 +1589,13 @@ class AddLossTest(keras_parameterized.TestCase):
x = np.ones((10, 10))
model.compile(
'sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, batch_size=2, epochs=1)
model2 = model.from_config(model.get_config())
model2.compile(
'sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model2.set_weights(initial_weights)
model2.fit(x, batch_size=2, epochs=1)
@ -1639,16 +1619,14 @@ class AddLossTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, batch_size=2, epochs=1)
model2 = model.from_config(model.get_config())
model2.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model2.set_weights(initial_weights)
model2.fit(x, y, batch_size=2, epochs=1)

31
tensorflow/python/keras/engine/sequential_test.py
View File

@ -77,8 +77,7 @@ class TestSequential(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.random.random((batch_size, input_dim))
y = np.random.random((batch_size, num_classes))
model.fit(x, y, epochs=1)
@ -88,8 +87,7 @@ class TestSequential(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
y = np.random.random((batch_size, num_hidden))
model.fit(x, y, epochs=1)
@ -117,8 +115,7 @@ class TestSequential(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=[keras.metrics.CategoricalAccuracy()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertEqual(len(model.layers), 2)
with self.assertRaisesRegexp(
ValueError, 'Weights for model .* have not yet been created'):
@ -145,8 +142,7 @@ class TestSequential(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=[keras.metrics.CategoricalAccuracy()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertEqual(len(model.layers), 2)
with self.assertRaisesRegexp(
ValueError, 'Weights for model .* have not yet been created'):
@ -276,8 +272,7 @@ class TestSequential(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=[keras.metrics.CategoricalAccuracy()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertFalse(model.built)
x = np.random.random((batch_size, input_dim))
@ -291,8 +286,7 @@ class TestSequential(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=[keras.metrics.CategoricalAccuracy()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.random.random((batch_size, input_dim))
y = np.random.random((batch_size, num_classes))
new_model.train_on_batch(x, y)
@ -331,8 +325,7 @@ class TestSequential(keras_parameterized.TestCase):
model.compile(
'rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((1, 2)), np.zeros((1, 5)))
@keras_parameterized.run_all_keras_modes
@ -344,8 +337,7 @@ class TestSequential(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.random.random((2, 6))
y = np.random.random((2, 5))
model.fit(x, y, epochs=1)
@ -376,7 +368,6 @@ class TestSequential(keras_parameterized.TestCase):
keras.layers.Lambda(lambda x: x[0])
])
seq.run_eagerly = testing_utils.should_run_eagerly()
seq._experimental_run_tf_function = testing_utils.should_run_tf_function()
preds = seq.predict([['tensorflow eager']])
self.assertEqual(preds.shape, (1,))
@ -458,8 +449,7 @@ class TestSequentialEagerIntegration(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.random.random((2, 6))
y = np.random.random((2, 5))
@ -472,8 +462,7 @@ class TestSequentialEagerIntegration(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.build((None, 6))

3
tensorflow/python/keras/engine/training_arrays_test.py
View File

@ -133,8 +133,7 @@ class PrintTrainingInfoTest(keras_parameterized.TestCase,
model.compile(
loss="mae",
optimizer="adam",
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(
x={

36
tensorflow/python/keras/engine/training_dataset_test.py
View File

@ -63,8 +63,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
optimizer,
loss,
metrics=metrics,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((10, 3), np.float32)
targets = np.zeros((10, 4), np.float32)
@ -89,8 +88,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
optimizer,
loss,
metrics=metrics,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((10, 3), np.float32)
targets = np.zeros((10, 4), np.float32)
@ -151,8 +149,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
input_a_np = np.random.random((10, 3)).astype(dtype=np.float32)
input_b_np = np.random.random((10, 3)).astype(dtype=np.float32)
@ -200,8 +197,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
optimizer,
loss,
metrics=metrics,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((10, 3), np.float32)
targets = np.zeros((10, 4), np.float32)
@ -247,8 +243,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model.compile(
optimizer,
loss='sparse_categorical_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((10, 3), dtype=np.float32)
targets = np.random.randint(0, 4, size=10, dtype=np.int32)
@ -272,8 +267,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model.compile(
'rmsprop',
loss='mae',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((40, 2), dtype=np.float32)
inputs[10:20, :] = 2
@ -344,8 +338,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((100, 3), dtype=np.float32)
targets = np.random.randint(0, 4, size=100, dtype=np.int32)
@ -368,8 +361,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((100, 3), dtype=np.float32)
targets = np.random.randint(0, 4, size=100, dtype=np.int32)
@ -408,8 +400,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((100, 3), dtype=np.float32)
targets = np.random.randint(0, 4, size=100, dtype=np.int32)
@ -445,8 +436,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((100, 3), dtype=np.float32)
targets = np.random.randint(0, 4, size=100, dtype=np.int32)
@ -501,8 +491,7 @@ class TestTrainingWithDataset(keras_parameterized.TestCase):
model = keras.Model(inp, out)
model.compile(
'rmsprop', loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.zeros((100, 4), dtype=np.float32)
targets = np.random.randint(0, 2, size=100, dtype=np.int32)
@ -551,8 +540,7 @@ class TestMetricsWithDatasets(keras_parameterized.TestCase):
loss='binary_crossentropy',
metrics=['accuracy', metrics_module.BinaryAccuracy()],
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np.random.seed(123)
x = np.random.randint(10, size=(100, 4)).astype(np.float32)

16
tensorflow/python/keras/engine/training_eager_test.py
View File

@ -56,8 +56,7 @@ class TrainingTest(keras_parameterized.TestCase):
model = DynamicModel()
model.compile(
'rmsprop', 'mae',
run_eagerly=True,
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=True)
hist = model.fit(np.zeros((1, 1)), np.zeros((1, 1)))
self.assertEqual(hist.history['loss'][-1], 1)
self.assertEqual(len(model.trainable_weights), 2)
@ -93,7 +92,6 @@ class TrainingTest(keras_parameterized.TestCase):
metrics=metrics,
loss_weights=loss_weights,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function(),
sample_weight_mode=None)
input_a = array_ops.zeros(shape=(10, 3))
@ -163,8 +161,7 @@ class TrainingTest(keras_parameterized.TestCase):
optimizer,
loss,
metrics=metrics,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = array_ops.zeros(shape=(10, 3))
targets = array_ops.zeros(shape=(10, 4))
@ -251,8 +248,7 @@ class CorrectnessTest(keras_parameterized.TestCase):
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=rmsprop.RMSprop(learning_rate=0.001, **optimizer_kwargs),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((100, 4))
np.random.seed(123)
y = np.random.randint(0, 1, size=(100, 1))
@ -273,8 +269,7 @@ class CorrectnessTest(keras_parameterized.TestCase):
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=rmsprop.RMSprop(learning_rate=0.001, clipvalue=0.0),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((100, 4))
np.random.seed(123)
y = np.random.randint(0, 1, size=(100, 1))
@ -296,8 +291,7 @@ class CorrectnessTest(keras_parameterized.TestCase):
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=rmsprop.RMSprop(learning_rate=0.001),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((100, 4), dtype=np.float32)
np.random.seed(123)
y = np.random.randint(0, 1, size=(100, 1))

16
tensorflow/python/keras/engine/training_generator_test.py
View File

@ -139,8 +139,7 @@ class TestGeneratorMethods(keras_parameterized.TestCase):
loss='mse',
optimizer=rmsprop.RMSprop(1e-3),
metrics=['mae', metrics_module.CategoricalAccuracy()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.evaluate_generator(custom_generator_threads(),
steps=5,
@ -165,7 +164,6 @@ class TestGeneratorMethods(keras_parameterized.TestCase):
model = testing_utils.get_small_mlp(
num_hidden=3, num_classes=4, input_dim=2)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
model.predict_generator(custom_generator_threads(),
steps=5,
@ -204,8 +202,7 @@ class TestGeneratorMethods(keras_parameterized.TestCase):
loss='mse',
optimizer=rmsprop.RMSprop(1e-3),
metrics=['mae', metrics_module.CategoricalAccuracy()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit_generator(custom_generator(mode=3),
steps_per_epoch=5,
@ -242,8 +239,7 @@ class TestGeneratorMethods(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=rmsprop.RMSprop(1e-3),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
with self.assertRaises(ValueError):
model.fit_generator(invalid_generator(),
@ -287,8 +283,7 @@ class TestGeneratorMethods(keras_parameterized.TestCase):
model.compile(
rmsprop.RMSprop(0.001),
'binary_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(
ones_generator(),
steps_per_epoch=2,
@ -303,8 +298,7 @@ class TestGeneratorMethods(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=rmsprop.RMSprop(1e-3),
metrics=['mae', metrics_module.CategoricalAccuracy()],
experimental_run_tf_function=testing_utils.should_run_tf_function())
metrics=['mae', metrics_module.CategoricalAccuracy()])
model.fit_generator(custom_generator_changing_batch_size(),
steps_per_epoch=5,
epochs=1,

7
tensorflow/python/keras/engine/training_integration_test.py
View File

@ -150,7 +150,6 @@ class CoreLayerIntegrationTest(keras_parameterized.TestCase):
layer_kwargs):
batch_size = 2
run_eagerly = testing_utils.should_run_eagerly()
experimental_run_tf_function = testing_utils.should_run_tf_function()
def map_fn(_):
x = keras.backend.random_uniform(shape=data_shape)
@ -169,12 +168,10 @@ class CoreLayerIntegrationTest(keras_parameterized.TestCase):
layer = keras.layers.Dense(1, activation=None)(layer)
model = keras.models.Model(inp, layer)
model.compile(loss='mse', optimizer='sgd', run_eagerly=run_eagerly,
experimental_run_tf_function=experimental_run_tf_function)
model.compile(loss='mse', optimizer='sgd', run_eagerly=run_eagerly)
model.fit(dataset, verbose=2, epochs=2)
model.compile(loss='mse', optimizer='sgd', run_eagerly=run_eagerly,
experimental_run_tf_function=experimental_run_tf_function)
model.compile(loss='mse', optimizer='sgd', run_eagerly=run_eagerly)
model.fit(dataset.repeat(2), verbose=2, epochs=2, steps_per_epoch=2)
eval_dataset = dataset_ops.DatasetV2.range(4).map(map_fn).batch(batch_size)

200
tensorflow/python/keras/engine/training_test.py
View File

@ -75,8 +75,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
hist = model.fit(x=np.array([0.]), y=np.array([0.]))
self.assertAllClose(hist.history['loss'][0], 10000)
@ -94,8 +93,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
loss='mae',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.ones((40, 2), dtype=np.float32)
targets = np.ones((40, 1), dtype=np.float32)
@ -128,8 +126,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
loss='mae',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.ones((40, 2), dtype=np.float32)
targets = np.ones((40, 1), dtype=np.float32)
@ -163,8 +160,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
loss=loss_fn,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(inputs, targets)
model.test_on_batch(inputs, targets)
self.assertEqual(model.predict(inputs).dtype, np.float64)
@ -197,8 +193,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
loss='mae',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.ones((40, 2), dtype=np.float32)
targets = np.ones((40, 1), dtype=np.float32)
@ -237,8 +232,7 @@ class TrainingTest(keras_parameterized.TestCase):
loss,
metrics=[metrics_module.CategoricalAccuracy(), 'mae'],
loss_weights=loss_weights,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
@ -350,8 +344,7 @@ class TrainingTest(keras_parameterized.TestCase):
optimizer,
loss,
metrics=[metrics_module.CategoricalAccuracy(), 'mae'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(
[input_a_np, input_b_np], [output_d_np, output_e_np],
epochs=1,
@ -371,8 +364,7 @@ class TrainingTest(keras_parameterized.TestCase):
loss,
metrics=metrics,
loss_weights=loss_weights,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(
[input_a_np, input_b_np], [output_d_np, output_e_np],
epochs=1,
@ -386,8 +378,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
optimizer,
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# This will work
model.fit([input_a_np], output_d_np, epochs=1)
@ -397,8 +388,7 @@ class TrainingTest(keras_parameterized.TestCase):
# Test execution on inputs that are lists of scalars.
# TF2 and TF1 have slightly different semantics:
if (testing_utils.should_run_tf_function()
or testing_utils.should_run_eagerly()):
if context.executing_eagerly():
# In TF2 to avoid any ambiguity when there are nested lists
# the entire input gets converted to a
# single numpy array (& it only works in the case of a single io model)
@ -442,8 +432,7 @@ class TrainingTest(keras_parameterized.TestCase):
metrics=['mae', metrics_module.CategoricalAccuracy()],
loss_weights=loss_weights,
sample_weight_mode=None,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
@ -586,7 +575,7 @@ class TrainingTest(keras_parameterized.TestCase):
)
def test_sequence_input_types(self, input_type):
"""Ensure that namedtuples and tuples are plumbed identically."""
if not testing_utils.should_run_tf_function():
if not context.executing_eagerly():
self.skipTest('Improved checking is only present in data_adapter.')
xy_function, x_function = self._make_sequence_input_functions(input_type)
@ -600,8 +589,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(xy_function(use_namedtuple=False), **fit_kwargs)
model.evaluate(xy_function(use_namedtuple=False), **evaluate_kwargs)
@ -660,8 +648,7 @@ class TrainingTest(keras_parameterized.TestCase):
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
@keras_parameterized.run_all_keras_modes
def test_that_trainable_disables_updates(self):
@ -679,8 +666,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
assert not model.updates
x1 = model.predict(val_a)
@ -692,8 +678,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
assert model.updates
model.train_on_batch(val_a, val_out)
@ -704,8 +689,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
assert not model.updates
x1 = model.predict(val_a)
@ -867,8 +851,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
RMSPropOptimizer(learning_rate=0.001),
loss='sparse_categorical_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# Test with Numpy data
x_train = np.random.random((10, 3, 4)).astype(np.float32)
y_train = np.random.randint(0, 5, size=(10, 3)).astype(np.float32)
@ -911,8 +894,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
RMSPropOptimizer(learning_rate=0.001),
loss='binary_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
with test.mock.patch.object(sys, 'stdout', mock_stdout):
model.fit(
np.ones((10, 10), 'float32'), np.ones((10, 1), 'float32'), epochs=10)
@ -1098,8 +1080,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
class ValCounter(keras.callbacks.Callback):
@ -1129,8 +1110,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
with self.assertRaisesRegexp(
ValueError, '`validation_steps` should not be specified if '
@ -1176,8 +1156,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((10, 10))
y = np.ones((10, 10))
@ -1193,8 +1172,7 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((10, 10)).astype(np.float64)
y = np.ones((10, 10)).astype(np.float64)
dataset = dataset_ops.Dataset.from_tensor_slices((x, y)).batch(2)
@ -1225,12 +1203,10 @@ class TrainingTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, x, epochs=1)
if (testing_utils.should_run_eagerly() or
testing_utils.should_run_tf_function()):
if context.executing_eagerly():
expected_training_arg = True
else:
expected_training_arg = keras.backend.symbolic_learning_phase()
@ -1321,8 +1297,7 @@ class TestExceptionsAndWarnings(keras_parameterized.TestCase):
'dense_2': 'categorical_accuracy',
'dense_1': metrics_module.CategoricalAccuracy(),
},
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
@keras_parameterized.run_with_all_model_types
@keras_parameterized.run_all_keras_modes
@ -1358,8 +1333,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
metrics=['acc', metrics_module.CategoricalAccuracy()],
weighted_metrics=['mae', metrics_module.CategoricalAccuracy()],
optimizer=RMSPropOptimizer(learning_rate=learning_rate),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np.random.seed(1337)
(x_train, y_train), (x_test, y_test) = testing_utils.get_test_data(
@ -1427,8 +1401,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
metrics=['acc', metrics_module.CategoricalAccuracy()],
weighted_metrics=['mae', metrics_module.CategoricalAccuracy()],
loss='categorical_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np.random.seed(43)
(x_train, y_train), (x_test, y_test) = testing_utils.get_test_data(
@ -1539,8 +1512,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
metrics=['acc', metrics_module.CategoricalAccuracy()],
weighted_metrics=['mae', metrics_module.CategoricalAccuracy()],
sample_weight_mode='temporal',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(
temporal_x_train,
@ -1587,8 +1559,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
model.compile(
optimizer='adam',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.random.random((10, 3))
y = np.random.random((10, 2))
@ -1622,8 +1593,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
optimizer,
loss='mse',
sample_weight_mode=[None],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, batch_size=10)
# sample_weight_mode is a list and mode value is `temporal`
@ -1631,8 +1601,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
optimizer,
loss='mse',
sample_weight_mode=['temporal'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, batch_size=10)
# sample_weight_mode is a dict and mode value is None
@ -1640,8 +1609,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
optimizer,
loss='mse',
sample_weight_mode={'time_distributed': None},
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, batch_size=10)
# sample_weight_mode is a dict and mode value is `temporal`
@ -1649,8 +1617,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
optimizer,
loss='mse',
sample_weight_mode={'time_distributed': 'temporal'},
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, batch_size=10)
# sample_weight_mode is a not a list/dict and mode value is None
@ -1658,8 +1625,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
optimizer,
loss='mse',
sample_weight_mode=None,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, batch_size=10)
# sample_weight_mode is a not a list/dict and mode value is `temporal`
@ -1667,8 +1633,7 @@ class LossWeightingTest(keras_parameterized.TestCase):
optimizer,
loss='mse',
sample_weight_mode='temporal',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, batch_size=10)
def test_sample_weight_tensor(self):
@ -1714,8 +1679,7 @@ class MaskingTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=RMSPropOptimizer(learning_rate=0.001),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
@keras_parameterized.run_with_all_model_types
@ -1760,8 +1724,7 @@ class MaskingTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=RMSPropOptimizer(learning_rate=0.001),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
y = np.random.random((5, 3))
model.train_on_batch(x, y)
@ -1779,8 +1742,7 @@ class TestDynamicTrainability(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.trainable = True
model.train_on_batch(x, y)
self.assertRaises(Warning)
@ -1795,8 +1757,7 @@ class TestDynamicTrainability(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
out = model.predict(x)
model.train_on_batch(x, y)
out_2 = model.predict(x)
@ -1809,8 +1770,7 @@ class TestDynamicTrainability(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
out = model.predict(x)
model.train_on_batch(x, y)
out_2 = model.predict(x)
@ -1927,8 +1887,7 @@ class TestDynamicTrainability(keras_parameterized.TestCase):
model1.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs2 = keras.Input(10)
outputs2 = shared_layer(inputs2)
@ -1937,8 +1896,7 @@ class TestDynamicTrainability(keras_parameterized.TestCase):
model2.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x, y = np.ones((10, 10)), np.ones((10, 10))
@ -1964,8 +1922,7 @@ class TestDynamicTrainability(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((10, 1))
y = 5 * x + 2
@ -2521,8 +2478,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
optimizer,
loss='mae',
metrics=metrics,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
mse_metric = 'mse' if context.executing_eagerly() else 'mean_squared_error'
reference_metric_names = [
@ -2552,8 +2508,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
loss='mae',
metrics=[acc_obj],
optimizer=RMSPropOptimizer(learning_rate=0.001),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x_train = np.random.random((100, 4))
y_train = np.random.random((100, 1))
@ -2586,8 +2541,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
loss='mse',
metrics=[keras.metrics.MeanSquaredError()],
weighted_metrics=[keras.metrics.MeanSquaredError()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# list of list of metrics.
model.compile(
@ -2603,8 +2557,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
[keras.metrics.MeanSquaredError(),
keras.metrics.Accuracy()]
],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# dict of metrics.
model.compile(
@ -2626,8 +2579,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
keras.metrics.Accuracy()
],
},
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
@keras_parameterized.run_all_keras_modes
def test_metrics_masking(self):
@ -2641,8 +2593,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
RMSPropOptimizer(learning_rate=0.001),
loss='mse',
weighted_metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# verify that masking is applied.
x = np.array([[[1], [1]], [[1], [1]], [[0], [0]]])
@ -2678,8 +2629,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
model.compile(
'sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.ones(shape=(10, 1))
targets = np.ones(shape=(10, 1))
@ -2721,8 +2671,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=RMSPropOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 1))
y = np.ones(shape=(10, 2))
@ -2764,8 +2713,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=RMSPropOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 1))
y = np.ones(shape=(10, 2))
@ -2823,8 +2771,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
'sgd',
loss='mse',
metrics=[metrics_module.Accuracy('metric_4')],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(np.ones((10, 1)), np.ones((10, 1)), batch_size=10)
@ -2852,8 +2799,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
loss='mse',
optimizer=RMSPropOptimizer(0.01),
metrics=[metrics_module.Accuracy('acc')],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 1))
y = np.ones(shape=(10, 2))
model.fit(x, y, epochs=2, batch_size=5, validation_data=(x, y))
@ -2883,8 +2829,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=RMSPropOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 1))
y = np.ones(shape=(10, 2))
@ -2919,8 +2864,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=RMSPropOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 1))
y = np.ones(shape=(10, 2))
@ -2947,8 +2891,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=RMSPropOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones(shape=(10, 1))
y = np.ones(shape=(10, 2))
@ -2985,8 +2928,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
loss='mae',
optimizer=keras.optimizer_v2.gradient_descent.SGD(0.1),
metrics=[metrics_module.MeanAbsoluteError(name='mae_3')],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.array([[0.], [1.], [2.]])
y = np.array([[0.5], [2.], [3.5]])
@ -3028,8 +2970,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(dataset_train, epochs=3)
self.assertDictEqual(
history.history, {
@ -3065,8 +3006,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
'sgd',
loss='mse',
metrics=[metrics_module.Accuracy('acc')],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inner_model.fit(np.ones((10, 1)), np.ones((10, 1)), batch_size=10)
self.assertEqual([m.name for m in inner_model.metrics],
@ -3082,8 +3022,7 @@ class TestTrainingWithMetrics(keras_parameterized.TestCase):
'sgd',
loss='mse',
metrics=[metrics_module.Accuracy('acc2')],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
outer_model.fit(np.ones((10, 1)), np.ones((10, 1)), batch_size=10)
self.assertEqual([m.name for m in outer_model.metrics],
['loss', 'acc2', 'mean', 'mean1', 'mean2'])
@ -3169,8 +3108,7 @@ class TestAutoUpdates(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, batch_size=2, epochs=1)
self.assertEqual(self.evaluate(layer.counter), 5)
@ -3183,16 +3121,14 @@ class TestAutoUpdates(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, batch_size=2, epochs=1)
self.assertEqual(self.evaluate(layer.counter), 5)
layer.trainable = False
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, batch_size=2, epochs=1)
self.assertEqual(self.evaluate(layer.counter), 5)
@ -3205,8 +3141,7 @@ class TestAutoUpdates(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, batch_size=2, epochs=1)
self.assertEqual(self.evaluate(layer.counter), 5)
@ -3241,8 +3176,7 @@ class TestAutoUpdates(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x, y = np.ones((10, 10)), np.ones((10, 1))
model.fit(x, y, batch_size=2, epochs=1)
self.assertAllEqual(self.evaluate(bn.moving_mean), np.zeros((10,)))

3
tensorflow/python/keras/layers/advanced_activations_test.py
View File

@ -97,8 +97,7 @@ class AdvancedActivationsTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(np.ones((10, 10)), np.ones((10, 1)), batch_size=2)

3
tensorflow/python/keras/layers/convolutional_recurrent_test.py
View File

@ -223,8 +223,7 @@ class ConvLSTMTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd', loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x_1 = np.random.rand(num_samples, sequence_len, 32, 32, 3)
x_2 = np.random.rand(num_samples, sequence_len, 32, 32, 4)
y = np.random.rand(num_samples, 32, 32, 1)

3
tensorflow/python/keras/layers/core_test.py
View File

@ -296,8 +296,7 @@ class TestStatefulLambda(keras_parameterized.TestCase):
model.compile(
keras.optimizer_v2.gradient_descent.SGD(0.1),
'mae',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x, y = np.ones((10, 10), 'float32'), 2 * np.ones((10, 10), 'float32')
model.fit(x, y, batch_size=2, epochs=2, validation_data=(x, y))
self.assertLen(model.trainable_weights, 1)

4
tensorflow/python/keras/layers/cudnn_recurrent_test.py
View File

@ -89,7 +89,6 @@ class CuDNNTest(keras_parameterized.TestCase):
self.assertEqual(len(state), num_states)
model = keras.models.Model(inputs, state[0])
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
inputs = np.random.random((num_samples, timesteps, input_size))
state = model.predict(inputs)
@ -149,8 +148,7 @@ class CuDNNTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer=RMSprop(learning_rate=0.001),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.random.random((num_samples, timesteps, input_size))
initial_state = [

2
tensorflow/python/keras/layers/embeddings_test.py
View File

@ -82,7 +82,6 @@ class EmbeddingTest(keras_parameterized.TestCase):
layer.set_weights([np.array([[1, 1], [2, 2]])])
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
outputs = model.predict(np.array([[0, 1, 0]], dtype='int32'))
self.assertAllClose(outputs, [[[1, 1], [2, 2], [1, 1]]])
@ -113,7 +112,6 @@ class EmbeddingTest(keras_parameterized.TestCase):
outputs = layer(outputs)
model = keras.Model(inputs, outputs)
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
model.run_eagerly = testing_utils.should_run_eagerly()
outputs = model.predict(
ragged_factory_ops.constant([[1., 2., 2.], [0.], [1., 2.]],

12
tensorflow/python/keras/layers/gru_test.py
View File

@ -72,8 +72,7 @@ class GRULayerTest(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.random.random((num_samples, timesteps, embedding_dim))
y = np.random.random((num_samples, units))
model.train_on_batch(x, y)
@ -128,8 +127,7 @@ class GRULayerTest(keras_parameterized.TestCase):
gru_model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
gru_model.fit(x_train, y_train)
gru_model.predict(x_train)
@ -146,8 +144,7 @@ class GRULayerTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(inputs, targets, epochs=1, batch_size=2, verbose=1)
def test_statefulness_GRU(self):
@ -173,8 +170,7 @@ class GRULayerTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
out1 = model.predict(np.ones((num_samples, timesteps)))
self.assertEqual(out1.shape, (num_samples, units))

12
tensorflow/python/keras/layers/gru_v2_test.py
View File

@ -490,8 +490,7 @@ class GRUV2Test(keras_parameterized.TestCase):
model.compile(
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
out1 = model.predict(np.ones((num_samples, timesteps)))
self.assertEqual(out1.shape, (num_samples, units))
@ -563,8 +562,7 @@ class GRUV2Test(keras_parameterized.TestCase):
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, shuffle=False)
@test_util.run_v2_only
@ -662,8 +660,7 @@ class GRUGraphRewriteTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss=['categorical_crossentropy', None],
experimental_run_tf_function=testing_utils.should_run_tf_function())
loss=['categorical_crossentropy', None])
existing_loss = 0
for _ in range(self.epoch):
@ -727,8 +724,7 @@ class GRUGraphRewriteTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss=['categorical_crossentropy', None],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x_train, y_train)

24
tensorflow/python/keras/layers/lstm_test.py
View File

@ -87,8 +87,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.random.random((num_samples, timesteps, embedding_dim))
y = np.random.random((num_samples, units))
@ -157,8 +156,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(inputs, targets, epochs=1, batch_size=2, verbose=1)
@parameterized.parameters([True, False])
@ -174,8 +172,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(inputs, targets, epochs=1, batch_size=2, verbose=1)
def test_from_config_LSTM(self):
@ -208,8 +205,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer=adam.AdamOptimizer(),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.random.random((num_samples, timesteps, embedding_dim))
initial_state = [np.random.random((num_samples, units))
@ -236,8 +232,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer=adam.AdamOptimizer(),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.random.random((num_samples, timesteps, embedding_dim))
targets = np.random.random((num_samples, units))
@ -289,8 +284,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
inputs = np.random.random((num_samples, timesteps, embedding_dim))
initial_state = [np.random.random((num_samples, units))
@ -355,8 +349,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
loss='categorical_crossentropy',
optimizer=adam.AdamOptimizer(),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
main_inputs = np.random.random((num_samples, timesteps, embedding_dim))
initial_state = [np.random.random((num_samples, units))
@ -408,8 +401,7 @@ class LSTMLayerTest(keras_parameterized.TestCase):
model.compile(
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
out1 = model.predict(np.ones((num_samples, timesteps)))
self.assertEqual(out1.shape, (num_samples, units))

12
tensorflow/python/keras/layers/lstm_v2_test.py
View File

@ -655,8 +655,7 @@ class LSTMV2Test(keras_parameterized.TestCase):
model.compile(
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
out1 = model.predict(np.ones((num_samples, timesteps)))
self.assertEqual(out1.shape, (num_samples, units))
@ -728,8 +727,7 @@ class LSTMV2Test(keras_parameterized.TestCase):
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, shuffle=False)
def test_dropout_LSTM(self):
@ -838,8 +836,7 @@ class LSTMGraphRewriteTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss=['categorical_crossentropy', None],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
existing_loss = 0
for _ in range(self.epoch):
@ -903,8 +900,7 @@ class LSTMGraphRewriteTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss=['categorical_crossentropy', None],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x_train, y_train)

9
tensorflow/python/keras/layers/merge_test.py
View File

@ -44,7 +44,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 4, 5])
model = keras.models.Model([i1, i2, i3], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
x1 = np.random.random((2, 4, 5))
x2 = np.random.random((2, 4, 5))
@ -78,7 +77,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 4, 5])
model = keras.models.Model([i1, i2], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
x1 = np.random.random((2, 4, 5))
x2 = np.random.random((2, 4, 5))
@ -112,7 +110,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 4, 5])
model = keras.models.Model([i1, i2, i3], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
x1 = np.random.random((2, 4, 5))
x2 = np.random.random((2, 4, 5))
@ -128,7 +125,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 4, 5])
model = keras.models.Model([i1, i2], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
x1 = np.random.random((2, 4, 5))
x2 = np.random.random((2, 4, 5))
@ -143,7 +139,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 4, 5])
model = keras.models.Model([i1, i2], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
x1 = np.random.random((2, 4, 5))
x2 = np.random.random((2, 4, 5))
@ -158,7 +153,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 4, 5])
model = keras.models.Model([i1, i2], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
x1 = np.random.random((2, 4, 5))
x2 = np.random.random((2, 4, 5))
@ -174,7 +168,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 8, 5])
model = keras.models.Model([i1, i2], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
x1 = np.random.random((2, 4, 5))
x2 = np.random.random((2, 4, 5))
@ -206,7 +199,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 1])
model = keras.models.Model([i1, i2], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
_ = keras.layers.Dot(axes=1).get_config()
x1 = np.random.random((2, 4))
@ -223,7 +215,6 @@ class MergeLayersTest(keras_parameterized.TestCase):
self.assertListEqual(o.shape.as_list(), [None, 1])
model = keras.models.Model([i1, i2], o)
model.run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
out = model.predict([x1, x2])
self.assertEqual(out.shape, (2, 1))
self.assertAllClose(out, expected, atol=1e-4)

21
tensorflow/python/keras/layers/normalization_test.py
View File

@ -106,8 +106,7 @@ class BatchNormalizationTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# centered on 5.0, variance 10.0
x = np.random.normal(loc=5.0, scale=10.0, size=(1000, 3, 4, 4))
@ -128,8 +127,7 @@ class BatchNormalizationTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# centered on 5.0, variance 10.0
x = np.random.normal(loc=5.0, scale=10.0, size=(1000, 4, 4, 3))
@ -178,8 +176,7 @@ class BatchNormalizationTest(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(np.random.random((100, 3)), np.random.random((100, 3)))
test_data = np.random.random((10, 3))
@ -190,8 +187,7 @@ class BatchNormalizationTest(keras_parameterized.TestCase):
model.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
train_loss = model.train_on_batch(test_data, test_targets)
self.assertAlmostEqual(test_loss, train_loss)
@ -369,8 +365,7 @@ def _run_batchnorm_correctness_test(layer, dtype='float32', fused=False):
model.compile(
loss='mse',
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# centered on 5.0, variance 10.0
x = (np.random.normal(loc=5.0, scale=10.0, size=(1000, 2, 2, 2))
@ -505,8 +500,7 @@ def _run_layernorm_correctness_test(layer, dtype='float32'):
model.compile(
loss='mse',
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# centered on 5.0, variance 10.0
x = (np.random.normal(loc=5.0, scale=10.0, size=(1000, 2, 2, 2))
@ -596,8 +590,7 @@ class LayerNormalizationTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# centered on 5.0, variance 10.0
x = np.random.normal(loc=5.0, scale=10.0, size=(1000, 4, 4, 3))

1
tensorflow/python/keras/layers/preprocessing/normalization_test.py
View File

@ -203,7 +203,6 @@ class NormalizationTest(keras_parameterized.TestCase,
output = layer(input_data)
model = keras.Model(input_data, output)
model._run_eagerly = testing_utils.should_run_eagerly()
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
output_data = model.predict(test_data)
self.assertAllClose(expected, output_data)

132
tensorflow/python/keras/layers/recurrent_test.py
View File

@ -85,8 +85,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
# Test stacking.
@ -99,8 +98,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
def test_minimal_rnn_cell_non_layer_multiple_states(self):
@ -130,8 +128,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
# Test stacking.
@ -146,8 +143,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
def test_minimal_rnn_cell_layer(self):
@ -189,8 +185,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
# Test basic case serialization.
@ -216,8 +211,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
# Test stacked RNN serialization.
@ -273,8 +267,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer="rmsprop",
loss="mse",
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
# Test stacking.
@ -287,8 +280,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
def test_rnn_with_time_major(self):
@ -316,8 +308,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, time_step, embedding_dim)),
np.zeros((batch, time_step, units)))
@ -337,8 +328,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, time_step, embedding_dim)),
np.zeros((batch, time_step, cell_units[-1])))
@ -355,8 +345,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, time_step, embedding_dim)),
np.zeros((batch, time_step, units)))
@ -370,8 +359,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, time_step, embedding_dim)),
np.zeros((batch, time_step, units)))
@ -405,8 +393,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((6, 5, 5)), np.zeros((6, 3))],
np.zeros((6, 32))
@ -446,8 +433,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((6, 5, 5)), np.zeros((6, 3))],
np.zeros((6, 32))
@ -463,8 +449,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((6, 5, 5)), np.zeros((6, 3))],
np.zeros((6, 32))
@ -496,8 +481,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
# Test stacking.
@ -510,8 +494,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
def test_rnn_cell_with_constants_layer_passing_initial_state(self):
@ -526,8 +509,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((6, 5, 5)), np.zeros((6, 32)), np.zeros((6, 3))],
np.zeros((6, 32))
@ -576,8 +558,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
# Test stacking.
@ -593,8 +574,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 32)))
def test_stacked_rnn_attributes(self):
@ -705,8 +685,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# Test basic case serialization.
x_np = np.random.random((6, 5, 5))
@ -730,8 +709,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# Test stacked RNN serialization.
x_np = np.random.random((6, 5, 5))
@ -761,8 +739,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x_np = np.random.random((6, 5, 5))
y_np = np.random.random((6, 3))
model.train_on_batch(x_np, y_np)
@ -786,8 +763,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x_np = np.random.random((6, 5, 5))
y_np = np.random.random((6, 3))
model.train_on_batch(x_np, y_np)
@ -924,8 +900,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, batch_size=1)
# check whether the model variables are present in the
@ -959,8 +934,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, time_step, input_a, input_b)),
np.zeros((batch, unit_a, unit_b)))
@ -978,8 +952,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, time_step, input_a, input_b)),
np.zeros((batch, unit_a * 4, unit_b * 4)))
@ -1004,8 +977,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch([
np.zeros((batch, time_step, input_a, input_b)),
np.zeros((batch, unit_a, unit_b))
@ -1043,8 +1015,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, time_step, input_size)),
np.zeros((batch, input_size)))
@ -1103,8 +1074,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((batch, t, i1)), np.zeros((batch, t, i2, i3))],
[np.zeros((batch, o1)), np.zeros((batch, o2, o3))])
@ -1128,8 +1098,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((batch, t, i1)),
np.zeros((batch, t, i2, i3))],
@ -1160,8 +1129,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((batch, t, i1)),
np.zeros((batch, t, i2, i3))],
@ -1187,8 +1155,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((batch, t, i1)),
np.zeros((batch, t, i2, i3))],
@ -1223,8 +1190,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((batch, t, i1)),
np.zeros((batch, t, i2, i3)),
@ -1257,8 +1223,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
[np.zeros((batch, t, i1)),
np.zeros((batch, t, i2, i3)),
@ -1335,8 +1300,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# last time step masked
x_np = np.array([[[1.], [2.], [0.]]])
@ -1362,8 +1326,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np_x = np.ones((6, 5, 5))
result_1 = model.predict(np_x)
@ -1387,8 +1350,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np_x = np.ones((6, 1, 5))
result = model.predict(np_x)
@ -1443,8 +1405,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, timesteps, input_dim)),
np.zeros((batch, output_dim)))
@ -1479,8 +1440,7 @@ class RNNTest(keras_parameterized.TestCase):
model = keras.Model(input_layer, rnn_output)
model.compile(
optimizer='rmsprop', loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
# Define a model with a constant state initialization
@ -1557,8 +1517,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(
np.zeros((batch, timesteps, input_dim)),
np.zeros((batch, output_dim)))
@ -1626,8 +1585,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(ragged_data, label_data)
# Test stateful and full shape specification
@ -1639,8 +1597,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(ragged_data, label_data)
# Must raise error when unroll is set to True
@ -1695,8 +1652,7 @@ class RNNTest(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch(np.zeros((6, 5, 5)), np.zeros((6, 5)))
@parameterized.parameters(

3
tensorflow/python/keras/layers/recurrent_v2_test.py
View File

@ -61,8 +61,7 @@ class RNNV2Test(keras_parameterized.TestCase):
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, epochs=1, shuffle=False)
@parameterized.parameters([rnn_v2.LSTM, rnn_v2.GRU])

3
tensorflow/python/keras/layers/simplernn_test.py
View File

@ -174,8 +174,7 @@ class SimpleRNNLayerTest(keras_parameterized.TestCase):
model.compile(
optimizer=gradient_descent.GradientDescentOptimizer(0.01),
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
out1 = model.predict(np.ones((num_samples, timesteps)))
self.assertEqual(out1.shape, (num_samples, units))

6
tensorflow/python/keras/layers/tensorflow_op_layer_test.py
View File

@ -211,8 +211,7 @@ class AutoLambdaTest(keras_parameterized.TestCase):
model.compile(
adam.Adam(0.001),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np_inputs = nest.map_structure(
lambda x: np.ones((10,) + tuple(x.shape[1:]), 'float32'), model.inputs)
@ -230,8 +229,7 @@ class AutoLambdaTest(keras_parameterized.TestCase):
new_model.compile(
adam.Adam(0.001),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
new_model.fit(np_inputs, np_outputs, batch_size=2)
new_model(np_inputs) # Test calling the new model directly on inputs.
# Assert that metrics are preserved and in the right order.

12
tensorflow/python/keras/layers/wrappers_test.py
View File

@ -371,8 +371,7 @@ class TimeDistributedTest(keras_parameterized.TestCase):
model_1.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
output_with_mask = model_1.predict(data, steps=1)
y = keras.layers.TimeDistributed(rnn_layer)(x)
@ -380,8 +379,7 @@ class TimeDistributedTest(keras_parameterized.TestCase):
model_2.compile(
'rmsprop',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
output = model_2.predict(data, steps=1)
self.assertNotAllClose(output_with_mask, output, atol=1e-7)
@ -392,7 +390,7 @@ class TimeDistributedTest(keras_parameterized.TestCase):
layer=[keras.layers.LSTM,
keras.layers.Dense]))
def test_TimeDistributed_with_ragged_input(self, layer):
if testing_utils.should_run_tf_function():
if context.executing_eagerly():
self.skipTest('b/143103634')
np.random.seed(100)
layer = layer(4)
@ -405,8 +403,6 @@ class TimeDistributedTest(keras_parameterized.TestCase):
x_ragged = keras.Input(shape=(None, 2, 1), dtype='float32', ragged=True)
y_ragged = keras.layers.TimeDistributed(layer)(x_ragged)
model_1 = keras.models.Model(x_ragged, y_ragged)
model_1._experimental_run_tf_function = (
testing_utils.should_run_tf_function())
model_1._run_eagerly = testing_utils.should_run_eagerly()
output_ragged = model_1.predict(ragged_data, steps=1)
@ -415,8 +411,6 @@ class TimeDistributedTest(keras_parameterized.TestCase):
y_dense = keras.layers.TimeDistributed(layer)(masking)
model_2 = keras.models.Model(x_dense, y_dense)
dense_data = ragged_data.to_tensor()
model_2._experimental_run_tf_function = (
testing_utils.should_run_tf_function())
model_2._run_eagerly = testing_utils.should_run_eagerly()
output_dense = model_2.predict(dense_data, steps=1)

9
tensorflow/python/keras/metrics_correctness_test.py
View File

@ -79,8 +79,7 @@ class TestMetricsCorrectnessMultiIO(keras_parameterized.TestCase):
weighted_metrics=[
metrics.MeanSquaredError(name='mean_squared_error_2')
],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
def setUp(self):
@ -354,8 +353,7 @@ class TestMetricsCorrectnessSingleIO(keras_parameterized.TestCase):
weighted_metrics=[
metrics.MeanSquaredError(name='mean_squared_error_2')
],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
def _custom_generator(self, sample_weight=None):
@ -564,8 +562,7 @@ class TestOutputLossMetrics(keras_parameterized.TestCase):
model.compile(
optimizer='rmsprop',
loss=loss,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model
def setUp(self):

3
tensorflow/python/keras/metrics_test.py
View File

@ -1991,8 +1991,7 @@ def _get_model(compile_metrics):
loss='mae',
metrics=compile_metrics,
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model

2
tensorflow/python/keras/mixed_precision/experimental/BUILD
View File

@ -211,7 +211,7 @@ cuda_py_test(
size = "medium",
srcs = ["keras_test.py"],
python_version = "PY3",
shard_count = 4,
shard_count = 10,
tags = ["no_windows"], # b/139083295: bfloat16 tests fail on Windows
deps = [
":test_util",

42
tensorflow/python/keras/mixed_precision/experimental/keras_test.py
View File

@ -496,10 +496,6 @@ class KerasModelTest(keras_parameterized.TestCase):
'strategy_fn': create_central_storage_strategy,
'use_regularizer': True,
'save_format': 'tf'
}, {
'testcase_name': 'norun_distributed',
'strategy_fn': create_mirrored_strategy,
'experimental_run_tf_function': False
})
def test_model(self,
strategy_fn,
@ -508,8 +504,7 @@ class KerasModelTest(keras_parameterized.TestCase):
policy_name='mixed_float16',
get_config=False,
save_format=None,
use_input_spec=False,
experimental_run_tf_function=True):
use_input_spec=False):
self._skip_if_strategy_unsupported(strategy_fn)
self._skip_if_save_format_unsupported(save_format)
regularizer = (mp_test_util.IdentityRegularizer() if use_regularizer
@ -546,8 +541,7 @@ class KerasModelTest(keras_parameterized.TestCase):
model.compile(
opt,
loss=loss_fn,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((2, 1))
y = np.ones((2, 1))
@ -606,14 +600,9 @@ class KerasModelTest(keras_parameterized.TestCase):
}, {
'testcase_name': 'distribute',
'strategy_fn': create_mirrored_strategy,
}, {
'testcase_name': 'norun_distributed',
'strategy_fn': create_mirrored_strategy,
'experimental_run_tf_function': False,
})
def test_fixed_loss_scaling(self,
strategy_fn,
experimental_run_tf_function=True):
strategy_fn):
# Note: We do not test mixed precision in this method, only loss scaling.
loss_scale = 8.
batch_size = 4
@ -640,8 +629,7 @@ class KerasModelTest(keras_parameterized.TestCase):
model.compile(
opt,
loss=loss_fn,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertEqual(backend.eval(layer.v), 1)
x = np.ones((batch_size, 1))
@ -720,8 +708,7 @@ class KerasModelTest(keras_parameterized.TestCase):
model.compile(
opt,
loss=loss_fn,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((2, 1))
y = np.ones((2, 1))
@ -760,16 +747,11 @@ class KerasModelTest(keras_parameterized.TestCase):
'testcase_name': 'central_storage',
'strategy_fn': create_central_storage_strategy,
'get_config': True,
}, {
'testcase_name': 'norun_distributed',
'strategy_fn': create_mirrored_strategy,
'experimental_run_tf_function': False,
})
def test_dynamic_loss_scaling(self,
strategy_fn,
pass_loss_scale_to_policy=False,
get_config=False,
experimental_run_tf_function=True):
get_config=False):
strategy = strategy_fn()
initial_loss_scale = 2.
batch_size = 4
@ -816,8 +798,7 @@ class KerasModelTest(keras_parameterized.TestCase):
model.compile(
opt,
loss=loss_fn,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertEqual(backend.eval(layer.v), 1)
x = np.ones((batch_size, 1))
@ -959,8 +940,7 @@ class KerasModelTest(keras_parameterized.TestCase):
model.compile(
optimizer=opt,
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(np.ones((2, 2)), np.zeros((2, 2)), batch_size=2)
weights_file = os.path.join(self.get_temp_dir(), 'weights')
@ -997,8 +977,7 @@ class KerasModelTest(keras_parameterized.TestCase):
model.compile(
optimizer=opt,
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# Run for 3 steps (6 examples with a batch size of 2)
model.fit(np.zeros((6, 2)), np.zeros((6, 2)), batch_size=2)
self.assertEqual(backend.get_value(loss_scale()), 2)
@ -1057,8 +1036,7 @@ class KerasModelTest(keras_parameterized.TestCase):
model.compile(
optimizer=opt,
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# Run for 3 steps (6 examples with a batch size of 2)
model.fit(np.ones((6, 2)), np.zeros((6, 2)), batch_size=2)
self.assertEqual(backend.get_value(loss_scale()), 2)

33
tensorflow/python/keras/models_test.py
View File

@ -177,8 +177,7 @@ class TestModelCloning(keras_parameterized.TestCase):
new_model.compile(
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
new_model.train_on_batch([val_a, val_b], val_out)
# On top of new tensors
@ -190,8 +189,7 @@ class TestModelCloning(keras_parameterized.TestCase):
new_model.compile(
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
new_model.train_on_batch([val_a, val_b], val_out)
# On top of new, non-Keras tensors
@ -205,8 +203,7 @@ class TestModelCloning(keras_parameterized.TestCase):
new_model.compile(
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
new_model.train_on_batch(None, val_out)
@keras_parameterized.run_all_keras_modes
@ -232,8 +229,7 @@ class TestModelCloning(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer=testing_utils.get_v2_optimizer('adam'),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
y = np.array([[[1], [1]], [[1], [1]]])
loss = model.train_on_batch(x, y)
self.assertEqual(float(loss), 0.)
@ -322,8 +318,7 @@ class CheckpointingTests(keras_parameterized.TestCase):
model.compile(
optimizer=opt,
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(
x=np.array([[1., 2., 3., 4.]]),
@ -352,8 +347,7 @@ class TestModelBackend(keras_parameterized.TestCase):
model.compile(
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
keras.backend.set_floatx(floatx)
@ -382,8 +376,7 @@ class TestCloneAndBuildModel(keras_parameterized.TestCase):
new_model.compile(
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
new_model.train_on_batch(inp, out)
# Create new tensors for inputs.
@ -400,8 +393,7 @@ class TestCloneAndBuildModel(keras_parameterized.TestCase):
new_model.compile(
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
new_model.train_on_batch(inp, out)
def _assert_same_compile_params(self, model):
@ -454,8 +446,7 @@ class TestCloneAndBuildModel(keras_parameterized.TestCase):
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
metrics=['acc', metrics.categorical_accuracy],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self._clone_and_build_test_helper(model, testing_utils.get_model_type())
@ -466,8 +457,7 @@ class TestCloneAndBuildModel(keras_parameterized.TestCase):
testing_utils.get_v2_optimizer('rmsprop'),
'mse',
metrics=['acc', metrics.categorical_accuracy],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self._clone_and_build_test_helper(model, 'sequential')
inp = np.random.random((10, 4))
@ -481,8 +471,7 @@ class TestCloneAndBuildModel(keras_parameterized.TestCase):
optimizer,
'mse',
metrics=['acc', metrics.categorical_accuracy],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
global_step = keras.backend.variable(123, dtype=dtypes.int64)
clone_model = models.clone_and_build_model(

38
tensorflow/python/keras/optimizer_v2/optimizer_v2_test.py
View File

@ -655,13 +655,10 @@ class OptimizerTest(test.TestCase):
@keras_parameterized.run_all_keras_modes
class OptimizersCompatibilityTest(keras_parameterized.TestCase):
# After experimental_run_tf_function is turned on, optimizer v1 can no longer
# work in eager mode, skipping the test if so.
def _testOptimizersCompatibility(self, opt_v1, opt_v2, test_weights=True):
if testing_utils.should_run_tf_function() or context.executing_eagerly():
if context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
'v1 optimizer does not run in eager mode')
np.random.seed(1331)
with test_util.use_gpu():
train_samples = 20
@ -681,8 +678,7 @@ class OptimizersCompatibilityTest(keras_parameterized.TestCase):
opt_v1,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model_v1.fit(x, y, batch_size=5, epochs=1)
model_v2 = testing_utils.get_small_sequential_mlp(
@ -692,8 +688,7 @@ class OptimizersCompatibilityTest(keras_parameterized.TestCase):
opt_v2,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model_v2._make_train_function()
if test_weights:
opt_v2.set_weights(opt_v1.get_weights())
@ -746,10 +741,9 @@ class OptimizersCompatibilityTest(keras_parameterized.TestCase):
self._testOptimizersCompatibility(opt_v1, opt_v2, False)
def testNumericEquivalenceForNesterovMomentum(self):
if testing_utils.should_run_tf_function() or context.executing_eagerly():
if context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
'v1 optimizer does not run in eager mode')
np.random.seed(1331)
with test_util.use_gpu():
train_samples = 20
@ -781,20 +775,17 @@ class OptimizersCompatibilityTest(keras_parameterized.TestCase):
opt_k_v1,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model_k_v2.compile(
opt_k_v2,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model_tf.compile(
opt_tf,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
hist_k_v1 = model_k_v1.fit(x, y, batch_size=5, epochs=10, shuffle=False)
hist_k_v2 = model_k_v2.fit(x, y, batch_size=5, epochs=10, shuffle=False)
@ -808,10 +799,9 @@ class OptimizersCompatibilityTest(keras_parameterized.TestCase):
def testNumericEquivalenceForAmsgrad(self):
self.skipTest('b/150382655')
if testing_utils.should_run_tf_function() or context.executing_eagerly():
if context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
'v1 optimizer does not run in eager mode')
np.random.seed(1331)
with test_util.use_gpu():
train_samples = 20
@ -838,14 +828,12 @@ class OptimizersCompatibilityTest(keras_parameterized.TestCase):
opt_k_v1,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model_k_v2.compile(
opt_k_v2,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
hist_k_v1 = model_k_v1.fit(x, y, batch_size=5, epochs=10, shuffle=False)
hist_k_v2 = model_k_v2.fit(x, y, batch_size=5, epochs=10, shuffle=False)

34
tensorflow/python/keras/optimizers_test.py
View File

@ -45,13 +45,10 @@ def _get_model(input_dim, num_hidden, output_dim):
@keras_parameterized.run_all_keras_modes
class KerasOptimizersTest(keras_parameterized.TestCase):
# After experimental_run_tf_function is turned on, optimizer v1 can no longer
# work in eager mode, skipping the test if so.
def _test_optimizer(self, optimizer, target=0.75):
if testing_utils.should_run_tf_function() or context.executing_eagerly():
if context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
'v1 optimizer does not run in eager mode')
np.random.seed(1337)
(x_train, y_train), _ = testing_utils.get_test_data(
train_samples=1000, test_samples=200, input_shape=(10,), num_classes=2)
@ -61,8 +58,7 @@ class KerasOptimizersTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np.testing.assert_equal(
keras.backend.get_value(model.optimizer.iterations), 0)
history = model.fit(x_train, y_train, epochs=2, batch_size=16, verbose=0)
@ -99,8 +95,7 @@ class KerasOptimizersTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
np.testing.assert_equal(
keras.backend.get_value(model.optimizer.iterations),
126) # Using same optimizer from before
@ -166,10 +161,9 @@ class KerasOptimizersTest(keras_parameterized.TestCase):
keras.optimizers.SGD(lr=0.01, momentum=0.9, clipvalue=0.5))
def test_tf_optimizer(self):
if testing_utils.should_run_tf_function() or context.executing_eagerly():
if context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
'v1 optimizer does not run in eager mode')
optimizer = keras.optimizers.TFOptimizer(AdamOptimizer(0.01))
model = keras.models.Sequential()
model.add(keras.layers.Dense(
@ -178,8 +172,7 @@ class KerasOptimizersTest(keras_parameterized.TestCase):
model.compile(
loss='mean_squared_error',
optimizer=optimizer,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
keras.backend.track_tf_optimizer(optimizer)
model.fit(np.random.random((5, 3)),
np.random.random((5, 2)),
@ -195,10 +188,9 @@ class KerasOptimizersTest(keras_parameterized.TestCase):
optimizer.from_config(None)
def test_optimizer_garbage_collection(self):
if testing_utils.should_run_tf_function() or context.executing_eagerly():
if context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
'v1 optimizer does not run in eager mode')
graph = ops.Graph()
with graph.as_default():
optimizer = keras.optimizers.TFOptimizer(AdamOptimizer(0.01))
@ -212,10 +204,9 @@ class KerasOptimizersTest(keras_parameterized.TestCase):
self.assertIs(optimizer_weak(), None)
def test_tf_optimizer_iterations(self):
if testing_utils.should_run_tf_function() or context.executing_eagerly():
if context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
'v1 optimizer does not run in eager mode')
with self.cached_session():
optimizer = keras.optimizers.TFOptimizer(AdamOptimizer(0.01))
model = keras.models.Sequential()
@ -224,8 +215,7 @@ class KerasOptimizersTest(keras_parameterized.TestCase):
model.compile(
loss='mean_squared_error',
optimizer=optimizer,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
keras.backend.track_tf_optimizer(optimizer)
self.assertEqual(keras.backend.get_value(model.optimizer.iterations), 0)

30
tensorflow/python/keras/premade/wide_deep_test.py
View File

@ -52,8 +52,7 @@ class WideDeepModelTest(keras_parameterized.TestCase):
optimizer=['sgd', 'adam'],
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
wide_deep_model.fit(inputs, output, epochs=5)
self.assertTrue(wide_deep_model.built)
@ -73,8 +72,7 @@ class WideDeepModelTest(keras_parameterized.TestCase):
optimizer=[linear_opt, dnn_opt],
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.evaluate(variables.global_variables_initializer())
wide_deep_model.fit(inputs, output, epochs=1)
self.assertAllClose(
@ -94,8 +92,7 @@ class WideDeepModelTest(keras_parameterized.TestCase):
optimizer=['sgd', 'adam'],
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
wide_deep_model.fit(inputs, output, epochs=5)
def test_wide_deep_model_with_multi_outputs(self):
@ -135,8 +132,7 @@ class WideDeepModelTest(keras_parameterized.TestCase):
optimizer='sgd',
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
wide_deep_model.fit(inputs, output, epochs=5)
self.assertTrue(wide_deep_model.built)
@ -160,8 +156,7 @@ class WideDeepModelTest(keras_parameterized.TestCase):
optimizer='sgd',
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit([linear_input_np, dnn_input_np, input_b_np], output_np, epochs=5)
def test_wide_deep_model_with_sub_model_trained(self):
@ -178,22 +173,19 @@ class WideDeepModelTest(keras_parameterized.TestCase):
optimizer='sgd',
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
dnn_model.compile(
optimizer='adam',
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
linear_model.fit(linear_inp, output, epochs=50)
dnn_model.fit(dnn_inp, output, epochs=50)
wide_deep_model.compile(
optimizer=['sgd', 'adam'],
loss='mse',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
wide_deep_model.fit(inputs, output, epochs=50)
# This test is an example for cases where linear and dnn model accepts
@ -221,8 +213,7 @@ class WideDeepModelTest(keras_parameterized.TestCase):
combined.compile(
opt,
'mse', [],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
combined.fit(x={'symbol': data}, y=y, batch_size=32, epochs=10)
# This test is an example for cases where linear and dnn model accepts
@ -255,8 +246,7 @@ class WideDeepModelTest(keras_parameterized.TestCase):
wide_deep_model.compile(
opt,
'mse', [],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
wide_deep_model.fit(x={'symbol': data}, y=y, batch_size=32, epochs=10)
def test_config(self):

18
tensorflow/python/keras/regularizers_test.py
View File

@ -79,8 +79,7 @@ class KerasRegularizersTest(keras_parameterized.TestCase,
model.compile(
loss='categorical_crossentropy',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertEqual(len(model.losses), 1)
model.fit(x_train, y_train, batch_size=10, epochs=1, verbose=0)
@ -97,8 +96,7 @@ class KerasRegularizersTest(keras_parameterized.TestCase,
model.compile(
loss='categorical_crossentropy',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertEqual(len(model.losses), 1 if context.executing_eagerly() else 1)
model.fit(x_train, y_train, batch_size=10, epochs=1, verbose=0)
@ -113,8 +111,7 @@ class KerasRegularizersTest(keras_parameterized.TestCase,
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, batch_size=5, epochs=1)
def test_custom_regularizer_saving(self):
@ -144,8 +141,7 @@ class KerasRegularizersTest(keras_parameterized.TestCase,
model.compile(
loss='categorical_crossentropy',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertLen(model.losses, 5)
@keras_parameterized.run_all_keras_modes
@ -167,8 +163,7 @@ class KerasRegularizersTest(keras_parameterized.TestCase,
model.compile(
loss='categorical_crossentropy',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
self.assertLen(model.losses, 6)
@keras_parameterized.run_all_keras_modes
@ -195,8 +190,7 @@ class KerasRegularizersTest(keras_parameterized.TestCase,
model.compile(
loss='categorical_crossentropy',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# We expect to see 9 losses on the model:
# - 2 from the 2 add_loss calls on the outer model.

6
tensorflow/python/keras/saving/losses_serialization_test.py
View File

@ -135,8 +135,7 @@ class LossesSerialization(keras_parameterized.TestCase):
model.compile(
optimizer_v2.gradient_descent.SGD(0.1),
loss=value,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.x], [self.y, self.y],
batch_size=3,
epochs=3,
@ -163,8 +162,7 @@ class LossesSerialization(keras_parameterized.TestCase):
model.compile(
optimizer_v2.gradient_descent.SGD(0.1),
loss=value,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.x], [self.y, self.y],
batch_size=3,
epochs=3,

6
tensorflow/python/keras/saving/metrics_serialization_test.py
View File

@ -181,8 +181,7 @@ class MetricsSerialization(keras_parameterized.TestCase):
'mae',
metrics=metric_input,
weighted_metrics=weighted_metric_input,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.x], [self.y, self.y],
batch_size=3,
epochs=3,
@ -222,8 +221,7 @@ class MetricsSerialization(keras_parameterized.TestCase):
'mae',
metrics=metric_input,
weighted_metrics=weighted_metric_input,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.x], [self.y, self.y],
batch_size=3,
epochs=3,

6
tensorflow/python/keras/saving/saving_utils_test.py
View File

@ -91,8 +91,7 @@ class TraceModelCallTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(
x=np.random.random((8, 5)).astype(np.float32),
y=np.random.random((8, 3)).astype(np.float32),
@ -137,8 +136,7 @@ class TraceModelCallTest(keras_parameterized.TestCase):
model.compile(
optimizer='sgd',
loss='mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x=[np.random.random((8, input_dim)).astype(np.float32),
np.random.random((8, input_dim)).astype(np.float32)],
y=[np.random.random((8, num_classes)).astype(np.float32),

27
tensorflow/python/keras/tests/add_loss_correctness_test.py
View File

@ -79,8 +79,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
model.add_loss(math_ops.reduce_mean(mae(targets, outputs)))
model.compile(
optimizer_v2.gradient_descent.SGD(0.05),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.y], batch_size=3, epochs=5)
self.assertAllClose(history.history['loss'], [2., 1.8, 1.6, 1.4, 1.2], 1e-3)
@ -97,8 +96,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
model.add_loss(callable_loss)
model.compile(
optimizer_v2.gradient_descent.SGD(0.1),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(self.x, batch_size=3, epochs=5)
self.assertAllClose(history.history['loss'], [0., -.1, -.2, -.3, -.4], 1e-3)
@ -157,8 +155,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
model.add_loss(3 * math_ops.reduce_mean(sw * mae(targets, outputs)))
model.compile(
optimizer_v2.gradient_descent.SGD(0.025),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.y, self.w], batch_size=3, epochs=5)
self.assertAllClose(history.history['loss'], [4., 3.6, 3.2, 2.8, 2.4], 1e-3)
@ -203,8 +200,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
model.predict([self.x, self.y, self.w])
model.compile(
optimizer_v2.gradient_descent.SGD(0.05),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.y, self.w], batch_size=3, epochs=5)
self.assertEqual(len(model.losses), 2)
@ -237,8 +233,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
model.predict([self.x, self.y, self.w])
model.compile(
optimizer_v2.gradient_descent.SGD(0.05),
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit([self.x, self.y, self.w], batch_size=3, epochs=5)
self.assertAllClose(history.history['loss'], [2., 1.8, 1.6, 1.4, 1.2], 1e-3)
@ -266,8 +261,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
loss = model.train_on_batch(np.ones((2, 3)), np.ones((2, 3)))
self.assertEqual(loss, 2 * 3)
@ -300,8 +294,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
model.compile(
optimizer,
'binary_crossentropy',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x, y, batch_size=2, epochs=5)
loss[reg] = model.evaluate(x, y)
self.assertLess(loss[None], loss['l2'])
@ -321,8 +314,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
optimizer = RMSPropOptimizer(learning_rate=0.001)
model.compile(
optimizer,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
loss = model.test_on_batch(x)
self.assertAlmostEqual(0.01, loss, places=4)
@ -336,8 +328,7 @@ class TestAddLossCorrectness(keras_parameterized.TestCase):
optimizer = RMSPropOptimizer(learning_rate=0.001)
model.compile(
optimizer,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
loss_small_batch = model.test_on_batch(np.ones((10, 10), 'float32'))
loss_big_batch = model.test_on_batch(np.ones((20, 10), 'float32'))

24
tensorflow/python/keras/tests/integration_test.py
View File

@ -75,8 +75,7 @@ class VectorClassificationIntegrationTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(x_train, y_train, epochs=10, batch_size=10,
validation_data=(x_train, y_train),
verbose=2)
@ -112,8 +111,7 @@ class VectorClassificationIntegrationTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
if not testing_utils.should_run_eagerly():
self.assertEqual(len(model.get_losses_for(None)), 2)
self.assertEqual(len(model.get_updates_for(x)), 2)
@ -153,8 +151,7 @@ class SequentialIntegrationTest(KerasIntegrationTest):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x_train, y_train, epochs=1, batch_size=10,
validation_data=(x_train, y_train),
verbose=2)
@ -176,8 +173,7 @@ class SequentialIntegrationTest(KerasIntegrationTest):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(x_train, y_train, epochs=10, batch_size=10,
validation_data=(x_train, y_train),
verbose=2)
@ -213,8 +209,7 @@ class TimeseriesClassificationIntegrationTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(x_train, y_train, epochs=15, batch_size=10,
validation_data=(x_train, y_train),
verbose=2)
@ -244,8 +239,7 @@ class TimeseriesClassificationIntegrationTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(x_train, y_train, epochs=15, batch_size=10,
validation_data=(x_train, y_train),
@ -284,8 +278,7 @@ class ImageClassificationIntegrationTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
history = model.fit(x_train, y_train, epochs=10, batch_size=10,
validation_data=(x_train, y_train),
verbose=2)
@ -329,8 +322,7 @@ class ActivationV2IntegrationTest(keras_parameterized.TestCase):
loss='categorical_crossentropy',
optimizer=keras.optimizer_v2.adam.Adam(0.005),
metrics=['accuracy'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(x_train, y_train, epochs=2, batch_size=10,
validation_data=(x_train, y_train),
verbose=2)

45
tensorflow/python/keras/tests/model_subclassing_compiled_test.py
View File

@ -49,8 +49,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=['acc', keras.metrics.CategoricalAccuracy()],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((num_samples, input_dim))
y = np.zeros((num_samples, num_classes))
@ -69,8 +68,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x1 = np.ones((num_samples, input_dim))
x2 = np.ones((num_samples, input_dim))
@ -91,8 +89,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((num_samples, input_dim), dtype=np.float32)
y = np.zeros((num_samples, num_classes), dtype=np.float32)
@ -125,8 +122,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch([x1, x2], [y1, y2])
self.assertEqual(model.built, True)
@ -157,8 +153,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
y_ref = model.predict(x)
model.train_on_batch(x, y)
@ -191,8 +186,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
loss = model.train_on_batch(x, y)
self.assertGreater(loss, 0.1)
@ -214,8 +208,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit([x1, x2], [y1, y2], epochs=2, batch_size=32, verbose=0)
model.fit({'input_1': x1, 'input_2': x2},
{'output_1': y1, 'output_2': y2},
@ -228,8 +221,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.train_on_batch([x1, x2], [y1, y2])
model.train_on_batch({'input_1': x1, 'input_2': x2},
{'output_1': y1, 'output_2': y2})
@ -251,8 +243,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.evaluate([x1, x2], [y1, y2])
model.test_on_batch([x1, x2], [y1, y2])
@ -279,8 +270,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit([x1, x2], [y1, y2], epochs=2, batch_size=32, verbose=0)
y_ref_1, y_ref_2 = model.predict([x1, x2])
@ -320,8 +310,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((num_samples, input_dim))
y = np.zeros((num_samples, num_classes))
@ -345,8 +334,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((num_samples, input_dim))
y = np.zeros((num_samples, num_classes))
@ -371,8 +359,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((num_samples, input_dim))
y = np.zeros((num_samples, num_classes))
@ -407,8 +394,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
loss='mse',
optimizer='rmsprop',
metrics=['acc'],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
x = np.ones((num_samples, input_dim))
y = np.zeros((num_samples, num_classes))
@ -447,8 +433,7 @@ class ModelSubclassCompiledTest(keras_parameterized.TestCase):
model.compile(
loss='mse',
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
loss = model.train_on_batch(x, y)
self.assertGreater(loss, 0.1)

6
tensorflow/python/keras/tests/model_subclassing_test.py
View File

@ -99,8 +99,7 @@ class ModelSubclassingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
model.fit(np.ones((10, 10)), np.ones((10, 1)), batch_size=2, epochs=2)
self.assertLen(model.layers, 2)
self.assertLen(model.trainable_variables, 4)
@ -122,8 +121,7 @@ class ModelSubclassingTest(keras_parameterized.TestCase):
model.compile(
'sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
data = dataset_ops.DatasetV2.from_tensor_slices(({
'a': np.ones((32, 10)),

3
tensorflow/python/keras/tests/temporal_sample_weights_correctness_test.py
View File

@ -63,8 +63,7 @@ def get_compiled_multi_io_model_temporal(sample_weight_mode):
metrics=[metrics.MeanAbsoluteError(name='mae')],
weighted_metrics=[metrics.MeanAbsoluteError(name='mae_2')],
sample_weight_mode=sample_weight_mode,
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
return model

17
tensorflow/python/keras/utils/composite_tensor_support_test.py
View File

@ -164,15 +164,8 @@ def get_model_from_layers_with_input(layers,
def get_test_mode_kwargs():
run_eagerly = testing_utils.should_run_eagerly()
# Certain things weren't supported correctly in the old path, therefore
# with these changes, some tests now only pass in the single code path in V2.
if run_eagerly or context.executing_eagerly():
experimental_run_tf_function = True
else:
experimental_run_tf_function = testing_utils.should_run_tf_function()
return {
"run_eagerly": run_eagerly,
"experimental_run_tf_function": experimental_run_tf_function
}
@ -232,7 +225,6 @@ class CompositeTensorOutputTest(keras_parameterized.TestCase):
# converts the ragged tensor back to a dense tensor.
layers = [ToRagged(padding=0)]
model = testing_utils.get_model_from_layers(layers, input_shape=(None,))
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
model._run_eagerly = testing_utils.should_run_eagerly()
# Define some input data with additional padding.
@ -247,7 +239,6 @@ class CompositeTensorOutputTest(keras_parameterized.TestCase):
# converts the ragged tensor back to a dense tensor.
layers = [ToRagged(padding=0)]
model = testing_utils.get_model_from_layers(layers, input_shape=(None,))
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
model._run_eagerly = testing_utils.should_run_eagerly()
# Define some input data with additional padding.
@ -262,7 +253,6 @@ class CompositeTensorOutputTest(keras_parameterized.TestCase):
# converts the ragged tensor back to a dense tensor.
layers = [ToSparse()]
model = testing_utils.get_model_from_layers(layers, input_shape=(None,))
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
model._run_eagerly = testing_utils.should_run_eagerly()
# Define some input data with additional padding.
@ -282,7 +272,6 @@ class CompositeTensorOutputTest(keras_parameterized.TestCase):
# converts the ragged tensor back to a dense tensor.
layers = [ToSparse()]
model = testing_utils.get_model_from_layers(layers, input_shape=(None,))
model._experimental_run_tf_function = testing_utils.should_run_tf_function()
model._run_eagerly = testing_utils.should_run_eagerly()
# Define some input data with additional padding.
@ -418,8 +407,7 @@ class ScipySparseTensorInputTest(keras_parameterized.TestCase,
model.compile(
optimizer="sgd",
loss="mse",
metrics=["accuracy"],
experimental_run_tf_function=testing_utils.should_run_tf_function())
metrics=["accuracy"])
input_data = scipy.sparse.coo_matrix(([1, 2, 3], ([0, 1, 1], [0, 0, 1])),
shape=[2, 3])
@ -480,8 +468,7 @@ class ScipySparseTensorInputTest(keras_parameterized.TestCase,
model.compile(
optimizer="sgd",
loss="mse",
metrics=["accuracy"],
experimental_run_tf_function=testing_utils.should_run_tf_function())
metrics=["accuracy"])
input_data = {
input_name:

3
tensorflow/python/keras/utils/io_utils_test.py
View File

@ -86,8 +86,7 @@ class TestIOUtils(keras_parameterized.TestCase):
model.compile(
loss='binary_crossentropy',
optimizer='sgd',
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
run_eagerly=testing_utils.should_run_eagerly())
# Note: you have to use shuffle='batch' or False with HDF5Matrix
model.fit(x_train, y_train, batch_size=32, shuffle='batch', verbose=False)

3
tensorflow/python/saved_model/load_test.py
View File

@ -1859,8 +1859,7 @@ class KerasLoadTest(test.TestCase, parameterized.TestCase):
[feature_column_lib.DenseFeatures(columns),
core.Dense(1)])
model_input = {"x": constant_op.constant([[1.]])}
model.compile(optimizer="adam", loss="mse", run_eagerly=True,
experimental_run_tf_function=True)
model.compile(optimizer="adam", loss="mse", run_eagerly=True)
model.fit(model_input, constant_op.constant([[3.]]))
loaded = cycle(model, cycles)
loaded._default_save_signature(model_input)