Ich habe kürzlich Fully Convolutional Networks for Semantic Segmentation von Jonathan Long, Evan Shelhamer und Trevor Darrell gelesen. Ich verstehe nicht, was "Dekonvolutionsschichten" tun / wie sie funktionieren.

Der relevante Teil ist

3.3. Upsampling ist eine rückwärts gerichtete Faltung

Eine andere Möglichkeit, Grobausgänge mit dichten Pixeln zu verbinden, ist die Interpolation. Beispielsweise berechnet eine einfache bilineare Interpolation jede Ausgabe aus den nächsten vier Eingaben durch eine lineare Abbildung, die nur von den relativen Positionen der Eingabe- und Ausgabezellen abhängt. In gewisser Weise ist das Upsampling mit dem Faktor eine Faltung mit einem Teilschritt von 1 / f. Solange ganzzahlig ist, ist ein natürlicher Weg zum Upsampling daher die Rückwärtsfaltung (manchmal auch als Entfaltung bezeichnet) mit einem Ausgabeschritt von . Eine solche Operation ist trivial zu implementieren, da sie einfach die Vorwärts- und Rückwärtsdurchläufe der Faltung umkehrt. f f $y_{ij}$
$f$$f$$f$
Auf diese Weise wird eine Aufwärtsabtastung im Netzwerk für ein Ende-zu-Ende-Lernen durch Rückausbreitung aus dem pixelweisen Verlust durchgeführt.
Es ist zu beachten, dass das Entfaltungsfilter in einer solchen Schicht nicht fest sein muss (z. B. auf bilineares Upsampling), sondern gelernt werden kann. Ein Stapel von Entfaltungsschichten und Aktivierungsfunktionen kann sogar ein nichtlineares Upsampling lernen.
In unseren Experimenten haben wir festgestellt, dass das Upsampling im Netzwerk schnell und effektiv ist, um eine dichte Vorhersage zu erlernen. Unsere beste Segmentierungsarchitektur verwendet diese Ebenen, um zu lernen, die Vorhersage in Abschnitt 4.2 zu verfeinern.

Ich glaube nicht wirklich verstanden zu haben, wie Faltungsschichten trainiert werden.

Ich glaube, ich habe verstanden, dass Faltungsschichten mit einer Kerngröße Filter der Größe lernen . Die Ausgabe einer Faltungsschicht mit der Kernelgröße , den Schritten und Filtern hat die Dimension . Ich weiß jedoch nicht, wie das Lernen von Faltungsschichten funktioniert. (Ich verstehe, wie einfach MLPs mit Gefälle lernen, wenn das hilft).k × k k s ∈ N n $k$$k \times k$$k$$s \in \mathbb{N}$$n$$\frac{\text{Input dim}}{s^2} \cdot n$

Wenn ich die Faltungsschichten richtig verstehe, habe ich keine Ahnung, wie dies rückgängig gemacht werden kann.

Könnte mir bitte jemand helfen, die Entfaltungsschichten zu verstehen?

Deconvolution Layer ist ein sehr unglücklicher Name und sollte eher als transponierte Faltungsschicht bezeichnet werden .

Visuell wird für eine transponierte Faltung mit Schritt Eins und ohne Auffüllung lediglich die ursprüngliche Eingabe (blaue Einträge) mit Nullen (weiße Einträge) aufgefüllt (Abbildung 1).

Im Falle von Schritt zwei und Polstern würde die transponierte Faltung wie folgt aussehen (Abbildung 2):

Weitere (großartige) Visualisierungen der Faltungsarithmetik finden Sie hier .

Ich denke, eine Möglichkeit, eine wirklich grundlegende Ebene der Faltung zu erreichen, besteht darin, dass Sie K-Filter, die Sie sich als K-Schablonen vorstellen können, über das Eingabebild schieben und K-Aktivierungen erzeugen, die jeweils einen Übereinstimmungsgrad mit einer bestimmten Schablone darstellen . Die umgekehrte Operation davon würde darin bestehen, K Aktivierungen zu nehmen und sie zu einem Vorbild der Faltungsoperation zu erweitern. Die intuitive Erklärung der inversen Operation ist daher grob gesagt eine Bildrekonstruktion, wenn die Schablonen (Filter) und Aktivierungen (der Übereinstimmungsgrad für jede Schablone) gegeben sind, und daher wollen wir auf der intuitiven Grundebene jede Aktivierung durch die Schablonenmaske in die Luft jagen und addieren sie.

Eine andere Möglichkeit zum Verständnis von Deconv besteht darin, die Implementierung der Deconvolution-Schicht in Caffe zu untersuchen (siehe die folgenden relevanten Codebits):

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

Sie können sehen, dass es in Caffe genau als Backprop für eine reguläre Vorwärtsfaltungsebene implementiert ist (für mich war es offensichtlicher, nachdem ich die Implementierung von Backprop in einer cuDNN-Conv-Ebene mit der mit GEMM implementierten ConvolutionLayer :: Backward_gpu verglichen habe). Wenn Sie also durcharbeiten, wie die Rückübertragung für die regelmäßige Faltung erfolgt, werden Sie verstehen, was auf mechanischer Berechnungsebene geschieht. Die Funktionsweise dieser Berechnung entspricht der im ersten Absatz dieses Klappentextes beschriebenen Intuition.

Ich weiß jedoch nicht, wie das Lernen von Faltungsschichten funktioniert. (Ich verstehe, wie einfach MLPs mit Gefälle lernen, wenn das hilft).

Um Ihre andere Frage innerhalb Ihrer ersten Frage zu beantworten, gibt es zwei Hauptunterschiede zwischen MLP-Backpropagation (vollständig verbundene Ebene) und Faltungsnetzen:

1) Der Einfluss von Gewichten ist lokalisiert, also finden Sie zuerst heraus, wie Sie Backprop für beispielsweise einen 3x3-Filter ausführen, der mit einem kleinen 3x3-Bereich eines Eingabebilds gefaltet ist und auf einen einzelnen Punkt im Ergebnisbild abgebildet wird.

2) Die Gewichte der Faltungsfilter werden für die räumliche Invarianz geteilt. In der Praxis bedeutet dies, dass im Vorwärtsdurchlauf derselbe 3 × 3-Filter mit den gleichen Gewichten für die Vorwärtsberechnung durch das gesamte Bild mit den gleichen Gewichten gezogen wird, um das Ausgabebild (für diesen bestimmten Filter) zu erhalten. Für Backprop bedeutet dies, dass die Backprop-Verläufe für jeden Punkt im Quellbild über den gesamten Bereich summiert werden, den wir diesen Filter während des Vorwärtsdurchlaufs gezogen haben. Beachten Sie, dass es auch unterschiedliche Verlustrate von x, w und bias gibt, da dLoss / dx rückpropagiert werden muss und dLoss / dw die Aktualisierung der Gewichte ist. w und bias sind unabhängige Eingaben in der Berechnungs-DAG (es gibt keine vorherigen Eingaben), sodass für diese keine Backpropagation erforderlich ist.

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

Schritt für Schritt Mathematik, die erklärt, wie die Transponierungsfaltung das 2x-Upsampling mit 3x3-Filter und 2er-Schritten durchführt:

Das einfachste TensorFlow-Snippet zur Validierung der Mathematik:

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()

Die von Andrej Karpathy zur Stanford CS-Klasse CS231n : Convolutional Neural Networks for Visual Recognition gehörenden Notizen eignen sich hervorragend zur Erklärung von Convolutional Neural Networks.

Das Lesen dieses Dokuments soll Ihnen eine ungefähre Vorstellung geben von:

• Dekonvolutionelle Netzwerke Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor und Rob Fergus, Abteilung für Informatik, Courant Institute, New York University

Diese Folien sind für Deconvolutional Networks.

Ich habe gerade einen großartigen Artikel von der Theaon-Website zu diesem Thema gefunden [1]:

Die Notwendigkeit für transponierte Windungen ergibt sich im Allgemeinen aus dem Wunsch, eine Transformation in die entgegengesetzte Richtung einer normalen [...] Faltung zu verwenden, um Feature-Maps auf einen höherdimensionalen Raum zu projizieren. dh von einem 4-dimensionalen Raum in einen 16-dimensionalen Raum abbilden, während das Konnektivitätsmuster der Faltung beibehalten wird.

Transponierte Windungen - auch als fraktionierte Windungen bezeichnet - tauschen die Vorwärts- und Rückwärtsgänge einer Windung aus. Um es so auszudrücken: Der Kernel definiert eine Faltung, aber ob es sich um eine direkte Faltung oder eine transponierte Faltung handelt, hängt davon ab, wie die Vorwärts- und Rückwärtsdurchläufe berechnet werden.

Die transponierte Faltungsoperation kann als Gradient einer gewissen Faltung in Bezug auf ihre Eingabe angesehen werden, wie dies in der Praxis üblicherweise der Fall ist.

Schließlich ist zu beachten, dass es immer möglich ist, eine transponierte Faltung mit einer direkten Faltung zu implementieren. Der Nachteil besteht darin, dass der Eingabe normalerweise viele Spalten und Zeilen mit Nullen hinzugefügt werden, was zu einer viel weniger effizienten Implementierung führt.

Einfach ausgedrückt ist eine "transponierte Faltung" eine mathematische Operation unter Verwendung von Matrizen (genau wie eine Faltung), ist jedoch effizienter als die normale Faltungsoperation, wenn Sie von den gefalteten Werten zum Original zurückkehren möchten (entgegengesetzte Richtung). Aus diesem Grund wird in Implementierungen die Faltung bevorzugt, wenn die entgegengesetzte Richtung berechnet wird (dh um viele unnötige 0-Multiplikationen zu vermeiden, die durch die dünne Matrix verursacht werden, die aus dem Auffüllen der Eingabe resultiert).

Image ---> convolution ---> Result

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

Manchmal speichern Sie einige Werte entlang des Faltungspfads und verwenden diese Informationen beim "Zurückgehen" erneut:

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

Das ist wahrscheinlich der Grund, warum es fälschlicherweise als "Entfaltung" bezeichnet wird. Es hat jedoch etwas mit der Matrixtransponierung der Faltung (C ^ T) zu tun, daher der passendere Name "transponierte Faltung".

Daher ist es sehr sinnvoll, die Rechenkosten zu berücksichtigen. Sie würden viel mehr für Amazon GPUS bezahlen, wenn Sie die transponierte Faltung nicht verwenden würden.

Lesen und beobachten Sie die Animationen hier sorgfältig: http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#no-zero-padding-unit-strides-transposed

Einige andere relevante Lektüre:

Die Transponierte (oder allgemeiner die hermitische oder konjugierte Transponierte) eines Filters ist einfach das passende Filter [3]. Dies wird gefunden, indem der Kernel zeitlich umgekehrt und das Konjugat aller Werte genommen wird [2].

Ich bin auch neu in diesem Bereich und wäre für Feedback oder Korrekturen dankbar.

[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/Matched_filter

Wir könnten PCA für die Analogie verwenden.

Bei Verwendung von conv besteht der Vorwärtsdurchlauf darin, die Koeffizienten der Hauptkomponenten aus dem Eingabebild zu extrahieren, und der Rückwärtsdurchlauf (der die Eingabe aktualisiert) besteht darin, die Koeffizienten zu verwenden (den Gradienten von), um ein neues Eingabebild zu rekonstruieren, so dass das Das neue Eingabebild hat PC-Koeffizienten, die besser mit den gewünschten Koeffizienten übereinstimmen.

Bei Verwendung von deconv werden der Vorwärtsdurchlauf und der Rückwärtsdurchlauf umgekehrt. Der Vorwärtsdurchlauf versucht, ein Bild aus PC-Koeffizienten zu rekonstruieren, und der Rückwärtsdurchlauf aktualisiert die PC-Koeffizienten, die für das Bild (den Gradienten) angegeben sind.

Der Dekonv.-Weiterleitungsdurchlauf führt genau die in diesem Beitrag angegebene Berechnung des Konv.-Gradienten durch: http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/

Aus diesem Grund werden in der caffe-Implementierung von deconv (siehe Andrei Pokrovskys Antwort) die Aufrufe backward_cpu_gemm () für den Vorwärtsdurchlauf und forward_cpu_gemm () für den Rückwärtsdurchlauf verwendet.

Zusätzlich zu David Daos Antwort: Es ist auch möglich, anders herum zu denken. Anstatt sich darauf zu konzentrieren, welche (niedrig aufgelösten) Eingabepixel zum Erzeugen eines einzelnen Ausgabepixels verwendet werden, können Sie sich auch darauf konzentrieren, welche einzelnen Eingabepixel zu welchem ​​Bereich von Ausgabepixeln beitragen.

Dies geschieht in dieser Destillationsveröffentlichung , einschließlich einer Reihe sehr intuitiver und interaktiver Visualisierungen. Ein Vorteil des Denkens in diese Richtung ist, dass das Erklären von Schachbrettartefakten einfach wird.

Faltungen aus DSP-Sicht

Ich bin etwas spät dran, möchte aber trotzdem meine Sichtweise und Erkenntnisse teilen. Mein Hintergrund ist theoretische Physik und digitale Signalverarbeitung. Insbesondere habe ich Wavelets studiert und Faltungen befinden sich fast in meinem Rückgrat;)

Die Art und Weise, wie Menschen in der Deep Learning-Community über Faltungen sprechen, hat mich ebenfalls verwirrt. Aus meiner Sicht scheint eine richtige Trennung der Anliegen zu fehlen. Ich werde die Deep-Learning-Konvolutionen mit einigen DSP-Tools erklären.

Haftungsausschluss

Meine Erklärungen werden ein wenig handgewellt und nicht streng mathematisch sein, um die Hauptpunkte zu vermitteln.

Definitionen

$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)$$

und

$$\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$

Deep Learning Convolutions nach Teilen

$\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}$$

Wie man sieht, ist die transponierte Operation, also der Name.

Verbindung zum Nearest Neighbor Upsampling

$\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),$$

dh wir können einen wiederholten Upsampler mit Faktor 2 und eine Faltung mit einem Kernel der Größe 3 durch eine transponierte Faltung mit Kernelgröße 4 ersetzen. Diese transponierte Faltung hat die gleiche "Interpolationskapazität", könnte jedoch besser passende Interpolationen lernen.

Schlussfolgerungen und Schlussbemerkungen

Ich hoffe, ich konnte einige häufige Konvolutionen des Tiefenlernens klären, indem ich sie in die grundlegenden Operationen zerlegte.

Ich habe das Pooling hier nicht behandelt. Dies ist jedoch nur ein nichtlinearer Downsampler und kann auch in dieser Notation behandelt werden.

Ich hatte große Probleme zu verstehen, was genau in der Zeitung passiert ist, bis ich auf diesen Blog-Beitrag stieß: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -mit-tensorflow-und-tf-slim /

Hier ist eine Zusammenfassung, wie ich verstehe, was in einem 2x-Upsampling passiert:

Informationen aus Papier

• Was ist Upsampling?
  • Ein Upsampling mit dem Faktor f ist eine Faltung mit einem Teileingabeschritt von 1 / f.
  • → Fractional Strided Convolutions werden auch als transponierte Convolution bezeichnet (siehe zB http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html)
• Was sind die Parameter dieser Faltung?
  • Faktor f = 2
  • → Schrittweite von 1 / f = 1/2 eingeben
  • → Kernelgröße = 2 * Faktor - Faktor% 2 = 2 * 2 -0 = 4 gemäß http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -mit-tensorflow-und-tf-slim /
• Sind die Gewichte fest oder trainierbar?
  • In dem Artikel heißt es: "Wir initialisieren das 2x-Upsampling zur bilinearen Interpolation, lassen aber zu, dass die Parameter gelernt werden [...]".
  • Die entsprechende Github-Seite gibt jedoch an: "In unseren ursprünglichen Experimenten wurden die Interpolationsschichten auf bilineare Kernel initialisiert und dann gelernt. In Folgeexperimenten und dieser Referenzimplementierung werden die bilinearen Kernel fixiert."
  • → feste gewichte

Einfaches Beispiel

1. Stellen Sie sich folgendes Eingabebild vor:

2. Fractional Strided Convolutions arbeiten, indem Faktor-1 = 2-1 = 1 Nullen zwischen diese Werte eingefügt werden und dann später Schritt = 1 angenommen wird. So erhalten Sie das folgende 6x6 gepolsterte Bild

3. Der bilineare 4x4-Filter sieht so aus. Seine Werte werden so gewählt, dass die verwendeten Gewichte (= alle Gewichte, die nicht mit einer eingefügten Null multipliziert werden) sich zu 1 summieren. Seine drei eindeutigen Werte sind 0,56, 0,19 und 0,06. Darüber hinaus ist das Zentrum des Filters gemäß der Konvention das Pixel in der dritten Reihe und dritten Spalte.

4. Wenn Sie den 4x4-Filter auf das aufgefüllte Bild anwenden (mit padding = 'same' und stride = 1), erhalten Sie das folgende 6x6-Bild mit Überabtastung:

5. Diese Art von Upsampling wird für jeden Kanal einzeln durchgeführt (siehe Zeile 59 in https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py ). Am Ende ist das 2x-Upsampling wirklich eine sehr einfache Größenänderung mit bilinearer Interpolation und Konventionen zum Umgang mit Rändern. 16x oder 32x Upsampling funktioniert meiner Meinung nach ähnlich.

Im folgenden Artikel werden Dekonvolutionsschichten erörtert. Sowohl aus architektonischer als auch aus Ausbildungssicht. Dekonvolutionelle Netzwerke