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

Je vais vous donner un exemple pour le rendre plus clair:

• 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 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 et ensuite 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.]

---

OriginalL'auteur Olivier Moindrot

Quand stride est de 1 (plus typique de convolution de mise en commun), nous pouvons penser à la distinction suivante:

• "SAME": la taille de la sortie est de la même que la taille de l'image. Cela nécessite la fenêtre de filtre à glisser à l'extérieur de l'entrée de la carte, d'où la nécessité de pad.
• "VALID": Fenêtre de filtre reste à valide position à l'intérieur de l'entrée de la carte, de sorte que la taille de sortie se rétrécit par filter_size - 1. Pas de rembourrage se produit.

OriginalL'auteur YvesgereY

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ée à 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é la MOITIÉ de rembourrage. 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é la 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 égal à k - 1.

---

À l'utilisation arbitraire de rembourrage en TF, vous pouvez utiliser tf.pad()

OriginalL'auteur Salvador Dali

Il y a trois choix de rembourrage: valide (pas de remplissage), même (ou la moitié), complet. Vous pouvez trouver des explications (en Théano) ici:
http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html

• Valide ou pas de rembourrage:

La validité de rembourrage n'implique pas de zéro de remplissage, de sorte qu'il ne couvre que les entrées valides, non compris les produits artificiellement des zéros. La longueur de sortie est ((la longueur de l'entrée) - (k-1)) pour le noyau de taille k si la foulée s=1.

• Même ou demi-rembourrage:

La même rembourrage rend la taille des sorties d'être le même que celui des entrées lorsque s=1. Si s=1, le nombre de zéros collier est (k-1).

• Remplissage complet:

Le remplissage complet signifie que le noyau s'exécute sur l'ensemble des entrées, donc à la fin, le noyau peut répondre à la seule entrée et des zéros ailleurs. Le nombre de zéros collier est de 2(k-1) si s=1. La longueur de sortie est ((la longueur de l'entrée) + (k-1)) si s=1.

Par conséquent, le nombre de remplissages: (valide) <= (lui-même) <= (complet)

OriginalL'auteur Change-the-world

Sur la base des explications ici et le suivi de Tristan réponse, j'ai l'habitude d'utiliser ces fonctions rapides pour des contrôles d'intégrité.

# a function to help us stay clean
def getPaddings(pad_along_height,pad_along_width):
# if even.. easy..
if pad_along_height%2 == 0:
pad_top = pad_along_height / 2
pad_bottom = pad_top
# if odd
else:
pad_top = np.floor( pad_along_height / 2 )
pad_bottom = np.floor( pad_along_height / 2 ) +1
# check if width padding is odd or even
# if even.. easy..
if pad_along_width%2 == 0:
pad_left = pad_along_width / 2
pad_right= pad_left
# if odd
else:
pad_left = np.floor( pad_along_width / 2 )
pad_right = np.floor( pad_along_width / 2 ) +1
#
return pad_top,pad_bottom,pad_left,pad_right
# strides [image index, y, x, depth]
# padding 'SAME' or 'VALID'
# bottom and right sides always get the one additional padded pixel (if padding is odd)
def getOutputDim (inputWidth,inputHeight,filterWidth,filterHeight,strides,padding):
if padding == 'SAME':
out_height = np.ceil(float(inputHeight) / float(strides[1]))
out_width  = np.ceil(float(inputWidth) / float(strides[2]))
#
pad_along_height = ((out_height - 1) * strides[1] + filterHeight - inputHeight)
pad_along_width = ((out_width - 1) * strides[2] + filterWidth - inputWidth)
#
# now get padding
pad_top,pad_bottom,pad_left,pad_right = getPaddings(pad_along_height,pad_along_width)
#
print 'output height', out_height
print 'output width' , out_width
print 'total pad along height' , pad_along_height
print 'total pad along width' , pad_along_width
print 'pad at top' , pad_top
print 'pad at bottom' ,pad_bottom
print 'pad at left' , pad_left
print 'pad at right' ,pad_right
elif padding == 'VALID':
out_height = np.ceil(float(inputHeight - filterHeight + 1) / float(strides[1]))
out_width  = np.ceil(float(inputWidth - filterWidth + 1) / float(strides[2]))
#
print 'output height', out_height
print 'output width' , out_width
print 'no padding'
# use like so
getOutputDim (80,80,4,4,[1,1,1,1],'SAME')

OriginalL'auteur ahmedhosny

VALIDE padding: c'est avec zéro de remplissage. Espérons qu'il y est pas de confusion.

x = tf.constant([[1., 2., 3.], [4., 5., 6.],[ 7., 8., 9.], [ 7., 8., 9.]])
x = tf.reshape(x, [1, 4, 3, 1])
valid_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='VALID')
print (valid_pad.get_shape()) # output-->(1, 2, 1, 1)

MÊME padding: C'est le genre de difficile à comprendre, en premier lieu, parce que nous avons à examiner 2 conditions séparément comme mentionné dans le officiel docs.

Prenons en entrée comme . (singal dimentina est pris en considération)

De cas 01:

Cas 02:

.

Nous allons travailler sur cet exemple:

x = tf.constant([[1., 2., 3.], [4., 5., 6.],[ 7., 8., 9.], [ 7., 8., 9.]])
x = tf.reshape(x, [1, 4, 3, 1])
same_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')
print (same_pad.get_shape()) # --> output (1, 2, 2, 1)

Ici la dimension de x est (3,4). Ensuite, si la direction horizontale (3):

Si le vertial direction est prise (4):

Espère que cela va aider à comprendre comment MÊME rembourrage travaille en TF.

OriginalL'auteur GPrathap