Jaka jest różnica między wypełnieniem „SAME” i „WAŻNE” w tf.nn.max_pool przepływu tensorflow?

Jaka jest różnica między „sam” i „skuteczne” w wyściółką tf.nn.max_poolz tensorflow?

Moim zdaniem „WAŻNE” oznacza, że ​​nie będzie zerowania na krawędziach, gdy wykonamy maksymalną pulę.

Według Przewodnika po arytmetyki splotowej dla głębokiego uczenia się , mówi, że operator puli nie będzie wypełniał, tj. Po prostu użyje „WAŻNE” z tensorflow. Ale w czym jest wypełnienie „SAME” maksymalnej puli tensorflow?

Podam przykład, aby wyjaśnić:

• x: obraz wejściowy o kształcie [2, 3], 1 kanał
• valid_pad: maksymalna pula z jądrem 2x2, krok 2 i WAŻNE wypełnienie.
• same_pad: maksymalna pula z jądrem 2x2, stride 2 i SAME wypełnienie (jest to klasyczny sposób)

Kształty wyjściowe to:

• valid_pad: tutaj, bez dopełnienia, więc kształt wyjściowy to [1, 1]
• same_pad: tutaj dopełniamy obraz do kształtu [2, 4] (za pomocą, -infa następnie stosujemy maksymalną pulę), więc kształt wyjściowy to [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.]

Jeśli lubisz sztukę ascii:

• "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:

• Szerokość wejściowa = 13
• Szerokość filtra = 6
• Krok = 5

Uwagi:

• "VALID" tylko upuszcza kolumny najbardziej po prawej (lub wiersze o najniższej pozycji).
• "SAME" próbuje przesunąć równomiernie po lewej i prawej stronie, ale jeśli liczba dodawanych kolumn jest nieparzysta, doda dodatkową kolumnę po prawej stronie, jak ma to miejsce w tym przykładzie (ta sama logika obowiązuje w pionie: może być dodatkowy wiersz zer na dole).

Edytuj :

O nazwie:

• W przypadku "SAME"paddingu, jeśli użyjesz kroku 1, wyjścia warstwy będą miały takie same wymiary przestrzenne jak jej wejścia.
• W przypadku "VALID"paddingu nie ma „gotowych” wkładek padding. Warstwa wykorzystuje tylko prawidłowe dane wejściowe.

Kiedy stridejest 1 (bardziej typowy dla splotu niż łączenia), możemy pomyśleć o następującym rozróżnieniu:

• "SAME": rozmiar wyjściowy jest taki sam jak rozmiar wejściowy. Wymaga to, aby okno filtra wyślizgnęło się poza mapę wprowadzania, stąd potrzeba wypełnienia.
• "VALID": Okno filtru pozostaje w prawidłowej pozycji na mapie wejściowej, więc rozmiar wyjściowy zmniejsza się o filter_size - 1. Nie występuje padding.

Przykład TensorFlow Convolution zawiera przegląd różnic między SAMEi VALID:

• W przypadku SAMEwypełnienia 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

• W przypadku VALIDwypełnienia wysokość i szerokość wyjściowa 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]))
  

Wypełnianie to operacja polegająca na zwiększeniu rozmiaru danych wejściowych. W przypadku danych 1-wymiarowych po prostu dodajesz / dodajesz tablicę ze stałą, w 2-dim otaczasz macierz tymi stałymi. W n-dim otaczasz hipersześcian n-dim stałą. W większości przypadków stała ta wynosi zero i nazywa się ją wypełnianiem zerowym.

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

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

• WAŻNE wypełnienie . Najłatwiejszy przypadek oznacza brak wyściółki. Po prostu zostaw swoje dane takie same.
• SAME wypełnienie czasami nazywane wypełnieniem POŁOWY . Nazywa się to SAMO, ponieważ dla splotu z krokiem = 1 (lub w puli) powinien generować dane wyjściowe tego samego rozmiaru co dane wejściowe. Nazywa się to PÓŁ, ponieważ dla jądra wielkościk
• WYPEŁNIENIE to maksymalne wypełnienie, które nie powoduje splotu tylko wyściełanych elementów. W przypadku jądra wielkości kta wypełnienie jest równa k - 1.

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

Szybkie wyjaśnienie

VALID: Nie stosuj żadnego dopełnienia, tzn. Załóż, że wszystkie wymiary są prawidłowe, aby obraz wejściowy był w pełni objęty przez filtr i krok określony przez Ciebie.

SAME: Zastosuj dopełnienie do danych wejściowych (w razie potrzeby), aby obraz wejściowy został w pełni pokryty przez określony filtr i krok. W kroku 1 zapewni to, że rozmiar obrazu wyjściowego będzie taki sam jak na wejściu.

Notatki

• Dotyczy to zarówno warstw konwekcyjnych, jak i maksymalnych warstw puli
• Termin „ważny” jest trochę mylący, ponieważ rzeczy nie stają się „nieprawidłowe”, jeśli upuścisz część obrazu. Czasem możesz tego chcieć. Powinno to prawdopodobnie zostać wywołane NO_PADDING.
• Termin „ten sam” jest również mylący, ponieważ ma sens tylko dla kroku 1, gdy wymiar wyjściowy jest taki sam jak wymiar wejściowy. Na przykład dla kroku 2 wymiary wyjściowe będą na przykład o połowę mniejsze. Powinno to prawdopodobnie zostać wywołane AUTO_PADDING.
• W SAME(tj. W trybie automatycznego padu) Tensorflow będzie próbował równomiernie rozłożyć wypełnienie zarówno po lewej, jak i po prawej stronie.
• W VALID(tj. Bez trybu wypełniania), Tensorflow spadnie w prawo i / lub dolne komórki, jeśli twój filtr i krok nie pokrywają w pełni obrazu wejściowego.

Cytuję tę odpowiedź z oficjalnych dokumentów tensorflow https://www.tensorflow.org/api_guides/python/nn#Convolution W przypadku wypełnienia „SAME” 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]))

a wypełnienie u góry i po lewej stronie jest 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

W przypadku wypełnienia „WAŻNE” wysokość i szerokość wyjściowa 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]))

a wartości wypełnienia są zawsze równe zero.

Istnieją trzy opcje wypełnienia: prawidłowe (bez wypełnienia), takie same (lub pół), pełne. Wyjaśnienia (w Theano) znajdziesz tutaj: http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html

• Prawidłowe wypełnienie lub brak:

Prawidłowe wypełnienie nie obejmuje wypełniania zerami, więc obejmuje tylko prawidłowe dane wejściowe, nie licząc sztucznie wygenerowanych zer. Długość wyjścia wynosi ((długość wejścia) - (k-1)) dla rozmiaru jądra k, jeśli krok s = 1.

• Ta sama lub połowa wypełnienia:

To samo wypełnienie sprawia, że ​​wielkość wyjściowa jest taka sama jak wielkość wejściowa, gdy s = 1. Jeśli s = 1, liczba zerowanych dopełnień wynosi (k-1).

• Pełne wypełnienie:

Pełne wypełnienie oznacza, że ​​jądro przebiega przez wszystkie dane wejściowe, więc na końcach jądro może spełniać tylko jedno wejście, a pozostałe zero. Liczba dopełnianych zer wynosi 2 (k-1), jeśli s = 1. Długość wyjścia wynosi ((długość wejścia) + (k-1)), jeżeli s = 1.

Dlatego liczba wypełnień: (ważna) <= (ta sama) <= (pełna)

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

VALID:Bez wyściółki. Operacje zwojowe itp. Są wykonywane tylko w miejscach, które są „ważne”, tj. Niezbyt blisko granic tensora.
Z jądrem 3x3 i obrazem 10x10, wykonałbyś splot na obszarze 8x8 wewnątrz granic.

SAME:Wypełnienie jest zapewnione. Ilekroć twoja operacja odwołuje się do sąsiedztwa (bez względu na to, jak duże), wartości zerowe są podawane, gdy sąsiedztwo wystaje poza pierwotny tensor, aby umożliwić tej operacji działanie również na wartościach granicznych.
Z jądrem 3x3 i obrazem 10x10 wykonujesz splot na pełnym obszarze 10x10.

WAŻNE wypełnienie: jest to wypełnienie zerowe. 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)

SAME wypełnienie: Jest to trochę trudne do zrozumienia w pierwszej kolejności, ponieważ musimy rozważyć dwa warunki oddzielnie, jak wspomniano w oficjalnych dokumentach .

Weźmy dane wejściowe jako , dane wyjściowe jako , wypełnienie jako , krok jako i rozmiar jądra jako (rozważany jest tylko jeden wymiar)

Przypadek 01 :

Przypadek 02 :

oblicza się w taki sposób, aby minimalną wartość, jaką można przyjąć dla wypełnienia. Ponieważ wartość jest znana, wartość można znaleźć za pomocą tego wzoru .

Opracujmy 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). Następnie, jeśli zostanie przyjęty kierunek poziomy (3):

Jeśli zostanie wybrany kierunek pionowy (4):

Mam nadzieję, że pomoże to zrozumieć, w jaki sposób SAME wypełnienie działa w TF.

W oparciu o wyjaśnienie tutaj i po odpowiedzi Tristana zwykle używam tych szybkich funkcji do sprawdzania 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')

Podsumowując, „prawidłowe” wypełnienie oznacza brak wypełnienia. Rozmiar wyjściowy warstwy splotowej kurczy się w zależności od rozmiaru wejściowego i rozmiaru jądra.

Przeciwnie, „to samo” wypełnienie oznacza użycie wypełnienia. Gdy krok jest ustawiony na 1, rozmiar wyjściowy warstwy splotowej zachowuje się jak rozmiar wejściowy, dodając pewną liczbę „granicy 0” wokół danych wejściowych podczas obliczania splotu.

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

Tutaj W i H oznaczają szerokość i wysokość wejścia, F to wymiary filtra, P to rozmiar wypełnienia (tj. Liczba wierszy lub kolumn do wypełnienia)

W przypadku SAMEGO wypełnienia:

W przypadku ważnego wypełnienia:

Uzupełniając świetną odpowiedź YvesgereY, ta wizualizacja okazała się niezwykle pomocna:

Padding „ valid ” to pierwsza cyfra. Okno filtru pozostaje wewnątrz obrazu.

Padding „ same ” to trzecia cyfra. Dane wyjściowe są tego samego rozmiaru.

Znalazłem to w tym artykule .

Odpowiedź zgodna z Tensorflow 2.0 : powyżej podano szczegółowe objaśnienia dotyczące „Ważnego” i „tego samego” wypełnienia.

Jednak Tensorflow 2.x (>= 2.0)z korzyścią dla społeczności określę różne funkcje łączenia i ich odpowiednie polecenia .

Funkcje w 1.x :

tf.nn.max_pool

tf.keras.layers.MaxPool2D

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

Funkcje w wersji 2.x :

tf.nn.max_pooljeśli jest używany w wersji 2.x i tf.compat.v1.nn.max_pool_v2lub tf.compat.v2.nn.max_pool, jeśli migrowany z wersji 1.x do wersji 2.x.

tf.keras.layers.MaxPool2D jeśli używany w 2.xi

tf.compat.v1.keras.layers.MaxPool2Dlub tf.compat.v1.keras.layers.MaxPooling2Dlub tf.compat.v2.keras.layers.MaxPool2Dlub tf.compat.v2.keras.layers.MaxPooling2D, w przypadku migracji z wersji 1.x do wersji 2.x.

Average Pooling => tf.nn.avg_pool2dlub tf.keras.layers.AveragePooling2Djeśli jest używany w TF 2.x i

tf.compat.v1.nn.avg_pool_v2lub tf.compat.v2.nn.avg_poollub tf.compat.v1.keras.layers.AveragePooling2Dlub tf.compat.v1.keras.layers.AvgPool2Dlub tf.compat.v2.keras.layers.AveragePooling2Dlub tf.compat.v2.keras.layers.AvgPool2D, w przypadku migracji z wersji 1.x do wersji 2.x.

Więcej informacji na temat migracji z Tensorflow 1.x do 2.x można znaleźć w niniejszym przewodniku migracji .