Недавно я прочитал « Полностью сверточные сети для семантической сегментации » Джонатана Лонга, Эвана Шелхамера, Тревора Даррелла. Я не понимаю, что делают "деконволюционные слои" / как они работают.

Соответствующая часть

3.3. Апсэмплинг - обратная свертка

Другим способом подключения грубых выходов к плотным пикселям является интерполяция. Например, простая билинейная интерполяция вычисляет каждый выход $y_{ij}$ из ближайших четырех входов по линейной карте, которая зависит только от относительных положений входных и выходных ячеек.
В некотором смысле повышение частоты дискретизации с коэффициентом $f$ является сверткой с дробным шагом ввода 1 / f. До тех пор, пока целочисленный, естественным способом повышения частоты является обратная свертка (иногда называемая деконволюцией) с выходным шагом . Такая операция тривиальна для реализации, так как она просто меняет прямой и обратный проходы свертки.$f$$f$
Таким образом, повышающая дискретизация выполняется в сети для сквозного обучения путем обратного распространения по пиксельным потерям.
Обратите внимание, что фильтр деконволюции в таком слое не нужно фиксировать (например, для билинейного повышения дискретизации), но можно изучить. Стек деконволюционных слоев и функций активации может даже изучить нелинейную повышающую дискретизацию.
В наших экспериментах мы обнаружили, что повышение частоты дискретизации в сети является быстрым и эффективным для обучения плотному прогнозированию. Наша лучшая архитектура сегментации использует эти уровни, чтобы научиться подбирать более точные прогнозы в Разделе 4.2.

Я не думаю, что я действительно понял, как обучают сверточные слои.

Я думаю, что я понял, что сверточные слои с размером ядра изучают фильтры размером . Выход сверточного слоя с размером ядра , шагом и n фильтров имеет размерность Input dimk × k k s ∈ $k$$k \times k$$k$$s \in \mathbb{N}$$n$. Однако я не знаю, как работает изучение сверточных слоев. (Я понимаю, как простые MLPs учатся с градиентным спуском, если это помогает).$\frac{\text{Input dim}}{s^2} \cdot n$

Поэтому, если мое понимание сверточных слоев правильное, я понятия не имею, как это можно изменить.

Кто-нибудь может помочь мне понять деконволюционные слои?

Деконволюционный слой - очень неудачное имя, и его лучше назвать транспонированным сверточным слоем .

Визуально, для транспонированной свертки с шагом один и без заполнения, мы просто заполняем исходный ввод (синие записи) нулями (белые записи) (рисунок 1).

В случае второго шага и отступа транспонированная свертка будет выглядеть следующим образом (рисунок 2):

Вы можете найти больше (отличных) визуализаций сверточной арифметики здесь .

Я думаю, что один из способов получить действительно базовую интуицию на уровне свертки состоит в том, что вы перемещаете K-фильтры, которые вы можете рассматривать как K-трафареты, по входному изображению и производите K-активаций - каждый из которых представляет степень соответствия с конкретным трафаретом. , Обратной операцией этого было бы взять K активаций и превратить их в прообраз операции свертки. Таким образом, интуитивное объяснение обратной операции - это, примерно, реконструкция изображения с учетом трафаретов (фильтров) и активаций (степень соответствия для каждого трафарета), и поэтому на базовом интуитивном уровне мы хотим взорвать каждую активацию маской трафарета. и сложите их.

Другой способ приблизиться к пониманию deconv - изучить реализацию уровня деконволюции в Caffe, см. Следующие важные фрагменты кода:

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

Вы можете видеть, что он реализован в Caffe точно так же, как backprop для обычного прямого сверточного уровня (для меня это было более очевидно после того, как я сравнил реализацию backprop в cuDNN conv layer против ConvolutionLayer :: Backward_gpu, реализованной с использованием GEMM). Поэтому, если вы поработаете над тем, как выполняется обратное распространение для регулярной свертки, вы поймете, что происходит на уровне механических вычислений. Способ, которым это вычисление работает, соответствует интуиции, описанной в первом параграфе этого объявления.

Однако я не знаю, как работает изучение сверточных слоев. (Я понимаю, как простые MLPs учатся с градиентным спуском, если это помогает).

Чтобы ответить на ваш второй вопрос в вашем первом вопросе, есть два основных различия между обратным распространением MLP (полностью связанный слой) и сверточными сетями:

1) влияние весов локализовано, поэтому сначала выясните, как сделать backprop для, скажем, фильтра 3x3, свернутого с небольшой областью 3x3 входного изображения, сопоставляя его с одной точкой в ​​результирующем изображении.

2) веса сверточных фильтров являются общими для пространственной инвариантности. На практике это означает, что при прямом проходе один и тот же фильтр 3x3 с одинаковыми весами перетаскивается по всему изображению с одинаковыми весами для прямого вычисления для получения выходного изображения (для этого конкретного фильтра). Для backprop это означает, что градиенты backprop для каждой точки исходного изображения суммируются по всему диапазону, который мы перетаскивали на этом фильтре во время прямого прохода. Обратите внимание, что существуют также разные градиенты потерь по x, w и смещению, поскольку dLoss / dx необходимо распространять в обратном направлении, а dLoss / dw - это то, как мы обновляем весы. w и bias являются независимыми входами в расчетной DAG (предварительных входов нет), поэтому нет необходимости выполнять обратное распространение на них.

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

Пошаговая математика, объясняющая, как транспонированная свертка выполняет 2-кратную повышающую дискретизацию с фильтром 3x3 и шагом 2:

Простейший фрагмент TensorFlow для проверки математики:

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

В примечания , которые сопровождают Stanford CS класса CS231n : сверточные нейронные сети для визуального распознавания, Андрей Karpathy , делает отличную работу по объяснению сверточных нейронных сетей.

Чтение этого документа должно дать вам общее представление о:

• Деконволюционные сети Мэтью Д. Зейлер, Дилип Кришнан, Грэм У. Тейлор и Роб Фергус, факультет компьютерных наук, Институт Куранта, Нью-Йоркский университет

Эти слайды отлично подходят для деконволюционных сетей.

Только что нашел отличную статью на сайте theaon на эту тему [1]:

Необходимость в транспонированных свертках обычно возникает из-за желания использовать преобразование, идущее в направлении, противоположном нормальной [...] свертке, для проецирования карт признаков в пространство более высокого измерения. [...] то есть, карта из 4-мерного пространства в 16-мерное пространство, сохраняя при этом схему связности свертки.

Транспонированные извилины - также называемые извилинами с дробным шагом - работают, меняя передний и задний проходы свертки. Один из способов выразить это - отметить, что ядро ​​определяет свертку, но то, является ли это прямой сверткой или транспонированной сверткой, определяется тем, как вычисляются прямой и обратный проходы.

Операция транспонированной свертки может рассматриваться как градиент некоторой свертки по отношению к ее вводу, что обычно является тем, как транспонированные свертки реализуются на практике.

В заключение отметим, что всегда можно реализовать транспонированную свертку с прямой сверткой. Недостатком является то, что обычно к входу добавляется множество столбцов и строк с нулями, что приводит к гораздо менее эффективной реализации.

Таким образом, в простом выражении «транспонированная свертка» является математической операцией с использованием матриц (точно так же как свертка), но она более эффективна, чем обычная операция свертки, в случае, когда вы хотите вернуться от свернутых значений к исходным (противоположное направление). Вот почему в реализациях предпочтительнее свертки при вычислении противоположного направления (то есть, чтобы избежать многих ненужных 0 умножений, вызванных разреженной матрицей, которая получается в результате заполнения ввода).

Image ---> convolution ---> Result

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

Иногда вы сохраняете некоторые значения по пути свертки и повторно используете эту информацию при «возврате»:

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

Это, вероятно, причина, почему это неправильно называют "деконволюцией". Однако это как-то связано с транспонированием матрицы свертки (C ^ T), отсюда и более подходящее название «транспонированная свертка».

Так что это имеет большой смысл при рассмотрении стоимости вычислений. Вы бы заплатили намного больше за Amazon Gpus, если бы не использовали транспонированную свертку.

Внимательно прочитайте и посмотрите анимацию: http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#no-zero-padding-unit-strides-transposed

Некоторые другие соответствующие чтения:

Транспонирование (или, в более общем случае, эрмитово или сопряженное транспонирование) фильтра - это просто согласованный фильтр [3]. Это обнаруживается путём обращения ядра к времени и получения сопряжённости всех значений [2].

Я также новичок в этом и был бы благодарен за любые отзывы или исправления.

[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

Мы могли бы использовать PCA для аналогии.

При использовании conv прямой проход должен извлечь коэффициенты основных компонентов из входного изображения, а обратный проход (который обновляет входные данные) должен использовать (градиент) коэффициентов для восстановления нового входного изображения, так что Новое входное изображение имеет коэффициенты ПК, которые лучше соответствуют желаемым коэффициентам.

При использовании deconv прямой проход и обратный проход меняются местами. Прямой проход пытается восстановить изображение из коэффициентов ПК, а обратный проход обновляет коэффициенты ПК, заданные (градиент) изображения.

Прямой проход deconv выполняет в точности вычисление градиента извилины, приведенное в этом посте: http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/

Вот почему в caffe-реализации deconv (см. Ответ Андрея Покровского) прямая передача deconv вызывает backward_cpu_gemm (), а обратная передача вызывает forward_cpu_gemm ().

В дополнение к ответу Дэвида Дао: можно также думать иначе. Вместо того, чтобы фокусироваться на том, какие входные пиксели (с низким разрешением) используются для создания одного выходного пикселя, вы также можете сосредоточиться на том, какие отдельные входные пиксели вносят вклад в какую область выходных пикселей.

Это сделано в этой публикации , включая серию очень интуитивных и интерактивных визуализаций. Одним из преимуществ размышлений в этом направлении является то, что объяснение артефактов шахматной доски становится легким.

Свертки с точки зрения DSP

Я немного опоздал на это, но все же хотел бы поделиться своими взглядами и идеями. Я занимаюсь теоретической физикой и цифровой обработкой сигналов. В частности я изучал вейвлеты и свертки почти у меня в позвоночнике;)

То, как люди в сообществе глубокого обучения говорят о свертках, меня также смущало. С моей точки зрения, что, кажется, не хватает, это правильное разделение интересов. Я объясню глубокие свертки обучения, используя некоторые инструменты DSP.

отказ

Мои объяснения будут немного волнистыми и не математически строгими, чтобы объяснить основные моменты.

Определения

Давайте сначала определим несколько вещей. Я ограничиваю свое обсуждение одним измерением (расширение до большего измерения является прямым) бесконечными (так что нам не нужно возиться с границами) последовательностей $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)$$

а также

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

Глубокие учебные свертки по частям

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

Как видно, это транспонированная операция, то есть имя.

Подключение к ближайшему соседу

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

то есть мы можем заменить повторную повышающую дискретизацию с коэффициентом 2 и свертку с ядром размером 3 на транспонированную свертку с размером ядра 4. Эта транспонированная свертка обладает той же «пропускной способностью интерполяции», но могла бы выучить лучше сопоставляемые интерполяции.

Выводы и заключительные замечания

Я надеюсь, что смогу немного прояснить некоторые общие извилины, обнаруженные в глубоком обучении, разобрав их в основных операциях.

Я не покрывал объединение здесь. Но это просто нелинейный понижающий дискретизатор, и его можно рассматривать и в этой записи.

Мне было очень трудно понять, что именно произошло в газете, пока я не наткнулся на это сообщение в блоге: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -с-tensorflow-и-тс-тонкий /

Вот краткое изложение того, как я понимаю, что происходит при 2-кратном повышении частоты дискретизации:

Информация из бумаги

• Что такое повышение частоты дискретизации?
  • "повышающая дискретизация с коэффициентом f является сверткой с дробным входным шагом 1 / f"
  • → дробно свернутые извилины также известны как транспонированная извилина согласно, например, http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html
• Каковы параметры этой свертки?
  • коэффициент f = 2
  • → шаг ввода 1 / f = 1/2
  • → размер ядра = 2 * фактор - коэффициент% 2 = 2 * 2 -0 = 4 согласно http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -с-tensorflow-и-тс-тонкий /
• Вес фиксирован или готов к тренировке?
  • В документе говорится: «мы инициализируем 2-кратную повышающую дискретизацию до билинейной интерполяции, но разрешаем изучение параметров [...]».
  • Тем не менее, соответствующая страница github гласит: «В наших оригинальных экспериментах интерполяционные слои были инициализированы для билинейных ядер, а затем изучены. В последующих экспериментах и ​​в этой эталонной реализации билинейные ядра фиксированы»
  • → фиксированные веса

Простой пример

1. представьте следующее входное изображение:

2. Дробно свернутые свертки работают, вставляя коэффициенты-1 = 2-1 = 1 нули между этими значениями, а затем допуская шаг = 1 позже. Таким образом, вы получите следующее 6x6 дополненное изображение

3. Билинейный фильтр 4х4 выглядит следующим образом. Его значения выбираются таким образом, чтобы используемые веса (= все веса, не умноженные на вставленный ноль) суммировались до 1. Его три уникальных значения: 0,56, 0,19 и 0,06. Кроме того, центр фильтра по общему правилу - пиксель в третьей строке и третьем столбце.

4. Применение фильтра 4x4 к дополненному изображению (используя padding = 'same' и stride = 1) дает следующее изображение с повышенной дискретизацией 6x6:

5. Этот вид повышающей дискретизации выполняется для каждого канала индивидуально (см. Строку 59 в https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py ). В итоге, 2-кратное повышение частоты дискретизации - это действительно очень простое изменение размера с использованием билинейной интерполяции и соглашений о том, как обрабатывать границы. Я полагаю, что повышение частоты дискретизации 16x или 32x работает примерно так же.

Следующая статья обсуждает деконволюционные слои. Оба с архитектурной и обучающей точки зрения. Деконволюционные сети