Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

tensorflow :: opérations :: FractionalMaxPool

#include <nn_ops.h>

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 nécessairement être un entier.

Les tailles des régions de mise en commun 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.

Tout d'abord, nous définissons 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 la mise en commun fractionnaire max.

  • 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 graphique 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.

Constructeurs et destructeurs

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)

Attributs publics

col_pooling_sequence
operation
output
row_pooling_sequence

Fonctions statiques publiques

Deterministic (bool x)
Overlapping (bool x)
PseudoRandom (bool x)
Seed (int64 x)
Seed2 (int64 x)

Structs

tensorflow :: ops :: FractionalMaxPool :: Attrs

Définisseurs d'attributs facultatifs pour FractionalMaxPool .

Attributs publics

col_ Covoiturage_sequence

::tensorflow::Output col_pooling_sequence

opération

Operation operation

production

::tensorflow::Output output

row_pool_sequence

::tensorflow::Output row_pooling_sequence

Fonctions publiques

FractionalMaxPool

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

FractionalMaxPool

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

Fonctions statiques publiques

Déterministe

Attrs Deterministic(
  bool x
)

Chevauchement

Attrs Overlapping(
  bool x
)

PseudoAlatoire

Attrs PseudoRandom(
  bool x
)

Planter

Attrs Seed(
  int64 x
)

Graine2

Attrs Seed2(
  int64 x
)