Niedawno przeczytałem w pełni sieci konwergentne dla segmentacji semantycznej autorstwa Jonathana Longa, Evana Shelhamera, Trevora Darrella. Nie rozumiem, co robią „warstwy dekonwolucyjne” / jak działają.

Odpowiednia część to

3.3 Upsampling jest konwertowanym krokiem wstecz

Innym sposobem łączenia gruboziarnistych wyjść z gęstymi pikselami jest interpolacja. Na przykład prosta interpolacja dwuliniowa oblicza każde wyjście z najbliższych czterech danych wejściowych za pomocą mapy liniowej, która zależy tylko od względnych pozycji komórek wejściowych i wyjściowych. W pewnym sensie upsampling ze współczynnikiem jest splotem z ułamkiem wejściowym kroku 1 / f. Tak długo, jak jest całką, naturalnym sposobem na upsamplowanie jest zatem splot wsteczny (czasami nazywany dekonwolucją) z krokiem wyjściowym . Taka operacja jest trywialna do wdrożenia, ponieważ po prostu odwraca postępy splotu do przodu i do tyłu. f f $y_{ij}$
$f$$f$$f$
W ten sposób upsampling wykonywany jest w sieci w celu kompleksowego uczenia się przez propagację wsteczną po utracie pikseli.
Zauważ, że filtr dekonwolucji w takiej warstwie nie musi być ustalony (np. Do dwuliniowego upsamplingu), ale można się go nauczyć. Stos warstw dekonwolucji i funkcji aktywacyjnych może nawet nauczyć się nieliniowego próbkowania w górę.
W naszych eksperymentach okazało się, że upsampling wewnątrz sieci jest szybki i skuteczny w nauce gęstego przewidywania. Nasza najlepsza architektura segmentacji wykorzystuje te warstwy do nauki próbkowania w celu uzyskania dokładniejszych prognoz w Rozdziale 4.2.

Nie sądzę, że naprawdę zrozumiałem, w jaki sposób trenowane są warstwy splotowe.

Wydaje mi się, że zrozumiałem, że warstwy splotowe z wielkością jądra uczą się filtrów wielkości . Dane wyjściowe warstwy splotowej o rozmiarze jądra , kroku i filtrach mają wymiary . Nie wiem jednak, jak działa uczenie się warstw splotowych. (Rozumiem, jak proste MLP uczą się z opadaniem gradientu, jeśli to pomaga).k × k k s ∈ N n $k$$k \times k$$k$$s \in \mathbb{N}$$n$$\frac{\text{Input dim}}{s^2} \cdot n$

Więc jeśli moje rozumienie warstw splotowych jest prawidłowe, nie mam pojęcia, jak można to odwrócić.

Czy ktoś mógłby mi pomóc zrozumieć warstwy dekonwolucyjne?

Warstwa dekonwolucji jest bardzo niefortunną nazwą i należy ją raczej nazwać transponowaną warstwą splotową .

Wizualnie, dla transponowanego splotu z krokiem pierwszym i bez dopełniania, po prostu wypełniamy oryginalne wejście (niebieskie wpisy) zerami (białe wpisy) (Rysunek 1).

W przypadku kroku drugiego i wypełnienia transponowany splot wyglądałby tak (Ryc. 2):

Można znaleźć więcej (świetnych) wizualizacji arytmetyki splotowej tutaj .

Myślę, że jednym ze sposobów uzyskania naprawdę podstawowej intuicji na poziomie splotu jest przesuwanie filtrów K, które można traktować jak szablony K, nad obrazem wejściowym i wytwarzanie aktywacji K - każdy reprezentuje stopień dopasowania do określonego szablonu . Odwrotną operacją tego byłoby wzięcie aktywacji K i rozwinięcie ich w preimage operacji splotu. Intuicyjnym wyjaśnieniem operacji odwrotnej jest zatem z grubsza rekonstrukcja obrazu przy uwzględnieniu szablonów (filtrów) i aktywacji (stopień dopasowania dla każdego szablonu), a zatem na podstawowym poziomie intuicyjnym chcemy wysadzić każdą aktywację za pomocą maski szablonu i dodaj je.

Innym sposobem podejścia do zrozumienia deconv byłoby zbadanie implementacji warstwy dekonwolucji w Caffe, zobacz następujące odpowiednie fragmenty kodu:

DeconvolutionLayer<Dtype>::Forward_gpu
ConvolutionLayer<Dtype>::Backward_gpu
CuDNNConvolutionLayer<Dtype>::Backward_gpu
BaseConvolutionLayer<Dtype>::backward_cpu_gemm

Widać, że jest on zaimplementowany w Caffe dokładnie tak, jak backprop dla zwykłej naprzód warstwy splotowej (dla mnie było to bardziej oczywiste po tym, jak porównałem implementację backprop w warstwie cuDNN vs ConvolutionLayer :: Backward_gpu zaimplementowane przy użyciu GEMM). Jeśli więc przeanalizujesz, w jaki sposób wykonuje się propagację wsteczną dla regularnego splotu, zrozumiesz, co dzieje się na poziomie obliczeń mechanicznych. Sposób, w jaki działa to obliczenie, odpowiada intuicji opisanej w pierwszym akapicie tej notki.

Nie wiem jednak, jak działa uczenie się warstw splotowych. (Rozumiem, jak proste MLP uczą się z opadaniem gradientu, jeśli to pomaga).

Aby odpowiedzieć na inne pytanie w pierwszym pytaniu, istnieją dwie główne różnice między propagacją wsteczną MLP (warstwa w pełni połączona) a sieciami splotowymi:

1) wpływ wag jest zlokalizowany, więc najpierw wymyśl, jak zrobić backprop, powiedzmy, filtr 3x3 splątany z małym obszarem 3x3 obrazu wejściowego, odwzorowując go do pojedynczego punktu na obrazie wynikowym.

2) wagi filtrów splotowych są wspólne dla niezmienności przestrzennej. W praktyce oznacza to, że w przebiegu do przodu ten sam filtr 3x3 o tych samych wagach jest przeciągany przez cały obraz z tymi samymi wagami do obliczeń w przód w celu uzyskania obrazu wyjściowego (dla tego konkretnego filtra). Oznacza to, że gradienty wsteczne dla każdego punktu na obrazie źródłowym są sumowane w całym zakresie, który przeciągnęliśmy ten filtr podczas przejścia do przodu. Zauważ, że istnieją również różne gradienty strat wrt x, w i stronniczości, ponieważ dLoss / dx wymaga uprzedniej propagacji, a dLoss / dw to sposób, w jaki aktualizujemy wagi. w i stronniczość są niezależnymi danymi wejściowymi w obliczeniach DAG (nie ma wcześniejszych danych wejściowych), więc nie ma potrzeby przeprowadzania na nich propagacji wstecznej.

(my notation here assumes that convolution is y = x*w+b where '*' is the convolution operation)

Matematyka krok po kroku wyjaśniająca, w jaki sposób transpozycja splotu robi 2x upsampling z filtrem 3x3 i krok 2:

Najprostszy fragment kodu TensorFlow do sprawdzania poprawności matematyki:

import tensorflow as tf
import numpy as np

def test_conv2d_transpose():
    # input batch shape = (1, 2, 2, 1) -> (batch_size, height, width, channels) - 2x2x1 image in batch of 1
    x = tf.constant(np.array([[
        [[1], [2]], 
        [[3], [4]]
    ]]), tf.float32)

    # shape = (3, 3, 1, 1) -> (height, width, input_channels, output_channels) - 3x3x1 filter
    f = tf.constant(np.array([
        [[[1]], [[1]], [[1]]], 
        [[[1]], [[1]], [[1]]], 
        [[[1]], [[1]], [[1]]]
    ]), tf.float32)

    conv = tf.nn.conv2d_transpose(x, f, output_shape=(1, 4, 4, 1), strides=[1, 2, 2, 1], padding='SAME')

    with tf.Session() as session:
        result = session.run(conv)

    assert (np.array([[
        [[1.0], [1.0],  [3.0], [2.0]],
        [[1.0], [1.0],  [3.0], [2.0]],
        [[4.0], [4.0], [10.0], [6.0]],
        [[3.0], [3.0],  [7.0], [4.0]]]]) == result).all()

Te notatki, które towarzyszą Stanford CS klasy CS231n : splotowego sieci neuronowych do wizualnego rozpoznawania, Andrej Karpathy , zrobić doskonałą pracę wyjaśniając splotowych sieci neuronowych.

Czytanie tego artykułu powinno dać ci ogólny pogląd na:

• Deconvolutional Networks Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor i Rob Fergus Dept. of Computer Science, Courant Institute, New York University

Te slajdy są idealne dla sieci Deconvolutional.

Właśnie znalazłem świetny artykuł na stronie theaon na ten temat [1]:

Potrzeba transponowania zwojów zasadniczo wynika z chęci zastosowania transformacji zmierzającej w przeciwnym kierunku niż normalny splot, [...] do projekcji map obiektów do przestrzeni o wyższych wymiarach. [...] tj. odwzoruj z przestrzeni 4-wymiarowej na przestrzeń 16-wymiarową, zachowując wzór połączenia splotu.

Transponowane zwoje - zwane także zwojami ułamkowymi - działają poprzez zamianę przednich i tylnych przebiegów splotu. Jednym ze sposobów jest zwrócenie uwagi, że jądro definiuje splot, ale to, czy jest to splot bezpośredni, czy transponowany, zależy od tego, jak obliczane są przejścia do przodu i do tyłu.

Transponowaną operację splotu można traktować jako gradient jakiegoś splotu w odniesieniu do jej wkładu, co zwykle jest sposobem implementacji transponowanych splotów w praktyce.

Na koniec zauważ, że zawsze możliwe jest wdrożenie transponowanego splotu z bezpośrednim splotem. Wadą jest to, że zwykle wymaga dodania wielu kolumn i wierszy zer do danych wejściowych, co powoduje znacznie mniej wydajną implementację.

Mówiąc w skrócie, „transponowany splot” jest operacją matematyczną z wykorzystaniem macierzy (podobnie jak splot), ale jest bardziej wydajny niż normalna operacja splotu w przypadku, gdy chcesz powrócić od splotu wartości do pierwotnego (przeciwnego kierunku). Dlatego w implementacjach preferuje się splot podczas obliczania kierunku przeciwnego (tj. Aby uniknąć wielu niepotrzebnych zwielokrotnień 0 spowodowanych przez rzadką macierz wynikającą z wypełniania danych wejściowych).

Image ---> convolution ---> Result

Result ---> transposed convolution ---> "originalish Image"

Czasami zapisujesz niektóre wartości wzdłuż ścieżki splotu i ponownie używasz tych informacji podczas „powrotu”:

Result ---> transposed convolution ---> Image

To prawdopodobnie powód, dla którego błędnie nazywa się to „dekonwolucją”. Ma to jednak coś wspólnego z transponowaniem macierzy splotu (C ^ T), stąd bardziej odpowiednia nazwa „transpozycja splotu”.

Rozważanie kosztów obliczeniowych ma więc sens. Za amazon gpus zapłaciłbyś dużo więcej, gdybyś nie używał transponowanego splotu.

Przeczytaj uważnie animacje tutaj: http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#no-zero-padding-unit-strides-transposed

Kilka innych istotnych lektur:

Transpozycja (lub bardziej ogólnie transpozycja hermitowska lub sprzężona) filtra jest po prostu dopasowanym filtrem [3]. Stwierdzono to poprzez czasowe odwrócenie jądra i pobranie koniugatu wszystkich wartości [2].

Jestem również nowy w tym względzie i byłbym wdzięczny za wszelkie opinie lub poprawki.

[1] http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html

[2] http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#transposed-convolution-arithmetic

[3] https://en.wikipedia.org/wiki/Mched_filter

Przydałoby się PCA do analogii.

W przypadku korzystania z konw. Przejście do przodu służy do wyodrębnienia współczynników składników zasadowych z obrazu wejściowego, a przejście do tyłu (które aktualizuje dane wejściowe) polega na wykorzystaniu (gradientu) współczynników do odtworzenia nowego obrazu wejściowego, tak aby nowy obraz wejściowy ma współczynniki PC, które lepiej pasują do pożądanych współczynników.

Podczas używania deconv przejście do przodu i przejście do tyłu są odwrócone. Przebieg do przodu próbuje zrekonstruować obraz ze współczynników PC, a przejście do tyłu aktualizuje współczynniki PC na podstawie (gradientu) obrazu.

Przełożenie do przodu deconv wykonuje dokładnie obliczenia gradientu konwekcyjnego podane w tym poście: http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/

Właśnie dlatego w implementacji deconv w kofeinie (patrz odpowiedź Andrieja Pokrovsky'ego) przekazanie w przód deconv wywołuje backward_cpu_gemm (), a przekazywanie w tył wywołuje forward_cpu_gemm ().

Oprócz odpowiedzi Davida Dao: można również pomyśleć na odwrót. Zamiast skupiać się na tym, które piksele wejściowe (niskiej rozdzielczości) są używane do wytworzenia pojedynczego piksela wyjściowego, możesz również skupić się na tym, które poszczególne piksele wejściowe przyczyniają się do tego, który region pikseli wyjściowych.

Odbywa się to w tej destylowanej publikacji , w tym w serii bardzo intuicyjnych i interaktywnych wizualizacji. Jedną z zalet myślenia w tym kierunku jest to, że wyjaśnianie artefaktów szachownicy staje się łatwe.

Zwoje z perspektywy DSP

Trochę się spóźniłem, ale nadal chciałbym podzielić się moją perspektywą i spostrzeżeniami. Moje wykształcenie to fizyka teoretyczna i cyfrowe przetwarzanie sygnałów. W szczególności badałem falki i zwoje są prawie w moim kręgosłupie;)

Sposób, w jaki ludzie ze społeczności zajmującej się głębokim uczeniem się mówią o zwojach, również mnie dezorientował. Z mojej perspektywy wydaje się, że brakuje właściwego podziału problemów. Wyjaśnię splot głębokiego uczenia się przy użyciu niektórych narzędzi DSP.

Zrzeczenie się

Moje wyjaśnienia będą nieco faliste, a nie matematyczne rygorystyczne, aby uzyskać główne punkty.

Definicje

$x_n = \{x_n\}_{n=-\infty}^{\infty} = \{\dots, x_{-1}, x_{0}, x_{1}, \dots \}$

$y_n$$x_n$

$$(y * x)_n = \sum_{k=-\infty}^{\infty} y_{n-k} x_k$$

$\mathbf{q} = (q_0,q_1,q_2)$$\mathbf{x} = (x_0, x_1, x_2, x_3)^T$

$$\mathbf{q} * \mathbf{x} = \left( \begin{array}{cccc} q_1 & q_0 & 0 & 0 \\ q_2 & q_1 & q_0 & 0 \\ 0 & q_2 & q_1 & q_0 \\ 0 & 0 & q_2 & q_1 \\ \end{array} \right) \left( \begin{array}{cccc} x_0 \\ x_1 \\ x_2 \\ x_3 \end{array} \right)$$

$\downarrow$$\uparrow$$k \in \mathbb{N}$

$$\downarrow_k\!x_n = x_{nk}$$

$k$$k-1$

$$\uparrow_k\!x_n = \left \{ \begin{array}{ll} x_{n/k} & n/k \in \mathbb{Z} \\ 0 & \text{otherwise} \end{array} \right.$$

$k=3$

$$\downarrow_3\!\{ \dots, x_0, x_1, x_2, x_3, x_4, x_5, x_6, \dots \} = \{ \dots, x_0, x_3, x_6, \dots \}$$ $$\uparrow_3\!\{ \dots, x_0, x_1, x_2, \dots \} = \{ \dots x_0, 0, 0, x_1, 0, 0, x_2, 0, 0, \dots \}$$

$k=2$

$$\downarrow_2\!x = \left( \begin{array}{cc} x_0 \\ x_2 \end{array} \right) = \left( \begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ \end{array} \right) \left( \begin{array}{cccc} x_0 \\ x_1 \\ x_2 \\ x_3 \end{array} \right)$$

i

$$\uparrow_2\!x = \left( \begin{array}{cccc} x_0 \\ 0 \\ x_1 \\ 0 \end{array} \right) = \left( \begin{array}{cc} 1 & 0 \\ 0 & 0 \\ 0 & 1 \\ 0 & 0 \\ \end{array} \right) \left( \begin{array}{cc} x_0 \\ x_1 \end{array} \right)$$

$\uparrow_k = \downarrow_k^T$

Rozwinięcia dogłębnego uczenia się według części

$\mathbf{q}$$\mathbf{x}$

• $k$$\downarrow_k\!(\mathbf{q} * \mathbf{x})$
• $k$$(\uparrow_k\!\mathbf{q}) * \mathbf{x}$
• $k$$\mathbf{q} * (\uparrow_k\!\mathbf{x})$

$$\mathbf{q} * (\uparrow_k\!\mathbf{x}) \; = \; \mathbf{q} * (\downarrow_k^T\!\mathbf{x}) \; = \; (\uparrow_k\!(\mathbf{q}*)^T)^T\mathbf{x}$$

$(\mathbf{q}*)$$\mathbf{q}$

$$\begin{align} \mathbf{q} * (\uparrow_k\!\mathbf{x}) & = \left( \begin{array}{cccc} q_1 & q_0 & 0 & 0 \\ q_2 & q_1 & q_0 & 0 \\ 0 & q_2 & q_1 & q_0 \\ 0 & 0 & q_2 & q_1 \\ \end{array} \right) \left( \begin{array}{cc} 1 & 0 \\ 0 & 0 \\ 0 & 1 \\ 0 & 0 \\ \end{array} \right) \left( \begin{array}{c} x_0\\ x_1\\ \end{array} \right) \\ & = \left( \begin{array}{cccc} q_1 & q_2 & 0 & 0 \\ q_0 & q_1 & q_2 & 0 \\ 0 & q_0 & q_1 & q_2 \\ 0 & 0 & q_0 & q_1 \\ \end{array} \right)^T \left( \begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 0 & 1 & 0\\ \end{array} \right)^T \left( \begin{array}{c} x_0\\ x_1\\ \end{array} \right) \\ & = \left( \left( \begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 0 & 1 & 0\\ \end{array} \right) \left( \begin{array}{cccc} q_1 & q_2 & 0 & 0 \\ q_0 & q_1 & q_2 & 0 \\ 0 & q_0 & q_1 & q_2 \\ 0 & 0 & q_0 & q_1 \\ \end{array} \right) \right)^T \left( \begin{array}{c} x_0\\ x_1\\ \end{array} \right) \\ & = (\uparrow_k\!(\mathbf{q}*)^T)^T\mathbf{x} \end{align}$$

Jak widać, transponowana jest operacja, stąd nazwa.

Połączenie z próbkowaniem do najbliższego sąsiada

$\uparrow_2\!(1\;1) * \mathbf{x}$$\mathbf{q}$$\uparrow_2\!(1\;1) * \mathbf{q} * \mathbf{x}$$\mathbf{q}=(q_0\;q_1\;q_2)$

$$(1\;1) * \mathbf{q} = (q_0\;\;q_0\!\!+\!q_1\;\;q_1\!\!+\!q_2\;\;q_2),$$

tzn. możemy zastąpić powtarzający się upsampler współczynnikiem 2 i splot jądrem o rozmiarze 3 transponowanym splotem o rozmiarze jądra 4. Ten transponowany splot ma tę samą „zdolność interpolacji”, ale byłby w stanie nauczyć się lepiej dopasowanych interpolacji.

Wnioski i uwagi końcowe

Mam nadzieję, że uda mi się wyjaśnić niektóre powszechne sploty, które można znaleźć w głębokim uczeniu się, dzieląc je na części w podstawowych operacjach.

Nie omawiałem tu basenów. Jest to jednak nieliniowy próbnik próbkujący w dół i można go również traktować w ramach tej notacji.

Miałem wiele problemów ze zrozumieniem, co dokładnie wydarzyło się w gazecie, dopóki nie natknąłem się na ten post na blogu: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -z -tensorflow-and-tf-slim /

Oto podsumowanie tego, jak rozumiem, co dzieje się w 2x próbkowaniu w górę:

Informacje z papieru

• Co to jest upsampling?
  • „próbkowanie w górę ze współczynnikiem f to splot z ułamkiem wejściowym 1 / f”
  • → ułamkowe kroki zwijane są również znane jako transponowanie transponowane, np. Http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html
• Jakie są parametry tego splotu?
  • współczynnik f = 2
  • → wejście krok 1 / f = 1/2
  • → rozmiar jądra = 2 * współczynnik - współczynnik% 2 = 2 * 2 -0 = 4 zgodnie z http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -z -tensorflow-and-tf-slim /
• Czy odważniki są stałe, czy można je trenować?
  • Artykuł stwierdza: „inicjalizujemy 2x upsampling do interpolacji dwuliniowej, ale pozwalamy na naukę parametrów [...]”.
  • Jednak odpowiednia strona github stwierdza: „W naszych oryginalnych eksperymentach warstwy interpolacji zostały zainicjowane na dwuliniowe jądra, a następnie wyuczone. W eksperymentach następczych i tej implementacji referencyjnej dwuliniowe jądra są naprawione”
  • → ustalone ciężary

Prosty przykład

1. wyobraź sobie następujący obraz wejściowy:

2. Frakcje ułożone krokowo działają poprzez wstawienie współczynnika-1 = 2-1 = 1 zera między tymi wartościami, a następnie przyjęcie kroku = 1 później. W ten sposób otrzymujesz następujący wyściełany obraz 6x6

3. Dwuliniowy filtr 4x4 wygląda następująco. Jego wartości dobiera się w taki sposób, aby użyte masy (= wszystkie masy nie pomnożone przez wstawione zero) sumowały się do 1. Jego trzy unikalne wartości to 0,56, 0,19 i 0,06. Co więcej, środek filtra to zgodnie z konwencją piksel w trzecim rzędzie i trzeciej kolumnie.

4. Zastosowanie filtru 4x4 na wyściełanym obrazie (używając padding = „same” i stride = 1) daje następujący obraz próbkowany w górę 6x6:

5. Ten rodzaj próbkowania w górę jest wykonywany dla każdego kanału osobno (patrz wiersz 59 w https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py ). Na koniec, 2x upsampling to naprawdę bardzo prosta zmiana rozmiaru przy użyciu interpolacji dwuliniowej i konwencji dotyczących obsługi granic. Uważam, że upsampling 16x lub 32x działa w podobny sposób.

Poniższy artykuł omawia warstwy dekonwolucyjne, zarówno z punktu widzenia architektury, jak i szkolenia. Sieci dekonwolucyjne