Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

tf.distribute.experimental.CentralStorageStrategy

TensorFlow 1 wersja Zobacz źródło na GitHub

Strategia jedna maszyna, która stawia wszystkie zmienne na jednym urządzeniu.

Dziedziczy: Strategy

Stosowany w notebookach

Używany w przewodniku

Zmienne są przypisywane do lokalnego procesora lub tylko GPU. Jeśli istnieje więcej niż jeden GPU, operacje obliczeniowe (inne niż zmiennych operacji aktualizacji) zostaną powtórzone we wszystkich procesorach graficznych.

Na przykład:

 strategy = tf.distribute.experimental.CentralStorageStrategy()
# Create a dataset
ds = tf.data.Dataset.range(5).batch(2)
# Distribute that dataset
dist_dataset = strategy.experimental_distribute_dataset(ds)

with strategy.scope():
  @tf.function
  def train_step(val):
    return val + 1

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

cluster_resolver Zwraca resolverowi klastra związanego z tą strategią.

Na ogół, przy zastosowaniu wielu pracowników tf.distribute strategię takiej jak tf.distribute.experimental.MultiWorkerMirroredStrategy lub tf.distribute.experimental.TPUStrategy() znajduje się tf.distribute.cluster_resolver.ClusterResolver związane ze strategią użyty, a takim przypadku jest zwracana przez tę właściwość.

Strategie, które zamierzają mieć skojarzony tf.distribute.cluster_resolver.ClusterResolver musi ustawić odpowiedni atrybut, lub zastąpić tę właściwość; w przeciwnym razie, None jest zwracany domyślnie. Strategie te powinny także dostarczyć informacji na temat tego, co jest zwracany przez tę właściwość.

Strategie Single-pracownik zazwyczaj nie mają tf.distribute.cluster_resolver.ClusterResolver , iw tych przypadkach ta właściwość zwróci None .

tf.distribute.cluster_resolver.ClusterResolver może być przydatna, gdy użytkownik potrzebuje dostępu do informacji, takich jak spec Hortona, zadań czy identyfikator zadań. Na przykład,

 
os.environ['TF_CONFIG'] = json.dumps({
'cluster': {
'worker': ["localhost:12345", "localhost:23456"],
'ps': ["localhost:34567"]
},
'task': {'type': 'worker', 'index': 0}
})

# This implicitly uses TF_CONFIG for the cluster and current task info.
strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()

...

if strategy.cluster_resolver.task_type == 'worker':
# Perform something that's only applicable on workers. Since we set this
# as a worker above, this block will run on this particular instance.
elif strategy.cluster_resolver.task_type == 'ps':
# Perform something that's only applicable on parameter servers. Since we
# set this as a worker above, this block will not run on this particular
# instance.
 

Aby uzyskać więcej informacji, proszę zobaczyć tf.distribute.cluster_resolver.ClusterResolver „s API docstring.

extended tf.distribute.StrategyExtended z dodatkowymi sposobami.
num_replicas_in_sync Zwraca liczbę replik nad którym gradienty są sumowane.

metody

experimental_assign_to_logical_device

Pokaż źródło

Dodaje adnotację, że tensor zostanie przypisany do urządzenia logicznego.

 
# Initializing TPU system with 2 logical devices and 4 replicas.
resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
tf.config.experimental_connect_to_cluster(resolver)
topology = tf.tpu.experimental.initialize_tpu_system(resolver)
device_assignment = tf.tpu.experimental.DeviceAssignment.build(
    topology,
    computation_shape=[1, 1, 1, 2],
    num_replicas=4)
strategy = tf.distribute.TPUStrategy(
    resolver, experimental_device_assignment=device_assignment)
iterator = iter(inputs)

@tf.function()
def step_fn(inputs):
  output = tf.add(inputs, inputs)

  # Add operation will be executed on logical device 0.
  output = strategy.experimental_assign_to_logical_device(output, 0)
  return output

strategy.run(step_fn, args=(next(iterator),))
 

args
tensor tensor wejście adnotacji.
logical_device_id Id logicznego rdzenia, do którego zostanie przypisany tensor.

podbicia
ValueError Logiczny identyfikator urządzenia przedstawiona jest zgodna z całkowitej liczby partycji określonych przez przypisanie urządzenia.

Zwroty
Tensor adnotacją o wartości idential jako tensor .

experimental_distribute_dataset

Pokaż źródło

Dystrybuuje instancji tf.data.Dataset dostarczone przez zestaw danych.

Zwrócony zestaw danych jest owinięty zestaw danych strategia, która tworzy iterator multidevice pod maską. To wstępnie wyłapuje dane wejściowe do określonych urządzeń na pracownika. Zwrócony zestaw danych może być rozpowszechniany powtórzyć nad podobny do tego, jak regularne zbiory danych możliwe.

Na przykład:

 strategy = tf.distribute.CentralStorageStrategy()  # with 1 CPU and 1 GPU
dataset = tf.data.Dataset.range(10).batch(2)
dist_dataset = strategy.experimental_distribute_dataset(dataset)
for x in dist_dataset:
  print(x)  # Prints PerReplica values [0, 1], [2, 3],...

 

Args: Zbiór danych: tf.data.Dataset być wstępnie pobrać do urządzenia.

Zwroty
A „dystrybuowane Dataset ”, że rozmówca może iteracyjnego.

experimental_distribute_datasets_from_function

Pokaż źródło

Dystrybuuje tf.data.Dataset instancje utworzone przez wywołania dataset_fn .

dataset_fn będzie wywoływana raz dla każdego pracownika w ramach strategii. W tym przypadku, mamy tylko jednego pracownika tak dataset_fn nazywa raz. Każda replika na tej pracownika wtedy dequeue partii elementów z tego lokalnego zestawu danych.

dataset_fn powinny brać tf.distribute.InputContext instancji, gdzie mogą być dostępne informacje na temat dozowania i replikacji wejściowego.

Na przykład:

 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.run(replica_fn, args=(batch,))
 

args
dataset_fn Funkcja robienia tf.distribute.InputContext instancji i przekazujących tf.data.Dataset .

Zwroty
A „dystrybuowane Dataset ”, które dzwoniący może iterować jak zwykłe zbiorów danych.

experimental_distribute_values_from_function

Pokaż źródło

Generuje tf.distribute.DistributedValues z value_fn .

Ta funkcja jest generowanie tf.distribute.DistributedValues przejść do run , reduce , lub inne metody, które mają rozdzielone wartości, jeśli nie używasz zestawów danych.

args
value_fn Funkcja biec do generowania wartości. Nazywa się dla każdej repliki z tf.distribute.ValueContext jako jedynego argumentu. musi powrócić tensora lub rodzaju, które można przekształcić w tensora.

Zwroty
A tf.distribute.DistributedValues zawierające wartości dla każdego repliki.

Przykładowe zastosowania:

  1. Powrót stałą wartość za replikę:
strategy = tf.distribute.MirroredStrategy()
def value_fn(ctx):
  return tf.constant(1.)
distributed_values = (
     strategy.experimental_distribute_values_from_function(
       value_fn))
local_result = strategy.experimental_local_results(distributed_values)
local_result
(<tf.Tensor: shape=(), dtype=float32, numpy=1.0>,)
  1. Rozpowszechniać wartości w tablicy na podstawie replica_id:
strategy = tf.distribute.MirroredStrategy()
array_value = np.array([3., 2., 1.])
def value_fn(ctx):
  return array_value[ctx.replica_id_in_sync_group]
distributed_values = (
     strategy.experimental_distribute_values_from_function(
       value_fn))