• 🍨 本文為🔗365天深度學(xué)習(xí)訓(xùn)練營 中的學(xué)習(xí)記錄博客
• 🍖 原作者：K同學(xué)啊

一、實驗?zāi)康?#xff1a;

1. 閱讀ResNeXt論文，了解作者的構(gòu)建思路
2. 對比之前介紹的ResNet50V2、DenseNet算法
3. 使用ResNeXt-50算法完成猴痘病識別

二、實驗環(huán)境：

• 語言環(huán)境：python 3.8
• 編譯器：Jupyter notebook
• 深度學(xué)習(xí)環(huán)境：Pytorch
  • torch==2.4.0+cu124
  • torchvision==0.19.0+cu124

三、模型介紹

ResNeXt是由何凱明團隊在2017年CVPR會議上提出來的新型圖像分類網(wǎng)絡(luò)。ResNeXt是ResNet的升級版，在ResNet的基礎(chǔ)上，引入了cardinality的概念，類似于ResNet，ResNeXt也有ResNeXt-50，ResNeXt-101的版本。

ResNeXt論文原文：Aggregated Residual Transformations for Deep Neural Networks。

這篇文章介紹了一種用于圖像分類的簡單而有效的網(wǎng)絡(luò)架構(gòu)，該網(wǎng)絡(luò)采用了VGG/ResNets的策略，通過重復(fù)層來增加深度和寬度，并利用分裂-變換-合并策略以易于擴展的方式進行轉(zhuǎn)換。文章還提出了一個新的維度——“基數(shù)”，它是指轉(zhuǎn)換集合的大小，可以在保持復(fù)雜性不變的情況下提高分類準確性。作者在ImageNet-1K數(shù)據(jù)集上進行了實證研究，證明了這種方法的有效性。

下圖是ResNet（左）與ResNeXt（右）block的差異。在ResNet中，輸入的具有256個通道的特征經(jīng)過1×1卷積壓縮4倍到64個通道，之后3×3的卷積核用于處理特征，經(jīng)1×1卷積擴大通道數(shù)與原特征殘差連接后輸出。

ResNeXt也是相同的處理策略，但在ResNeXt中，輸入的具有256個通道的特征被分為32個組，每組被壓縮64倍到4個通道后進行處理。32個組相加后與原特征殘差連接后輸出。這里cardinatity指的是一個block中所具有的相同分支的數(shù)目。

分組卷積

ResNeXt中采用的分組卷機簡單來說就是將特征圖分為不同的組，再對每組特征圖分別進行卷積，這個操作可以有效的降低計算量。
在分組卷積中，每個卷積核只處理部分通道，比如下圖中，紅色卷積核只處理紅色的通道，綠色卷積核只處理綠色通道，黃色卷積核只處理黃色通道。此時每個卷積核有2個通道，每個卷積核生成一張?zhí)卣鲌D。


總結(jié)：ResNeXt-50網(wǎng)絡(luò)簡單講就是在ResNet結(jié)構(gòu)的基礎(chǔ)上采用了聚合殘差結(jié)構(gòu)和局部連接結(jié)構(gòu)，同時引入了Random Erasing和Mixup等數(shù)據(jù)增強和正則化方法。

• Random Erasing是一種數(shù)據(jù)增強技術(shù)，隨機刪除圖像中的一些像素，并用隨機值填充，從而增強模型的泛化性能。該技術(shù)可以防止模型過分關(guān)注圖像中的一些細節(jié)和特定的區(qū)域，從而更好地適應(yīng)新的數(shù)據(jù)。此外，Random Erasing還可以增加數(shù)據(jù)集的多樣性，從而降低過擬合的風(fēng)險。
• Mixup則是一種數(shù)據(jù)增強和正則化技術(shù)，將兩張圖像的像素按比例混合，生成一張新的圖像作為輸入，從而提高模型的魯棒性和泛化性能。Mixup的基本思想是在訓(xùn)練過程中使用凸組合的方法，將輸入的不同樣本進行線性組合，從而生成一些新的數(shù)據(jù)樣本。這種方法可以有效地增加數(shù)據(jù)集的多樣性，從而提高模型的泛化性能。此外，Mixup還可以作為一種正則化技術(shù)，可以降低模型的過擬合風(fēng)險。

四、使用Pytorch實現(xiàn)ResNeXt-50

設(shè)置GPU、導(dǎo)入數(shù)據(jù)、劃分數(shù)據(jù)集等步驟同前。

1. 構(gòu)建模型

class Bottleneck(nn.Module):expansion = 4def __init__(self, in_channel, out_channel, stride=1, downsample=None,groups=1, width_per_group=64):super(Bottleneck, self).__init__()width = int(out_channel * (width_per_group / 64.)) * groupsself.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width,kernel_size=1, stride=1, bias=False)  # squeeze channelsself.bn1 = nn.BatchNorm2d(width)# -----------------------------------------self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, groups=groups,kernel_size=3, stride=stride, bias=False, padding=1)self.bn2 = nn.BatchNorm2d(width)# -----------------------------------------self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel*self.expansion,kernel_size=1, stride=1, bias=False)  # unsqueeze channelsself.bn3 = nn.BatchNorm2d(out_channel*self.expansion)self.relu = nn.ReLU(inplace=True)self.downsample = downsampledef forward(self, x):identity = xif self.downsample is not None:identity = self.downsample(x)out = self.conv1(x)out = self.bn1(out)out = self.relu(out)out = self.conv2(out)out = self.bn2(out)out = self.relu(out)out = self.conv3(out)out = self.bn3(out)out += identityout = self.relu(out)return out

class ResNet(nn.Module):def __init__(self,block,blocks_num,num_classes=1000,include_top=True,groups=1,width_per_group=64):super(ResNet, self).__init__()self.include_top = include_topself.in_channel = 64self.groups = groupsself.width_per_group = width_per_groupself.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,padding=3, bias=False)self.bn1 = nn.BatchNorm2d(self.in_channel)self.relu = nn.ReLU(inplace=True)self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)self.layer1 = self._make_layer(block, 64, blocks_num[0])self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)if self.include_top:self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # output size = (1, 1)self.fc = nn.Linear(512 * block.expansion, num_classes)for m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')def _make_layer(self, block, channel, block_num, stride=1):downsample = Noneif stride != 1 or self.in_channel != channel * block.expansion:downsample = nn.Sequential(nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),nn.BatchNorm2d(channel * block.expansion))layers = []layers.append(block(self.in_channel,channel,downsample=downsample,stride=stride,groups=self.groups,width_per_group=self.width_per_group))self.in_channel = channel * block.expansionfor _ in range(1, block_num):layers.append(block(self.in_channel,channel,groups=self.groups,width_per_group=self.width_per_group))return nn.Sequential(*layers)def forward(self, x):x = self.conv1(x)x = self.bn1(x)x = self.relu(x)x = self.maxpool(x)x = self.layer1(x)x = self.layer2(x)x = self.layer3(x)x = self.layer4(x)if self.include_top:x = self.avgpool(x)x = torch.flatten(x, 1)x = self.fc(x)return x

def resnext50_32x4d(num_classes=1000, include_top=True):# 預(yù)訓(xùn)練權(quán)重：https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pthgroups = 32width_per_group = 4return ResNet(Bottleneck, [3, 4, 6, 3],num_classes=num_classes,include_top=include_top,groups=groups,width_per_group=width_per_group)model = resnext50_32x4d(num_classes=4, include_top=True)
model.to(device)# 統(tǒng)計模型參數(shù)量以及其他指標
import torchsummary as summary
summary.summary(model,(3,224,224))

代碼輸出部分截圖：

2. 編寫訓(xùn)練與測試函數(shù)

# 編寫訓(xùn)練函數(shù)
def train(dataloader, model, loss_fn, optimizer):size = len(dataloader.dataset)num_batches = len(dataloader)train_acc, train_loss = 0, 0for X, y in dataloader:X, y = X.to(device), y.to(device)pred = model(X)loss = loss_fn(pred, y)optimizer.zero_grad()loss.backward()optimizer.step()train_loss += loss.item()train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss /= num_batchestrain_acc /= sizereturn train_acc, train_loss

# 編寫測試函數(shù)
def test(dataloader, model, loss_fn):size = len(dataloader.dataset)  # 測試集的大小num_batches = len(dataloader)  # 批次數(shù)目, (size/batch_size，向上取整)test_loss, test_acc = 0, 0# 當(dāng)不進行訓(xùn)練時，停止梯度更新，節(jié)省計算內(nèi)存消耗with torch.no_grad():for imgs, target in dataloader:imgs, target = imgs.to(device), target.to(device)# 計算losstarget_pred = model(imgs)loss = loss_fn(target_pred, target)test_loss += loss.item()test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()test_acc /= sizetest_loss /= num_batchesreturn test_acc, test_loss

3. 設(shè)置損失函數(shù)和學(xué)習(xí)率

import copyloss_fn = nn.CrossEntropyLoss()
learn_rate = 1e-4
opt = torch.optim.Adam(model.parameters(), lr=learn_rate)scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=1, gamma=0.9)  # 定義學(xué)習(xí)率高度器epochs = 100  # 設(shè)置訓(xùn)練模型的最大輪數(shù)為100，但可能到不了100
patience = 10  # 早停的耐心值，即如果模型連續(xù)10個周期沒有準確率提升，則跳出訓(xùn)練train_loss = []
train_acc = []
test_loss = []
test_acc = []
best_acc = 0  # 設(shè)置一個最佳的準確率，作為最佳模型的判別指標
no_improve_epoch = 0  # 用于跟蹤準確率是否提升的計數(shù)器
epoch = 0  # 用于統(tǒng)計最終的訓(xùn)練模型的輪數(shù)，這里設(shè)置初始值為0；為繪圖作準備，這里的繪圖范圍不是epochs = 100

4. 正式訓(xùn)練

# 開始訓(xùn)練
for epoch in range(epochs):model.train()epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)model.eval()epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)if epoch_test_acc > best_acc:best_acc = epoch_test_accbest_model = copy.deepcopy(model)no_improve_epoch = 0  # 重置計數(shù)器# 保存最佳模型的檢查點PATH = 'J6_best_model.pth'torch.save({'epoch': epoch,'model_state_dict': best_model.state_dict(),'optimizer_state_dict': opt.state_dict(),'loss': epoch_test_loss,}, PATH)else:no_improve_epoch += 1if no_improve_epoch >= patience:print(f"Early stop triggered at epoch {epoch + 1}")break  # 早停train_acc.append(epoch_train_acc)train_loss.append(epoch_train_loss)test_acc.append(epoch_test_acc)test_loss.append(epoch_test_loss)scheduler.step()  # 更新學(xué)習(xí)率lr = opt.state_dict()['param_groups'][0]['lr']template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss, lr))

代碼輸出部分截圖：

5. 結(jié)果可視化

# 結(jié)果可視化
# Loss與Accuracy圖import matplotlib.pyplot as plt
# 隱藏警告
import warnings
warnings.filterwarnings("ignore")  # 忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用來正常顯示中文標簽
plt.rcParams['axes.unicode_minus'] = False  # 用來正常顯示負號
plt.rcParams['figure.dpi'] = 100  # 分辨率epochs_range = range(epoch)plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

6. 預(yù)測

from PIL import Imageclasses = list(total_data.class_to_idx)def predict_one_image(image_path, model, transform, classes):test_img = Image.open(image_path).convert('RGB')plt.imshow(test_img)  # 展示預(yù)測的圖片test_img = transform(test_img)img = test_img.to(device).unsqueeze(0)model.eval()output = model(img)_, pred = torch.max(output, 1)pred_class = classes[pred]print(f'預(yù)測結(jié)果是：{pred_class}')import os
from pathlib import Path
import random#從所有的圖片的隨機選擇一張圖片image=[]
def image_path(data_dir):file_list=os.listdir(data_dir)                       #列出四個分類標簽data_file_dir=file_list                              #從四個分類標簽中隨機選擇一個data_dir=Path(data_dir)for i in data_file_dir:i=Path(i)image_file_path=data_dir.joinpath(i)            #拼接路徑data_file_paths=image_file_path.iterdir()       #羅列文件夾的內(nèi)容data_file_paths=list(data_file_paths)           #要轉(zhuǎn)換為列表image.append(data_file_paths)file=random.choice(image)                           #從所有的圖像中隨機選擇一類file=random.choice(file)                            #從選擇的類中隨機選擇一張圖片return filedata_dir='./monkeypox_photos'
image_path=image_path(data_dir)# 預(yù)測訓(xùn)練集中的某張照片
predict_one_image(image_path=image_path,model=model,transform=train_transforms,classes=classes)

# 模型評估
# 將參數(shù)加載到model當(dāng)中
best_model.load_state_dict(torch.load(PATH,map_location=device))
epoch_test_acc,epoch_test_loss=test(test_dl,best_model,loss_fn)
epoch_test_acc,epoch_test_loss

(0.8508158508158508, 0.39013327977487017)

總結(jié)

ResNeXt是在ResNet的網(wǎng)絡(luò)架構(gòu)上，使用類似于Inception的分治思想，即split-tranform-merge策略，將模塊中的網(wǎng)絡(luò)拆開分組，與Inception不同，每組的卷積核大小一致，這樣其感受野一致，但由于每組的卷積核參數(shù)不同，提取的特征自然不同。然后將每組得到的特征進行concat操作后，再與原輸入特征x或者經(jīng)過卷積等處理（即進行非線性變換）的特征進行Add操作。這樣做的好處是，在不增加參數(shù)復(fù)雜度的前提下提高準確率，同時還能提高超參數(shù)的數(shù)量。

另外，cardinality是基的意思，將數(shù)個通道特征進行分組，不同的特征組之間可以看作是由不同基組成的子空間，每個組的核雖然一樣，但參數(shù)不同，在各自的子空間中學(xué)到的特征就多種多樣，這點跟transformer中的Multi-head attention不謀而合（Multi-head attention allows the model to jointly attend to information from different representation subspaces.）而且分組進行特征提取，使得學(xué)到的特征冗余度降低，獲取能起到正則化的作用。

ResNeXt-50與ResNet50V2、DenseNet的對比：

• 網(wǎng)絡(luò)結(jié)構(gòu)：
  • ResNeXt-50：基于ResNet結(jié)構(gòu)改進而來，采用聚合殘差結(jié)構(gòu)和局部連接結(jié)構(gòu)。它通過重復(fù)構(gòu)建塊來構(gòu)建，每個構(gòu)建塊聚合了一組具有相同拓撲結(jié)構(gòu)的轉(zhuǎn)換。引入了分組卷積的方法，可以將不同的通道分組處理，還使用了深度可分離卷積的方法進一步減少計算量。
  • ResNet50V2：是ResNet系列中的經(jīng)典模型，由50層卷積層、批量歸一化、激活函數(shù)和池化層構(gòu)成。引入了一種全新的殘差塊結(jié)構(gòu)，即bottleneck結(jié)構(gòu)，使得網(wǎng)絡(luò)參數(shù)量大幅度降低，同時精度也有所提升。
  • DenseNet：其特點是不同于傳統(tǒng)的網(wǎng)絡(luò)結(jié)構(gòu)，每一層的輸出不僅和前一層的輸出有關(guān)，還和之前所有層的輸出有關(guān)，這種密集連接的結(jié)構(gòu)可以有效地緩解梯度消失和參數(shù)稀疏問題，提高了模型的泛化能力和精度。它由多個denseblock和transition層組成，denseblock內(nèi)部采用密集連接，相鄰denseblock之間通過transition層連接并降低特征圖大小。
• 精度和計算量：
  • ResNeXt-50：在相同的深度下具有更高的精度，并且在參數(shù)量和計算量上都顯著降低。在較深的網(wǎng)絡(luò)結(jié)構(gòu)下，優(yōu)勢更加明顯，可以達到更高的精度。
  • ResNet50V2：能在保持較低參數(shù)量的同時，實現(xiàn)較高的精度。
  • DenseNet：在參數(shù)和計算成本更少的情形下實現(xiàn)比ResNet更優(yōu)的性能，通過特征在channel上的連接來實現(xiàn)特征重用，減少了網(wǎng)絡(luò)的參數(shù)總量，但由于密集連接方式，計算量相對較大。
• 適用范圍：
  • ResNeXt-50：適用于各種圖像分類任務(wù)，在對精度要求較高且計算資源相對充足的場景下表現(xiàn)良好。
  • ResNet50V2：廣泛適用于各種圖像分類任務(wù)，尤其在對模型復(fù)雜度和精度有一定平衡要求的場景中應(yīng)用較多。
  • DenseNet：適用于對特征重用和模型緊湊性要求較高的任務(wù)，例如圖像分類、目標檢測等，但在計算資源有限的情況下，可能需要對其進行適當(dāng)?shù)恼{(diào)整或優(yōu)化。

它們各自的優(yōu)點和創(chuàng)新之處如下：

• ResNeXt-50：
  • 優(yōu)點：在不明顯增加參數(shù)量的情況下提升了準確率，具有很好的可擴展性和可適應(yīng)性，超參數(shù)數(shù)量相對較少，便于模型移植。
  • 創(chuàng)新：提出aggregated residual transformations結(jié)構(gòu)，利用分組卷積構(gòu)建平行堆疊相同拓撲結(jié)構(gòu)的blocks，代替原來ResNet的三層卷積的block；同時引入了cardinality的概念，即通過增加分組的數(shù)量（基數(shù)），可以在不增加模型復(fù)雜度的前提下提高性能，實驗表明增加基數(shù)比增加深度或?qū)挾雀行А?/li>
• ResNet50V2：
  • 優(yōu)點：通過改進殘差結(jié)構(gòu)，先進行批量歸一化和激活函數(shù)計算后再卷積，并將addition后的ReLU計算放到殘差結(jié)構(gòu)內(nèi)部，提高了模型的精度，同時降低了參數(shù)量。
  • 創(chuàng)新：全新的殘差塊結(jié)構(gòu)（bottleneck結(jié)構(gòu)），減少了網(wǎng)絡(luò)參數(shù)量，使得在保持較高精度的同時，模型更容易訓(xùn)練和優(yōu)化，這種結(jié)構(gòu)上的創(chuàng)新為后續(xù)許多網(wǎng)絡(luò)的設(shè)計提供了借鑒思路。
• DenseNet：
  • 優(yōu)點：緩解了梯度消失問題，加強了特征傳播，鼓勵了特征復(fù)用，極大地減少了網(wǎng)絡(luò)的參數(shù)總量，在參數(shù)較少的情況下能取得較好的性能，而且通過密集連接方式，提升了梯度的反向傳播，使得網(wǎng)絡(luò)更容易訓(xùn)練，對過擬合有一定的抑制作用。
  • 創(chuàng)新：建立了前面所有層與后面層的密集連接機制，實現(xiàn)了特征重用，每個層都會與前面所有層在channel維度上連接并作為下一層的輸入，這一創(chuàng)新的連接方式充分利用了特征信息，與傳統(tǒng)的網(wǎng)絡(luò)結(jié)構(gòu)相比，在相同性能下可以減少參數(shù)數(shù)量，提高了模型的效率和泛化能力。此外，在denseblock中使用bottleneck層來減少計算量，以及在transition層采用特定的結(jié)構(gòu)來處理特征圖的尺寸匹配問題，也是其重要的創(chuàng)新點。