卷積神經網路(CNN)詳解

紅色石頭 發表於 2021-08-05
神經網路

章節

  • Filter
  • 池化

  • Demo

  • 冷知識

  • 參考

卷積神經網路(CNN)詳解

CNN 一共分為輸入,卷積,池化,拉直,softmax,輸出

卷積由互關運算(用Filter完成)和啟用函式

Filter

CNN常用於影像識別,在深度學習中我們不可能直接將圖片輸入進去,向量是機器學習的通行證,我們將圖片轉換為畫素矩陣再送進去,對於黑白的圖片,每一個點只有一個畫素值,若為彩色的,每一個點會有三個畫素值(RGB)

互關運算其實就是做矩陣點乘運算,用下面的Toy Example說明:其實就是用kernel(filter)來與畫素矩陣區域性做乘積,如下圖,output的第一個陰影值其實是input和kernel的陰影部分進行矩陣乘法所得

卷積神經網路(CNN)詳解

接下來引入一個引數(Stride),代表我們每一次濾波器在畫素矩陣上移動的步幅,步幅共分為水平步幅和垂直步幅,下圖為水平步幅為2,垂直步幅為3的設定

卷積神經網路(CNN)詳解

所以filter就不斷滑過圖片,所到之處做點積,那麼,做完點積之後的shape是多少呢?假設input shape是32 * 32,stride 為1,filter shape 為4 * 4,那麼結束後的shape為29 * 29,計算公式是((input shape – filter shape) / stride ) + 1,記住在深度學習中務必要掌握每一層的輸入輸出。

那麼,假如stride改為3,那麼((32 – 4) / 3) + 1 不是整數,所以這樣的設定是錯誤的,那麼,我們可以通過padding的方式填充input shape,用0去填充,這裡padding設為1,如下圖,填充意味著輸入的寬和高都會進行增加2 * 1,那麼接下來的out shape 就是 ((32 + 2 * 1 – 4)/3) + 1,即為11 * 11

卷積神經網路(CNN)詳解

接下來引入通道(channel),或為深度(depth)的介紹,一張彩色照片的深度為3,每一個畫素點由3個值組成,我們的filter的輸入通道或者說是深度應該和輸入的一致,舉例來說,一張照片32 * 32 * 3,filter可以設定為3 * 3 * 3,我們剛開始理解了一維的互關運算,三維無非就是filter拿出每一層和輸入的每一層做運算,最後再組成一個深度為3的輸出,這裡stride設定為1,padding也為1,所以輸出的shape為30 * 30 * 3。

卷積的時候是用多個filter完成的,一般經過卷積之後的output shape 的輸入通道(深度)為filter的數量,下圖為輸入深度為2的操作,會發現一個filter的輸出最終會相加,將它的深度壓為1,而不是一開始的輸入通道。這是一個filter,多個filter最後放在一起,最後的深度就是filter的數量了。

卷積神經網路(CNN)詳解

Q & A:

1.卷積的意義是什麼呢?

其實如果用圖片處理上的專業術語,被叫做銳化,卷積其實強調某些特徵,然後將特徵強化後提取出來,不同的卷積核關注圖片上不同的特徵,比如有的更關注邊緣而有的更關注中心地帶等等,如下圖:

卷積神經網路(CNN)詳解

當完成幾個卷積層後(卷積 + 啟用函式 + 池化):

卷積神經網路(CNN)詳解

可以看出,一開始提取一些比較基礎簡單的特徵,比如邊角,後面會越來越關注某個區域性比如頭部甚至是整體

2.如何使得不同的卷積核關注不同的地方?

設定filter矩陣的值,比如input shape是4 * 4的,filter是2 * 2,filter是以一個一個小區域為單位,如果說我們想要關注每一個小區域的左上角,那麼將filter矩陣的第一個值設為1,其他全為0即可

總結來說,就是通過不斷改變filter矩陣的值來關注不同的細節,提取不同的特徵

3.filter矩陣裡的權重引數是怎麼來的?

首先會初始化權重引數,然後通過梯度下降不斷降低loss來獲得最好的權重引數

4.常見引數的預設設定有哪些?

一般filter的數量(output channels)通常可以設定為2的指數次,如32,64,128,512,這裡提供一組比較穩定的搭配(具體還得看任務而定),F(kernel_size/filter_size)= 3,stride = 1,padding = 1;F = 5,stride = 1,Padding = 2;F = 1,S = 1,P = 0

5.引數數量?

舉例來說,filter的shape為5 * 5 * 3 ,一共6個,stride設定為1,padding設為2,卷積層為(32 * 32 * 6),注意卷積層這裡是代表最後的輸出shape,輸入shape為 32 * 32 * 3,那麼所需要的引數數量為 6 * (5 * 5 * 3 + 1),裡面 +1 的原因是原因是做完點積運算之後會加偏置(bias),當然這個引數是可以設定為沒有的

6.1 x 1 卷積的意義是什麼?

filter的shape為1 x 1,stride = 1,padding = 0,假如input為32 * 32 * 3,那麼output shape = (32 – 1) / 1 + 1 = 32,換言之,它並沒有改變原來的shape,但是filter的數量可以決定輸出通道,所以,1 x 1的卷積目的是改變輸出通道。可以對輸出通道進行升維或者降維,降維之後乘上的引數數量會減少,訓練會更快,記憶體佔用會更少。升維或降維的技術在ResNet中同樣運用到啦(右圖):

卷積神經網路(CNN)詳解

另外,其實1 x 1的卷積不過是實現多通道之間的線性疊加,如果你還記得上面多通道的意思,1 x 1 卷積改變卷積核的數量,無非就是使得不同的feature map進行線性疊加而已(feature map指的是最後輸出的每一層疊加出來的),因為通道的數量可以隨時改變,1 x 1卷積也可以有跨通道資訊交流的內涵。

池化

卷積好之後會用RELU進行啟用,當然,這並不會改變原來的shape,這樣可以增加模型的非線性相容性,如果模型是線性的,很容易出問題,如XOR問題,接下來進行池化操作(Pooling),常見的是MaxPooling(最大池化),它基本上長得跟filter一樣,只不過功能是選出區域內的最大值。假如我們的shape是4 * 4 ,池化矩陣的shape是2 * 2,那麼池化後的shape是2 * 2(4 / 2)

那麼,池化的意義是什麼?池化又可以被成為向下取樣(DownSample),經過池化之後shape會減小不少,如果說卷積的意義是提取出特徵,那麼,池化的意義是在這些特徵中取出最有代表性的特徵,這樣可以降低畫素的重複性,使得後續的卷積更有意義,同時可以降低shape,使得計算更為方便

當然,也還有平均池化(AveragePooling),這樣做試圖包含區域內的所有的特徵,那麼,如果圖片相鄰色素重複很多,那麼最大池化是不錯的,如果說一張圖片很多不同的特徵需要關注,那麼可以考慮平均池化

補充一下,可以給上述池操作加一個Global,這就意味著全域性,而不是一個一個的小區域

Demo

!!!我的PyTorch完整Demo在:

https://colab.research.google.com/drive/1XMlSmiZ4FjHohptX-GSHsT_CFs4EoE6f?usp=sharing

進行卷積池化這樣一組操作多次之後再全部拉直送入全連線網路,最後輸出10個值,然後優化它們與真實標籤的交叉熵損失,接下來用PyTorch和TensorFlow實操一下

首先先搭建一個簡單的PyTorch網路,這裡採用Sequential容器寫法,當然也可以按照普遍的self.conv1 = …,按照Sequential寫法更加簡潔明瞭,後面前向傳播函式也沒有采取x = …不斷更新x,而是直接放進layer,遍歷每一層即可,簡潔乾淨

# 匯入庫
import torch
from torch import nn
import torchvision
from torchvision import datasets,transforms
import torch.nn.functional as F
import matplotlib.pyplot as plt
class Net(nn.Module):
   def __init__(self):
      super().__init__()
      self.layer = nn.Sequential(
                   nn.Conv2d(in_channels=1,out_channels=32,kernel_size=3),nn.ReLU(),
                   nn.MaxPool2d(kernel_size=2),
                   nn.Conv2d(32,64,2),nn.ReLU(),
                   nn.MaxPool2d(2,2),
                   nn.Flatten(),
                   nn.Linear(64 * 6 * 6,10),nn.Softmax(),
                   )

   def forward(self,x):
      x = self.layer(x)
      return x

PyTorch中輸入必須為(1,1,28,28),這裡比tensorflow多了一個1,原因是Torch中有一個group引數,預設為1,所以可以不設定,如果為N,就會把輸入分為N個小部分,每一個部分進行卷積,最後再將結果拼接起來

搭建好網路之後,建議先檢驗一下網路和優化器引數

# 如果GPU沒有就會調到CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
model = Net().to(device)
print(model.parameters)
# 訓練時還需要優化器(Optimizer)
optimizer = torch.optim.Adam(model.parameters())
print(optimizer)

卷積神經網路(CNN)詳解

接下來定義訓練和測試函式,先介紹幾個小知識

model.train() # 啟用BatchNormalization和Dropout
model.eval() # 因為是測試,所以取消兩者
i = torch.tensor([
    [1,2,3],
    [4,5,6]
])
# 輸出最大的值和它的索引
print(i.max(1,keepdim=True))
# torch.return_types.max(values=tensor([[3],[6]]), indices=tensor([[2],[2]]))
# 一般只要索引的話:
print(i.max(1,keepdim=True))[1]
# tensor([[2],
#         [2]])
a = torch.tensor([1,2,3,4])
b = torch.tensor([[1],
                  [-1],
                  [-2],
                  2])
# 將a轉換為與b形狀相同
a.view_as(b)
print(a)
# tensor([[1],
#        [2],
#        [3],
#        [4]])

# 相對於numpy的equal函式,判斷tensor裡每一個值是否相等
# 輸出為True 或者 False
print(b.eq(a.view_as(b)))

# tensor([[ True],
#        [False],
#        [False],
#        [False]])

# 求和用來判斷損失和準確率
# True --> 1,False --> 0
print(b.eq(a.view_as(b)).sum())

# tensor(1)

# 最後將PyTorch的tensor轉換為Python中標準值
print(b.eq(a.view_as(b)).sum().item())
# 1
# 下載訓練和測試資料集
# transforms函式可以對下載的資料做一些預處理
# Compose 指的是將多個transforms操作組合在一起
# ToTensor 是將[0,255] 範圍 轉換為[0,1]
# 灰度圖片(channel=1),所以每一個括號內只有一個值,前者代表mean,後者std(標準差)
# 彩色圖片(channel=3),所以每一個括號內有三個值,如
# transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,),(0.5,))
])

data_train = datasets.MNIST(root="填自己的主路徑",
                            transform=transform,
                            train=True,
                            download=True)

data_test = datasets.MNIST(root="填自己的主路徑",
                           transform=transform,
                           train=False)
# 載入資料集
# Load Data
train_loader = torch.utils.data.DataLoader(dataset=data_train,
                                                batch_size=64,
                                                shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=data_test,
                                               batch_size=64,
                                               shuffle=True)

每一次新的batch中都需要梯度清零,否則的話梯度就會跨batch

def train(model,device,train_loader,optimizer,epoch):
    model.train()
    for batch_idx,(data,target) in enumerate(train_loader):
        data,target = data.to(device),target.to(device)
        optimizer.zero_grad() # 梯度清零
        output = model(data)
        loss = F.nll_loss(output,target) # negative likelihood loss
        loss.backward() # 誤差反向傳播
        optimizer.step() # 引數更新
        if (batch_idx + 1) % 200 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item())) # .item()轉換為python值
    return loss.item()

因為測試的時候不需要更新引數,所以with torch.no_grad()

# 定義測試函式
def test(model, device, test_loader):
    model.eval()
    test_loss,correct = 0 , 0
    with torch.no_grad(): # 不track梯度
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.nll_loss(output, target, reduction = 'sum') # 將一批的損失相加
            pred = output.max(1, keepdim = True)[1] # 找到概率最大的下標
            correct += pred.eq(target.view_as(pred)).sum().item() # equals
    test_loss /= len(test_loader.dataset)
    acc = correct / len(test_loader.dataset)
    print("\nTest set: Average loss: {:.4f}, Accuracy: {} ({:.0f}%) \n".format(
        test_loss, acc ,
        100.* correct / len(test_loader.dataset)
            ))

    return acc

接下來定義視覺化函式

def visualize(lis,epoch,*label):
    plt.xlabel("epochs")
    plt.ylabel(label)
    plt.plot(epoch,lis)
    plt.show()

最後進行訓練和測試

BATCH_SIZE = 512 # 大概需要2G的視訊記憶體
EPOCHS = 20 # 總共訓練批次
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
train_ = []
test_acc = []
for epoch in range(1,EPOCHS+1):
    train_loss = train(model,DEVICE,train_loader,optimizer,epoch)
    acc = test(model,DEVICE,test_loader)
    train_.append(train_loss)
    test_acc.append(acc)

visualize(train_,[i for i in range(20)],"loss")
visualize(test_acc,[i for i in range(20)],"accuracy")

卷積神經網路(CNN)詳解

接下來使用tensorflow-gpu 1.14.0再實操一下

from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import matplotlib as mpl
import sys 

# solve could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.compat.v1.InteractiveSession(config=config)

# 不同庫版本,使用此程式碼塊檢視
print(sys.version_info)
for module in mpl,np,tf,keras:
  print(module.__name__,module.__version__)

'''
sys.version_info(major=3, minor=6, micro=9, releaselevel='final', serial=0)
matplotlib 3.3.4
numpy 1.16.0
tensorflow 1.14.0
tensorflow.python.keras.api._v1.keras 2.2.4-tf
'''
# If you get numpy futurewarning,then try numpy 1.16.0

# load train and test
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Scale images to the [0, 1] range
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255

# 1 Byte = 8 Bits,2^8 -1 = 255。[0,255]代表圖上的畫素,同時除以一個常數進行歸一化。1 就代表全部塗黑。0 就代表沒塗

# Make sure images have shape (28, 28, 1)
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

# CNN 的輸入方式必須得帶上channel,這裡擴充一下維度

# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

# y 屬於 [0,9]代表手寫數字的標籤,這裡將它轉換為0-1表示,可以類比one-hot,舉個例子,如果是2

# [[0,0,1,0,0,0,0,0,0,0]……]

model = keras.Sequential(
    [
        keras.Input(shape=(28, 28, 1)),
        keras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation="relu"),
        keras.layers.MaxPooling2D(pool_size=(2, 2)),
        keras.layers.Conv2D(filters=64, kernel_size=(3, 3), activation="relu"),
        keras.layers.MaxPooling2D(pool_size=(2, 2)),
        keras.layers.Flatten(),
        keras.layers.Dense(units=10, activation="softmax"),
    ]
)

# 注意,Conv2D裡面有啟用函式不代表在卷積和池化的時候進行。而是在DNN裡進行,最後拉直後直接接softmax就行


# kernel_size 代表濾波器的大小,pool_size 代表池化的濾波器的大小

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])

model.summary()

history = model.fit(x_train, y_train, batch_size=128, epochs=15, validation_split=0.1) #10層交叉檢驗
score = model.evaluate(x_test, y_test)
print("Test loss:", score[0])
print("Test accuracy:", score[1])

# Test loss: 0.03664601594209671
# Test accuracy: 0.989300012588501

# visualize accuracy and loss
def plot_(history,label):
    plt.plot(history.history[label])
    plt.plot(history.history["val_" + label])
    plt.title("model " + label)
    plt.ylabel(label)
    plt.xlabel("epoch")
    plt.legend(["train","test"],loc = "upper left")
    plt.show()

plot_(history,"acc")
plot_(history,"loss")

在機器學習中畫精確度和loss的圖很有必要,這樣可以發現自己的程式碼中是否存在問題,並且將這個問題視覺化

卷積神經網路(CNN)詳解

卷積神經網路(CNN)詳解

冷知識

We don’t minimize total loss to find the best function.

我們採取將資料打亂並分組成一個一個的mini-batch,每個資料所含的資料個數也是可調的。關於epoch

卷積神經網路(CNN)詳解

將一個mini-batch中的loss全部加起來,就更新一次引數。一個epoch就等於將所有的mini-batch都遍歷一遍,並且經過一個就更新一次引數。

如果epoch設為20,就將上述過程重複20遍

這裡再細談一下batch 和 epoch

卷積神經網路(CNN)詳解

由圖可知,當batch數目越多,分的越開,每一個epoch的速度理所應當就會上升的,當batch_size = 1的時候,1 epoch 就更新引數50000次 和 batch_size = 10的時候,1 epoch就更新5000次,那麼如果更新次數相等的話,batch_size = 1會花166s;batch_size = 10每個epoch會花17s,總的時間就是17 * 10 = 170s。其實batch_size = 1不就是SGD。隨機化很不穩定,相對而言,batch_size = 10,收斂的會更穩定,時間和等於1的差不多。那麼何樂而不為呢?

肯定有人要問了?隨機速度快可以理解,看一眼就更新一次引數

卷積神經網路(CNN)詳解

為什麼batch_size = 10速度和它差不多呢?按照上面來想,應該是一個mini-batch結束再來下一個,這樣慢慢進行下去,其實沒理由啊。

接下來以batch_size = 2來介紹一下

卷積神經網路(CNN)詳解

學過線性代數應該明白,可以將同維度的向量拼成矩陣,來進行矩陣運算,這樣每一個mini-batch都在同一時間計算出來,即為平行運算

所有平行運算GPU都能進行加速。
那麼,好奇的是到底計算機看到了什麼?是一個一個的數字嗎?

卷積神經網路(CNN)詳解

其實這件事情很反直覺,原以為計算機是看一張一張的圖片,可是這個很難看出是單個數字而是數字集,那麼我們試試看最大化畫素

卷積神經網路(CNN)詳解

其實左下角的6其實蠻像的耶。

參考

https://zh-v2.d2l.ai/

https://demo.leemeng.tw/

http://cs231n.stanford.edu/

https://www.youtube.com/watch?v=FrKWiRv254g&list=PLJV_el3uVTsPy9oCRY30oBPNLCo89yu49&index=19


卷積神經網路(CNN)詳解

相關文章