Jaka jest różnica między "tym samym" a "prawidłowym" wypełnieniem w tf.nn.maksymalna Pula tensorflow?

Jeśli lubisz ascii art:

• "VALID" = bez wypełnienia:

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

• "SAME" = z zerowym wypełnieniem:

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

W tym przykładzie:

• Input width = 13
• Szerokość filtra = 6
• Stride = 5

Uwagi:

• "VALID" zawsze upuszcza tylko najbardziej prawe kolumny (lub najbardziej dolne wiersze).
• "SAME" próbuje padnąć równomiernie w lewo i w prawo, ale jeśli ilość kolumn do dodania jest nieparzysta, to dodaj dodatkową kolumnę po prawej stronie, tak jak w tym przykładzie (ta sama logika ma zastosowanie w pionie: na dole może znajdować się dodatkowy rząd zer).

Edit :

O nazwie:

• z wyściółką "SAME", jeśli użyjesz kroku 1, wyjścia warstwy będą miały takie same wymiary przestrzenne jak jej wejścia.
• z wyściółką "VALID", nie ma "zmyślonych" wejść padding. Warstwa używa tylko danych wejściowych valid.

Gdy stride jest 1 (bardziej typowe dla splotu niż łączenia), możemy myśleć o następującym rozróżnieniu:

• "SAME": rozmiar wyjściowy jest taki sam jak rozmiar wejściowy. Wymaga to, aby okno filtra wysunęło się na zewnątrz mapy wejściowej, stąd potrzeba padu.
• "VALID": okno filtra pozostaje na poprawnej pozycji wewnątrz mapy wejściowej, więc rozmiar wyjściowy zmniejsza się o filter_size - 1. Nie występuje wyściółka.

Przykład TensorFlow daje przegląd różnicy między SAME i VALID:

• Dla wypełnienia SAME wysokość i szerokość wyjścia są obliczane jako:

  out_height = ceil(float(in_height) / float(strides[1]))
  out_width  = ceil(float(in_width) / float(strides[2]))
  

I

• Dla wypełnienia VALID wysokość i szerokość wyjścia są obliczane jako:

  out_height = ceil(float(in_height - filter_height + 1) / float(strides[1]))
  out_width  = ceil(float(in_width - filter_width + 1) / float(strides[2]))
  

Padding jest operacją zwiększającą Rozmiar danych wejściowych. W przypadku danych 1-wymiarowych wystarczy dołączyć/poprzedzić tablicę stałą, w 2-wymiarowej macierzy otaczamy tymi stałymi. W n-dim otaczasz swoją N-dim hipersześcian stałą. W większości przypadków stała ta jest równa zeru i nazywa się ją zero-padding.

Oto przykład zerowego wypełnienia z p=1 zastosowanego do tensora 2-d:

Możesz użyć dowolnego wypełnienia dla swojego jądro, ale niektóre z wartości padding są używane częściej niż inne są to:

• VALID padding. Najprostszy przypadek, oznacza brak wyściółki w ogóle. Po prostu zostaw swoje dane tak, jak było.
• ta sama wyściółka czasami nazywana HALF padding . Jest on nazywany tym samym, ponieważ dla splotu o stride=1 (lub dla łączenia) powinien wytwarzać wyjście o tej samej wielkości co wejście. Nazywa się pół , ponieważ dla jądra o wielkości k
• FULL padding jest maksymalnym wyściółką, która nie powoduje splotu na tylko wyściełane elementy. Dla jądra o rozmiarze k, padding ten jest równy k - 1.

Aby użyć dowolnego wypełnienia w TF, możesz użyć tf.pad()

Uzupełniając świetną odpowiedź Yvesgereya, uznałem tę wizualizację za niezwykle pomocną:

Padding ' valid ' jest pierwszą cyfrą. Okno filtrowania pozostaje wewnątrz obrazu.

Padding ' ten sam ' jest trzecią cyfrą. Wyjście jest tego samego rozmiaru.

Znalazłem to na tym Artykuł

Napisy wizualizacyjne: vdumoulin@GitHub

Szybkie Wyjaśnienie

VALID: nie stosuj żadnych wypełnień, tzn. Załóżmy, że wszystkie wymiary są poprawne, aby obraz wejściowy został w pełni pokryty przez filtr i krok, który podałeś.

SAME: Zastosuj padding na wejściu (w razie potrzeby), aby obraz wejściowy został w pełni pokryty przez filtr i krok określony przez Ciebie. W przypadku stride 1 rozmiar wyjściowego obrazu będzie taki sam jak w przypadku wejściowego.

Uwagi

• dotyczy to również warstw conv jak max warstwy puli w ten sam sposób
• termin " poprawny "jest nieco mylący, ponieważ rzeczy nie stają się" niepoprawne", jeśli upuścisz część obrazu. Czasami możesz nawet tego chcieć. Powinno to być raczej nazwane NO_PADDING.
• termin" ten sam " jest również błędną nazwą, ponieważ ma sens tylko dla kroku 1, gdy wymiar wyjściowy jest taki sam jak wymiar wejściowy. Dla kroku 2, wymiary wyjściowe będą na przykład o połowę. To powinno być prawdopodobnie nazwane AUTO_PADDING zamiast tego.
• w trybie SAME (tj. w trybie auto-pad), Tensorflow spróbuje równomiernie rozłożyć padding zarówno po lewej, jak i po prawej stronie.
• W VALID (tj. bez trybu padding), Tensorflow spadnie w prawo i/lub w dół komórek, jeśli filtr i stride nie pokryją pełnego obrazu wejściowego.

Cytuję tę odpowiedź z oficjalnych dokumentów tensorflow https://www.tensorflow.org/api_guides/python/nn#Convolution Dla tej samej wyściółki wysokość i szerokość wyjściowa są obliczane jako:

out_height = ceil(float(in_height) / float(strides[1]))
out_width  = ceil(float(in_width) / float(strides[2]))

I padding na górze i po lewej są obliczane jako:

pad_along_height = max((out_height - 1) * strides[1] +
                    filter_height - in_height, 0)
pad_along_width = max((out_width - 1) * strides[2] +
                   filter_width - in_width, 0)
pad_top = pad_along_height // 2
pad_bottom = pad_along_height - pad_top
pad_left = pad_along_width // 2
pad_right = pad_along_width - pad_left

Dla "poprawnego" wypełnienia, wysokość i szerokość wyjścia są obliczane jako:

out_height = ceil(float(in_height - filter_height + 1) / float(strides[1]))
out_width  = ceil(float(in_width - filter_width + 1) / float(strides[2]))

I wartości wypełnienia są zawsze zerowe.

Istnieją trzy opcje padding: valid( no padding), same (lub half), full. Wyjaśnienia (w Języku Angielskim) znajdziesz tutaj: http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html

• Valid or no padding:

Poprawne wypełnienie nie zawiera zera, więc obejmuje tylko poprawne wejście, Nie włączając sztucznie wygenerowanych zer. Długość wyjścia wynosi ((długość wejścia) - (k-1)) dla rozmiaru jądra k, jeśli s=1.

• to samo lub half padding:

Ta sama wyściółka sprawia, że rozmiar wyjść jest taki sam z rozmiarem wejść, gdy s=1. Jeżeli s=1, to liczba zer jest równa (k-1).

• pełne wypełnienie:

Full padding oznacza, że jądro przebiega nad całymi wejściami, więc na końcach jądro może spełniać tylko jedno wejście i zera. Liczba zer jest równa 2 (k-1), jeżeli s=1. Długość wyjścia wynosi ((długość wejścia) + (k-1)), jeżeli s=1.

Dlatego liczba paddingów: (valid)

VALID padding: jest to zero padding. Mam nadzieję, że nie ma zamieszania.

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)

To samo padding: jest to trochę trudne do zrozumienia, ponieważ musimy rozważyć dwa warunki oddzielnie, jak wspomniano w official docs.

Przyjmijmy wejście jako , wyjście jako , padding jako , stride jako i rozmiar jądra jako (rozważany jest tylko jeden wymiar)

Przypadek 01: :

Case 02: :

Jest obliczana w taki sposób, że minimalna wartość, którą można przyjąć dla wypełnienia. Ponieważ wartość jest znana, wartość można znaleźć za pomocą tego wzoru .

Wypracujmy ten przykład:

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)

Tutaj wymiar x wynosi (3,4). Wtedy, jeśli kierunek poziomy jest przyjmowany (3):

Jeśli kierunek wierzchołkowy jest obrany (4):

Mam nadzieję, że to pomoże zrozumieć, jak właściwie to samo padding działa w TF.

Podsumowując,' poprawne ' padding oznacza brak padding. Rozmiar wyjściowy warstwy konwolutalnej kurczy się w zależności od rozmiaru wejścia i rozmiaru jądra.

Wręcz przeciwnie, "ta sama" wyściółka oznacza użycie wyściółki. Gdy stride jest ustawiony jako 1, rozmiar wyjściowy warstwy konwolucyjnej zachowuje się jako rozmiar wejściowy, dodając pewną liczbę "granicy 0" wokół danych wejściowych podczas obliczania splotu.

Mam nadzieję, że ten intuicyjny opis pomoże.

Bazując na wyjaśnieniu Tutaj i podążając za odpowiedzią Tristana, zwykle używam tych szybkich funkcji do sprawdzania zdrowego rozsądku.

# 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')

Padding on / off. Określa efektywny Rozmiar danych wejściowych.

VALID: bez wyściółki. Splot itp. operacje wykonywane są tylko w miejscach, które są "ważne", tzn. nie są zbyt blisko granic tensora.
z jądrem 3x3 i obrazem 10x10, wykonywałbyś splot na obszarze 8x8 wewnątrz granic.

SAME: wyściółka jest zapewniona. Ilekroć operacja odwołuje się do dzielnicy (bez względu na to, jak duża), wartości zerowe są dostarczane, gdy ta dzielnica rozciąga się poza pierwotny tensor, aby operacja ta działała również na wartościach granicznych.
z jądrem 3x3 i obrazem 10x10, wykonywałbyś splot na pełnym obszarze 10x10.

Tutaj W I H to szerokość i wysokość wejścia, F to wymiary filtra, P to Rozmiar wypełnienia (tj. liczba wierszy lub kolumn do wypełnienia)

Dla tej samej wyściółki:

Dla prawidłowego wypełnienia:

TensorFlow 2.0 Compatible odpowiedź: szczegółowe wyjaśnienia zostały przedstawione powyżej, dotyczące" poprawnego "i" tego samego " wypełnienia.

Będę jednak określał różne funkcje Poolingowe i ich odpowiednie polecenia w Tensorflow 2.x (>= 2.0), dla dobra społeczności.

Funkcje w 1.x :

tf.nn.max_pool

tf.keras.layers.MaxPool2D

Average Pooling => None in tf.nn, tf.keras.layers.AveragePooling2D

Funkcje w 2.x :

tf.nn.max_pool w przypadku stosowania w 2.x i tf.compat.v1.nn.max_pool_v2 lub tf.compat.v2.nn.max_pool, W przypadku migracji z 1.x do 2.x.

tf.keras.layers.MaxPool2D W przypadku stosowania w 2.x i

tf.compat.v1.keras.layers.MaxPool2D lub tf.compat.v1.keras.layers.MaxPooling2D lub tf.compat.v2.keras.layers.MaxPool2D lub tf.compat.v2.keras.layers.MaxPooling2D, W przypadku migracji z 1.x do 2.x.

Average Pooling => tf.nn.avg_pool2d lub tf.keras.layers.AveragePooling2D W przypadku stosowania w TF 2.x i

tf.compat.v1.nn.avg_pool_v2 lub tf.compat.v2.nn.avg_pool lub tf.compat.v1.keras.layers.AveragePooling2D lub tf.compat.v1.keras.layers.AvgPool2D lub tf.compat.v2.keras.layers.AveragePooling2D lub tf.compat.v2.keras.layers.AvgPool2D , W przypadku migracji od 1.x do 2.x.

Aby uzyskać więcej informacji na temat migracji z Tensorflow 1.x do 2.x, zapoznaj się z tym poradnikiem migracji .