Quelle est la différence entre ' SAME ' et ' VALID ' rembourrage en tf.nn.max_pool de tensorflow ?

Question

Quelle est la différence entre le "MÊME" et "VALIDES" rembourrage en tf.nn.max_pool de tensorflow?

À mon avis, "VALIDE" signifie qu'il n'y aura pas de zéro de remplissage à l'extérieur des limites quand nous faisons max de la piscine.

Selon Un guide de la convolution de l'arithmétique pour l'apprentissage en profondeur, il dit qu'il n'y aura pas de rembourrage dans la piscine de l'opérateur, c'est à dire l'utilisation juste "VALIDES" de tensorflow. Mais qu'est-ce que "MÊME" remplissage de la piscine max en tensorflow?

Answer 1

Si vous aimez l'art ascii:

• "VALID" = sans padding:

     inputs:         1  2  3  4  5  6  7  8  9  10 11 (12 13)
                    |________________|                dropped
                                   |_________________|
  

• "SAME" = zéro padding:

                 pad|                                      |pad
     inputs:      0 |1  2  3  4  5  6  7  8  9  10 11 12 13|0  0
                 |________________|
                                |_________________|
                                               |________________|
  

Dans cet exemple:

• Largeur d'entrée = 13
• Filtre largeur = 6
• Stride = 5

Notes:

• "VALID" seulement des gouttes les plus à droite des colonnes (ou lignes les plus basses).
• "SAME" tente de pad uniformément à gauche et à droite, mais si le nombre de colonnes à ajouter est impair, il va ajouter de la colonne à la droite, comme c'est le cas dans cet exemple (la même logique s'applique à la verticale: il peut y avoir une ligne supplémentaire de zéros à la fin.)

Answer 2

Lorsque `` est 1 (plus typique avec la convolution de mise en commun), nous pouvons penser la distinction suivante :

• ``: taille de sortie est la même que la taille d’entrée. Pour cela, la fenêtre de filtre pour glisser en dehors de la carte d’entrée, d'où la nécessité de pad.
• : Filtre fenêtre reste en position **valide** à l’intérieur de la carte d’entrée, de sortie donc taille rétrécit par . Pas de remplissage se produit.

Answer 3

Je vais vous donner un exemple pour plus de clarté:

• x: image d'entrée de la forme [2, 3], 1 canal
• valid_pad: max de la piscine avec 2x2 noyau, stride 2 et VALIDE rembourrage.
• same_pad: max de la piscine avec 2x2 noyau, stride 2 et MÊME le rembourrage (c'est le classique de la voie à suivre)

La sortie de formes sont:

• valid_pad: ici, pas de rembourrage afin que la sortie de la forme [1, 1]
• same_pad: ici, nous tampon de l'image de la forme [2, 4] (avec -inf , puis appliquer max de la piscine), de sorte que la sortie de la forme [1, 2]

---

x = tf.constant([[1., 2., 3.],
                 [4., 5., 6.]])

x = tf.reshape(x, [1, 2, 3, 1])  # give a shape accepted by tf.nn.max_pool

valid_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='VALID')
same_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

valid_pad.get_shape() == [1, 1, 1, 1]  # valid_pad is [5.]
same_pad.get_shape() == [1, 1, 2, 1]   # same_pad is  [5., 6.]

---

Answer 4

Le TensorFlow Convolution exemple donne un aperçu sur la différence entre l' SAME et VALID :

• Pour l' SAME rembourrage, la sortie de la hauteur et la largeur sont calculés comme:

out_height = ceil(float(in_height) / float(foulées[1]))

out_width = ceil(float(in_width) / float(foulées[2]))

Et

• Pour l' VALID rembourrage, la sortie de la hauteur et la largeur sont calculés comme:

out_height = ceil(float(in_height - filter_height + 1) / float(foulées[1]))

out_width = ceil(float(in_width - filter_width + 1) / float(foulées[2]))

Answer 5

Le rembourrage est une opération pour augmenter la taille des données d'entrée. Dans le cas de 1-dimensions données que vous venez d'ajouter/préfixer le tableau avec une constante, dans 2-dim vous entourent matrice avec ces constantes. En n-dim vous entourez votre n-dim hypercube avec la constante. Dans la plupart des cas, cette constante est égale à zéro et il est appelé zero-padding.

Voici un exemple de zéro-padding avec p=1 appliqué à 2-d tenseur:

---

Vous pouvez utiliser arbitraire de rembourrage pour votre noyau, mais certaines des valeurs de remplissage sont utilisés plus fréquemment que d'autres, ils sont:

• VALIDE rembourrage. Le cas le plus facile, moyen pas de rembourrage. Il suffit de laisser vos données de la même il est.
• MÊME rembourrage parfois appelé DEMI-remplissage. Il est appelé MÊME parce que, pour un produit de convolution avec une foulée=1, (ou pour la mise en commun), il doit produire une sortie de la même taille que l'entrée. Il est appelé à MOITIÉ parce que pour un noyau de taille k
• Remplissage COMPLET est la durée maximale de rembourrage, qui ne fait pas une convolution par rapport à un simple collier éléments. Pour un noyau de taille k, ce remplissage est égale à k - 1.

---

Pour utiliser arbitraire rembourrage en TF, vous pouvez utiliser tf.pad()