def test_raises_no_repeat_and_no_take(self):
with self.assertRaisesRegex(
ValueError, 'Argument client_epochs_per_round is set to -1'):
cifar100_dataset.get_federated_cifar100(
client_epochs_per_round=-1,
train_batch_size=10,
max_batches_per_client=-1)
def test_raises_length_2_crop(self):
with self.assertRaises(ValueError):
cifar100_dataset.get_federated_cifar100(
client_epochs_per_round=1, train_batch_size=10, crop_shape=(32, 32))
with self.assertRaises(ValueError):
cifar100_dataset.get_centralized_cifar100(
train_batch_size=10, crop_shape=(32, 32))
def test_federated_cifar_structure(self):
crop_shape = (32, 32, 3)
cifar_train, _ = cifar100_dataset.get_federated_cifar100(
client_epochs_per_round=1, train_batch_size=10, crop_shape=crop_shape)
client_id = cifar_train.client_ids[0]
client_dataset = cifar_train.create_tf_dataset_for_client(client_id)
train_batch = next(iter(client_dataset))
train_batch_shape = tuple(train_batch[0].shape)
self.assertEqual(train_batch_shape, (10, 32, 32, 3))
def test_take_with_repeat(self):
cifar_train, _ = cifar100_dataset.get_federated_cifar100(
client_epochs_per_round=-1,
train_batch_size=10,
max_batches_per_client=10)
self.assertEqual(len(cifar_train.client_ids), 500)
for i in range(10):
client_ds = cifar_train.create_tf_dataset_for_client(
cifar_train.client_ids[i])
self.assertEqual(_compute_length_of_dataset(client_ds), 10)
def main(argv):
if len(argv) > 1:
raise app.UsageError('Expected no command-line arguments, '
'got: {}'.format(argv))
cifar_train, cifar_test = cifar100_dataset.get_federated_cifar100(
client_epochs_per_round=FLAGS.client_epochs_per_round,
train_batch_size=FLAGS.client_batch_size,
crop_shape=CROP_SHAPE)
input_spec = cifar_train.create_tf_dataset_for_client(
cifar_train.client_ids[0]).element_spec
model_builder = functools.partial(resnet_models.create_resnet18,
input_shape=CROP_SHAPE,
num_classes=NUM_CLASSES)
logging.info('Training model:')
logging.info(model_builder().summary())
loss_builder = tf.keras.losses.SparseCategoricalCrossentropy
metrics_builder = lambda: [tf.keras.metrics.SparseCategoricalAccuracy()]
training_process = iterative_process_builder.from_flags(
input_spec=input_spec,
model_builder=model_builder,
loss_builder=loss_builder,
metrics_builder=metrics_builder)
client_datasets_fn = training_utils.build_client_datasets_fn(
train_dataset=cifar_train,
train_clients_per_round=FLAGS.clients_per_round,
random_seed=FLAGS.client_datasets_random_seed)
assign_weights_fn = fed_avg_schedule.ServerState.assign_weights_to_keras_model
evaluate_fn = training_utils.build_evaluate_fn(
eval_dataset=cifar_test,
model_builder=model_builder,
loss_builder=loss_builder,
metrics_builder=metrics_builder,
assign_weights_to_keras_model=assign_weights_fn)
training_loop.run(iterative_process=training_process,
client_datasets_fn=client_datasets_fn,
validation_fn=evaluate_fn)
def run_federated(
iterative_process_builder: Callable[...,
tff.templates.IterativeProcess],
assign_weights_fn: Callable[[Any, tf.keras.Model], None],
client_epochs_per_round: int,
client_batch_size: int,
clients_per_round: int,
max_batches_per_client: Optional[int] = -1,
client_datasets_random_seed: Optional[int] = None,
crop_size: Optional[int] = 24,
total_rounds: Optional[int] = 1500,
experiment_name: Optional[str] = 'federated_cifar100',
root_output_dir: Optional[str] = '/tmp/fed_opt',
**kwargs):
"""Runs an iterative process on the CIFAR-100 classification task.
This method will load and pre-process dataset and construct a model used for
the task. It then uses `iterative_process_builder` to create an iterative
process that it applies to the task, using
`tensorflow_federated.python.research.utils.training_loop`.
We assume that the iterative process has the following functional type
signatures:
* `initialize`: `( -> S@SERVER)` where `S` represents the server state.
* `next`: `<S@SERVER, {B*}@CLIENTS> -> <S@SERVER, T@SERVER>` where `S`
represents the server state, `{B*}` represents the client datasets,
and `T` represents a python `Mapping` object.
Args:
iterative_process_builder: A function that accepts a no-arg `model_fn`, and
returns a `tff.templates.IterativeProcess`. The `model_fn` must return a
`tff.learning.Model`.
assign_weights_fn: A function that accepts the server state `S` and a
`tf.keras.Model`, and updates the weights in the Keras model. This is used
to do evaluation using Keras.
client_epochs_per_round: An integer representing the number of epochs of
training performed per client in each training round.
client_batch_size: An integer representing the batch size used on clients.
clients_per_round: An integer representing the number of clients
participating in each round.
max_batches_per_client: An optional int specifying the number of batches
taken by each client at each round. If `-1`, the entire client dataset is
used.
client_datasets_random_seed: An optional int used to seed which clients are
sampled at each round. If `None`, no seed is used.
crop_size: An optional integer representing the resulting size of input
images after preprocessing.
total_rounds: The number of federated training rounds.
experiment_name: The name of the experiment being run. This will be appended
to the `root_output_dir` for purposes of writing outputs.
root_output_dir: The name of the root output directory for writing
experiment outputs.
**kwargs: Additional arguments configuring the training loop. For details
on supported arguments, see
`tensorflow_federated/python/research/utils/training_utils.py`.
"""
crop_shape = (crop_size, crop_size, 3)
cifar_train, cifar_test = cifar100_dataset.get_federated_cifar100(
client_epochs_per_round=client_epochs_per_round,
train_batch_size=client_batch_size,
crop_shape=crop_shape,
max_batches_per_client=max_batches_per_client)
input_spec = cifar_train.create_tf_dataset_for_client(
cifar_train.client_ids[0]).element_spec
model_builder = functools.partial(resnet_models.create_resnet18,
input_shape=crop_shape,
num_classes=NUM_CLASSES)
loss_builder = tf.keras.losses.SparseCategoricalCrossentropy
metrics_builder = lambda: [tf.keras.metrics.SparseCategoricalAccuracy()]
def tff_model_fn() -> tff.learning.Model:
return tff.learning.from_keras_model(keras_model=model_builder(),
input_spec=input_spec,
loss=loss_builder(),
metrics=metrics_builder())
training_process = iterative_process_builder(tff_model_fn)
client_datasets_fn = training_utils.build_client_datasets_fn(
train_dataset=cifar_train,
train_clients_per_round=clients_per_round,
random_seed=client_datasets_random_seed)
evaluate_fn = training_utils.build_evaluate_fn(
eval_dataset=cifar_test,
model_builder=model_builder,
loss_builder=loss_builder,
metrics_builder=metrics_builder,
assign_weights_to_keras_model=assign_weights_fn)
logging.info('Training model:')
logging.info(model_builder().summary())
training_loop.run(iterative_process=training_process,
client_datasets_fn=client_datasets_fn,
validation_fn=evaluate_fn,
test_fn=evaluate_fn,
total_rounds=total_rounds,
experiment_name=experiment_name,
root_output_dir=root_output_dir,
**kwargs)
def main(argv):
if len(argv) > 1:
raise app.UsageError('Expected no command-line arguments, '
'got: {}'.format(argv))
cifar_train, _ = cifar100_dataset.get_federated_cifar100(
client_epochs_per_round=FLAGS.client_epochs_per_round,
train_batch_size=FLAGS.client_batch_size,
crop_shape=CROP_SHAPE,
max_batches_per_client=FLAGS.max_batches_per_client)
central_cifar_train, cifar_test = cifar100_dataset.get_centralized_cifar100(
100, crop_shape=CROP_SHAPE)
input_spec = cifar_train.create_tf_dataset_for_client(
cifar_train.client_ids[0]).element_spec
model_builder = functools.partial(resnet_models.create_resnet18,
input_shape=CROP_SHAPE,
num_classes=NUM_CLASSES)
logging.info('Training model:')
logging.info(model_builder().summary())
loss_builder = tf.keras.losses.SparseCategoricalCrossentropy
metrics_builder = lambda: [tf.keras.metrics.SparseCategoricalAccuracy()]
if FLAGS.client_weight == 'uniform':
def client_weight_fn(local_outputs):
del local_outputs
return 1.0
elif FLAGS.client_weight == 'num_samples':
client_weight_fn = None
else:
raise ValueError(
'Unsupported client_weight flag [{!s}]. Currently only '
'`uniform` and `num_samples` are supported.'.format(
FLAGS.client_weight))
training_process = decay_iterative_process_builder.from_flags(
input_spec=input_spec,
model_builder=model_builder,
loss_builder=loss_builder,
metrics_builder=metrics_builder,
client_weight_fn=client_weight_fn)
client_datasets_fn = training_utils.build_client_datasets_fn(
cifar_train,
FLAGS.clients_per_round,
random_seed=FLAGS.client_datasets_random_seed)
assign_weights_fn = adaptive_fed_avg.ServerState.assign_weights_to_keras_model
evaluate_fn = training_utils.build_evaluate_fn(
eval_dataset=cifar_test,
model_builder=model_builder,
loss_builder=loss_builder,
metrics_builder=metrics_builder,
assign_weights_to_keras_model=assign_weights_fn)
train_evaluate_fn = training_utils.build_evaluate_fn(
eval_dataset=central_cifar_train,
model_builder=model_builder,
loss_builder=loss_builder,
metrics_builder=metrics_builder,
assign_weights_to_keras_model=assign_weights_fn)
training_loop.run(iterative_process=training_process,
client_datasets_fn=client_datasets_fn,
validation_fn=evaluate_fn,
train_eval_fn=train_evaluate_fn)