摘要

1、SENet概述

? Squeeze-and-Excitation Networks（簡稱 SENet）是 Momenta 胡杰團隊（WMW）提出的新的網路結構，利用SENet，一舉取得最后一屆 ImageNet 2017 競賽 Image Classification 任務的冠軍，在ImageNet資料集上將top-5 error降低到2.251%，原先的最好成績是2.991%，

作者在文中將SENet block插入到現有的多種分類網路中，都取得了不錯的效果，作者的動機是希望顯式地建模特征通道之間的相互依賴關系，另外，作者并未引入新的空間維度來進行特征通道間的融合，而是采用了一種全新的「特征重標定」策略，具體來說，就是通過學習的方式來自動獲取到每個特征通道的重要程度，然后依照這個重要程度去提升有用的特征并抑制對當前任務用處不大的特征，

通俗的來說SENet的核心思想在于通過網路根據loss去學習特征權重，使得有效的feature map權重大，無效或效果小的feature map權重小的方式訓練模型達到更好的結果，SE block嵌在原有的一些分類網路中不可避免地增加了一些引數和計算量，但是在效果面前還是可以接受的 ，Sequeeze-and-Excitation(SE) block并不是一個完整的網路結構，而是一個子結構，可以嵌到其他分類或檢測模型中，

2、SENet 結構組成詳解

上述結構中，Squeeze 和 Excitation 是兩個非常關鍵的操作，下面進行詳細說明，

上圖是SE 模塊的示意圖，給定一個輸入 x，其特征通道數為 C ′ {C}' C′，通過一系列卷積等一般變換后得到一個特征通道數為C 的特征，通過下面的三個操作還重標前面得到的特征：

1、Squeeze 操作，順著空間維度來進行特征壓縮，將每個二維的特征通道變成一個實數，這個實數某種程度上具有全域的感受野，并且輸出的維度和輸入的特征通道數相匹配，它表征著在特征通道上回應的全域分布，而且使得靠近輸入的層也可以獲得全域的感受野，這一點在很多任務中都是非常有用的，

2、 Excitation 操作，它是一個類似于回圈神經網路中門的機制，通過引數 w 來為每個特征通道生成權重，其中引數 w 被學習用來顯式地建模特征通道間的相關性，

3、 Reweight 操作，將 Excitation 的輸出的權重看做是進過特征選擇后的每個特征通道的重要性，然后通過乘法逐通道加權到先前的特征上，完成在通道維度上的對原始特征的重標定，

3、詳細的計算程序

首先 F t r F_{tr} Ftr?這一步是轉換操作（嚴格講并不屬于SENet，而是屬于原網路，可以看后面SENet和Inception及ResNet網路的結合），在文中就是一個標準的卷積操作而已，輸入輸出的定義如下表示：

?

那么這個 F t r F_{tr} Ftr?的公式就是下面的公式1（卷積操作， V c V_{c} Vc?表示第c個卷積核， X s X^{s} Xs表示第s個輸入)，

?
F t r F_{tr} Ftr?得到的U就是Figure1中的左邊第二個三維矩陣，也叫tensor，或者叫C個大小為HW的feature map，而uc表示U中第c個二維矩陣，下標c表示channel，
接下來就是Squeeze操作，公式非常簡單，就是一個global average pooling:
?
因此公式2就將的 H × W × C H \times W \times C H×W×C輸入轉換成 1 × 1 × C 1 \times 1 \times C 1×1×C的輸出，對應Figure1中的Fsq操作，為什么會有這一步呢？這一步的結果相當于表明該層C個feature map的數值分布情況，或者叫全域資訊，
再接下來就是Excitation操作，如公式3，直接看最后一個等號，前面squeeze得到的結果是z，這里先用W1乘以z，就是一個全連接層操作，W1的維度是 C / r × C C/ r \times C C/r×C，這個r是一個縮放引數，在文中取的是16，這個引數的目的是為了減少channel個數從而降低計算量，又因為z的維度是 1 × 1 × C 1 \times 1\times C 1×1×C所以W1z的結果就是 1 × 1 × C / r 1 \times 1 \times C / r 1×1×C/r；然后再經過一個ReLU層，輸出的維度不變；然后再和W2相乘，和W2相乘也是一個全連接層的程序，W2的維度是 C × C / r C \times C/r C×C/r，因此輸出的維度就是 1 × 1 × C 1 \times 1 \times C 1×1×C；最后再經過sigmoid函式，得到s：
?
也就是說最后得到的這個s的維度是 1 × 1 × C 1 \times 1 \times C 1×1×C，C表示channel數目，這個s其實是本文的核心，它是用來刻畫tensor U中C個feature map的權重，而且這個權重是通過前面這些全連接層和非線性層學習得到的，因此可以end-to-end訓練，這兩個全連接層的作用就是融合各通道的feature map資訊，因為前面的squeeze都是在某個channel的feature map里面操作，
在得到s之后，就可以對原來的tensor U操作了，就是下面的公式4，也很簡單，就是channel-wise multiplication，什么意思呢？ u c u_{c} uc?是一個二維矩陣， s c s_{c} sc?是一個數，也就是權重，因此相當于把矩 u c u_{c} uc?陣中的每個值都乘以 s c s_{c} sc?，對應Figure1中的Fscale，

SENet 在具體網路中應用（代碼實作SE_ResNet）

介紹完具體的公式實作，下面介紹下SE block怎么運用到具體的網路之中，

上圖是將 SE 模塊嵌入到 Inception 結構的一個示例，方框旁邊的維度資訊代表該層的輸出，

這里我們使用 global average pooling 作為 Squeeze 操作，緊接著兩個 Fully Connected 層組成一個 Bottleneck 結構去建模通道間的相關性，并輸出和輸入特征同樣數目的權重，我們首先將特征維度降低到輸入的 1/16，然后經過 ReLu 激活后再通過一個 Fully Connected 層升回到原來的維度，這樣做比直接用一個 Fully Connected 層的好處在于：

1）具有更多的非線性，可以更好地擬合通道間復雜的相關性；

2）極大地減少了引數量和計算量，然后通過一個 Sigmoid 的門獲得 0~1 之間歸一化的權重，最后通過一個 Scale 的操作來將歸一化后的權重加權到每個通道的特征上，

除此之外，SE 模塊還可以嵌入到含有 skip-connections 的模塊中，上右圖是將 SE 嵌入到 ResNet 模塊中的一個例子，操作程序基本和 SE-Inception 一樣，只不過是在 Addition 前對分支上 Residual 的特征進行了特征重標定，如果對 Addition 后主支上的特征進行重標定，由于在主干上存在 0~1 的 scale 操作，在網路較深 BP 優化時就會在靠近輸入層容易出現梯度消散的情況，導致模型難以優化，

目前大多數的主流網路都是基于這兩種類似的單元通過 repeat 方式疊加來構造的，由此可見，SE 模塊可以嵌入到現在幾乎所有的網路結構中，通過在原始網路結構的 building block 單元中嵌入 SE 模塊，我們可以獲得不同種類的 SENet，如 SE-BN-Inception、SE-ResNet、SE-ReNeXt、SE-Inception-ResNet-v2 等等，

本例通過實作SE-ResNet,來顯示如何將SE模塊嵌入到ResNet網路中，SE-ResNet模型如下圖：

實戰詳解

1、資料集

資料集選用植物幼苗分類，總共12類，資料集連接如下：
鏈接：https://pan.baidu.com/s/1gYb-3XCZBhBoEFyj6d_kdw
提取碼：q060

在工程的根目錄新建data檔案夾，獲取資料集后，將trian和test解壓放到data檔案夾下面，如下圖：

2、安裝庫，并匯入需要的庫

本專案用到pretrainedmodels，這里有seresenet的預訓練模型，安裝方法：

pip install pretrainedmodels

安裝完成后，匯入到專案中，

import torch.optim as optim
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
from dataset.dataset import SeedlingData
from torch.autograd import Variable
import pretrainedmodels

3、設定全域引數

設定使用GPU，設定學習率、BatchSize、epoch等引數

# 設定全域引數
modellr = 1e-4
BATCH_SIZE = 16
EPOCHS = 50
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

4、資料預處理

資料處理比較簡單，沒有做復雜的嘗試，有興趣的可以加入一些處理，

# 資料預處理

transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

])
transform_test = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])

5、資料讀取

然后我們在dataset檔案夾下面新建 init.py和dataset.py，在mydatasets.py檔案夾寫入下面的代碼：

說一下代碼的核心邏輯，

第一步 建立字典，定義類別對應的ID,用數字代替類別，

第二步 在__init__里面撰寫獲取圖片路徑的方法，測驗集只有一層路徑直接讀取，訓練集在train檔案夾下面是類別檔案夾，先獲取到類別，再獲取到具體的圖片路徑，然后使用sklearn中切分資料集的方法，按照7：3的比例切分訓練集和驗證集，

第三步 在__getitem__方法中定義讀取單個圖片和類別的方法，由于影像中有位深度32位的，所以我在讀取影像的時候做了轉換，

代碼如下：

# coding:utf8
import os
from PIL import Image
from torch.utils import data
from torchvision import transforms as T
from sklearn.model_selection import train_test_split
 
Labels = {'Black-grass': 0, 'Charlock': 1, 'Cleavers': 2, 'Common Chickweed': 3,
          'Common wheat': 4, 'Fat Hen': 5, 'Loose Silky-bent': 6, 'Maize': 7, 'Scentless Mayweed': 8,
          'Shepherds Purse': 9, 'Small-flowered Cranesbill': 10, 'Sugar beet': 11}
 
 
class SeedlingData (data.Dataset):
 
    def __init__(self, root, transforms=None, train=True, test=False):
        """
        主要目標： 獲取所有圖片的地址，并根據訓練，驗證，測驗劃分資料
        """
        self.test = test
        self.transforms = transforms
 
        if self.test:
            imgs = [os.path.join(root, img) for img in os.listdir(root)]
            self.imgs = imgs
        else:
            imgs_labels = [os.path.join(root, img) for img in os.listdir(root)]
            imgs = []
            for imglable in imgs_labels:
                for imgname in os.listdir(imglable):
                    imgpath = os.path.join(imglable, imgname)
                    imgs.append(imgpath)
            trainval_files, val_files = train_test_split(imgs, test_size=0.3, random_state=42)
            if train:
                self.imgs = trainval_files
            else:
                self.imgs = val_files
 
    def __getitem__(self, index):
        """
        一次回傳一張圖片的資料
        """
        img_path = self.imgs[index]
        img_path=img_path.replace("\\",'/')
        if self.test:
            label = -1
        else:
            labelname = img_path.split('/')[-2]
            label = Labels[labelname]
        data = Image.open(img_path).convert('RGB')
        data = self.transforms(data)
        return data, label
 
    def __len__(self):
        return len(self.imgs)

然后我們在train.py呼叫SeedlingData讀取資料 ，記著匯入剛才寫的dataset.py(from mydatasets import SeedlingData)

# 讀取資料
dataset_train = SeedlingData('data/train', transforms=transform, train=True)
dataset_test = SeedlingData("data/train", transforms=transform_test, train=False)
# 匯入資料
train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=False)

6、設定模型

• 設定loss函式為nn.CrossEntropyLoss()，
• 設定模型為se_resnet50，修改最后一層全連接輸出改為12，
• 優化器設定為adamw，

# 實體化模型并且移動到GPU
criterion = nn.CrossEntropyLoss()
model_ft = pretrainedmodels.__dict__['se_resnet50'](num_classes=1000, pretrained='imagenet')
model_ft.fc = classifier = nn.Sequential(
    nn.Linear(2048, 512),
    nn.LeakyReLU(True),
    nn.Dropout(0.5),
    nn.Linear(512, 12),
)
model_ft.to(DEVICE)
# 選擇簡單暴力的Adam優化器，學習率調低
optimizer = optim.AdamW(model_ft.parameters(), lr=modellr)

7、定義訓練和驗證函式

def adjust_learning_rate(optimizer, epoch):
    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
    modellrnew = modellr * (0.1 ** (epoch // 50))
    print("lr:", modellrnew)
    for param_group in optimizer.param_groups:
        param_group['lr'] = modellrnew


# 定義訓練程序

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    sum_loss = 0
    total_num = len(train_loader.dataset)
    print(total_num, len(train_loader))
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = Variable(data).to(device), Variable(target).to(device)
        output = model(data)
        loss = criterion(output, target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        print_loss = loss.data.item()
        sum_loss += print_loss
        if (batch_idx + 1) % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
                       100. * (batch_idx + 1) / len(train_loader), loss.item()))
    ave_loss = sum_loss / len(train_loader)
    print('epoch:{},loss:{}'.format(epoch, ave_loss))


# 驗證程序
def val(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    total_num = len(test_loader.dataset)
    print(total_num, len(test_loader))
    with torch.no_grad():
        for data, target in test_loader:
            data, target = Variable(data).to(device), Variable(target).to(device)
            output = model(data)
            loss = criterion(output, target)
            _, pred = torch.max(output.data, 1)
            correct += torch.sum(pred == target)
            print_loss = loss.data.item()
            test_loss += print_loss
        correct = correct.data.item()
        acc = correct / total_num
        avgloss = test_loss / len(test_loader)
        print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            avgloss, correct, len(test_loader.dataset), 100 * acc))
# 訓練
for epoch in range(1, EPOCHS + 1):
    adjust_learning_rate(optimizer, epoch)
    train(model_ft, DEVICE, train_loader, optimizer, epoch)
    val(model_ft, DEVICE, test_loader)
torch.save(model_ft, 'model.pth')

8、測驗

我介紹兩種常用的測驗方式，第一種是通用的，通過自己手動加載資料集然后做預測，具體操作如下：

測驗集存放的目錄如下圖：

第一步 定義類別，這個類別的順序和訓練時的類別順序對應，一定不要改變順序！！！！

classes = ('Black-grass', 'Charlock', 'Cleavers', 'Common Chickweed',
           'Common wheat', 'Fat Hen', 'Loose Silky-bent',
           'Maize', 'Scentless Mayweed', 'Shepherds Purse', 'Small-flowered Cranesbill', 'Sugar beet')

第二步 定義transforms，transforms和驗證集的transforms一樣即可，別做資料增強，

transform_test = transforms.Compose([
         transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])

第三步 加載model，并將模型放在DEVICE里，

DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = torch.load("model.pth")
model.eval()
model.to(DEVICE)

第四步 讀取圖片并預測圖片的類別，在這里注意，讀取圖片用PIL庫的Image，不要用cv2，transforms不支持，

path = 'data/test/'
testList = os.listdir(path)
for file in testList:
    img = Image.open(path + file)
    img = transform_test(img)
    img.unsqueeze_(0)
    img = Variable(img).to(DEVICE)
    out = model(img)
    # Predict
    _, pred = torch.max(out.data, 1)
    print('Image Name:{},predict:{}'.format(file, classes[pred.data.item()]))

第二種，使用自定義的Dataset讀取圖片，前三步同上，差別主要在第四步，讀取資料的時候，使用Dataset的SeedlingData讀取，

dataset_test =SeedlingData('data/test/', transform_test,test=True)
print(len(dataset_test))
# 對應檔案夾的label
 
for index in range(len(dataset_test)):
    item = dataset_test[index]
    img, label = item
    img.unsqueeze_(0)
    data = Variable(img).to(DEVICE)
    output = model(data)
    _, pred = torch.max(output.data, 1)
    print('Image Name:{},predict:{}'.format(dataset_test.imgs[index], classes[pred.data.item()]))
    index += 1

關注公眾號，回復“senet實戰”，獲取代碼、資料集和模型，