TensorFlow

https://www.tensorflow.org/api_docs/python/
Admin
TensorFlow is an open-source machine learning framework for numerical computation, large-scale...
Tokens:1,873,563
Snippets:15,056
Trust Score:9.9
Update:5 days ago
Show doc for...
Tokens:
Raw
### MinSizePartitioner usage examples

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/partitioners/MinSizePartitioner

Shows how to create a MinSizePartitioner and call it on a tensor shape to get partition sizes. Includes two examples with different max_shards values and a commented example for use in ParameterServerStrategy.

```python
partitioner = MinSizePartitioner(min_shard_bytes=4, max_shards=2)
partitions = partitioner(tf.TensorShape([6, 1]), tf.float32)
[2, 1]
```

```python
partitioner = MinSizePartitioner(min_shard_bytes=4, max_shards=10)
partitions = partitioner(tf.TensorShape([6, 1]), tf.float32)
[6, 1]
```

```python
# use in ParameterServerStrategy
# strategy = tf.distribute.experimental.ParameterServerStrategy(
#   cluster_resolver=cluster_resolver, variable_partitioner=partitioner)
```

--------------------------------

### Example usage

Source: https://www.tensorflow.org/api_docs/python/tf/keras/metrics/MeanAbsolutePercentageError

Shows how to instantiate the metric, update state, get result, reset, and update with sample weights.

```python
m = keras.metrics.MeanAbsolutePercentageError()
m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]])
m.result()
250000000.0
m.reset_state()
m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]],
               sample_weight=[1, 0])
m.result()
500000000.0
```

--------------------------------

### Create and start a gRPC server with registered function

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/rpc/Server

Example usage from the create method: imports portpicker, defines a tf.function with input signature, picks an unused port, creates a server with 'grpc', registers the function, and starts the server.

```python
>>> import portpicker
>>> @tf.function(input_signature=[
...      tf.TensorSpec([], tf.int32),
...      tf.TensorSpec([], tf.int32)])
... def remote_fn(a, b):
...   return tf.add(a, b)
```

```python
port = portpicker.pick_unused_port()
address = "localhost:{}".format(port)
server = tf.distribute.experimental.rpc.Server.create("grpc", address)
server.register("addition", remote_fn)
server.start()
```

--------------------------------

### CentralStorageStrategy reduce example

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/CentralStorageStrategy

Example of using reduce with a CentralStorageStrategy and a dataset, though the code is incomplete as it only shows the setup.

```python
strategy = tf.distribute.experimental.CentralStorageStrategy(
    compute_devices=['CPU:0', 'GPU:0'], parameter_device='CPU:0')
ds = tf.data.Dataset.range(10)
```

--------------------------------

### Basic usage example

Source: https://www.tensorflow.org/api_docs/python/tf/keras/metrics/SparseCategoricalAccuracy

Demonstrates creating the metric, updating state with true labels and predictions, and getting the result (0.5).

```python
m = keras.metrics.SparseCategoricalAccuracy()
m.update_state([[2], [1]], [[0.1, 0.6, 0.3], [0.05, 0.95, 0]])
m.result()
0.5
```

--------------------------------

### Example usage of get_tpu_system_metadata

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/cluster_resolver/TPUClusterResolver

Example showing how to get facts of the TPU system, such as total number of cores, number of TPU workers, and devices.

```python
resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
tpu_system_metadata = resolver.get_tpu_system_metadata()
num_hosts = tpu_system_metadata.num_hosts

```

--------------------------------

### Example usage of tf.config.get_logical_device_configuration

Source: https://www.tensorflow.org/api_docs/python/tf/config/get_logical_device_configuration

Demonstrates how to get the logical device configuration for a CPU physical device, set a new configuration, and verify the change. Includes a try-except block to handle cases where virtual devices cannot be modified after initialization.

```python
physical_devices = tf.config.list_physical_devices('CPU')
assert len(physical_devices) == 1, "No CPUs found"
configs = tf.config.get_logical_device_configuration(
  physical_devices[0])
try:
  assert configs is None
  tf.config.set_logical_device_configuration(
    physical_devices[0],
    [tf.config.LogicalDeviceConfiguration(),
     tf.config.LogicalDeviceConfiguration()])
  configs = tf.config.get_logical_device_configuration(
    physical_devices[0])
  assert len(configs) == 2
except:
  # Cannot modify virtual devices once initialized.
  pass

```

--------------------------------

### start

Source: https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/DispatchServer

Starts the server. This is useful when the server was created with start=False.

```APIDOC
## start

### Description
Starts this server.

### Method Signature
```python
start()
```

### Example
```python
dispatcher = tf.data.experimental.service.DispatchServer(start=False)
dispatcher.start()
```

### Raises
- **tf.errors.OpError** - Or one of its subclasses if an error occurs while starting the server.
```

--------------------------------

### Example serialized_examples for make_batched_features_dataset

Source: https://www.tensorflow.org/api_docs/python/tf/data/experimental/make_batched_features_dataset

Example input data in the form of serialized Example protos, showing feature values for age, gender, and kws.

```python
serialized_examples = [
  features {
    feature { key: "age" value { int64_list { value: [ 0 ] } } }
    feature { key: "gender" value { bytes_list { value: [ "f" ] } } }
    feature { key: "kws" value { bytes_list { value: [ "code", "art" ] } } }
  },
  features {
    feature { key: "age" value { int64_list { value: [] } } }
    feature { key: "gender" value { bytes_list { value: [ "f" ] } } }
    feature { key: "kws" value { bytes_list { value: [ "sports" ] } } }
  }
]
```

--------------------------------

### start

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/rpc/Server

Starts the RPC server on the provided address. The server listens for new requests from clients once it is started.

```APIDOC
## start

### Description
Starts the RPC server on provided address. Server listens for new requests from client, once it is started.

### Method
start

### Signature
start()
```

--------------------------------

### Start the server with start=False

Source: https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/DispatchServer

Creates a dispatcher without starting it, then starts it manually.

```python
dispatcher = tf.data.experimental.service.DispatchServer(start=False)
dispatcher.start()
```

--------------------------------

### Example with num_oov_buckets

Source: https://www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_vocabulary_list

Shows how to create a categorical column with an in-memory vocabulary and out-of-vocabulary buckets. Inputs in vocabulary_list get IDs 0-3, others are hashed to IDs 4-5.

```python
colors = categorical_column_with_vocabulary_list(
    key='colors', vocabulary_list=('R', 'G', 'B', 'Y'),
    num_oov_buckets=2)
columns = [colors, ...]
features = tf.io.parse_example(..., features=make_parse_example_spec(columns))
linear_prediction, _, _ = linear_model(features, columns)
```

--------------------------------

### from_config example

Source: https://www.tensorflow.org/api_docs/python/tf/keras/initializers/RandomNormal

Shows how to instantiate an initializer from a configuration dictionary using from_config.

```python
initializer = RandomUniform(-1, 1)
config = initializer.get_config()
initializer = RandomUniform.from_config(config)
```

--------------------------------

### row_starts example

Source: https://www.tensorflow.org/api_docs/python/tf/RaggedTensor

Shows how to use rt.row_starts() to get the start indices for rows in a ragged tensor. The example prints the values and the row starts.

```python
rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)
print(rt.row_starts())  # indices of row starts in rt.values
tf.Tensor([0 4 4 7 8], shape=(5,), dtype=int64)
```

--------------------------------

### Example: Enabling and disabling device placement logging

Source: https://www.tensorflow.org/api_docs/python/tf/debugging/set_log_device_placement

This example shows how to enable device placement logging, create tensors on GPU and CPU, and then disable logging. The output comments show the device placement messages.

```python
tf.debugging.set_log_device_placement(True)
tf.ones([])
# [...] op Fill in device /job:localhost/replica:0/task:0/device:GPU:0
with tf.device("CPU"):
 tf.ones([])
# [...] op Fill in device /job:localhost/replica:0/task:0/device:CPU:0
tf.debugging.set_log_device_placement(False)
```

--------------------------------

### hex examples

Source: https://www.tensorflow.org/api_docs/python/tf/experimental/numpy/float64

Examples of using hex to get hexadecimal representations of floats. Shows the output for -0.1 and 3.14159.

```python
(-0.1).hex()
'-0x1.999999999999ap-4'
3.14159.hex()
'0x1.921f9f01b866ep+1'

```

--------------------------------

### Example: using from_config with RandomUniform

Source: https://www.tensorflow.org/api_docs/python/tf/constant_initializer

Demonstrates instantiating an initializer from a configuration dictionary using get_config and from_config.

```python
initializer = RandomUniform(-1, 1)
config = initializer.get_config()
initializer = RandomUniform.from_config(config)

```

--------------------------------

### counter: usage examples

Source: https://www.tensorflow.org/api_docs/python/tf/data/Dataset

Examples of using tf.data.experimental.Counter with various start, step, and dtype arguments, showing the resulting elements and element_spec.

```python
dataset = tf.data.experimental.Counter().take(5)
list(dataset.as_numpy_iterator())
[0, 1, 2, 3, 4]
dataset.element_spec
TensorSpec(shape=(), dtype=tf.int64, name=None)
```

```python
dataset = tf.data.experimental.Counter(dtype=tf.int32)
dataset.element_spec
TensorSpec(shape=(), dtype=tf.int32, name=None)
```

```python
dataset = tf.data.experimental.Counter(start=2).take(5)
list(dataset.as_numpy_iterator())
[2, 3, 4, 5, 6]
```

```python
dataset = tf.data.experimental.Counter(start=2, step=5).take(5)
list(dataset.as_numpy_iterator())
[2, 7, 12, 17, 22]
```

```python
dataset = tf.data.experimental.Counter(start=10, step=-1).take(5)
list(dataset.as_numpy_iterator())
[10, 9, 8, 7, 6]
```

--------------------------------

### Start RPC server

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/rpc/Client

Pick an unused port, create a server, register the remote function, and start the server.

```python
port = portpicker.pick_unused_port()
address = "localhost:{}".format(port)
server = tf.distribute.experimental.rpc.Server.create("grpc", address)
server.register("addition", remote_fn)
server.start()

```

--------------------------------

### Example: using CommunicationOptions with all_reduce

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/CommunicationOptions

Demonstrates creating options with a pack size of 50MB, a timeout of 120 seconds, and NCCL implementation, then using them in all_reduce and apply_gradients.

```python
options = tf.distribute.experimental.CommunicationOptions(
    bytes_per_pack=50 * 1024 * 1024,
    timeout_seconds=120.0,
    implementation=tf.distribute.experimental.CommunicationImplementation.NCCL
)
grads = tf.distribute.get_replica_context().all_reduce(
    'sum', grads, options=options)
optimizer.apply_gradients(zip(grads, vars),
    experimental_aggregate_gradients=False)
```

--------------------------------

### Basic window example

Source: https://www.tensorflow.org/api_docs/python/tf/data/Dataset

Creates a dataset of windows of size 3 from a range of 7 elements. Each window is a dataset, and iterating over the outer dataset yields window datasets.

```python
dataset = tf.data.Dataset.range(7).window(3)
for window in dataset:
  print(window)
```

```text
<...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)>
<...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)>
<...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)>
```

--------------------------------

### row_limits example

Source: https://www.tensorflow.org/api_docs/python/tf/RaggedTensor

Shows how to use rt.row_limits() to get the limit indices for rows in a ragged tensor. The example prints the values and the row limits.

```python
rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)
print(rt.row_limits())  # indices of row limits in rt.values
tf.Tensor([4 4 7 8 8], shape=(5,), dtype=int64)
```

--------------------------------

### Example usage of SquaredHinge

Source: https://www.tensorflow.org/api_docs/python/tf/keras/metrics/SquaredHinge

Shows how to update the metric with labels and predictions, get the result (1.86), reset, and update with sample weights to get 1.46.

```python
m = keras.metrics.SquaredHinge()
m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]])
m.result()
1.86
m.reset_state()
m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]],
               sample_weight=[1, 0])
m.result()
1.46
```

--------------------------------

### Basic window example

Source: https://www.tensorflow.org/api_docs/python/tf/data/FixedLengthRecordDataset

Creates a dataset of windows of size 3 from a range of 7 elements. Each window is a dataset, and iterating over the outer dataset yields window datasets.

```python
dataset = tf.data.Dataset.range(7).window(3)
for window in dataset:
  print(window)
<...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)>
<...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)>
<...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)>
```

```python
for window in dataset:
  print(list(window.as_numpy_iterator()))
[0, 1, 2]
[3, 4, 5]
[6]
```

--------------------------------

### Example of experimental_distribute_dataset

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/OneDeviceStrategy

This example shows how to create a OneDeviceStrategy, create a dataset, distribute it, and iterate over it. The output is shown as comments.

```python
strategy = tf.distribute.OneDeviceStrategy()
dataset = tf.data.Dataset.range(10).batch(2)
dist_dataset = strategy.experimental_distribute_dataset(dataset)
for x in dist_dataset:
  print(x)  # [0, 1], [2, 3],...
```

--------------------------------

### row_lengths example

Source: https://www.tensorflow.org/api_docs/python/tf/RaggedTensor

Shows how to use rt.row_lengths() to get the lengths of rows in a ragged tensor. The example prints the row lengths for the default axis and for axis=2.

```python
rt = tf.ragged.constant(
    [[[3, 1, 4], [1]], [], [[5, 9], [2]], [[6]], []])
print(rt.row_lengths())  # lengths of rows in rt
tf.Tensor([2 0 2 1 0], shape=(5,), dtype=int64)
print(rt.row_lengths(axis=2))  # lengths of axis=2 rows.
<tf.RaggedTensor [[3, 1], [], [2, 1], [1], []]>
```

--------------------------------

### Example with default_value

Source: https://www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_vocabulary_list

Shows how to create a categorical column with a default value for out-of-vocabulary inputs. Inputs in vocabulary_list get IDs 0-4, others get default_value 0.

```python
colors = categorical_column_with_vocabulary_list(
    key='colors', vocabulary_list=('X', 'R', 'G', 'B', 'Y'), default_value=0)
columns = [colors, ...]
features = tf.io.parse_example(..., features=make_parse_example_spec(columns))
linear_prediction, _, _ = linear_model(features, columns)
```

--------------------------------

### take example with output

Source: https://www.tensorflow.org/api_docs/python/tf/data/Dataset

Example of using take(3) on a range dataset, showing the resulting elements [0, 1, 2].

```python
dataset = tf.data.Dataset.range(10)
dataset = dataset.take(3)
list(dataset.as_numpy_iterator())
[0, 1, 2]
```

--------------------------------

### Example: value_rowids() with ragged constant

Source: https://www.tensorflow.org/api_docs/python/tf/RaggedTensor

Shows how to use rt.value_rowids() to get row indices for each value in a ragged tensor. The example creates a ragged constant and prints its values and row_ids.

```python
rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)
print(rt.value_rowids())  # corresponds 1:1 with rt.values
tf.Tensor([0 0 0 0 2 2 2 3], shape=(8,), dtype=int64)
```

--------------------------------

### nrows example

Source: https://www.tensorflow.org/api_docs/python/tf/RaggedTensor

Shows how to get the number of rows in a RaggedTensor using nrows(), with the output tensor.

```python
rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.nrows())  # rt has 5 rows.
tf.Tensor(5, shape=(), dtype=int64)
```

--------------------------------

### tf.data.Dataset.range examples

Source: https://www.tensorflow.org/api_docs/python/tf/data/Dataset

Demonstrates various range calls with different start, stop, step, and output_type arguments.

```python
list(Dataset.range(5).as_numpy_iterator())
[0, 1, 2, 3, 4]
list(Dataset.range(2, 5).as_numpy_iterator())
[2, 3, 4]
list(Dataset.range(1, 5, 2).as_numpy_iterator())
[1, 3]
list(Dataset.range(1, 5, -2).as_numpy_iterator())
[]
list(Dataset.range(5, 1).as_numpy_iterator())
[]
list(Dataset.range(5, 1, -2).as_numpy_iterator())
[5, 3]
list(Dataset.range(2, 5, output_type=tf.int32).as_numpy_iterator())
[2, 3, 4]
list(Dataset.range(1, 5, 2, output_type=tf.float32).as_numpy_iterator())
[1.0, 3.0]
```

--------------------------------

### Configure cluster with direct arguments on process 0

Source: https://www.tensorflow.org/api_docs/python/tf/keras/distribution/initialize

Example of initializing the distribution system on process 0 by passing the job addresses, number of processes, and process ID directly.

```python
keras.distribute.initialize(
    job_addresses="10.0.0.1:1234,10.0.0.2:2345",
    num_processes=2,
    process_id=0)
```

--------------------------------

### Configure cluster with direct arguments on process 1

Source: https://www.tensorflow.org/api_docs/python/tf/keras/distribution/initialize

Example of initializing the distribution system on process 1 by passing the job addresses, number of processes, and process ID directly.

```python
keras.distribute.initialize(
    job_addresses="10.0.0.1:1234,10.0.0.2:2345",
    num_processes=2,
    process_id=1)
```

--------------------------------

### CategoricalHinge usage example

Source: https://www.tensorflow.org/api_docs/python/tf/keras/metrics/CategoricalHinge

Shows how to update the metric, get the result, reset, and update with sample weights.

```python
m = keras.metrics.CategoricalHinge()
m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]])
m.result().numpy()
1.4000001
m.reset_state()
m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]],
               sample_weight=[1, 0])
m.result()
1.2
```

--------------------------------

### nested_value_rowids example

Source: https://www.tensorflow.org/api_docs/python/tf/RaggedTensor

Demonstrates how to get value_rowids for each ragged dimension of a RaggedTensor, printing the row ids for each dimension.

```python
rt = tf.ragged.constant(
    [[[[3, 1, 4, 1], [], [5, 9, 2]], [], [[6], []]]])
for i, ids in enumerate(rt.nested_value_rowids()):
  print('row ids for dimension %d: %s' % (i+1, ids.numpy()))
row ids for dimension 1: [0 0 0]
row ids for dimension 2: [0 0 0 2 2]
row ids for dimension 3: [0 0 0 0 2 2 2 3]
```

--------------------------------

### Basic restore and restore with options

Source: https://www.tensorflow.org/api_docs/python/tf/experimental/dtensor/DTensorCheckpoint

Basic usage of restore() and passing CheckpointOptions with experimental_io_device.

```python
checkpoint = tf.train.Checkpoint( ... )
checkpoint.restore(path)

# You can additionally pass options to restore():
options = tf.CheckpointOptions(experimental_io_device="/job:localhost")
checkpoint.restore(path, options=options)

```

--------------------------------

### BinaryAccuracy usage example

Source: https://www.tensorflow.org/api_docs/python/tf/keras/metrics/BinaryAccuracy

Shows how to create a metric, update it with predictions and labels, and get the result. The result is 0.75.

```python
m = keras.metrics.BinaryAccuracy()
m.update_state([[1], [1], [0], [0]], [[0.98], [1], [0], [0.6]])
m.result()
```

--------------------------------

### initialize(...)

Source: https://www.tensorflow.org/api_docs/python/tf/keras/distribution

Initialize the distribution system for multi-host/process setting.

```APIDOC
## initialize(...)

### Description
Initialize the distribution system for multi-host/process setting.

```

--------------------------------

### ragged_rank example

Source: https://www.tensorflow.org/api_docs/python/tf/RaggedTensor

Shows how to get the ragged_rank of a ragged tensor, first for a simple ragged constant and then after using from_uniform_row_length.

```python
values = tf.ragged.constant([[1, 2, 3], [4], [5, 6], [7, 8, 9, 10]])
values.ragged_rank
1
```

```python
rt = tf.RaggedTensor.from_uniform_row_length(values, 2)
rt.ragged_rank
2
```

--------------------------------

### MirroredStrategy.__init__

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/MirroredStrategy

Creates a MirroredStrategy instance with specified devices and cross-device operations.

```APIDOC
## MirroredStrategy.__init__

### Description
Initializes a MirroredStrategy with a list of devices and an optional cross-device operations object.

### Method
Constructor

### Endpoint
MirroredStrategy(devices=None, cross_device_ops=None)

### Parameters
#### Constructor Parameters
- **devices** (list of strings) - Optional - A list of device strings such as `['/gpu:0', '/gpu:1']`. If `None`, all available GPUs are used. If no GPUs are found, CPU is used.
- **cross_device_ops** (CrossDeviceOps) - Optional - A descendant of `CrossDeviceOps`. If not set, `NcclAllReduce()` is used by default. Customize if NCCL isn't available or if a special implementation exploits particular hardware.

### Request Example
```python
strategy = tf.distribute.MirroredStrategy(devices=['/gpu:0', '/gpu:1'])
```

### Response
#### Success Response
No return value (constructor).

```

--------------------------------

### RootMeanSquaredError usage example

Source: https://www.tensorflow.org/api_docs/python/tf/keras/metrics/RootMeanSquaredError

Shows how to instantiate the metric, update state with y_true and y_pred, and get the result. The result is 0.5.

```python
m = keras.metrics.RootMeanSquaredError()
m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]])
m.result()
0.5
```

--------------------------------

### save usage example

Source: https://www.tensorflow.org/api_docs/python/tf/experimental/dtensor/DTensorCheckpoint

Example of saving and restoring a checkpoint using save and restore, including passing options.

```python
step = tf.Variable(0, name="step")
checkpoint = tf.train.Checkpoint(step=step)
checkpoint.save("/tmp/ckpt")

# Later, read the checkpoint with restore()
checkpoint.restore("/tmp/ckpt-1")

# You can also pass options to save() and restore(). For example this
# runs the IO ops on the localhost:
options = tf.train.CheckpointOptions(experimental_io_device="/job:localhost")
checkpoint.save("/tmp/ckpt", options=options)

# Later, read the checkpoint with restore()
checkpoint.restore("/tmp/ckpt-1", options=options)
```

--------------------------------

### Hinge metric usage example

Source: https://www.tensorflow.org/api_docs/python/tf/keras/metrics/Hinge

Shows how to update the metric, get the result, reset state, and update with sample weights.

```python
m = keras.metrics.Hinge()
m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]])
m.result()
1.3
m.reset_state()
m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]],
               sample_weight=[1, 0])
m.result()
1.1
```

--------------------------------

### Prefetching dataset elements to a device

Source: https://www.tensorflow.org/api_docs/python/tf/data/experimental/prefetch_to_device

An example showing how to apply the prefetch_to_device transformation to a dataset and verify the device placement of the elements.

```python
>>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
>>> dataset = dataset.apply(tf.data.experimental.prefetch_to_device("/cpu:0"))
>>> for element in dataset:
...   print(f'Tensor {element} is on device {element.device}')
Tensor 1 is on device /job:localhost/replica:0/task:0/device:CPU:0
Tensor 2 is on device /job:localhost/replica:0/task:0/device:CPU:0
Tensor 3 is on device /job:localhost/replica:0/task:0/device:CPU:0
```

--------------------------------

### Get ConcreteFunction with get_concrete_function

Source: https://www.tensorflow.org/api_docs/python/tf/function

Shows how to obtain a ConcreteFunction from a tf.function using get_concrete_function. The example checks that the graph is a tf.Graph instance.

```python
@tf.function
def f(x):
  return x + 1
isinstance(f.get_concrete_function(1).graph, tf.Graph)
True
```

--------------------------------

### read method example

Source: https://www.tensorflow.org/api_docs/python/tf/experimental/dtensor/DTensorCheckpoint

Shows how to use the read method to load a checkpoint written with write(), including passing options to run IO ops on localhost.

```python
# Create a checkpoint with write()
ckpt = tf.train.Checkpoint(v=tf.Variable(1.))
path = ckpt.write('/tmp/my_checkpoint')

# Later, load the checkpoint with read()
# With restore() assert_consumed() would have failed.
checkpoint.read(path).assert_consumed()

# You can also pass options to read(). For example this
# runs the IO ops on the localhost:
options = tf.train.CheckpointOptions(
    experimental_io_device="/job:localhost")
checkpoint.read(path, options=options)
```

--------------------------------

### Parse the binary proto with tf.io.parse_example

Source: https://www.tensorflow.org/api_docs/python/tf/io/decode_json_example

Demonstrates that the binary string is equivalent to Example.SerializeToString() and can be parsed with tf.io.parse_example.

```python
tf.io.parse_example(
  serialized=[example_binary.numpy(),
             example.SerializeToString()],
  features = {'a': tf.io.FixedLenFeature(shape=[3], dtype=tf.int64)})
{'a': <tf.Tensor: shape=(2, 3), dtype=int64, numpy=
 array([[1, 1, 3],
        [1, 1, 3]])>}
```

--------------------------------

### Example: using categorical_column_with_hash_bucket with linear_model

Source: https://www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_hash_bucket

Creates a hashed categorical column for 'keywords', then uses it with tf.compat.v1.feature_column.linear_model to get a linear prediction.

```python
import tensorflow as tf
keywords = tf.feature_column.categorical_column_with_hash_bucket("keywords",
10000)
columns = [keywords]
features = {'keywords': tf.constant([['Tensorflow', 'Keras', 'RNN', 'LSTM',
'CNN'], ['LSTM', 'CNN', 'Tensorflow', 'Keras', 'RNN'], ['CNN', 'Tensorflow',
'LSTM', 'Keras', 'RNN']])}
linear_prediction, _, _ = tf.compat.v1.feature_column.linear_model(features,
columns)
```

--------------------------------

### Basic usage of tf.argsort on a 1D tensor

Source: https://www.tensorflow.org/api_docs/python/tf/argsort

Example showing how to get the sort indices for a 1D tensor and the resulting numpy array.

```python
values = [1, 10, 26.9, 2.8, 166.32, 62.3]
sort_order = tf.argsort(values)
sort_order.numpy()
array([0, 3, 1, 2, 5, 4], dtype=int32)
```

--------------------------------

### Example: cropping an image with tf.image.resize_with_crop_or_pad

Source: https://www.tensorflow.org/api_docs/python/tf/image/resize_with_crop_or_pad

Demonstrates cropping a 5x5 image to 3x3 using the function. The example creates a 3-D image input, prints the first channel, applies the crop, and shows the centrally cropped output tensor.

```python
image = np.arange(75).reshape(5, 5, 3)  # create 3-D image input
image[:,:,0]  # print first channel just for demo purposes
array([[ 0,  3,  6,  9, 12],
       [15, 18, 21, 24, 27],
       [30, 33, 36, 39, 42],
       [45, 48, 51, 54, 57],
       [60, 63, 66, 69, 72]])
image = tf.image.resize_with_crop_or_pad(image, 3, 3)  # crop
# print first channel for demo purposes; centrally cropped output
image[:,:,0]
<tf.Tensor: shape=(3, 3), dtype=int64, numpy=
array([[18, 21, 24],
       [33, 36, 39],
       [48, 51, 54]])>
```

--------------------------------

### Setting TF_CONFIG for Cluster Setup

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/ParameterServerStrategy

Example of configuring the TF_CONFIG environment variable for a parameter server task before initializing the cluster resolver.

```python
os.environ['TF_CONFIG'] = '''
{
  "cluster": {
    "chief": ["chief.example.com:2222"],
    "ps": ["ps0.example.com:2222", "ps1.example.com:2222"],
    "worker": ["worker0.example.com:2222", "worker1.example.com:2222",
               "worker2.example.com:2222"]
  },
  "task": {
    "type": "ps",
    "index": 1
  }
}
'''
```

--------------------------------

### MaxSizePartitioner usage examples

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/experimental/partitioners/MaxSizePartitioner

Demonstrates creating MaxSizePartitioner with different parameters and calling it on a TensorShape. Shows how max_shard_bytes and max_shards affect the resulting partitions. Also includes a commented example for use in ParameterServerStrategy.

```python
partitioner = MaxSizePartitioner(max_shard_bytes=4)
partitions = partitioner(tf.TensorShape([6, 1]), tf.float32)
[6, 1]
partitioner = MaxSizePartitioner(max_shard_bytes=4, max_shards=2)
partitions = partitioner(tf.TensorShape([6, 1]), tf.float32)
[2, 1]
partitioner = MaxSizePartitioner(max_shard_bytes=1024)
partitions = partitioner(tf.TensorShape([6, 1]), tf.float32)
[1, 1]

# use in ParameterServerStrategy
# strategy = tf.distribute.experimental.ParameterServerStrategy(
#   cluster_resolver=cluster_resolver, variable_partitioner=partitioner)
```

--------------------------------

### Example: Allocating tensors on specific GPUs using tf.config.list_logical_devices

Source: https://www.tensorflow.org/api_docs/python/tf/config/list_logical_devices

This example demonstrates how to use tf.config.list_logical_devices('GPU') to get a list of logical GPU devices and then allocate tensors on GPU:0 and GPU:1 using tf.device. It checks that the list is non-empty before accessing indices.

```python
logical_devices = tf.config.list_logical_devices('GPU')
if len(logical_devices) > 0:
  # Allocate on GPU:0
  with tf.device(logical_devices[0].name):
    one = tf.constant(1)
  # Allocate on GPU:1
  with tf.device(logical_devices[1].name):
    two = tf.constant(2)
```

--------------------------------

### Example usage of TPUClusterResolver.connect

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/cluster_resolver/TPUClusterResolver

Example showing how to connect to a remote TPU cluster and initialize the TPU hardware using the connect method.

```python
resolver = tf.distribute.cluster_resolver.TPUClusterResolver.connect(
    tpu='')

```

--------------------------------

### Example: Get current image data format

Source: https://www.tensorflow.org/api_docs/python/tf/keras/backend/set_image_data_format

Shows how to retrieve the current image data format using keras.config.image_data_format(), which returns 'channels_last' by default.

```python
keras.config.image_data_format()
'channels_last'

```

--------------------------------

### Example (SipHash64)

Source: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Hashing

Example of using the Hashing layer with SipHash64 by providing a salt list. The output shows the hashed values.

```python
layer = keras.layers.Hashing(num_bins=3, salt=[133, 137])
inp = [['A'], ['B'], ['C'], ['D'], ['E']]
layer(inp)
array([[1],
        [2],
        [1],
        [0],
        [2]])
```

--------------------------------

### Inspect per-replica values locally with experimental_local_results

Source: https://www.tensorflow.org/api_docs/python/tf/distribute/DistributedValues

Shows how to get a list of per-replica tensors using strategy.experimental_local_results. The example prints the local results as a tuple.

```python
strategy = tf.distribute.MirroredStrategy(["GPU:0", "GPU:1"])
dataset = tf.data.Dataset.from_tensor_slices([5., 6., 7., 8.]).batch(2)
dataset_iterator = iter(strategy.experimental_distribute_dataset(dataset))
per_replica_values = strategy.experimental_local_results(
   distributed_values)
per_replica_values
(<tf.Tensor: shape=(1,), dtype=float32, numpy=array([5.], dtype=float32)>,
 <tf.Tensor: shape=(1,), dtype=float32, numpy=array([6.], dtype=float32)>)
```

--------------------------------

### get_next_as_optional() example with output

Source: https://www.tensorflow.org/api_docs/python/tf/data/Iterator

Demonstrates using get_next_as_optional() to get the next element wrapped in tf.experimental.Optional, including checking has_value() and retrieving the value with get_value().

```python
dataset = tf.data.Dataset.from_tensors(42)
iterator = iter(dataset)
optional = iterator.get_next_as_optional()
print(optional.has_value())
tf.Tensor(True, shape=(), dtype=bool)
print(optional.get_value())
tf.Tensor(42, shape=(), dtype=int32)
optional = iterator.get_next_as_optional()
print(optional.has_value())
tf.Tensor(False, shape=(), dtype=bool)
```
Tokens:
Raw