Saya baru-baru ini membaca Jaringan Konvolusional Sepenuhnya untuk Segmentasi Semantik oleh Jonathan Long, Evan Shelhamer, Trevor Darrell. Saya tidak mengerti apa yang dilakukan "lapisan dekonvolusional" / cara kerjanya.

Bagian yang relevan adalah

3.3. Upsampling adalah belokan terbalik ke belakang

Cara lain untuk menghubungkan output kasar ke piksel padat adalah interpolasi. Misalnya, sederhana interpolasi bilinear menghitung setiap output dari empat input terdekat dengan peta linear yang hanya bergantung pada posisi relatif dari sel input dan output. Dalam arti tertentu, upampling dengan faktor f berbelit-belit dengan langkah input fraksional 1 / f. Selama f merupakan bagian integral, maka cara alami untuk melakukan upample adalah konvolusi mundur (kadang-kadang disebut dekonvolusi) dengan langkah keluaran f . Operasi semacam itu sepele untuk dilaksanakan, karena hanya membalikkan lintasan ke depan dan ke belakang dari belokan.$y_{ij}$
$f$$f$$f$
Dengan demikian upampling dilakukan dalam jaringan untuk pembelajaran ujung ke ujung dengan backpropagation dari hilangnya pixelwise.
Perhatikan bahwa filter dekonvolusi pada lapisan seperti itu tidak perlu diperbaiki (misalnya, untuk bilinear upampling), tetapi dapat dipelajari. Tumpukan lapisan dekonvolusi dan fungsi aktivasi bahkan dapat mempelajari upliner nonlinear.
Dalam percobaan kami, kami menemukan bahwa upampling dalam jaringan cepat dan efektif untuk mempelajari prediksi yang padat. Arsitektur segmentasi terbaik kami menggunakan lapisan-lapisan ini untuk mempelajari upample untuk prediksi yang lebih baik di Bagian 4.2.

Saya tidak berpikir saya benar-benar mengerti bagaimana lapisan convolutional dilatih.

Apa yang saya pikir saya mengerti adalah bahwa lapisan konvolusional dengan ukuran kernel belajar filter dengan ukuran k × k . Output dari lapisan konvolusional dengan ukuran kernel k , filter s ∈ N dan n berukuran dimensi $k$$k \times k$$k$$s \in \mathbb{N}$$n$. Namun, saya tidak tahu bagaimana cara kerja lapisan konvolusional. (Saya mengerti bagaimana MLP sederhana belajar dengan gradient descent, jika itu membantu).$\frac{\text{Input dim}}{s^2} \cdot n$

Jadi, jika pemahaman saya tentang lapisan konvolusional benar, saya tidak tahu bagaimana ini dapat dibalik.

Adakah yang bisa membantu saya memahami lapisan dekonvolusional?

Lapisan dekonvolusi adalah nama yang sangat disayangkan dan lebih baik disebut lapisan konvolusional transpos .

Secara visual, untuk konvolusi yang dialihkan dengan langkah satu dan tanpa pelapis, kami hanya mengisi input asli (entri biru) dengan nol (entri putih) (Gambar 1).

Dalam hal langkah kedua dan padding, konvolusi yang berubah akan terlihat seperti ini (Gambar 2):

Anda dapat menemukan lebih banyak visualisasi aritmatika konvolusional (hebat) di sini .

Saya pikir salah satu cara untuk mendapatkan intuisi tingkat yang benar-benar dasar di balik konvolusi adalah bahwa Anda menggeser filter K, yang dapat Anda anggap sebagai stensil K, pada gambar input dan menghasilkan aktivasi K - masing-masing mewakili tingkat kecocokan dengan stensil tertentu . Operasi terbalik dari itu adalah untuk mengambil aktivasi K dan memperluasnya menjadi preimage operasi konvolusi. Penjelasan intuitif dari operasi terbalik karena itu, kira-kira, rekonstruksi gambar diberikan stensil (filter) dan aktivasi (tingkat kecocokan untuk setiap stensil) dan oleh karena itu pada tingkat intuitif dasar kami ingin meledakkan setiap aktivasi oleh topeng stensil dan menambahkannya.

Cara lain untuk mendekati pemahaman dekon adalah dengan memeriksa implementasi lapisan dekonvolusi dalam Caffe, lihat bit kode yang relevan berikut ini:

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

Anda dapat melihat bahwa itu diterapkan di Caffe persis seperti backprop untuk lapisan konvolusional maju biasa (bagi saya itu lebih jelas setelah saya membandingkan implementasi backprop di lapisan cuDNN vs ConvolutionLayer :: Backward_gpu diimplementasikan menggunakan GEMM). Jadi, jika Anda mempelajari cara melakukan backpropagation untuk konvolusi reguler, Anda akan memahami apa yang terjadi pada tingkat perhitungan mekanis. Cara penghitungan ini cocok dengan intuisi yang dijelaskan dalam paragraf pertama uraian singkat ini.

Namun, saya tidak tahu bagaimana cara kerja lapisan konvolusional. (Saya mengerti bagaimana MLP sederhana belajar dengan gradient descent, jika itu membantu).

Untuk menjawab pertanyaan Anda yang lain di dalam pertanyaan pertama Anda, ada dua perbedaan utama antara backpropagation MLP (lapisan yang terhubung penuh) dan jaring konvolusional:

1) pengaruh bobot dilokalisasi, jadi pertama-tama cari tahu bagaimana melakukan backprop untuk, katakanlah filter 3x3 yang dihubungkan dengan area kecil 3x3 dari gambar input, pemetaan ke satu titik di gambar hasil.

2) bobot filter konvolusional dibagi untuk invarian spasial. Apa artinya ini dalam praktiknya adalah bahwa dalam penyaluran ke depan filter 3x3 yang sama dengan bobot yang sama diseret ke seluruh gambar dengan bobot yang sama untuk perhitungan penerusan untuk menghasilkan gambar output (untuk filter tertentu). Apa artinya ini untuk backprop adalah bahwa gradien backprop untuk setiap titik dalam gambar sumber dijumlahkan di seluruh rentang yang kami seret filter itu selama meneruskan. Perhatikan bahwa ada juga perbedaan gradien loss wrt x, w dan bias karena dLoss / dx perlu di-backpropagated, dan dLoss / dw adalah cara kami memperbarui bobot. w dan bias adalah input independen dalam DAG perhitungan (tidak ada input sebelumnya), jadi tidak perlu melakukan backpropagation pada mereka.

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

Matematika langkah demi langkah menjelaskan bagaimana transpose convolution 2x upampling dengan filter 3x3 dan langkah 2:

Cuplikan TensorFlow paling sederhana untuk memvalidasi matematika:

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

The catatan yang menyertai Stanford CS kelas CS231n : Konvolusional Neural Networks untuk Visual Recognition, dengan Andrej Karpathy , melakukan pekerjaan yang sangat baik menjelaskan jaringan saraf convolutional.

Membaca makalah ini seharusnya memberi Anda gambaran kasar tentang:

• Jaringan Dekonvolusional Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor dan Departemen Ilmu Komputer Rob Fergus, Courant Institute, New York University

Ini slide yang besar untuk Deconvolutional Networks.

Baru saja menemukan artikel yang bagus dari situs web theaon tentang topik ini [1]:

Kebutuhan untuk konvolusi yang dialihkan umumnya muncul dari keinginan untuk menggunakan transformasi yang berlawanan dengan konvolusi normal, [...] untuk memproyeksikan peta fitur ke ruang dimensi yang lebih tinggi. [...] yaitu, memetakan dari ruang 4-dimensi ke ruang 16-dimensi, sambil menjaga pola konektivitas konvolusi.

Konvolusi berubah - juga disebut konvolusi fraksional - bekerja dengan menukar lintasan maju dan mundur dari konvolusi. Salah satu cara untuk mengatakannya adalah dengan mencatat bahwa kernel mendefinisikan konvolusi, tetapi apakah itu konvolusi langsung atau konvolusi transpos ditentukan oleh bagaimana lintasan maju dan mundur dihitung.

Operasi konvolusi yang dialihkan dapat dianggap sebagai gradien dari beberapa konvolusi sehubungan dengan inputnya, yang biasanya merupakan cara konvolusi yang dialihkan diimplementasikan dalam praktik.

Akhirnya perhatikan bahwa selalu mungkin untuk mengimplementasikan konvolusi yang berubah dengan konvolusi langsung. Kerugiannya adalah biasanya melibatkan penambahan banyak kolom dan baris nol ke input, sehingga implementasi menjadi jauh lebih efisien.

Jadi dalam simplespeak, "transposed convolution" adalah operasi matematika menggunakan matriks (seperti konvolusi) tetapi lebih efisien daripada operasi konvolusi normal dalam kasus ketika Anda ingin kembali dari nilai-nilai yang dililitkan ke yang asli (arah yang berlawanan). Inilah sebabnya mengapa lebih disukai dalam implementasi untuk konvolusi ketika menghitung arah yang berlawanan (yaitu untuk menghindari banyak perkalian 0 yang tidak perlu yang disebabkan oleh matriks jarang yang dihasilkan dari pengisian input).

Image ---> convolution ---> Result

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

Terkadang Anda menyimpan beberapa nilai di sepanjang jalur konvolusi dan menggunakan kembali informasi itu ketika "kembali":

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

Mungkin itulah alasan mengapa hal itu secara keliru disebut "dekonvolusi". Namun, itu memang ada hubungannya dengan matriks transpos konvolusi (C ^ T), maka nama yang lebih tepat "transvolusi konvolusi".

Jadi sangat masuk akal ketika mempertimbangkan biaya komputasi. Anda akan membayar lebih banyak untuk amazon GPU jika Anda tidak akan menggunakan konvolusi yang dialihkan.

Baca dan saksikan animasi di sini dengan hati-hati: http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#no-zero-padding-unit-strides-transposed

Beberapa bacaan lain yang relevan:

Transpos (atau lebih umum, transpos Hermitian atau konjugat) dari filter adalah filter yang cocok [3]. Ini ditemukan saat membalikkan kernel dan mengambil konjugat dari semua nilai [2].

Saya juga baru dalam hal ini dan akan berterima kasih atas umpan balik atau koreksi.

[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

Kita bisa menggunakan PCA untuk analogi.

Saat menggunakan conv, forward pass adalah mengekstraksi koefisien komponen utama dari gambar input, dan pass mundur (yang memperbarui input) adalah menggunakan (gradien) koefisien untuk merekonstruksi gambar input baru, sehingga gambar input baru memiliki koefisien PC yang lebih cocok dengan koefisien yang diinginkan.

Saat menggunakan deconv, operan maju dan mundur mundur dibalik. Pass maju mencoba merekonstruksi gambar dari koefisien PC, dan pass mundur memperbarui koefisien PC yang diberikan (gradien) gambar.

Dek lulus maju melakukan persis gradien perhitungan yang diberikan dalam posting ini: http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/

Itu sebabnya dalam implementasi caffe dari deconv (lihat jawaban Andrei Pokrovsky), forward pass deconv memanggil backward_cpu_gemm (), dan pass backward memanggil forward_cpu_gemm ().

Selain jawaban David Dao: Dimungkinkan juga untuk memikirkan sebaliknya. Alih-alih berfokus pada piksel input (resolusi rendah) mana yang digunakan untuk menghasilkan piksel output tunggal, Anda juga dapat fokus pada masing-masing piksel input mana yang berkontribusi pada wilayah piksel output mana.

Ini dilakukan dalam publikasi penyulingan ini , termasuk serangkaian visualisasi yang sangat intuitif dan interaktif. Salah satu keuntungan berpikir ke arah ini adalah menjelaskan artefak kotak-kotak menjadi mudah.

Konvolusi dari perspektif DSP

Saya agak terlambat untuk ini, tetapi masih ingin berbagi perspektif dan wawasan saya. Latar belakang saya adalah teori fisika dan pemrosesan sinyal digital. Secara khusus saya mempelajari wavelet dan konvolusi hampir di tulang punggung saya;)

Cara orang-orang di komunitas belajar yang mendalam berbicara tentang konvolusi juga membingungkan saya. Dari sudut pandang saya, apa yang tampaknya tidak ada adalah pemisahan keprihatinan yang tepat. Saya akan menjelaskan konvolusi pembelajaran yang mendalam menggunakan beberapa alat DSP.

Penolakan

Penjelasan saya akan sedikit bergelombang dan tidak matematis untuk mendapatkan poin utama.

Definisi

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

dan

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

Konvolusi Pembelajaran Mendalam oleh Bagian

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

Seperti yang dapat dilihat adalah operasi yang dialihkan, demikianlah namanya.

Koneksi ke Upsampling Neighbor Terdekat

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

yaitu kita dapat mengganti upsampler berulang dengan faktor 2 dan konvolusi dengan kernel ukuran 3 oleh konvolusi yang ditransformasikan dengan ukuran kernel 4. Konvolusi yang dialihkan ini memiliki "kapasitas interpolasi" yang sama, tetapi akan dapat mempelajari interpolasi yang lebih cocok.

Kesimpulan dan Keterangan Akhir

Saya harap saya dapat mengklarifikasi beberapa konvolusi umum yang ditemukan dalam pembelajaran mendalam sedikit dengan memisahkan mereka dalam operasi mendasar.

Saya tidak menutup kolam di sini. Tapi ini hanya downsampler nonlinear dan dapat ditangani dalam notasi ini juga.

Saya memiliki banyak kesulitan memahami apa yang sebenarnya terjadi di koran sampai saya menemukan posting blog ini: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -dengan-tensorflow-dan-tf-slim /

Berikut ini adalah ringkasan bagaimana saya memahami apa yang terjadi dalam 2x upampling:

Informasi dari kertas

• Apa itu upsampling?
  • "upsampling dengan faktor f berbelit-belit dengan langkah input pecahan 1 / f"
  • → konvolusi fraksional juga dikenal sebagai konvolusi transposed menurut misalnya http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html
• Apa parameter dari belokan itu?
  • faktor f = 2
  • → input langkah 1 / f = 1/2
  • → ukuran kernel = 2 * faktor - faktor% 2 = 2 * 2 -0 = 4 menurut http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -dengan-tensorflow-dan-tf-slim /
• Apakah bobotnya tetap atau bisa dilatih?
  • Makalah ini menyatakan "kami menginisialisasi 2x upampling untuk interpolasi bilinear, tetapi memungkinkan parameter untuk dipelajari [...]".
  • Namun, halaman github yang sesuai menyatakan "Dalam percobaan awal kami, lapisan interpolasi diinisialisasi ke kernel bilinear dan kemudian dipelajari. Dalam percobaan lanjutan, dan implementasi referensi ini, kernel bilinear diperbaiki"
  • → bobot tetap

Contoh sederhana

1. bayangkan gambar input berikut:

2. Konvolusi dengan fraksional berjalan bekerja dengan memasukkan faktor-1 = 2-1 = 1 nol di antara nilai-nilai ini dan kemudian dengan asumsi langkah = 1 nanti. Dengan demikian, Anda menerima gambar empuk 6x6 berikut

3. Filter bilinear 4x4 terlihat seperti ini. Nilai-nilainya dipilih sedemikian rupa sehingga bobot yang digunakan (= semua bobot yang tidak dikalikan dengan nol yang dimasukkan) berjumlah hingga 1. Tiga nilai uniknya adalah 0,56, 0,19, dan 0,06. Selain itu, pusat filter adalah per konvensi pixel di baris ketiga dan kolom ketiga.

4. Menerapkan filter 4x4 pada gambar empuk (menggunakan padding = 'sama' dan melangkah = 1) menghasilkan gambar 6x6 upampled berikut:

5. Upampling semacam ini dilakukan untuk setiap saluran secara individual (lihat baris 59 di https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py ). Pada akhirnya, upampling 2x benar-benar mengubah ukuran yang sangat sederhana menggunakan interpolasi bilinear dan konvensi tentang bagaimana menangani perbatasan. Upacara 16x atau 32x bekerja dengan cara yang sama, saya percaya.

Makalah berikut membahas lapisan dekonvolusional. Keduanya dari sudut pandang arsitektur dan pelatihan. Jaringan dekonvolusi