神經網絡系列---卷積

文章目錄

- 卷積神經網絡
- - 卷積
  - 轉置卷積
- 卷積核和反卷積的三種實現方式
- 卷積的次數計算

卷積神經網絡

在神經網絡的卷積層中，向下取整（Floor）是一種常用的策略，特別是在處理輸出尺寸不是整數的情況時。當你計算出卷積層輸出的尺寸（通常是寬度和高度）不是整數時，你可以簡單地去掉小數部分，即對該數進行向下取整。

向下取整通常意味著在卷積操作中你可能會忽略輸入矩陣（也就是圖像或者上一層的輸出）的一小部分。這可能導致一些空間信息的丟失，但在實踐中通常不會產生重大影響。

舉一個簡單的例子，假設你有一個7x7的輸入和一個3x3的卷積核，步長為2。通常，輸出的尺寸會用以下公式來計算：

$\text{輸出尺寸} = \left\lfloor \frac{{\text{輸入尺寸} - \text{核尺寸}}}{\text{步長}} \right\rfloor + 1$

如果用這個公式計算，輸出尺寸會是：

$\left\lfloor \frac{{7 - 3}}{2} \right\rfloor + 1 = 3$

這里，向下取整實際上沒有影響，因為計算結果剛好是一個整數。但如果輸入尺寸是8x8，那么輸出尺寸會是：

$\left\lfloor \frac{{8 - 3}}{2} \right\rfloor + 1 = \left\lfloor \frac{5}{2} \right\rfloor + 1 = 2 + 1 = 3$

在這個例子中，盡管精確的計算結果是3.5，但通過向下取整，輸出尺寸變成了3。

使用向下取整的一個優點是它簡化了實現，因為你不需要特別處理邊界條件。缺點是可能會丟失一些空間信息，尤其是當步長比較大的時候。然而，在許多應用場景中，這種信息丟失通常是可以接受的。

神經網絡中關于卷積池化的計算（不為整數時，卷積向下取整，池化向上取整）

在這里插入圖片描述

對于正向傳播，我們使用原始的卷積核進行卷積操作。在反向傳播時，為了計算輸入或權重的梯度，通常需要進行“翻轉”操作。

需要注意的是，正向卷積和反向傳播中的卷積（通常稱為轉置卷積或反卷積）在數學和實現上有一些不同。在正向傳播中，卷積核與輸入數據進行卷積以生成輸出。而在反向傳播中，我們關心的是如何改變輸入或卷積核以最小化某個損失函數。

為了具體說明為什么需要翻轉卷積核，考慮一維情況（二維情況是類似的）：

假設正向卷積表示為 $y = x ? w$ ，其中 $x$ 是輸入， $w$ 是卷積核， $y$ 是輸出，‘*’ 是卷積操作。

在反向傳播過程中，我們通常需要計算損失函數 $L$ 關于輸入 $x$ 的梯度（ $\frac{\partial L}{\partial x}$ ）。為了找到這個梯度，我們需要用到鏈式法則：

$\frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} * \text{rot180}(w)$

其中， $\text{rot180}(w)$ 表示將 $w$ 進行180度翻轉。

這樣做的主要原因是數學上的一致性和計算的方便性。這樣，前向和反向傳播可以用相似的卷積操作來實現，大大簡化了算法的實現。

簡而言之，在正向傳播中我們使用原始的卷積核，而在反向傳播時，為了計算梯度，我們通常需要用到翻轉的卷積核。這主要是為了數學和計算的方便。

在反向傳播（backpropagation）過程中，通常會使用原始卷積核（kernel）的翻轉版本。這里的“翻轉”通常意味著沿兩個空間維度（即不是批量維度或通道維度）旋轉180度。

例如，如果你有一個3x3的卷積核：

$\begin{pmatrix}a & b & c \\d & e & f \\g & h & i\end{pmatrix}$

翻轉這個卷積核會得到：

$K^{\text{rot}} = \begin{pmatrix}i & h & g\\f & e & d \\c & b & a\end{pmatrix}$

在Eigen中，使用reverse()函數并指定需要翻轉的維度可以實現這一點。例如，對于一個Eigen::MatrixXf對象kernel，你可以這樣翻轉它：

Eigen::MatrixXf rotated_kernel = kernel.reverse();

這里簡單假設reverse()默認沿兩個維度翻轉矩陣。實際使用中，請確保你正確地翻轉了維度。

這個翻轉的卷積核（或旋轉180度的卷積核）通常用于反向傳播過程中，以計算相對于輸入的梯度。這與前向傳播中使用的卷積核是同一個卷積核，只是翻轉了。

【卷積神經網絡中的反向傳播動畫演示】
在這里插入圖片描述

通過將輸入和卷積核展開（unroll）為矩陣，可以使用矩陣乘法來實現卷積和轉置卷積操作。下面簡要介紹如何使用這種技術。

卷積

假設我們有一個輸入矩陣 $X$ 和一個卷積核 $K$ 。我們首先將 $X$ 展開為一個大矩陣 $X_{\text{unroll}}$ ，其中每一列都包含一個 $K$ 能應用于 $X$ 的局部區域。然后，我們將 $K$ 展開為一個行向量 $K_{\text{unroll}}$ 。

接下來，卷積操作可以通過以下矩陣乘法進行：

$K_{\text{unroll}} \times X_{\text{unroll}}$

其中 $O$ 是輸出矩陣。

轉置卷積

對于轉置卷積，方法基本相同，但展開和乘法的方向會有所不同。

假設我們有一個輸入矩陣 $Y$ 和相同的卷積核 $K$ 。為了進行轉置卷積，我們將 $Y$ 展開為 $Y_{\text{unroll}}$ ，然后執行以下矩陣乘法：

$X_{\text{unroll}} \times K^T$

這里， $K^T$ 是 $K$ 的轉置。

請注意，在這兩種情況下，我們都需要格外注意矩陣的維度和展開的順序。

卷積核和反卷積的三種實現方式

#include <Eigen/Dense>
#include <iostream>//卷積
Eigen::MatrixXf conv2D(const Eigen::MatrixXf& input, const Eigen::MatrixXf& kernel, int stride) {// 計算輸出矩陣的尺寸int rows = (input.rows() - kernel.rows()) / stride + 1;int cols = (input.cols() - kernel.cols()) / stride + 1;// 創建輸出矩陣Eigen::MatrixXf output(rows, cols);for (int i = 0; i < rows; ++i) {for (int j = 0; j < cols; ++j) {// 計算每個輸出元素Eigen::MatrixXf block = input.block(i * stride, j * stride, kernel.rows(), kernel.cols());output(i, j) = (block.array() * kernel.array()).sum();}}return output;
}// deconv2D 是一個函數，用于執行反卷積（也叫轉置卷積）
Eigen::MatrixXf deconv2D( const Eigen::MatrixXf& y_grad,const Eigen::MatrixXf& kernel, int stride) {// 計算輸出尺寸int outputRows = (y_grad.rows() - 1) * stride + kernel.rows();int outputCols = (y_grad.cols() - 1) * stride + kernel.cols();// 初始化輸出矩陣為零Eigen::MatrixXf output = Eigen::MatrixXf::Zero(outputRows, outputCols);// 進行轉置卷積操作for (int i = 0; i < y_grad.rows(); ++i) {for (int j = 0; j < y_grad.cols(); ++j) {// 注意：這里我們假設步長（stride）是1，你可以通過修改下面的索引來調整步長output.block(i * stride, j * stride, kernel.rows(), kernel.cols()) += y_grad(i, j) * kernel;}}return output;
}// 轉置卷積
Eigen::MatrixXf Conv2DTransposed( int rows,int cols ,const Eigen::MatrixXf& kernel, int stride)
{int r = (rows - kernel.rows()) / stride + 1;int c = (cols - kernel.cols()) / stride + 1;// 初始化輸出矩陣為零Eigen::MatrixXf output1 = Eigen::MatrixXf::Zero(r * c, rows * cols);int jj =0;// 進行轉置卷積操作for (int i = 0; i < r; ++i){for (int j = 0; j < c ; ++j){// 初始化輸出矩陣為零Eigen::MatrixXf output = Eigen::MatrixXf::Zero(rows, cols);// 注意：這里我們假設步長（stride）是1，你可以通過修改下面的索引來調整步長output.block(i * stride, j * stride, kernel.rows(), kernel.cols()) = kernel;output1.row(jj++) = output.reshaped<Eigen::RowMajor>();}}return output1;
}
//圖像轉換為列
Eigen::MatrixXf im2col(const Eigen::MatrixXf& input, int kernel_rows, int kernel_cols, int stride) {int output_rows = (input.rows() - kernel_rows) / stride + 1;int output_cols = (input.cols() - kernel_cols) / stride + 1;Eigen::MatrixXf output(kernel_rows * kernel_cols, output_rows * output_cols);int col_idx = 0;for (int row = 0; row <= input.rows() - kernel_rows; row += stride){for (int col = 0; col <= input.cols() - kernel_cols; col += stride){Eigen::VectorXf col_vector = input.block(row, col, kernel_rows, kernel_cols).reshaped<Eigen::RowMajor>();//const Eigen::VectorXf col_vector = Eigen::Map<const Eigen::VectorXf, Eigen::RowMajor>(block.data(), block.size());output.col(col_idx++) = col_vector;}}return output;
}//列轉換為圖像
Eigen::MatrixXf col2im(const Eigen::MatrixXf& input, int original_rows, int original_cols, int kernel_rows, int kernel_cols, int stride) {Eigen::MatrixXf output = Eigen::MatrixXf::Zero(original_rows, original_cols);int col_idx = 0;for (int row = 0; row <= original_rows - kernel_rows; row += stride){for (int col = 0; col <= original_cols - kernel_cols; col += stride){Eigen::MatrixXf block = input.col(col_idx++).reshaped<Eigen::RowMajor>(kernel_rows, kernel_cols);//const Eigen::MatrixXf block = Eigen::Map<const Eigen::MatrixXf, Eigen::RowMajor>(col_vector.data(), kernel_rows, kernel_cols);output.block(row, col, kernel_rows, kernel_cols) += block;}}return output;
}int main() {// 用于測試的輸入和卷積核Eigen::MatrixXf input(5, 5);input << 1, 2, 3, 4, 5,5, 4, 3, 2, 1,1, 2, 3, 4, 5,5, 4, 3, 2, 1,1, 2, 3, 4, 5;Eigen::MatrixXf kernel(3, 3);kernel << 1, 0, -1,1, 5, -1,1, 4, -1;int stride = 2;//第一種實現：正常卷積{//卷積Eigen::MatrixXf output = conv2D(input, kernel, stride);std::cout << "1: Conv2D Output:\n" << output << std::endl;//反卷積Eigen::MatrixXf output1 = deconv2D(output,kernel, stride);std::cout << "1: deconv2D output1:\n" << output1 << std::endl;}//第二種實現：轉置卷積{Eigen::MatrixXf Unfold = Conv2DTransposed(input.rows(),input.cols(),kernel,stride);std::cout << "2: Unfold:\n" << Unfold << std::endl;Eigen::VectorXf Input = input.reshaped<Eigen::RowMajor>();Eigen::MatrixXf output = Unfold * Input;std::cout << "2: Conv2D Output:\n" << output << std::endl;Eigen::MatrixXf output1 =  (Unfold.transpose() * output).reshaped<Eigen::RowMajor>(input.rows(),input.cols());std::cout << "2: deconv2D output1:\n" << output1 << std::endl;}//第三種種實現：圖像轉換為列  矩陣相乘實現  加速運算{Eigen::MatrixXf input_unroll = im2col(input, kernel.rows(),kernel.cols(), stride);Eigen::RowVectorXf kernel_unroll = kernel.reshaped<Eigen::RowMajor>();Eigen::MatrixXf output = kernel_unroll * input_unroll ;std::cout << "3: Conv2D Output:\n" << output << std::endl;Eigen::MatrixXf output_unroll11 = kernel_unroll.transpose() * output;std::cout << "3: output_unroll11:\n" << output_unroll11 << std::endl;Eigen::MatrixXf output1 = col2im(output_unroll11, input.rows(),input.cols(),kernel.rows(),kernel.cols(), stride);std::cout << "3: deconv2D output1:\n" << output1 << std::endl;}}

1: Conv2D Output:
26 24
26 24
1: deconv2D output1:26   0  -2   0 -2426 130  -2 120 -2452 104  -4  96 -4826 130  -2 120 -2426 104  -2  96 -24
2: Unfold:1  0 -1  0  0  1  5 -1  0  0  1  4 -1  0  0  0  0  0  0  0  0  0  0  0  00  0  1  0 -1  0  0  1  5 -1  0  0  1  4 -1  0  0  0  0  0  0  0  0  0  00  0  0  0  0  0  0  0  0  0  1  0 -1  0  0  1  5 -1  0  0  1  4 -1  0  00  0  0  0  0  0  0  0  0  0  0  0  1  0 -1  0  0  1  5 -1  0  0  1  4 -1
2: Conv2D Output:
26
24
26
24
2: deconv2D output1:26   0  -2   0 -2426 130  -2 120 -2452 104  -4  96 -4826 130  -2 120 -2426 104  -2  96 -24
3: Conv2D Output:
26 24 26 24
3: output_unroll11:26  24  26  240   0   0   0
-26 -24 -26 -2426  24  26  24
130 120 130 120
-26 -24 -26 -2426  24  26  24
104  96 104  96
-26 -24 -26 -24
3: deconv2D output1:26   0  -2   0 -2426 130  -2 120 -2452 104  -4  96 -4826 130  -2 120 -2426 104  -2  96 -24

卷積的次數計算

在這里插入圖片描述

當然可以。給定一個輸入特征圖的大小和一個濾波器的大小，以及卷積的步長和填充，以下是如何計算卷積后的輸出特征圖的維度的完整公式：

高度 $H_2$ 的計算：
$H_2 = \frac{H_1 - F_{H} + 2P}{S} + 1$
寬度 $W_2$ 的計算：
$W_2 = \frac{W_1 - F_{W} + 2P}{S} + 1$

其中：

$H_1, W_1$ 是輸入特征圖的高和寬。
$F_H, F_W$ 是濾波器的高和寬。
$P$ 是填充的數量。
$S$ 是步長。

以下是使用C++和Eigen庫實現的示例：

#include <Eigen/Dense>
#include <iostream>
#include <cmath>std::pair<int, int> computeConvTimes(int input_rows, int input_cols, int kernel_rows, int kernel_cols, int stride) {int rows_times = (input_rows - kernel_rows) / stride + 1;int cols_times = (input_cols - kernel_cols) / stride + 1;return {rows_times, cols_times};
}int main() {int input_rows = 5, input_cols = 5;int kernel_rows = 3, kernel_cols = 3;int stride = 2;auto [rows_times, cols_times] = computeConvTimes(input_rows, input_cols, kernel_rows, kernel_cols, stride);std::cout << "Rows can be convolved: " << rows_times << " times.\n";std::cout << "Columns can be convolved: " << cols_times << " times.\n";return 0;
}