Conv1D ve Conv2D arasındaki fark nedir?

Keras evrişim belgelerinden geçiyordum ve Conv1D ve Conv2D olmak üzere iki tür konvülsiyon buldum. Biraz web araması yaptım ve Conv1D ve Conv2D hakkında anladığım şey bu; Conv1D diziler için kullanılır ve Conv2D görüntüler için kullanılır.

Her zaman evrişim sinir ağlarının sadece görüntüler için kullanıldığını düşündüm ve CNN'i bu şekilde görselleştirdim

Bir görüntü büyük bir matris olarak kabul edilir ve daha sonra bir filtre bu matrisin üzerinde kayar ve nokta ürünü hesaplar. Bu keras bir Conv2D olarak bahsettiğine inanıyorum. Conv2D bu şekilde çalışırsa, Conv1D'nin mekanizması nedir ve mekanizmasını nasıl hayal edebiliriz?

Konvolüsyon, bir tensörü veya bir matrisi veya vektörü daha küçük olana "özetlediğiniz" matematiksel bir işlemdir. Eğer giriş matrisiniz bir boyutlu ise, o zaman boyutlar üzerinde özetlersiniz ve bir tensörün n boyutu varsa , tüm n boyutları boyunca özetleyebilirsiniz. Conv1D ve Conv2D bir veya iki boyut boyunca özetliyor (kıvrılıyor).

$$b_i=\sum_{j=m-1}^0 a_{i+j}*w_j$$ $i=[1,n-m+1]$

$w_i=1/n$

$$\begin{bmatrix} a:&a_1 & a_2 & a_3\\ w:&1/2 & 1/2&\\ w:&&1/2 & 1/2\\ \end{bmatrix}=\begin{bmatrix} b:&\frac{a_1+a_2} 2 & \frac{a_2+a_3} 2 \end{bmatrix}$$

$$b_{ikl}=\sum_{j_1=m_1-1\\j_2=m_2-1\\j_3=m_4-1}^{0} a_{i+j_1,k+j_2,l+j_3}*w_{j_1j_2j_3}$$ $i=[1,n_1-m_1+1],k=[1,n_2-m_2+1],l=[1,n_3-m_3+1]$

Bu 1d evrişimi maliyet tasarrufu sağlar, aynı şekilde çalışır, ancak öğelerle çarpma yapan 1 boyutlu bir dizi olduğunu varsayar. Eğer çoğaldığımızda, satır veya sütunların bir matrisini, yani tek bir boyutu düşünmeyi görselleştirmek istiyorsanız, aynı şekle sahip ancak daha düşük veya daha yüksek değerlerden oluşan bir dizi elde ederiz, böylece değerlerin yoğunluğunu en üst düzeye çıkarmaya veya en aza indirmeye yardımcı olur.

Bu görüntü size yardımcı olabilir,

Ayrıntılar için bkz. Https://www.youtube.com/watch?v=qVP574skyuM

Bir Pytorch perspektifi kullanacağım, ancak mantık aynı kalıyor.

Conv1d () kullanırken, büyük olasılıkla tek sıcak kodlamalı DNA dizileri veya siyah beyaz resimler gibi 2 boyutlu girişlerle çalışacağımızı unutmamalıyız.

Daha geleneksel Conv2d () ve Conv1d () arasındaki tek fark, ikincisinin aşağıdaki resimde gösterildiği gibi 1 boyutlu bir çekirdek kullanmasıdır.

Burada, giriş verilerinizin yüksekliği “derinlik” (veya kanallar) haline gelir ve satırlarımız çekirdek boyutu haline gelir. Örneğin,

import torch
import torch.nn as nn

tensor = torch.randn(1,100,4)
output = nn.Conv1d(in_channels =100,out_channels=1,kernel_size=1,stride=1)(tensor)
#output.shape == [1,1,4]

Çekirdeğin otomatik olarak resmin yüksekliğine yayıldığını görebiliriz (tıpkı Conv2d () 'de olduğu gibi, çekirdeğin derinliği otomatik olarak görüntünün kanallarını kapsar) ve bu nedenle vermemiz gereken tek şey, satırları.

Sadece 2 boyutlu bir girdi varsayarsak, filtrelerimizin sütunlarımız ve satırlarımızın çekirdek boyutu haline geldiğini unutmamalıyız.

Farkı görsel olarak ve ayrıntılı olarak (kodda yorumlar) ve çok çok kolay bir yaklaşımla açıklamak istiyorum.

Önce TensorFlow'daki Conv2D'yi kontrol edelim .

c1 = [[0, 0, 1, 0, 2], [1, 0, 2, 0, 1], [1, 0, 2, 2, 0], [2, 0, 0, 2, 0], [2, 1, 2, 2, 0]]
c2 = [[2, 1, 2, 1, 1], [2, 1, 2, 0, 1], [0, 2, 1, 0, 1], [1, 2, 2, 2, 2], [0, 1, 2, 0, 1]]
c3 = [[2, 1, 1, 2, 0], [1, 0, 0, 1, 0], [0, 1, 0, 0, 0], [1, 0, 2, 1, 0], [2, 2, 1, 1, 1]]
data = tf.transpose(tf.constant([[c1, c2, c3]], dtype=tf.float32), (0, 2, 3, 1))
# we transfer [batch, in_channels, in_height, in_width] to [batch, in_height, in_width, in_channels]
# where batch = 1, in_channels = 3 (c1, c2, c3 or the x[:, :, 0], x[:, :, 1], x[:, :, 2] in the gif), in_height and in_width are all 5(the sizes of the blue matrices without padding) 
f2c1 = [[0, 1, -1], [0, -1, 0], [0, -1, 1]]
f2c2 = [[-1, 0, 0], [1, -1, 0], [1, -1, 0]]
f2c3 = [[-1, 1, -1], [0, -1, -1], [1, 0, 0]]
filters = tf.transpose(tf.constant([[f2c1, f2c2, f2c3]], dtype=tf.float32), (2, 3, 1, 0))
# we transfer the [out_channels, in_channels, filter_height, filter_width] to [filter_height, filter_width, in_channels, out_channels]
# out_channels is 1(in the gif it is 2 since here we only use one filter W1), in_channels is 3 because data has three channels(c1, c2, c3), filter_height and filter_width are all 3(the sizes of the filter W1)
# f2c1, f2c2, f2c3 are the w1[:, :, 0], w1[:, :, 1] and w1[:, :, 2] in the gif
output = tf.squeeze(tf.nn.conv2d(data, filters, strides=2, padding=[[0, 0], [1, 1], [1, 1], [0, 0]]))
# this is just the o[:,:,1] in the gif
# <tf.Tensor: id=93, shape=(3, 3), dtype=float32, numpy=
# array([[-8., -8., -3.],
#        [-3.,  1.,  0.],
#        [-3., -8., -5.]], dtype=float32)>

Conv1D, bu paragrafta Conv1D'nin TensorFlow belgesinden belirtildiği gibi özel bir Conv2D vakasıdır .

Dahili olarak, bu op giriş tensörlerini yeniden şekillendirir ve tf.nn.conv2d'yi çağırır. Örneğin, data_format "NC" ile başlamazsa, [batch, in_width, in_channels] şeklinde bir tensör [batch, 1, in_width, in_channels] şeklinde yeniden şekillendirilir ve filtre [1, filter_width, in_channels, out_channels]. Sonuç daha sonra [toplu iş, dışarı_ genişlik, dışarı_kanallar] şeklinde yeniden şekillendirilir (burada dışarı_ genişlik, adım2'de olduğu gibi adım ve dolgu işlevinin bir fonksiyonudur) ve arayana geri döner.

Conv1D'yi de bir Conv2D problemini nasıl aktarabileceğimizi görelim. Conv1D genellikle NLP senaryolarında kullanıldığından, bunu aşağıdaki NLP probleminde gösterebiliriz.

cat = [0.7, 0.4, 0.5]
sitting = [0.2, -0.1, 0.1]
there = [-0.5, 0.4, 0.1]
dog = [0.6, 0.3, 0.5]
resting = [0.3, -0.1, 0.2]
here = [-0.5, 0.4, 0.1]
sentence = tf.constant([[cat, sitting, there, dog, resting, here]]
# sentence[:,:,0] is equivalent to x[:,:,0] or c1 in the first example and the same for sentence[:,:,1] and sentence[:,:,2]
data = tf.reshape(sentence), (1, 1, 6, 3))
# we reshape [batch, in_width, in_channels] to [batch, 1, in_width, in_channels] according to the quote above
# each dimension in the embedding is a channel(three in_channels)
f3c1 = [0.6, 0.2]
# equivalent to f2c1 in the first code snippet or w1[:,:,0] in the gif
f3c2 = [0.4, -0.1]
# equivalent to f2c2 in the first code snippet or w1[:,:,1] in the gif
f3c3 = [0.5, 0.2]
# equivalent to f2c3 in the first code snippet or w1[:,:,2] in the gif
# filters = tf.constant([[f3c1, f3c2, f3c3]])
# [out_channels, in_channels, filter_width]: [1, 3, 2]
# here we have also only one filter and also three channels in it. please compare these three with the three channels in W1 for the Conv2D in the gif
filter1D = tf.transpose(tf.constant([[f3c1, f3c2, f3c3]]), (2, 1, 0))
# shape: [2, 3, 1] for the conv1d example
filters = tf.reshape(filter1D, (1, 2, 3, 1))  # this should be expand_dim actually
# transpose [out_channels, in_channels, filter_width] to [filter_width, in_channels, out_channels]] and then reshape the result to [1, filter_width, in_channels, out_channels] as we described in the text snippet from Tensorflow doc of conv1doutput
output = tf.squeeze(tf.nn.conv2d(data, filters, strides=(1, 1, 2, 1), padding="VALID"))
# the numbers for strides are for [batch, 1, in_width, in_channels] of the data input
# <tf.Tensor: id=119, shape=(3,), dtype=float32, numpy=array([0.9       , 0.09999999, 0.12      ], dtype=float32)>

Bunu Conv1D kullanarak da yapalım (ayrıca TensorFlow'da):

output = tf.squeeze(tf.nn.conv1d(sentence, filter1D, stride=2, padding="VALID"))
# <tf.Tensor: id=135, shape=(3,), dtype=float32, numpy=array([0.9       , 0.09999999, 0.12      ], dtype=float32)>
# here stride defaults to be for the in_width

Conv2D'deki 2B'nin giriş ve filtredeki her kanalın 2 boyutlu (gif örneğinde gördüğümüz gibi) ve Conv1D'deki 1D'nin giriş ve filtredeki her kanalın 1 boyutlu (kedide gördüğümüz gibi) anlamına geldiğini görebiliriz ve köpek NLP örneği).