Geçenlerde Jonathan Long, Evan Shelhamer, Trevor Darrell tarafından Semantik Segmentasyon için Tamamen Konvolüsyon Ağları'nı okudum . Dekonvolüsyon katmanlarının ne yaptığını / nasıl çalıştıklarını anlamıyorum.

İlgili bölüm

3.3. Örnekleme tersten izlemeli evrişimdir

Kalın çıktıları yoğun piksellere bağlamak için başka bir yol enterpolasyondur. Örneğin, basit bilinear enterpolasyon, her bir çıktısını , yalnızca girdi ve çıktı hücrelerinin göreceli konumlarına bağlı olan doğrusal bir harita ile en yakın dört girişten hesaplar . Bir anlamda, faktörü ile örnekleme 1 / f'lik kesirli girdi adımına sahip evrişimdir. integral olduğu sürece , örneklemenin doğal bir yolu bu nedenle bir çıkış basamağıyla geriye doğru evrişimdir (bazen dekonvolüsyon olarak adlandırılır) . Bu tür bir işlemin uygulanması önemsizdir, çünkü sadece evrişimin ileri ve geri geçişlerini tersine çevirir.$y_{ij}$
f $f$$f$$f$
Bu nedenle, üst örnekleme, pikseller arası kayıptan geri yayılma yoluyla uçtan uca öğrenme için ağ içinde gerçekleştirilir.
Böyle bir katmandaki dekonvolüsyon filtresinin sabitlenmesi gerekmediğine dikkat edin (örneğin, bilinear yukarı örneklemeye), ancak öğrenilebilir. Bir dekonvolüsyon katmanları ve aktivasyon fonksiyonları yığını doğrusal olmayan bir örneklemeyi bile öğrenebilir.
Deneylerimizde, ağ içi örneklemenin yoğun tahmini öğrenmek için hızlı ve etkili olduğunu bulduk. En iyi segmentasyon mimarimiz, bu katmanları Bölüm 4.2'deki ayrıntılı tahmin için örneklemeyi öğrenmek amacıyla kullanır.

Evrişimli katmanların nasıl eğitildiğini gerçekten anladığımı sanmıyorum.

Anladığım kadarıyla, çekirdek boyutu olan evrişimli katmanların, boyutundaki filtreleri öğrendiğidir . Çekirdek boyutu , adım ve filtreli bir evrişimli katmanın çıktısı, boyutundadır . Ancak, evrişim katmanlarının öğrenilmesinin nasıl çalıştığını bilmiyorum. (Eğer yardımcı olursa, MLP'lerin gradyan inişiyle nasıl öğrendiklerini anlıyorum).k × k k s ∈ N n $k$$k \times k$$k$$s \in \mathbb{N}$$n$$\frac{\text{Input dim}}{s^2} \cdot n$

Eğer evrişimsel katmanlar anlayışım doğruysa, bunun nasıl tersine çevrileceğine dair hiçbir fikrim yok.

Biri lütfen dekonvolüsyonel katmanları anlamama yardımcı olabilir mi?

Dekonvolüsyon tabakası çok talihsiz bir isimdir ve bunun yerine geçişli bir evrişim tabakası olarak adlandırılmalıdır .

Görsel olarak, adım adım ve dolgulu olmayan bir geçiş için, orijinal girişi (mavi girişleri) sıfırlarla (beyaz girişler) doldururuz (Şekil 1).

İkinci adım ve doldurma durumunda, devredilen evrişim şuna benzerdi (Şekil 2):

Konvolüsyon aritmetiğinin (harika) görselleştirmelerini burada bulabilirsiniz .

Evrimin arkasındaki gerçekten temel bir sezgiyi elde etmenin bir yolu, giriş görüntüsü üzerinde K kalıpları olarak düşünebileceğiniz K filtrelerini kaydırmanız ve K aktivasyonları üretmenizdir - her biri belirli bir şablonla eşleşme derecesini temsil eder. . Bunun tersi işlemi K aktivasyonları almak ve onları evrişim işleminin bir ön izlemesine genişletmek olacaktır. Bu nedenle, ters işlemin sezgisel açıklaması, kabaca, şablonlar (filtreler) ve aktivasyonlar (her şablon için eşleşme derecesi) verilen görüntü rekonstrüksiyonudur ve bu nedenle, her bir aktivasyonu şablon maskesi ile bloke etmek istiyoruz. ve onları ekleyin.

Dekonv işleminin anlaşılmasının bir başka yolu, Caffe'deki dekonvolüsyon tabakası uygulamasının incelenmesi, aşağıdaki ilgili kod bitlerine bakınız:

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

Caffe'de normal ileri evrişimli bir tabaka için tam olarak backprop olarak uygulandığını görebilirsiniz (benim için cuDNN conv katmanı ile ConvolutionLayer :: Backward_gpu'da GEMM kullanılarak uygulanan backprop uygulaması karşılaştırıldıktan sonra daha belirgindi). Bu nedenle, düzenli yayılma için geri yayılımın nasıl yapıldığına bakarsanız, mekanik bir hesaplama seviyesinde ne olduğunu anlayacaksınız. Bu hesaplamanın çalışma şekli, bu bulanıklığın ilk paragrafında açıklanan sezgiyle eşleşir.

Ancak, evrişim katmanlarının öğrenilmesinin nasıl çalıştığını bilmiyorum. (Eğer yardımcı olursa, MLP'lerin gradyan inişiyle nasıl öğrendiklerini anlıyorum).

Diğer sorunuza ilk sorunuza cevap vermek için, MLP backpropagation (tamamen bağlı katman) ve evrişimli ağlar arasında iki ana fark vardır:

1) ağırlıkların etkisi lokalizedir, bu nedenle ilk önce nasıl geri dönüş yapılacağına karar verin, sonuçta görüntüde tek bir noktaya eşlenen 3x3'lük bir giriş görüntüsünün küçük bir 3x3 alanı ile kıvrılmış 3x3 filtre.

2) evrişimli filtrelerin ağırlıkları mekansal değişimler için paylaşılır. Bunun pratikte anlamı, ileri geçişte aynı ağırlıkları içeren aynı 3x3 filtrenin, çıktı görüntüsünü (belirli bir filtre için) elde etmek için ileri hesaplama için aynı ağırlıklarla tüm görüntü boyunca sürüklenmesidir. Bunun backprop için anlamı, kaynak görüntüdeki her nokta için backprop gradyanlarının, ileriye geçiş sırasında o filtreyi sürüklediğimiz tüm aralık boyunca toplanmasıdır. DLoss / dx'in geri yayınlanması gerektiğinden, x, w ve bias kayıplarının farklı derecelerinde de olduğuna dikkat edin, dLoss / dw ağırlıkları nasıl güncellediğimizdir. w ve önyargı, DAG hesaplamasında bağımsız girdilerdir (önceden girdi yoktur), bu nedenle bunlar üzerinde geri yayılma yapılmasına gerek yoktur.

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

Transpozisyon konvolüsyonunun 2x örneklemenin 3x3 filtre ve 2 adımlı adımlarla örneklemesini açıklayan adım adım matematik:

Matematiği onaylayan en basit TensorFlow pasajı:

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 sınıf CS231n eşlik notlar : Andrej karpathy tarafından, Görsel Tanıma için Evrişimsel Sinir Ağları , katlamalı sinir ağları açıklayan mükemmel bir iş yapmak.

Bu makaleyi okumak size aşağıdakilerle ilgili kaba bir fikir vermelidir:

• Dekonvolüsyonlu Ağlar Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor ve Rob Fergus Bilgisayar Bilimleri Bölümü, Courant Institute, New York Üniversitesi

Bu slaytlar Dekonvolüsyon Ağları için mükemmeldir.

Bu konuda theaon web sitesinden harika bir yazı buldum [1]:

Devredilen konvolüsyonlara duyulan ihtiyaç, genellikle normal bir konvolüsyonun ters yönünde ilerleyen bir dönüşüm kullanma arzusundan, [...] özellik haritalarını daha yüksek boyutlu bir uzaya yansıtmaktan kaynaklanır. [...] yani, evrişimin bağlantı düzenini korurken, 4 boyutlu bir alandan 16 boyutlu bir uzaya harita.

Devredilen konvolüsyonlar - ayrıca kesirli olarak düzenlenmiş konvolüsyonlar olarak da bilinir - bir konvolüsyonun ileri ve geri geçişlerini değiştirerek çalışır. Bunu belirtmenin bir yolu çekirdeğin bir evrişim tanımladığını, ancak bunun bir evrişim ya da devredilen bir evrişimin ileri ve geri geçişlerin nasıl hesaplandığına göre belirlendiğine dikkat etmektir.

Devredilen evrişim işlemi, girişine göre bazı evrişimin gradyanı olarak düşünülebilir, bu genellikle pratik olarak evrimleşmiş devirlerin pratikte nasıl uygulandığıdır.

Son olarak, aktarılmış bir evrişimi doğrudan bir evrişim ile uygulamak her zaman mümkün olduğunu unutmayın. Dezavantajı, girişe çok sayıda sütun ve sıfır sıra eklemeyi içermesi ve bunun sonucunda çok daha az verimli bir uygulama yapılmasıdır.

Dolayısıyla, basitçe "geçişli bir evrişim", matrislerin kullanıldığı (aynı evrişim gibi) matematiksel işlemdir, ancak evrişimsel değerlerden orjinaline (ters yöne) geri dönmek istediğinizde normal evrişim işleminden daha verimlidir. Bu nedenle, ters yönde hesaplanırken (yani girişin doldurulmasından kaynaklanan seyrek matrisin neden olduğu birçok gereksiz çarpmalardan kaçınmak için) kıvrılma uygulamalarında tercih edilir.

Image ---> convolution ---> Result

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

Bazen evrişim yolu boyunca bazı değerleri kaydedersiniz ve "geri dönerken" bu bilgileri yeniden kullanırsınız:

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

Muhtemelen yanlış bir “dekonvolüsyon” olarak adlandırılmasının nedeni budur. Bununla birlikte, evrişimin matriksinin transpozisyonu (C ^ T) ile bir ilgisi vardır, bu nedenle daha uygun olan "geçişli evrişim" adıdır.

Bu yüzden hesaplama maliyetini düşünürken çok anlamlı olur. Aktarılan evrişimi kullanmazsan, amazon gpus için çok daha fazla öderdin.

Buradaki animasyonları dikkatlice okuyun ve izleyin: http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#no-zero-padding-unit-strides-transposed

İlgili diğer bazı okumalar:

Bir filtrenin transpozisyonu (veya daha genel olarak Hermitiyen veya konjugat transpozisyonu) basitçe eşleşen filtredir [3]. Bu, çekirdeği tersine çevirerek ve tüm değerlerin konjugatını alarak bulunur [2].

Ben de bu konuda yeniyim ve herhangi bir geri bildirim veya düzeltme için minnettar olurum.

[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

Analoji için PCA kullanabiliriz.

Conv kullanılırken, ileriye doğru geçiş ana bileşen bileşenlerinin katsayılarını girdi görüntüsünden çıkarmaktır ve geriye doğru geçiş (girdiyi güncelleyen) yeni bir girdi görüntüsünü yeniden oluşturmak için katsayıları kullanmak (gradyanını) kullanmaktır. Yeni giriş görüntüsünde istenen katsayılarla daha iyi eşleşen PC katsayıları bulunur.

Dekonv kullanılırken, ileri geçiş ve geri geçiş tersine çevrilir. İleri geçiş PC katsayılarından bir görüntüyü yeniden oluşturmaya çalışır ve geri geçiş görüntüye verilen PC katsayılarını (gradyanı) günceller.

Deconv iletme geçişi tam olarak bu yazıda verilen konveksiyon gradyan hesaplamasını yapar: http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/

Bu nedenle deconv'un caffe uygulamasında (Andrei Pokrovsky'nin cevabına bakınız), deconv ileri geçişi backward_cpu_gemm () 'i ve geri geçiş geçişi forward_cpu_gemm ()' i çağırır.

David Dao'nun cevabına ek olarak: Etrafında başka şekilde düşünmek de mümkündür. Tek bir çıktı pikseli üretmek için hangi (düşük çözünürlüklü) giriş piksellerine odaklanmak yerine, ayrı ayrı girdi piksellerinin hangi çıktı piksellerinin bulunduğu bölgeye katkıda bulunduğuna da odaklanabilirsiniz.

Bu, bir dizi çok sezgisel ve etkileşimli görselleştirme de dahil olmak üzere bu distile yayınında yapılır . Bu yönde düşünmenin bir avantajı, dama tahtası yapılarını açıklamanın kolay hale gelmesidir.

DSP perspektifinden konvolüsyonlar

Buna biraz geç kaldım ama yine de bakış açımı ve görüşlerimi paylaşmak istiyorum. Geçmişim teorik fizik ve dijital sinyal işleme. Özellikle dalgacık okudum ve konvolüsyonlar neredeyse omurgamda;)

Derin öğrenme topluluğundaki insanların toplantılar hakkında konuşma şekilleri de kafa karıştırıcıydı. Benim bakış açıma göre eksik görünen şey kaygıların uygun bir şekilde ayrılmasıdır. Bazı DSP araçlarını kullanarak derin öğrenme toplantılarını açıklayacağım.

feragat

Açıklamalarım ana noktaları aşmak için biraz el dalgalı ve matematiksel titiz değil.

Tanımlar

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

ve

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

Parçalarla Derin Öğrenme Konvolüsyonları

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

Görüldüğü gibi devredilen işlem, dolayısıyla adıdır.

En Yakın Komşu Örneklemesine Bağlantı

Evrişimli ağlarda bulunan diğer bir yaygın yaklaşım, bazı yerleşik enterpolasyon formları ile örneklemektir. Basit bir tekrar enterpolasyonu ile faktör 2 ile örneklemeyi ele alalım. Bu, olarak yazılabilir.$\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),$$

yani, faktör 2 ile tekrarlanan bir üst örnekleyiciyi ve çekirdek büyüklüğü 4 ile devredilen bir evrişim ile 3 boyutunda bir çekirdeği olan bir evrişimi değiştirebiliriz.

Sonuçlar ve Son Açıklamalar

İnşallah derin öğrenmede bulunan bazı ortak sarsıntıları, temel işlemlerde bir araya getirerek biraz netleştirebilirim.

Burada havuzlamayı örtmedim. Ancak bu sadece doğrusal olmayan bir aşağı örnekleyicidir ve bu gösterim dahilinde de tedavi edilebilir.

Bu blog yazısı ile karşılaşana kadar gazetede tam olarak ne olduğunu anlama konusunda çok sorun yaşadım: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -ile-tensorflow-ve-tf-ince /

2x örneklemede neler olup bittiğini nasıl anladığımın bir özeti:

Kağıttan Bilgi

• Örnekleme nedir?
  • "f faktörü ile örnekleme 1 / f kesirli girdi adımlı evrişim"
  • → Fraksiyonel olarak düzenlenmiş konvolüsyonlar ayrıca, örneğin http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html
• Bu evrimin parametreleri nelerdir?
  • faktör f = 2
  • → giriş dizisi 1 / f = 1/2
  • → çekirdek boyutu = 2 * faktör - faktör% 2 = 2 * 2 -0 = 4: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -ile-tensorflow-ve-tf-ince /
• Ağırlıklar sabit mi yoksa eğitilebilir mi?
  • Makalede "2x üst örneklemesini bilinear enterpolasyon için başlattık, ancak parametrelerin öğrenilmesine izin verdik [...]" yazıyor.
  • Bununla birlikte, karşılık gelen github sayfasında "Özgün deneylerimizde enterpolasyon katmanları bilinear çekirdeklere başlatıldı ve sonra öğrenildi. Takip deneylerinde ve bu referans uygulamasında bilinear çekirdekler sabittir"
  • → sabit ağırlıklar

Basit bir örnek

1. aşağıdaki giriş görüntüsünü hayal edin:

2. Kesirli olarak düzenlenmiş konvolüsyonlar, bu değerler arasına faktör-1 = 2-1 = 1 sıfır ekleyerek ve ardından adım = 1 olduğunu varsayarak çalışır. Böylece, aşağıdaki 6x6 yastıklı görüntüyü alırsınız

3. Bilinear 4x4 filtresi buna benzer. Değerleri, kullanılan ağırlıklar (= eklenen sıfır ile çarpılmayan tüm ağırlıklar) 1'e kadar olacak şekilde seçilir. Üç benzersiz değeri 0,56, 0,19 ve 0,06'dır. Ayrıca, filtrenin merkezi, konvansiyon başına üçüncü sıradaki ve üçüncü sütundaki pikseldir.

4. Dolgulu görüntüye 4x4 filtresi uygulamak (dolgulu = 'same' ve stride = 1 kullanarak) aşağıdaki 6x6 örneklenmiş görüntüyü verir:

5. Bu tür yukarı örnekleme her kanal için ayrı ayrı gerçekleştirilir (bkz. Https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py . Sonunda, 2x örneklemesi sınırların nasıl ele alınacağına dair bilinear enterpolasyon ve sözleşmeler kullanılarak gerçekten çok basit bir yeniden boyutlandırma. 16x veya 32x örneklemenin aynı şekilde çalıştığını düşünüyorum.

Aşağıdaki yazıda dekonvolüsyon olmayan tabakalar tartışılmaktadır. Mimari ve eğitim açısından bakıldığında. Dekonvolüsyon ağları