# tf.distribute.experimental.TPUStrategy

<br />

|---|---|
| [![](https://www.tensorflow.org/images/tf_logo_32px.png) TensorFlow 2 version](https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/TPUStrategy) | [![](https://www.tensorflow.org/images/GitHub-Mark-32px.png) View source on GitHub](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/tpu_strategy.py#L115-L150) |

TPU distribution strategy implementation.

Inherits From: [`Strategy`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/Strategy)

#### View aliases


**Main aliases**

\`tf.contrib.distribute.TPUStrategy\`
**Compat aliases for migration**

See
[Migration guide](https://www.tensorflow.org/guide/migrate) for
more details.

[`tf.compat.v1.distribute.experimental.TPUStrategy`](https://www.tensorflow.org/api_docs/python/tf/compat/v1/distribute/experimental/TPUStrategy)

<br />

    tf.distribute.experimental.TPUStrategy(
        tpu_cluster_resolver=None, steps_per_run=None, device_assignment=None
    )

<br />

<br />

<br />

| ## Args ||
|---|---|
| `tpu_cluster_resolver` | A tf.distribute.cluster_resolver.TPUClusterResolver, which provides information about the TPU cluster. |
| `steps_per_run` | Number of steps to run on device before returning to the host. Note that this can have side-effects on performance, hooks, metrics, summaries etc. This parameter is only used when Distribution Strategy is used with estimator or keras. |
| `device_assignment` | Optional [`tf.tpu.experimental.DeviceAssignment`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/tpu/experimental/DeviceAssignment) to specify the placement of replicas on the TPU cluster. Currently only supports the usecase of using a single core within a TPU cluster. |

<br />

<br />

<br />

<br />

| ## Attributes ||
|---|---|
| `extended` | [`tf.distribute.StrategyExtended`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/StrategyExtended) with additional methods. |
| `num_replicas_in_sync` | Returns number of replicas over which gradients are aggregated. |
| `steps_per_run` | DEPRECATED: use .extended.steps_per_run instead. |

<br />

## Methods

### `experimental_distribute_dataset`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L614-L678)

    experimental_distribute_dataset(
        dataset
    )

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

The returned distributed dataset can be iterated over similar to how
regular datasets can.
NOTE: Currently, the user cannot add any more transformations to a
distributed dataset.

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,))

We will assume that the input dataset is batched by the
global batch size. With this assumption, we will make a best effort to
divide each batch across all the replicas (one or more workers).

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. In this case, consider using
`experimental_distribute_datasets_from_function` instead.

You can disable dataset sharding across workers using the `auto_shard`
option in [`tf.data.experimental.DistributeOptions`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/experimental/DistributeOptions).

Within each worker, 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.

If the above batch splitting and dataset sharding logic is undesirable,
please use `experimental_distribute_datasets_from_function` instead, which
does not do any automatic splitting or sharding.

<br />

<br />

<br />

| Args ||
|---|---|
| `dataset` | [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) that will be sharded across all replicas using the rules stated above. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A "distributed `Dataset`", which acts like a [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) except it produces "per-replica" values. ||

<br />

### `experimental_distribute_datasets_from_function`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L680-L728)

    experimental_distribute_datasets_from_function(
        dataset_fn
    )

Distributes [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) instances created by calls to `dataset_fn`.

`dataset_fn` will be called once for each worker in the strategy. Each
replica on that worker will dequeue one batch of inputs from the local
`Dataset` (i.e. if a worker has two replicas, two batches will be dequeued
from the `Dataset` every step).

This method can be used for several purposes. For example, where
`experimental_distribute_dataset` is unable to shard the input files, this
method might be used to manually shard the dataset (avoiding the slow
fallback behavior in `experimental_distribute_dataset`). In cases where the
dataset is infinite, this sharding can be done by creating dataset replicas
that differ only in their random seed.
`experimental_distribute_dataset` may also sometimes fail to split the
batch across replicas on a worker. In that case, this method can be used
where that limitation does not exist.

The `dataset_fn` should take an [`tf.distribute.InputContext`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/InputContext) instance where
information about batching and input replication can be accessed:

    def dataset_fn(input_context):
      batch_size = input_context.get_per_replica_batch_size(global_batch_size)
      d = tf.data.Dataset.from_tensors([[1.]]).repeat().batch(batch_size)
      return d.shard(
          input_context.num_input_pipelines, input_context.input_pipeline_id)

    inputs = strategy.experimental_distribute_datasets_from_function(dataset_fn)

    for batch in inputs:
      replica_results = strategy.experimental_run_v2(replica_fn, args=(batch,))

> [!IMPORTANT]
> **Key Point:** The [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) returned by `dataset_fn` should have a per-replica batch size, unlike `experimental_distribute_dataset`, which uses the global batch size. This may be computed using `input_context.get_per_replica_batch_size`.

<br />

<br />

<br />

| Args ||
|---|---|
| `dataset_fn` | A function taking a [`tf.distribute.InputContext`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/InputContext) instance and returning a [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset). |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A "distributed `Dataset`", which acts like a [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) except it produces "per-replica" values. ||

<br />

### `experimental_local_results`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L887-L904)

    experimental_local_results(
        value
    )

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

> [!NOTE]
> **Note:** This only returns values on the worker initiated by this client. When using a [`tf.distribute.Strategy`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/Strategy) like [`tf.distribute.experimental.MultiWorkerMirroredStrategy`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/experimental/MultiWorkerMirroredStrategy), each worker will be its own client, and this function will only return values computed on that worker.

<br />

<br />

<br />

| Args ||
|---|---|
| `value` | A value returned by `experimental_run()`, `experimental_run_v2()`, `extended.call_for_each_replica()`, or a variable created in `scope`. |

<br />

<br />

<br />

<br />

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

<br />

### `experimental_make_numpy_dataset`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L1052-L1081)

    experimental_make_numpy_dataset(
        numpy_input, session=None
    )

Makes a tf.data.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.

Note that you will likely need to use
tf.distribute.Strategy.experimental_distribute_dataset
with the returned dataset to further distribute it with the strategy.

#### Example:

    numpy_input = np.ones([10], dtype=np.float32)
    dataset = strategy.experimental_make_numpy_dataset(numpy_input)
    dist_dataset = strategy.experimental_distribute_dataset(dataset)

<br />

<br />

<br />

| Args ||
|---|---|
| `numpy_input` | A nest of NumPy input arrays that will be converted into a dataset. Note that lists of Numpy arrays are stacked, as that is normal [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) behavior. |
| `session` | (TensorFlow v1.x graph execution only) A session used for initialization. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) representing `numpy_input`. ||

<br />

### `experimental_run`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L1083-L1116)

    experimental_run(
        fn, input_iterator=None
    )

Runs ops in `fn` on each replica, with inputs from `input_iterator`.

DEPRECATED: This method is not available in TF 2.x. Please switch
to using `experimental_run_v2` instead.

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

Each replica will take a single, different input from the inputs provided by
one `get_next` call on the input iterator.

`fn` may call [`tf.distribute.get_replica_context()`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/get_replica_context) to access members such
as `replica_id_in_sync_group`.

> [!IMPORTANT]
> **Key Point:** Depending on the [`tf.distribute.Strategy`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/Strategy) implementation being used, and whether eager execution is enabled, `fn` may be called one or more times (once for each replica).

<br />

<br />

<br />

| Args ||
|---|---|
| `fn` | The function to run. The inputs to the function must match the outputs of `input_iterator.get_next()`. The output must be a [`tf.nest`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/nest) of `Tensor`s. |
| `input_iterator` | (Optional) input iterator from which the inputs are taken. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| 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). ||

<br />

### `experimental_run_v2`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/tpu_strategy.py#L147-L150)

    experimental_run_v2(
        fn, args=(), kwargs=None
    )

See base class.

### `make_dataset_iterator`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L984-L1008)

    make_dataset_iterator(
        dataset
    )

Makes an iterator for input provided via `dataset`.

DEPRECATED: This method is not available in TF 2.x.

Data from the given dataset will be distributed evenly across all the
compute replicas. We will assume that the input dataset is batched by the
global batch size. With this assumption, we will make a best effort to
divide each batch across all the replicas (one or more workers).
If this effort fails, an error will be thrown, and the user should instead
use `make_input_fn_iterator` which provides more control to the user, and
does not try to divide a batch across replicas.

The user could also use `make_input_fn_iterator` if they want to
customize which input is fed to which replica/worker etc.

<br />

<br />

<br />

| Args ||
|---|---|
| `dataset` | [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) that will be distributed evenly across all replicas. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `tf.distribute.InputIterator` which returns inputs for each step of the computation. User should call `initialize` on the returned iterator. ||

<br />

### `make_input_fn_iterator`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L1010-L1050)

    make_input_fn_iterator(
        input_fn, replication_mode=tf.distribute.InputReplicationMode.PER_WORKER
    )

Returns an iterator split across replicas created from an input function.

DEPRECATED: This method is not available in TF 2.x.

The `input_fn` should take an [`tf.distribute.InputContext`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/InputContext) object where
information about batching and input sharding can be accessed:

    def input_fn(input_context):
      batch_size = input_context.get_per_replica_batch_size(global_batch_size)
      d = tf.data.Dataset.from_tensors([[1.]]).repeat().batch(batch_size)
      return d.shard(input_context.num_input_pipelines,
                     input_context.input_pipeline_id)
    with strategy.scope():
      iterator = strategy.make_input_fn_iterator(input_fn)
      replica_results = strategy.experimental_run(replica_fn, iterator)

The [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) returned by `input_fn` should have a per-replica
batch size, which may be computed using
`input_context.get_per_replica_batch_size`.

<br />

<br />

<br />

| Args ||
|---|---|
| `input_fn` | A function taking a [`tf.distribute.InputContext`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/InputContext) object and returning a [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset). |
| `replication_mode` | an enum value of [`tf.distribute.InputReplicationMode`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/distribute/InputReplicationMode). Only `PER_WORKER` is supported currently, which means there will be a single call to `input_fn` per worker. Replicas will dequeue from the local [`tf.data.Dataset`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/data/Dataset) on their worker. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An iterator object that should first be `.initialize()`-ed. It may then either be passed to `strategy.experimental_run()` or you can `iterator.get_next()` to get the next value to pass to `strategy.extended.call_for_each_replica()`. ||

<br />

### `reduce`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L1118-L1119)

    reduce(
        reduce_op, value, axis=None
    )

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`](https://www.tensorflow.org/versions/r1.15/api_docs/python/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`.

<br />

<br />

<br />

| Args ||
|---|---|
| `reduce_op` | A [`tf.distribute.ReduceOp`](https://www.tensorflow.org/versions/r1.15/api_docs/python/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). |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A `Tensor`. ||

<br />

### `scope`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L545-L555)

    scope()

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".

<br />

<br />

<br />

| Returns ||
|---|---|
| A context manager. ||

<br />

### `update_config_proto`

[View source](https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/distribute/distribute_lib.py#L1123-L1138)

    update_config_proto(
        config_proto
    )

Returns a copy of `config_proto` modified for use with this strategy.

DEPRECATED: This method is not available in TF 2.x.

The updated config has something needed to run a strategy, e.g.
configuration to run collective ops, or device filters to improve
distributed training performance.

<br />

<br />

<br />

| Args ||
|---|---|
| `config_proto` | a [`tf.ConfigProto`](https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/ConfigProto) object. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| The updated copy of the `config_proto`. ||

<br />