利用Pytorch實現ResNet網絡構建及模型訓練

Posted on by

構建網絡

ResNet由一系列堆疊的殘差塊組成，其主要作用是通過無限制地增加網絡深度，從而使其更加強大。在建立ResNet模型之前，讓我們先定義4個層，每個層由多個殘差塊組成。這些層的目的是降低空間尺寸，同時增加通道數量。

以ResNet50為例，我們可以使用以下代碼來定義ResNet網絡：

class ResNet(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace
（續）
即模型需要在輸入層加入一些 normalization 和激活層。
```python
import torch.nn.init as init
class Flatten(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self, x):
        return x.view(x.size(0), -1)
class ResNet(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.layer1 = nn.Sequential(
            ResidualBlock(64, 256, stride=1),
            *[ResidualBlock(256, 256) for _ in range(1, 3)]
        )
        self.layer2 = nn.Sequential(
            ResidualBlock(256, 512, stride=2),
            *[ResidualBlock(512, 512) for _ in range(1, 4)]
        )
        self.layer3 = nn.Sequential(
            ResidualBlock(512, 1024, stride=2),
            *[ResidualBlock(1024, 1024) for _ in range(1, 6)]
        )
        self.layer4 = nn.Sequential(
            ResidualBlock(1024, 2048, stride=2),
            *[ResidualBlock(2048, 2048) for _ in range(1, 3)]
        )
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.flatten = Flatten()
        self.fc = nn.Linear(2048, num_classes)
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
                init.constant_(m.weight, 1)
                init.constant_(m.bias, 0)
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = self.avgpool(x)
        x = self.flatten(x)
        x = self.fc(x)
        return x

改進點如下：

  • 我們使用nn.Sequential組件，將多個殘差塊組合成一個功能塊（layer）。這樣可以方便地修改網絡深度，並將其與其他層分離九更容易上手，例如遷移學習中重新訓練頂部分類器時。
  • 我們在ResNet的輸出層添加瞭標準化和激活函數。它們有助於提高模型的收斂速度並改善性能。
  • 對於nn.Conv2d和批標準化層等神經網絡組件，我們使用瞭PyTorch中的內置初始化函數。它們會自動為我們設置好每層的參數。
  • 我們還添加瞭一個Flatten層，將4維輸出展平為2維張量，以便通過接下來的全連接層進行分類。

訓練模型

我們現在已經實現瞭ResNet50模型，接下來我們將解釋如何訓練和測試該模型。

首先我們需要定義損失函數和優化器。在這裡，我們使用交叉熵損失函數，以及Adam優化器。

import torch.optim as optim
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ResNet(num_classes=1000).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

在使用PyTorch進行訓練時，我們通常會創建一個循環，為每個批次的輸入數據計算損失並對模型參數進行更新。以下是該循環的代碼：

def train(model, optimizer, criterion, train_loader, device):
    model.train()
    train_loss = 0
    correct = 0
    total = 0
    for batch_idx, (inputs, targets) in enumerate(train_loader):
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        _, predicted = outputs.max(1)
        total += targets.size(0)
        correct += predicted.eq(targets).sum().item()
    acc = 100 * correct / total
    avg_loss = train_loss / len(train_loader)
    return acc, avg_loss

在上面的訓練循環中，我們首先通過model.train()代表進入訓練模式。然後使用optimizer.zero_grad()清除

以上就是利用Pytorch實現ResNet網絡構建及模型訓練的詳細內容，更多關於Pytorch ResNet構建網絡模型訓練的資料請關註WalkonNet其它相關文章！

推薦閱讀：