Missed TensorFlow World? Check out the recap. Learn more


View source on GitHub

Class MultiWorkerMirroredStrategy

Distribution strategy that uses collective ops for all-reduce.

Inherits From: Strategy

It is similar to MirroredStrategy but it uses collective ops for reduction.

By default it uses all local GPUs or CPU for single-worker training.

When 'TF_CONFIG' environment variable is given, it parses cluster_spec, task_type and task_id from 'TF_CONFIG' and turns into a multi-worker strategy which mirrores models on GPUs of all machines in a cluster. In the current implementation, it uses all GPUs in a cluster and it assumes all workers have the same number of GPUs.

It supports both eager mode and graph mode. However, for eager mode, it has to set up the eager context in its constructor and therefore all ops in eager mode have to run after the strategy object is created.


  • communication: optional Enum of type distribute.experimental.CollectiveCommunication. This provides a way for the user to override the choice of collective op communication. Possible values include AUTO, RING, and NCCL.


View source


Initializes the object.



tf.distribute.StrategyExtended with additional methods.


Returns number of replicas over which gradients are aggregated.



View source


Distributes a tf.data.Dataset instance provided via dataset.

In a multi-worker setting, we will first attempt to distribute the dataset by attempting to detect whether the dataset is being created out of ReaderDatasets (e.g. TFRecordDataset, TextLineDataset, etc.) and if so, attempting to shard the input files. Note that there has to be at least one input file per worker. If you have less than one input file per worker, we suggest that you should disable distributing your dataset using the method below.

If that attempt is unsuccessful (e.g. the dataset is created from a Dataset.range), we will shard the dataset evenly at the end by appending a .shard operation to the end of the processing pipeline. This will cause the entire preprocessing pipeline for all the data to be run on every worker, and each worker will do redundant work. We will print a warning if this method of sharding is selected.

You can disable dataset distribution using the auto_shard option in tf.data.experimental.DistributeOptions.

Within each host, we will also split the data among all the worker devices (if more than one a present), and this will happen even if multi-worker sharding is disabled using the method above.

The following is an example:

strategy = tf.distribute.MirroredStrategy()

# Create a dataset
dataset = dataset_ops.Dataset.TFRecordDataset([
  "/a/1.tfr", "/a/2.tfr", "/a/3.tfr", /a/4.tfr"])

# Distribute that dataset
dist_dataset = strategy.experimental_distribute_dataset(dataset)
# Iterate over the distributed dataset
for x in dist_dataset:
  # process dataset elements
  strategy.experimental_run_v2(train_step, args=(x,))


  • dataset: tf.data.Dataset that will be sharded across all replicas using the rules stated above.


A DistributedDataset which returns inputs for each step of the computation.


View source


Returns the list of all local per-replica values contained in value.


  • value: A value returned by experimental_run(), experimental_run_v2(), extended.call_for_each_replica(), or a variable created in scope.


A tuple of values contained in value. If value represents a single value, this returns (value,).


View source


Makes a dataset for input provided via a numpy array.

This avoids adding numpy_input as a large constant in the graph, and copies the data to the machine or machines that will be processing the input.


  • numpy_input: A nest of NumPy input arrays that will be distributed evenly across all replicas. Note that lists of Numpy arrays are stacked, as that is normal tf.data.Dataset behavior.


A tf.data.Dataset representing numpy_input.


View source


Runs ops in fn on each replica, with the given arguments.

When eager execution is enabled, executes ops specified by fn on each replica. Otherwise, builds a graph to execute the ops on each replica.

fn may call tf.distribute.get_replica_context() to access members such as replica_id_in_sync_group.

IMPORTANT: Depending on the tf.distribute.Strategy implementation being used, and whether eager execution is enabled, fn may be called one or more times (once for each replica).


  • fn: The function to run. The output must be a tf.nest of Tensors.
  • args: (Optional) Positional arguments to fn.
  • kwargs: (Optional) Keyword arguments to fn.


Merged return value of fn across replicas. The structure of the return value is the same as the return value from fn. Each element in the structure can either be PerReplica (if the values are unsynchronized), Mirrored (if the values are kept in sync), or Tensor (if running on a single replica).


View source


Reduce value across replicas.

Given a per-replica value returned by experimental_run_v2, say a per-example loss, the batch will be divided across all the replicas. This function allows you to aggregate across replicas and optionally also across batch elements. For example, if you have a global batch size of 8 and 2 replicas, values for examples [0, 1, 2, 3] will be on replica 0 and [4, 5, 6, 7] will be on replica 1. By default, reduce will just aggregate across replicas, returning [0+4, 1+5, 2+6, 3+7]. This is useful when each replica is computing a scalar or some other value that doesn't have a "batch" dimension (like a gradient). More often you will want to aggregate across the global batch, which you can get by specifying the batch dimension as the axis, typically axis=0. In this case it would return a scalar 0+1+2+3+4+5+6+7.

If there is a last partial batch, you will need to specify an axis so that the resulting shape is consistent across replicas. So if the last batch has size 6 and it is divided into [0, 1, 2, 3] and [4, 5], you would get a shape mismatch unless you specify axis=0. If you specify tf.distribute.ReduceOp.MEAN, using axis=0 will use the correct denominator of 6. Contrast this with computing reduce_mean to get a scalar value on each replica and this function to average those means, which will weigh some values 1/8 and others 1/4.


  • reduce_op: A tf.distribute.ReduceOp value specifying how values should be combined.
  • value: A "per replica" value, e.g. returned by experimental_run_v2 to be combined into a single tensor.
  • axis: Specifies the dimension to reduce along within each replica's tensor. Should typically be set to the batch dimension, or None to only reduce across replicas (e.g. if the tensor has no batch dimension).


A Tensor.


View source


Returns a context manager selecting this Strategy as current.

Inside a with strategy.scope(): code block, this thread will use a variable creator set by strategy, and will enter its "cross-replica context".


A context manager.