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

tf.scan

TensorFlow 1 versão Ver fonte no GitHub

varredura na lista dos tensores desempacotado de elems na dimensão 0. (valores de argumento opostas)

A versão mais simples scan repetidamente aplica a exigível fn a uma sequência de elementos do primeiro ao último. Os elementos são feitos dos tensores desempacotado de elems na dimensão 0. O fn exigível leva dois tensores como argumentos. O primeiro argumento é o valor acumulado calculado a partir da chamada anterior de fn, e o segundo é o valor na posição actual do elems . Se initializer é Nenhum, elems deve conter pelo menos um elemento, e o primeiro elemento é usado como o inicializador.

Suponha que elems é descompactado em values , uma lista de tensores. A forma do tensor resultado é [len(values)] + fn(initializer, values[0]).shape . Se reversa = verdade, é fn (inicializador, os valores de [-1]). Forma.

Este método também permite multi-arity elems e acumulador. Se elems é uma lista (possivelmente aninhados) ou tupla de tensores, então cada um desses tensores deve ter um primeiro (descompactar) dimensão correspondente. O segundo argumento de fn deve corresponder à estrutura do elems .

Se não initializer é fornecido, a estrutura de saída e dtypes de fn são assumidos como sendo a mesma que a sua entrada; e neste caso, o primeiro argumento de fn deve corresponder à estrutura do elems .

Se um initializer é fornecido, então a saída do fn devem ter a mesma estrutura como initializer ; e o primeiro argumento de fn deve coincidir com esta estrutura.

Por exemplo, se elems é (t1, [t2, t3]) e initializer é [i1, i2] , em seguida, uma assinatura apropriada para fn em python2 é: fn = lambda (acc_p1, acc_p2), (t1, [t2, t3]): e fn deve retornar uma lista, [acc_n1, acc_n2] . Uma assinatura alternativa correcta para fn , e a que funciona em python3 , é: fn = lambda a, t: , onde a e t correspondem aos tuplos de entrada.

fn O que pode ser chamado a ser realizado. Ele aceita dois argumentos. A primeira vai ter a mesma estrutura como initializer se uma é fornecida, caso contrário irá ter a mesma estrutura como elems . O segundo terão a mesma estrutura (possivelmente aninhada) como elems . Sua saída deve ter a mesma estrutura que initializer se for fornecido, caso contrário, ele deve ter a mesma estrutura que elems .
elems Um tensor ou sequência (possivelmente aninhada) de tensores, cada um dos quais irá ser desembalado ao longo da sua primeira dimensão. A sequência aninhada das fatias resultantes serão o primeiro argumento para fn .
initializer (opcional) um tensor ou sequência (possivelmente aninhada) de tensores, o valor inicial para o acumulador, e o tipo de saída esperado do fn .
parallel_iterations (Opcional) O número de iterações pode ser executado em paralelo.
back_prop (Opcional) Reprovado. desativa falsos apoiar para a propagação de volta. Preferem usar tf.stop_gradient vez.
swap_memory (Opcional) Verdadeiro permite troca de memória GPU-CPU.
infer_shape (opcional) desactiva testes falsos para formas saída consistente.
reverse (opcional) scans Verdadeiros o tensor último para o primeiro (em vez de primeiro ao último).
name (Opcional) prefixo nome para a tensores devolvidos.

Um tensor ou sequência (possivelmente aninhada) de tensores. Cada tensor pacotes os resultados da aplicação da fn para tensores de desempacotados elems ao longo da primeira dimensão, e o valor anterior acumulador (s), da primeira para a última (ou passado para a primeira, se reverse=True ).

TypeError se fn não é exigível ou a estrutura da produção de fn e initializer não coincidem.
ValueError se os comprimentos da saída do fn e initializer não coincidem.

Exemplos:

 elems = np.array([1, 2, 3, 4, 5, 6])
sum = scan(lambda a, x: a + x, elems)
# sum == [1, 3, 6, 10, 15, 21]
sum = scan(lambda a, x: a + x, elems, reverse=True)
# sum == [21, 20, 18, 15, 11, 6]
 
 elems = np.array([1, 2, 3, 4, 5, 6])
initializer = np.array(0)
sum_one = scan(
    lambda a, x: x[0] - x[1] + a, (elems + 1, elems), initializer)
# sum_one == [1, 2, 3, 4, 5, 6]
 
 elems = np.array([1, 0, 0, 0, 0, 0])
initializer = (np.array(0), np.array(1))
fibonaccis = scan(lambda a, _: (a[1], a[0] + a[1]), elems, initializer)
# fibonaccis == ([1, 1, 2, 3, 5, 8], [1, 2, 3, 5, 8, 13])