tensorflow :: opérations :: FractionalMaxPool

Effectue un pool max fractionnaire sur l'entrée.

Résumé

La mise en commun fractionnaire maximale est légèrement différente de la mise en commun maximale régulière. Dans le pooling max normal, vous réduisez la taille d'un ensemble d'entrée en prenant la valeur maximale de N x N sous-sections plus petites de l'ensemble (souvent 2x2), et essayez de réduire l'ensemble d'un facteur N, où N est un entier. Le regroupement fractionnaire maximal, comme vous pouvez vous y attendre avec le mot «fractionnaire», signifie que le rapport de réduction global N ne doit pas être un entier.

Les tailles des régions de regroupement sont générées de manière aléatoire mais sont assez uniformes. Par exemple, regardons la dimension de hauteur et les contraintes sur la liste des lignes qui seront les limites du pool.

Nous définissons d'abord ce qui suit:

1. input_row_length: le nombre de lignes de l'ensemble d'entrée
2. output_row_length: qui sera plus petit que l'entrée
3. alpha = input_row_length / output_row_length: notre taux de réduction
4. K = plancher (alpha)
5. row_ Covoiturage_sequence: il s'agit de la liste de résultats des lignes de limite de pool

Ensuite, row_pool_sequence doit satisfaire:

1. a [0] = 0: la première valeur de la séquence est 0
2. a [end] = input_row_length: la dernière valeur de la séquence est la taille
3. K <= (a [i + 1] - a [i]) <= K + 1: tous les intervalles sont de taille K ou K + 1
4. length (row_pool_sequence) = output_row_length + 1

Pour plus de détails sur le pooling fractionnaire maximal, consultez cet article: Benjamin Graham, Fractional Max-Pooling

Arguments:

• scope: un objet Scope
• valeur: 4-D avec forme [batch, height, width, channels] .
• pooling_ratio: Ratio de mise en commun pour chaque dimension de value , ne prend actuellement en charge que les dimensions de ligne et de colonne et doit être> = 1,0. Par exemple, un ratio de mise en commun valide ressemble à [1.0, 1.44, 1.73, 1.0]. Le premier et le dernier éléments doivent être 1.0 car nous n'autorisons pas le regroupement sur les dimensions des lots et des canaux. 1,44 et 1,73 sont respectivement le rapport de mise en commun sur les dimensions de hauteur et de largeur.

Attributs facultatifs (voir Attrs ):

• pseudo_random: lorsqu'il est défini sur True, génère la séquence de regroupement de manière pseudo-aléatoire, sinon de manière aléatoire. Vérifiez le papier Benjamin Graham, Fractional Max-Pooling pour la différence entre pseudo-aléatoire et aléatoire.
• chevauchement: lorsqu'il est défini sur True, cela signifie que lors du regroupement, les valeurs à la limite des cellules de regroupement adjacentes sont utilisées par les deux cellules. Par example:

index 0 1 2 3 4

value 20 5 16 3 7

Si la séquence de regroupement est [0, 2, 4], alors 16, à l'index 2 sera utilisé deux fois. Le résultat serait [20, 16] pour un pool max fractionnaire.

• déterministe: lorsqu'il est défini sur True, une région de regroupement fixe sera utilisée lors de l'itération sur un nœud FractionalMaxPool dans le graphe de calcul. Principalement utilisé dans les tests unitaires pour rendre FractionalMaxPool déterministe.
• seed: Si seed ou seed2 est défini pour être différent de zéro, le générateur de nombres aléatoires est amorcé par la graine donnée. Sinon, il est semé par une graine aléatoire.
• seed2: Une deuxième graine pour éviter la collision de graines.

Retour:

• Output sortie: tenseur de sortie après pooling max fractionnaire.
• Output row_pool_sequence: séquence de regroupement de lignes, nécessaire pour calculer le gradient.
• Output col_pool_sequence: séquence de regroupement de colonnes, nécessaire pour calculer le gradient.

Attributs publics

::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
)