def evaluate_distributed(model, x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None, callbacks=None): """Evaluate loop for Distribution Strategies.""" distributed_training_utils.validate_inputs(x, y, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps, batch_size = distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps, batch_size) batch_size = model._validate_or_infer_batch_size(batch_size, steps, x) dataset = model._distribution_standardize_user_data( x, y, sample_weight=sample_weight, batch_size=batch_size) if distributed_training_utils.is_tpu_strategy( model._distribution_strategy): return experimental_tpu_test_loop(model, dataset, verbose=verbose, steps=steps, callbacks=callbacks) else: return training_arrays.test_loop(model, inputs=dataset, batch_size=batch_size, verbose=verbose, steps=steps, callbacks=callbacks)
def predict_distributed(model, x=None, batch_size=None, verbose=0, steps=None, callbacks=None): """Predict loop for Distribution Strategies.""" distributed_training_utils.validate_inputs( x, None, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps, batch_size = distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps, batch_size) batch_size = model._validate_or_infer_batch_size(batch_size, steps, x) iterator = model._distribution_standardize_user_data( x, batch_size=batch_size, check_steps=True, steps_name='steps', steps=steps) if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): # TODO(fchollet): why aren't callbacks supported here? return experimental_tpu_predict_loop( model, iterator, verbose=verbose, steps=steps) else: return training_arrays.predict_loop( model, iterator, batch_size=batch_size, verbose=verbose, steps=steps, callbacks=callbacks)
def predict_distributed(model, x=None, batch_size=None, verbose=0, steps=None, callbacks=None): """Predict loop for Distribution Strategies.""" distributed_training_utils.validate_inputs( x, None, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps, batch_size = distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps, batch_size) batch_size = model._validate_or_infer_batch_size(batch_size, steps, x) dataset = model._distribution_standardize_user_data( x, batch_size=batch_size, check_steps=True, steps_name='steps', steps=steps) if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): # TODO(fchollet): why aren't callbacks supported here? return experimental_tpu_predict_loop( model, dataset, verbose=verbose, steps=steps) else: return training_arrays.predict_loop( model, dataset, batch_size=batch_size, verbose=verbose, steps=steps, callbacks=callbacks)
def predict_distributed(model, x=None, batch_size=None, verbose=0, steps=None, callbacks=None): """Predict loop for Distribution Strategies.""" distributed_training_utils.validate_inputs( x, None, model._distribution_strategy, allow_partial_batch=True) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps, batch_size = distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps, batch_size, mode=ModeKeys.PREDICT) batch_size = model._validate_or_infer_batch_size(batch_size, steps, x) dataset = model._distribution_standardize_user_data( x, batch_size=batch_size, repeat=False, allow_partial_batch=True) if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): return experimental_tpu_predict_loop( model, dataset, verbose=verbose, steps=steps, callbacks=callbacks) else: return training_arrays.predict_loop( model, dataset, batch_size=batch_size, verbose=verbose, steps=steps, callbacks=callbacks)
def predict_distributed(model, x=None, batch_size=None, verbose=0, steps=None, callbacks=None): """Predict loop for Distribution Strategies.""" distributed_training_utils.validate_inputs( x, None, model._distribution_strategy, allow_partial_batch=True) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps, batch_size = distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps, batch_size, mode=ModeKeys.PREDICT) batch_size = model._validate_or_infer_batch_size(batch_size, steps, x) dataset = model._distribution_standardize_user_data( x, batch_size=batch_size, repeat=False, allow_partial_batch=True) if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): return experimental_tpu_predict_loop( model, dataset, verbose=verbose, steps=steps, callbacks=callbacks) else: return training_arrays.predict_loop( model, dataset, batch_size=batch_size, verbose=verbose, steps=steps, callbacks=callbacks)
def evaluate_distributed(model, x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None, callbacks=None): """Evaluate loop for Distribution Strategies.""" distributed_training_utils.validate_inputs(x, y, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps, batch_size = distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps, batch_size) batch_size = model._validate_or_infer_batch_size(batch_size, steps, x) dataset = model._distribution_standardize_user_data( x, y, sample_weight=sample_weight, batch_size=batch_size) if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): return experimental_tpu_test_loop( model, dataset, verbose=verbose, steps=steps, callbacks=callbacks) else: return training_arrays.test_loop( model, inputs=dataset, batch_size=batch_size, verbose=verbose, steps=steps, callbacks=callbacks)
def test_on_dataset_with_unknown_cardinality_without_steps( self, distribution): with self.cached_session(): with distribution.scope(): model = get_model() optimizer = gradient_descent.GradientDescentOptimizer(0.001) loss = 'mse' metrics = ['mae', keras.metrics.CategoricalAccuracy()] model.compile(optimizer, loss, metrics=metrics) inputs = np.zeros((1000, 3), dtype=np.float32) targets = np.zeros((1000, 4), dtype=np.float32) # steps/steps_per_epoch are calculated when using numpy arrays as # input data. fit_with_numpy = model.fit(inputs, targets, epochs=1, batch_size=10).history fit_with_numpy_multiple_epochs = model.fit( inputs, targets, epochs=2, batch_size=10).history eval_with_numpy = model.evaluate(inputs, targets, batch_size=10) predict_with_numpy = model.predict(inputs, batch_size=10) dataset = convert_numpy_to_dataset_with_unknown_cardinality( inputs, targets) predict_dataset = convert_numpy_to_dataset_with_unknown_cardinality( inputs) self.assertEqual(keras.backend.get_value(cardinality.cardinality( dataset)), cardinality.UNKNOWN) self.assertEqual(keras.backend.get_value(cardinality.cardinality( predict_dataset)), cardinality.UNKNOWN) eval_with_ds = model.evaluate(dataset) predict_with_ds = model.predict(predict_dataset) self.assertAllClose( eval_with_numpy, eval_with_ds, atol=1e-4, rtol=1e-4) self.assertAllClose( predict_with_numpy, predict_with_ds, atol=1e-4, rtol=1e-4) if (distributed_training_utils.is_tpu_strategy(distribution) and distribution.extended.steps_per_run != 1): with self.assertRaisesRegexp(ValueError, '`steps_per_epoch` ' 'should be specified'): fit_with_ds = model.fit(dataset, epochs=1) else: fit_with_ds = model.fit(dataset, epochs=1).history fit_with_ds_multiple_epochs = model.fit(dataset, epochs=2).history self.assertAllClose( fit_with_numpy, fit_with_ds, atol=1e-4, rtol=1e-4) self.assertAllClose( fit_with_numpy_multiple_epochs, fit_with_ds_multiple_epochs, atol=1e-4, rtol=1e-4)
def evaluate_distributed(model, x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None, callbacks=None): """Evaluate loop for Distribution Strategies.""" # TODO(b/122314600): Remove the scope validate. distributed_training_utils.validate_not_in_strategy_scope() distributed_training_utils.validate_inputs(x, y, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps, batch_size = distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps, batch_size) batch_size = model._validate_or_infer_batch_size(batch_size, steps, x) iterator = model._distribution_standardize_user_data( x, y, sample_weight=sample_weight, batch_size=batch_size, check_steps=True, steps_name='steps', steps=steps) if distributed_training_utils.is_tpu_strategy( model._distribution_strategy): # TODO(fchollet): why aren't callbacks supported here? return experimental_tpu_test_loop(model, iterator=iterator, verbose=verbose, steps=steps) else: return training_arrays.test_loop(model, inputs=iterator, batch_size=batch_size, verbose=verbose, steps=steps, callbacks=callbacks)
def fit_distributed(model, x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0., validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1): """Fit loop for Distribution Strategies.""" distributed_training_utils.validate_callbacks(callbacks, model.optimizer) distributed_training_utils.validate_inputs( x, y, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): # Until support for partial batch is implemented across all # functions and distribution strategy, we pass `mode` to selectively # relax the costraint to consume all the training samples. steps_per_epoch, batch_size = ( distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps_per_epoch, batch_size, mode=ModeKeys.TRAIN)) batch_size = model._validate_or_infer_batch_size( batch_size, steps_per_epoch, x) steps_name = 'steps_per_epoch' if isinstance(x, dataset_ops.DatasetV2): steps_per_epoch = training_utils.infer_steps_for_dataset( x, steps_per_epoch, steps_name=steps_name) dataset = model._distribution_standardize_user_data( x, y, sample_weight=sample_weight, class_weight=class_weight, batch_size=batch_size, check_steps=True, steps_name=steps_name, steps=steps_per_epoch, validation_split=validation_split, shuffle=shuffle) val_dataset = None if validation_data: val_x, val_y, val_sample_weights = model._unpack_validation_data( validation_data) distributed_training_utils.validate_inputs( val_x, val_y, model._distribution_strategy) first_valx_value = nest.flatten(val_x)[0] if isinstance(first_valx_value, np.ndarray): validation_steps, _ = distributed_training_utils.get_input_params( model._distribution_strategy, first_valx_value, validation_steps, batch_size) steps_name = 'validation_steps' if isinstance(val_x, dataset_ops.DatasetV2): validation_steps = training_utils.infer_steps_for_dataset( val_x, validation_steps, steps_name=steps_name) val_dataset = model._distribution_standardize_user_data( val_x, val_y, sample_weight=val_sample_weights, class_weight=None, batch_size=batch_size, check_steps=True, steps_name=steps_name, steps=validation_steps, validation_split=validation_split, shuffle=shuffle) elif validation_split: raise ValueError('validation_split argument is not supported with ' 'distribution strategies.') if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): return experimental_tpu_fit_loop( model, dataset, epochs=epochs, verbose=verbose, callbacks=callbacks, val_dataset=val_dataset, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps, validation_freq=1) else: return training_arrays.fit_loop( model, dataset, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks=callbacks, val_inputs=val_dataset, shuffle=shuffle, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps, validation_freq=validation_freq)
def fit_distributed(model, x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0., validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1): """Fit loop for Distribution Strategies.""" distributed_training_utils.validate_callbacks(callbacks, model.optimizer) distributed_training_utils.validate_inputs(x, y, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): # Until support for partial batch is implemented across all # functions and distribution strategy, we pass `mode` to selectively # relax the costraint to consume all the training samples. steps_per_epoch, batch_size = ( distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps_per_epoch, batch_size, mode=ModeKeys.TRAIN)) batch_size = model._validate_or_infer_batch_size(batch_size, steps_per_epoch, x) dataset = model._distribution_standardize_user_data( x, y, sample_weight=sample_weight, class_weight=class_weight, batch_size=batch_size, check_steps=True, steps_name='steps_per_epoch', steps=steps_per_epoch, validation_split=validation_split, shuffle=shuffle) val_dataset = None if validation_data: val_x, val_y, val_sample_weights = model._unpack_validation_data( validation_data) distributed_training_utils.validate_inputs( val_x, val_y, model._distribution_strategy) first_valx_value = nest.flatten(val_x)[0] if isinstance(first_valx_value, np.ndarray): validation_steps, _ = distributed_training_utils.get_input_params( model._distribution_strategy, first_valx_value, validation_steps, batch_size) val_dataset = model._distribution_standardize_user_data( val_x, val_y, sample_weight=val_sample_weights, class_weight=None, batch_size=batch_size, check_steps=True, steps_name='validation_steps', steps=validation_steps, validation_split=validation_split, shuffle=shuffle) elif validation_split: raise ValueError('validation_split argument is not supported with ' 'distribution strategies.') if distributed_training_utils.is_tpu_strategy( model._distribution_strategy): return experimental_tpu_fit_loop(model, dataset, epochs=epochs, verbose=verbose, callbacks=callbacks, val_dataset=val_dataset, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps, validation_freq=1) else: return training_arrays.fit_loop(model, dataset, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks=callbacks, val_inputs=val_dataset, shuffle=shuffle, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps, validation_freq=validation_freq)
def fit_distributed(model, x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0., validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None): """Fit loop for Distribution Strategies.""" distributed_training_utils.validate_callbacks(callbacks, model.optimizer) distributed_training_utils.validate_inputs( x, y, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps_per_epoch, batch_size = ( distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps_per_epoch, batch_size, is_training=True)) batch_size = model._validate_or_infer_batch_size( batch_size, steps_per_epoch, x) iterator = model._distribution_standardize_user_data( x, y, sample_weight=sample_weight, class_weight=class_weight, batch_size=batch_size, check_steps=True, steps_name='steps_per_epoch', steps=steps_per_epoch, validation_split=validation_split, shuffle=shuffle) val_iterator = None if validation_data: val_x, val_y, val_sample_weights = model._unpack_validation_data( validation_data) distributed_training_utils.validate_inputs( val_x, val_y, model._distribution_strategy) first_valx_value = nest.flatten(val_x)[0] if isinstance(first_valx_value, np.ndarray): validation_steps, _ = distributed_training_utils.get_input_params( model._distribution_strategy, first_valx_value, validation_steps, batch_size) val_iterator = model._distribution_standardize_user_data( val_x, val_y, sample_weight=val_sample_weights, class_weight=None, batch_size=batch_size, check_steps=True, steps_name='validation_steps', steps=validation_steps, validation_split=validation_split, shuffle=shuffle) elif validation_split: raise ValueError('validation_split argument is not supported with ' 'distribution strategies.') if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): return experimental_tpu_fit_loop( model, iterator, epochs=epochs, verbose=verbose, callbacks=callbacks, val_iterator=val_iterator, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps) else: return training_arrays.fit_loop( model, iterator, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks=callbacks, val_inputs=val_iterator, shuffle=shuffle, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps)
def fit_distributed(model, x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0., validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1): """Fit loop for Distribution Strategies.""" distributed_training_utils.validate_callbacks(callbacks, model.optimizer) distributed_training_utils.validate_inputs( x, y, model._distribution_strategy) first_x_value = nest.flatten(x)[0] if isinstance(first_x_value, np.ndarray): steps_per_epoch, batch_size = ( distributed_training_utils.get_input_params( model._distribution_strategy, first_x_value, steps_per_epoch, batch_size, is_training=True)) batch_size = model._validate_or_infer_batch_size( batch_size, steps_per_epoch, x) dataset = model._distribution_standardize_user_data( x, y, sample_weight=sample_weight, class_weight=class_weight, batch_size=batch_size, check_steps=True, steps_name='steps_per_epoch', steps=steps_per_epoch, validation_split=validation_split, shuffle=shuffle) val_dataset = None if validation_data: val_x, val_y, val_sample_weights = model._unpack_validation_data( validation_data) distributed_training_utils.validate_inputs( val_x, val_y, model._distribution_strategy) first_valx_value = nest.flatten(val_x)[0] if isinstance(first_valx_value, np.ndarray): validation_steps, _ = distributed_training_utils.get_input_params( model._distribution_strategy, first_valx_value, validation_steps, batch_size) val_dataset = model._distribution_standardize_user_data( val_x, val_y, sample_weight=val_sample_weights, class_weight=None, batch_size=batch_size, check_steps=True, steps_name='validation_steps', steps=validation_steps, validation_split=validation_split, shuffle=shuffle) elif validation_split: raise ValueError('validation_split argument is not supported with ' 'distribution strategies.') if distributed_training_utils.is_tpu_strategy(model._distribution_strategy): return experimental_tpu_fit_loop( model, dataset, epochs=epochs, verbose=verbose, callbacks=callbacks, val_dataset=val_dataset, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps, validation_freq=1) else: return training_arrays.fit_loop( model, dataset, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks=callbacks, val_inputs=val_dataset, shuffle=shuffle, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps, validation_freq=validation_freq)