tensorflow :: ops :: FractionalMaxPool

Executa o pooling máximo fracionário na entrada.

Resumo

O pool máximo fracionário é ligeiramente diferente do pool máximo regular. No pool máximo regular, você reduz o tamanho de um conjunto de entrada tomando o valor máximo de N x N subseções menores do conjunto (geralmente 2x2) e tenta reduzir o conjunto por um fator de N, onde N é um inteiro. O agrupamento máximo fracionário, como você pode esperar da palavra "fracionário", significa que a taxa de redução geral N não precisa ser um número inteiro.

Os tamanhos das regiões de pool são gerados aleatoriamente, mas são bastante uniformes. Por exemplo, vamos examinar a dimensão da altura e as restrições na lista de linhas que serão os limites do pool.

Primeiro, definimos o seguinte:

1. input_row_length: o número de linhas do conjunto de entrada
2. output_row_length: que será menor que a entrada
3. alpha = input_row_length / output_row_length: nossa taxa de redução
4. K = piso (alfa)
5. row_pool_sequence: esta é a lista de resultados das linhas de limite do pool

Então, row_pool_sequence deve satisfazer:

1. a [0] = 0: o primeiro valor da sequência é 0
2. a [end] = input_row_length: o último valor da sequência é o tamanho
3. K <= (a [i + 1] - a [i]) <= K + 1: todos os intervalos são de tamanho K ou K + 1
4. comprimento (row_pool_sequence) = output_row_length + 1

Para obter mais detalhes sobre o pool máximo fracionário, consulte este artigo: Benjamin Graham, Fractional Max-Pooling

Argumentos:

• escopo: um objeto Scope
• valor: 4-D com forma [batch, height, width, channels] .
• pooling_ratio: proporção de pooling para cada dimensão de value , atualmente suporta apenas dimensão de linha e coluna e deve ser> = 1,0. Por exemplo, uma proporção de agrupamento válida se parece com [1,0, 1,44, 1,73, 1,0]. O primeiro e o último elementos devem ser 1,0 porque não permitimos o pool em dimensões de lote e canais. 1,44 e 1,73 são a razão de agrupamento nas dimensões de altura e largura, respectivamente.

Atributos opcionais (consulte Attrs ):

• pseudo_random: quando definido como True, gera a sequência de pooling de forma pseudo-aleatória, caso contrário, de forma aleatória. Verifique o artigo Benjamin Graham, Fractional Max-Pooling para a diferença entre pseudo-aleatório e aleatório.
• overlapping: quando definido como True, significa que, ao agrupar, os valores no limite das células de agrupamento adjacentes são usados ​​por ambas as células. Por exemplo:

index 0 1 2 3 4

value 20 5 16 3 7

Se a sequência de agrupamento for [0, 2, 4], então 16, no índice 2, será usado duas vezes. O resultado seria [20, 16] para pooling máximo fracionário.

• determinística: quando definido como Verdadeiro, uma região de agrupamento fixa será usada ao iterar sobre um nó FractionalMaxPool no gráfico de computação. Usado principalmente em teste de unidade para tornar FractionalMaxPool determinístico.
• seed: Se seed ou seed2 forem definidos como diferentes de zero, o gerador de números aleatórios é propagado pelo seed fornecido. Caso contrário, é semeado por uma semente aleatória.
• seed2: Uma segunda semente para evitar a colisão de sementes.

Retorna:

• Output saída: tensor de saída após o pool máximo fracionário.
• Output row_pool_sequence: sequência de pool de linhas, necessária para calcular o gradiente.
• Output col_pooling_sequence: sequência de agrupamento de colunas, necessária para calcular o gradiente.

Atributos públicos

::tensorflow::Output col_pooling_sequence

Operation operation

::tensorflow::Output output

::tensorflow::Output row_pooling_sequence

 FractionalMaxPool(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input value,
  const gtl::ArraySlice< float > & pooling_ratio
)

 FractionalMaxPool(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input value,
  const gtl::ArraySlice< float > & pooling_ratio,
  const FractionalMaxPool::Attrs & attrs
)

Attrs Deterministic(
  bool x
)

Attrs Overlapping(
  bool x
)

Attrs PseudoRandom(
  bool x
)

Attrs Seed(
  int64 x
)

Attrs Seed2(
  int64 x
)