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

tf.distribute.OneDeviceStrategy

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

Strategia dystrybucji działa na jednym urządzeniu.

Dziedziczy: Strategy

Stosowany w notebookach

Używany w samouczków

Korzystanie z tej strategii będzie stawiać żadnych zmiennych utworzonych w jej zakresu na określonym urządzeniu. Wejście dystrybuowane za pośrednictwem tej strategii zostaną wstępnie pobrać do określonego urządzenia. Ponadto, wszelkie funkcje wywoływane strategy.run także być wprowadzane do określonego urządzenia, jak również.

Typowe zastosowanie tej strategii może być testowanie kodu i interfejsu API tf.distribute.Strategy przed przejściem do innych strategii, które faktycznie rozprowadzają do wielu urządzeń / maszyn.

Na przykład:

 strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")

with strategy.scope():
  v = tf.Variable(1.0)
  print(v.device)  # /job:localhost/replica:0/task:0/device:GPU:0

def step_fn(x):
  return x * 2

result = 0
for i in range(10):
  result += strategy.run(step_fn, args=(i,))
print(result)  # 90
 

device Urządzenie identyfikator ciąg do urządzenia, na którym zmienne powinny być umieszczone. Zobacz docs klasowych więcej szczegółów na temat sposobu korzystania z urządzenia. Przykłady: "/ CPU: 0" "/ Grafika: 0" "/ urządzenie: procesor: 0" "/ urządzenie: Grafika: 0"

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.

W tym przypadku jest tylko jedno urządzenie, więc jest to tylko cienka owijka wokół zestawu danych wejściowych. To będzie jednak wstępne pobieranie danych wejściowych do określonego urządzenia. Zwrócony zestaw danych może być rozpowszechniany powtórzyć nad podobny do tego, jak regularne zbiory danych możliwe.

Przykład:

 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],...
 

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, a jedno urządzenie tak dataset_fn jest wywoływana raz.

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

 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 = (