Esta página foi traduzida pela API Cloud Translation.
Switch to English

tf.CriticalSection

TensorFlow 1 versão Ver fonte no GitHub

Seção Crítica.

Um CriticalSection objecto é um recurso no gráfico que executa subgráficos em ordem serial. Um exemplo comum de um subgrafo pode-se desejar executar exclusivamente é aquela dada pela seguinte função:

 v = resource_variable_ops.ResourceVariable(0.0, name="v")

def count():
  value = v.read_value()
  with tf.control_dependencies([value]):
    with tf.control_dependencies([v.assign_add(1)]):
      return tf.identity(value)
 

Aqui, um instantâneo de v é capturado em value ; e, em seguida, v é atualizado. O valor instantâneo é retornado.

Se vários trabalhadores ou tópicos todos executar count em paralelo, não há garantia de que o acesso à variável v é atômica em qualquer ponto dentro de cálculo de qualquer fio de count . Na verdade, mesmo a implementação de um balcão atômica que garante que o usuário verá cada valor 0, 1, ..., é actualmente impossível.

A solução é garantir qualquer acesso ao recurso subjacente v só é processada através de uma secção crítica:

 cs = CriticalSection()
f1 = cs.execute(count)
f2 = cs.execute(count)
output = f1 + f2
session.run(output)
 

As funções f1 e f2 serão executados em série, e atualidades v será atômica.

NOTAS

Todos os objetos de recursos, incluindo a seção crítica e quaisquer variáveis ​​capturadas de funções executadas nessa seção crítica, será colocated para o mesmo dispositivo (host e CPU / GPU).

Ao usar várias seções críticas sobre os mesmos recursos, não há garantia de acesso exclusivo a esses recursos. Este comportamento não é permitido por padrão (mas veja a kwarg exclusive_resource_access ).

Por exemplo, executar a mesma função em duas seções críticas separadas não vai garantir a execução de série:

 v = tf.compat.v1.get_variable("v", initializer=0.0, use_resource=True)
def accumulate(up):
  x = v.read_value()
  with tf.control_dependencies([x]):
    with tf.control_dependencies([v.assign_add(up)]):
      return tf.identity(x)
ex1 = CriticalSection().execute(
  accumulate, 1.0, exclusive_resource_access=False)
ex2 = CriticalSection().execute(
  accumulate, 1.0, exclusive_resource_access=False)
bad_sum = ex1 + ex2
sess.run(v.initializer)
sess.run(bad_sum)  # May return 0.0
 

name

Métodos

execute

Ver fonte

Executar a função fn() dentro da secção crítica.

fn não deve aceitar quaisquer argumentos. Para adicionar argumentos extras para ao chamar fn na seção crítica, criar um lambda:

 critical_section.execute(lambda: fn(*my_args, **my_kwargs))
 

args
fn A função a ser executada. Deve retornar pelo menos um tensor.
exclusive_resource_access Se os recursos exigidos pelo fn deve ser exclusiva para este CriticalSection . Padrão: True . Você pode querer definir isso para False se você vai acessar um recurso no modo de somente leitura em dois CriticalSections diferentes.
name O nome para usar ao criar a operação executar.

Devoluções
Os tensores retornados a partir fn() .

Levanta
ValueError Se fn tentativas de bloquear este CriticalSection de qualquer forma aninhada ou preguiçoso que pode causar um bloqueio.
ValueError Se exclusive_resource_access == True e outra CriticalSection tem uma execução solicitando os mesmos recursos que fn . Note, even if exclusive_resource_access is verdadeira , if another execution in another CriticalSection was created without exclusive_resource_access = True , a ValueError` será gerado.