全網都在要Manus AI邀請碼，可能是 DeepSeek 后最大驚喜
VGG塊的組成規律是：連續使?數個相同的填充為1、窗口形狀為3 ×3的卷積層后接上?個步幅為2、窗口形狀為2 ×2的最?池化層。卷積層保持輸?的?和寬不變，而池化層則對其減半。
從李沐大神的《動手學深度學習》中有提到，VGG塊的實現為：
import d2lzh as d2l
from mxnet import gluon, init, nd
from mxnet.gluon import nn
def vgg_block(num_convs, num_channels):
blk = nn.Sequential()
for _ in range(num_convs):
blk.add(nn.Conv2D(num_channels, kernel_size=3, padding=1, activation='relu'))
blk.add(nn.MaxPool2D(pool_size=2, strides=2))
return blk而我們經常用torch的話，可以這樣實現：
import torch
import torch.nn as nn
def vgg_block(in_channels, out_channels, num_convs, kernel_size=3, stride=1, padding=1):
layers = []
for _ in range(num_convs):
layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding))
layers.append(nn.ReLU(inplace=True))
in_channels = out_channels
layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
return nn.Sequential(*layers)
# 創建一個包含2個卷積層的VGG塊
vgg_block_example = vgg_block(in_channels=64, out_channels=128, num_convs=2)
# 打印VGG塊的結構
print(vgg_block_example)而VGG網絡則是通過多個 VGG 塊堆疊而成，常見的結構是 VGG-16 和 VGG-19，分別表示包含 16 和 19 層可訓練參數的網絡。
VGG16的網絡結構如圖所示：
網絡的具體設計如下：
VGGNet-16由13個卷積層和3個全連接層組成。下面我會列出每一層的具體信息，可能有點長，這個其實作為了解就夠了：
第一層卷積的輸入圖像大小為224×224×3，使用64個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為224×224×64，接著應用ReLU激活函數。
第二層卷積的輸入為224×224×64，使用64個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為224×224×64，再應用ReLU激活函數，隨后進行最大池化，使用2×2大小的池化核、步長為2、填充為0，最終輸出112×112×64。
第三層卷積的輸入為112×112×64，使用128個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為112×112×128，隨后應用ReLU激活函數。
第四層卷積的輸入為112×112×128，使用128個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為112×112×128，應用ReLU后進行最大池化，池化核大小為2×2、步長為2、填充為0，最終輸出56×56×128。
第五層卷積的輸入為56×56×128，使用256個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為56×56×256，隨后應用ReLU激活函數。
第六層卷積的輸入為56×56×256，使用256個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為56×56×256，再應用ReLU激活函數。
第七層卷積的輸入為56×56×256，使用256個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為56×56×256，經過ReLU激活后進行最大池化，池化核大小為2×2、步長為2、填充為0，最終輸出28×28×256。
第八層卷積的輸入為28×28×256，使用512個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為28×28×512，隨后應用ReLU激活函數。
第九層卷積的輸入為28×28×512，使用512個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為28×28×512，接著應用ReLU激活函數。
第十層卷積的輸入為28×28×512，使用512個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為28×28×512，應用ReLU后進行最大池化，池化核大小為2×2、步長為2、填充為0，最終輸出14×14×512。
第十一層卷積的輸入為14×14×512，使用512個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為14×14×512，隨后應用ReLU激活函數。
第十二層卷積的輸入為14×14×512，使用512個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為14×14×512，再應用ReLU激活函數。
第十三層卷積的輸入為14×14×512，使用512個大小為3×3、步長為1、填充為1的卷積核，輸出特征圖大小為14×14×512，應用ReLU后進行最大池化，池化核大小為2×2、步長為2、填充為0，最終輸出7×7×512。
VGG16中的13個卷積層均采用大小為3×3、步長為1、填充為1的卷積核，而5次最大池化操作均使用大小為2×2、步長為2、填充為0的池化核。
VGG 的顯著特點是結構簡單，所有卷積層的參數大小都相同。這種一致性讓它易于理解和實現。
接下來我基于torch來實現VGG網絡：
import torch
import torch.nn as nn
# 定義VGG16和VGG19的配置，數字代表輸出通道，M代表池化層
cfgs = {
'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
'VGG19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}
# 添加模型層
def make_layers(cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if v == 'M':
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = v
return nn.Sequential(*layers)
# 定義VGG模型
class VGG(nn.Module):
def __init__(self, features, num_classes=1000):
super(VGG, self).__init__()
self.features = features
self.classifier = nn.Sequential(
nn.Linear(512 * 7 * 7, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, num_classes),
)
def forward(self, x):
x = self.features(x)
x = torch.flatten(x, 1)
x = self.classifier(x)
return x
# 創建VGG16和VGG19模型實例
def vgg_model(model_name='VGG16', num_classes=1000, batch_norm=False):
cfg = cfgs[model_name]
model = VGG(make_layers(cfg, batch_norm=batch_norm), num_classes=num_classes)
return model
# 創建VGG16模型實例
model_vgg16 = vgg_model('VGG16')
print(model_vgg16)
# 創建VGG19模型實例
model_vgg19 = vgg_model('VGG19')
print(model_vgg19)在訓練 VGG 網絡時，有幾個常用的處理方式：
transform = transforms.Compose([
transforms.RandomResizedCrop(224), # 隨機裁剪到224x224
transforms.RandomHorizontalFlip(), # 隨機水平翻轉
transforms.ToTensor(), # 將圖像轉換為張量
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), # 歸一化處理
])訓練代碼可以參考我下面的這部分代碼：
# 加載數據集
train_dataset = ImageFolder(root='./data/train', transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
val_dataset = ImageFolder(root='./data/val', transform=transform)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)
# 初始化模型、損失函數和優化器
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = vgg_model(model_name='VGG16', num_classes=1000).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# 定義訓練函數
def train_model(model, train_loader, val_loader, criterion, optimizer, num_epochs=25, device='cuda'):
since = time.time()
best_acc = 0.0
writer = SummaryWriter()
for epoch in range(num_epochs):
print(f'Epoch {epoch}/{num_epochs - 1}')
print('-' * 10)
# 訓練階段：計算損失、反向傳播、更新權重。
model.train()
running_loss = 0.0
running_corrects = 0
for inputs, labels in train_loader:
inputs = inputs.to(device)
labels = labels.to(device)
optimizer.zero_grad()
with torch.set_grad_enabled(True):
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / len(train_loader.dataset)
epoch_acc = running_corrects.double() / len(train_loader.dataset)
writer.add_scalar('Loss/train', epoch_loss, epoch)
writer.add_scalar('Accuracy/train', epoch_acc, epoch)
print(f'Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
# 驗證階段：計算驗證集上的損失和準確率。
model.eval()
val_running_loss = 0.0
val_running_corrects = 0
for inputs, labels in val_loader:
inputs = inputs.to(device)
labels = labels.to(device)
with torch.set_grad_enabled(False):
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
val_running_loss += loss.item() * inputs.size(0)
val_running_corrects += torch.sum(preds == labels.data)
val_epoch_loss = val_running_loss / len(val_loader.dataset)
val_epoch_acc = val_running_corrects.double() / len(val_loader.dataset)
writer.add_scalar('Loss/val', val_epoch_loss, epoch)
writer.add_scalar('Accuracy/val', val_epoch_acc, epoch)
print(f'Val Loss: {val_epoch_loss:.4f} Acc: {val_epoch_acc:.4f}')
# 保存最佳模型
if val_epoch_acc > best_acc:
best_acc = val_epoch_acc
torch.save(model.state_dict(), 'best_model.pth')
print()
# 開始訓練
train_model(model, train_loader, val_loader, criterion, optimizer, num_epochs=25, device=device)盡管 VGG 的性能不錯，但它的計算成本和存儲需求較高，并且現在有了性能更好的其他模型作為替代，VGG現在還是作為學習多了解即可。
1 NiN塊
NiN全名叫做Network in Network，通過引入全局思維解決了傳統 CNN 模型中局部性強的問題。NiN 塊的核心是用 1×1 卷積層替代全連接層：
在花書中，nin塊的實現是這樣的：
import d2lzh as d2l
from mxnet import gluon, init, nd
from mxnet.gluon import nn
def nin_block(num_channels, kernel_size, strides, padding):
blk = nn.Sequential()
blk.add(nn.Conv2D(num_channels, kernel_size,strides, padding, activation='relu'),
nn.Conv2D(num_channels, kernel_size=1, activation='relu'),
nn.Conv2D(num_channels, kernel_size=1, activation='relu'))
return blkNiN 塊一般由三個主要部分組成：
2 NiN模型
NiN 模型是由多個 NiN 塊堆疊而成，通常在塊之間插入最大池化層來壓縮特征：
通過這種設計，NiN 不僅提升了計算效率，還減輕了過擬合風險。
因此我們可以得到NiN模型的簡單實現如下：
net = nn.Sequential()
net.add(nin_block(96, kernel_size=11, strides=4, padding=0),
nn.MaxPool2D(pool_size=3, strides=2),
nin_block(256, kernel_size=5, strides=1, padding=2),
nn.MaxPool2D(pool_size=3, strides=2),
nin_block(384, kernel_size=3, strides=1, padding=1),
nn.MaxPool2D(pool_size=3, strides=2), nn.Dropout(0.5),
# 標簽類別數是10
nin_block(10, kernel_size=3, strides=1, padding=1),
# 全局平均池化層將窗?形狀?動設置成輸?的?和寬
nn.GlobalAvgPool2D(),
# 將四維的輸出轉成?維的輸出，其形狀為(批量??, 10)
nn.Flatten())3 訓練模型
訓練 NiN 模型時與 VGG 相似，但 NiN 由于參數更少，對硬件要求稍低：
NiN 的創新點在于將全局信息和局部信息結合，但受限于設計思想，NiN 的表達能力與后續更復雜的模型相比還是有所不足。當然，作為經典的網絡模型架構，還是值得我們一學，作為了解即可
1 Inception塊
GoogLeNet 的核心是 Inception 塊，通過多分支的并行計算從多種尺度提取特征。每個 Inception 塊包括：
通過以上設計，Inception 塊實現了高效的多尺度特征提取。下面是使用torch對Inception塊的實現：
class Inception(nn.Module):
def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
super(Inception, self).__init__()
# 1x1卷積路徑
self.branch1 = nn.Sequential(
nn.Conv2d(in_channels, ch1x1, kernel_size=1),
nn.ReLU(inplace=True)
)
# 1x1卷積 + 3x3卷積路徑
self.branch2 = nn.Sequential(
nn.Conv2d(in_channels, ch3x3red, kernel_size=1),
nn.ReLU(inplace=True),
nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1),
nn.ReLU(inplace=True)
)
# 1x1卷積 + 5x5卷積路徑
self.branch3 = nn.Sequential(
nn.Conv2d(in_channels, ch5x5red, kernel_size=1),
nn.ReLU(inplace=True),
nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2),
nn.ReLU(inplace=True)
)
# 3x3最大池化 + 1x1卷積路徑
self.branch4 = nn.Sequential(
nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
nn.Conv2d(in_channels, pool_proj, kernel_size=1),
nn.ReLU(inplace=True)
)
def forward(self, x):
branch1 = self.branch1(x)
branch2 = self.branch2(x)
branch3 = self.branch3(x)
branch4 = self.branch4(x)
# 將四個分支的輸出在通道維度上拼接
outputs = [branch1, branch2, branch3, branch4]
return torch.cat(outputs, 1)2 GoogLeNet模型
GoogLeNet 是由多個 Inception 塊堆疊而成的深度網絡，并結合一些特殊設計：
因此googlenet的實現也比剛才提到的兩個模型架構要稍微復雜一丟丟，用torch的實現方式如下：
class GoogLeNet(nn.Module):
def __init__(self, num_classes=1000):
super(GoogLeNet, self).__init__()
# 初始卷積層
self.conv1 = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
nn.LocalResponseNorm(size=5, alpha=0.0001, beta=0.75, k=1)
)
# 第二卷積層
self.conv2 = nn.Sequential(
nn.Conv2d(64, 64, kernel_size=1),
nn.ReLU(inplace=True),
nn.Conv2d(64, 192, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.LocalResponseNorm(size=5, alpha=0.0001, beta=0.75, k=1),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
)
# Inception模塊
self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)
self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)
self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)
self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)
self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)
self.maxpool4 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)
# 輔助分類器
self.aux1 = nn.Sequential(
nn.AvgPool2d(kernel_size=5, stride=3),
nn.Conv2d(512, 128, kernel_size=1),
nn.ReLU(inplace=True),
nn.Flatten(),
nn.Linear(2048, 1024),
nn.ReLU(inplace=True),
nn.Dropout(0.7),
nn.Linear(1024, num_classes)
)
self.aux2 = nn.Sequential(
nn.AvgPool2d(kernel_size=5, stride=3),
nn.Conv2d(528, 128, kernel_size=1),
nn.ReLU(inplace=True),
nn.Flatten(),
nn.Linear(2048, 1024),
nn.ReLU(inplace=True),
nn.Dropout(0.7),
nn.Linear(1024, num_classes)
)
# 最終分類器
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.dropout = nn.Dropout(0.4)
self.fc = nn.Linear(1024, num_classes)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = self.inception3a(x)
x = self.inception3b(x)
x = self.maxpool3(x)
x = self.inception4a(x)
if self.training:
aux1 = self.aux1(x)
x = self.inception4b(x)
x = self.inception4c(x)
x = self.inception4d(x)
if self.training:
aux2 = self.aux2(x)
x = self.inception4e(x)
x = self.maxpool4(x)
x = self.inception5a(x)
x = self.inception5b(x)
x = self.avgpool(x)
x = torch.flatten(x, 1)
x = self.dropout(x)
x = self.fc(x)
if self.training:
return x, aux1, aux2
else:
return x
model = GoogLeNet(num_classes=1000)
print(model)看著很長，其實沒有那么復雜（你別忘了現在的模型可比這些復雜多了）。GoogLeNet 的訓練過程更復雜，但效率較高：
盡管 GoogLeNet 的設計獨特，但其復雜性較高，后來被更現代的架構（如 ResNet）所取代。
VGG、NiN 和 GoogLeNet 是深度學習發展過程中具有里程碑意義的模型。它們的設計理念各有側重：
這些網絡的誕生不僅提升了圖像分類的精度，還為后續的深度學習模型奠定了基礎。雖然現在有了更好的模型更好的架構，但是無論是學習經典架構還是設計新模型，理解這些網絡的設計思想都是至關重要的。
本文章轉載微信公眾號@Chal1ceAI
