pytorch fcn

PyTorch FCN是一种基于全卷积网络（Fully Convolutional Network）的语义分割模型，它在2015年首次提出并广泛应用于语义分割任务中。FCN的思想是将传统的卷积神经网络转换成全卷积结构，使其能够接受任意大小的输入并输出对应的像素级别的语义分割结果。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* *2* *3* [语义分割系列1-FCN(全卷积网络)（pytorch实现）](https://blog.csdn.net/yumaomi/article/details/124730993)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"]
[ .reference_list ]

相关问题

pytorch fcn训练

### 如何使用 PyTorch 实现 FCN 训练

#### 准备工作
为了成功训练一个FCN模型，需要准备好相应的数据集以及定义好网络架构。对于图像分割任务来说，输入的数据通常是带有标注的图片。

#### 数据加载与预处理
在实际操作前，先要加载并预处理数据。这一步骤中会涉及到读取文件路径、解码图像、调整大小等一系列操作。得益于PyTorch优秀的集成能力，可以借助`torchvision.transforms`模块轻松完成这些任务[^2]。

import torch
from torchvision import transforms, datasets

transform = transforms.Compose([
    transforms.Resize((256, 256)), 
    transforms.ToTensor()
])

dataset = datasets.ImageFolder(root='path/to/dataset', transform=transform)

dataloader = torch.utils.data.DataLoader(dataset, batch_size=4, shuffle=True)

#### 定义FCN模型结构
基于VGG16设计了一个简单的FCN头部（FCNHead），它包含了几个重要的组成部分：全卷积层、跳跃连接机制和上采样过程。这里采用的是最基础版本的FCN-VGG16作为例子[^3]。

class FCNVGG16(nn.Module):
    def __init__(self, num_classes):
        super(FCNVGG16, self).__init__()
        
        vgg_features = models.vgg16(pretrained=True).features
        
        # 去掉最后几层池化后的部分
        self.backbone = nn.Sequential(*list(vgg_features.children())[:-7])
    
        # 添加自定义的FCN Head
        self.fcn_head = nn.Conv2d(in_channels=512, out_channels=num_classes, kernel_size=(1, 1))
        
    def forward(self, x):
        features = self.backbone(x)
        output = F.interpolate(input=self.fcn_head(features), size=x.shape[-2:], mode="bilinear", align_corners=False)
        return output

#### 设置损失函数与优化算法
针对语义分割问题，常用的损失函数有交叉熵损失等。而Adam是一种较为流行的梯度下降法变种，在很多情况下都能取得不错的效果[^4]。

criterion = nn.CrossEntropyLoss(weight=None, ignore_index=-100)
optimizer = optim.Adam(model.parameters(), lr=0.001)

#### 开始训练循环
进入正式的训练阶段后，每一轮迭代都会经历以下几个步骤：获取批次样本 -> 将其送入GPU (如果可用的话) -> 执行forward pass得到预测结果 -> 计算loss值 -> 反向传播更新权重参数->记录当前epoch的各项指标变化情况。

device = 'cuda' if torch.cuda.is_available() else 'cpu'
model.to(device)

for epoch in range(num_epochs):
    model.train()

    running_loss = 0.
    for images, labels in dataloader:
        images, labels = images.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
    
    print(f"[Epoch {epoch+1}/{num_epochs}] Loss: {(running_loss/len(dataloader)):.4f}")

pytorch FCN8s代码编写

FCN8s（Fully Convolutional Network）是一个经典的语义分割模型，下面是使用PyTorch实现FCN8s的代码：

import torch
import torch.nn as nn
import torch.nn.functional as F

class FCN8s(nn.Module):
    def __init__(self, num_classes):
        super(FCN8s, self).__init__()

        # conv1
        self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, padding=100)
        self.relu1_1 = nn.ReLU(inplace=True)
        self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
        self.relu1_2 = nn.ReLU(inplace=True)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)

        # conv2
        self.conv2_1 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.relu2_1 = nn.ReLU(inplace=True)
        self.conv2_2 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
        self.relu2_2 = nn.ReLU(inplace=True)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)

        # conv3
        self.conv3_1 = nn.Conv2d(128, 256, kernel_size=3, padding=1)
        self.relu3_1 = nn.ReLU(inplace=True)
        self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, padding=1)
        self.relu3_2 = nn.ReLU(inplace=True)
        self.conv3_3 = nn.Conv2d(256, 256, kernel_size=3, padding=1)
        self.relu3_3 = nn.ReLU(inplace=True)
        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)

        # conv4
        self.conv4_1 = nn.Conv2d(256, 512, kernel_size=3, padding=1)
        self.relu4_1 = nn.ReLU(inplace=True)
        self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1)
        self.relu4_2 = nn.ReLU(inplace=True)
        self.conv4_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1)
        self.relu4_3 = nn.ReLU(inplace=True)
        self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)

        # conv5
        self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1)
        self.relu5_1 = nn.ReLU(inplace=True)
        self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1)
        self.relu5_2 = nn.ReLU(inplace=True)
        self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1)
        self.relu5_3 = nn.ReLU(inplace=True)
        self.pool5 = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)

        # fc6
        self.fc6 = nn.Conv2d(512, 4096, kernel_size=7)
        self.relu6 = nn.ReLU(inplace=True)
        self.drop6 = nn.Dropout2d()

        # fc7
        self.fc7 = nn.Conv2d(4096, 4096, kernel_size=1)
        self.relu7 = nn.ReLU(inplace=True)
        self.drop7 = nn.Dropout2d()

        # score_fr
        self.score_fr = nn.Conv2d(4096, num_classes, kernel_size=1)

        # upscore2
        self.upscore2 = nn.ConvTranspose2d(num_classes, num_classes, kernel_size=4, stride=2, bias=False)
        self.upscore_pool4 = nn.ConvTranspose2d(512, num_classes, kernel_size=4, stride=2, bias=False)

        # upscore8
        self.upscore8 = nn.ConvTranspose2d(num_classes, num_classes, kernel_size=16, stride=8, bias=False)

    def forward(self, x):
        # conv1
        x = self.conv1_1(x)
        x = self.relu1_1(x)
        x = self.conv1_2(x)
        x = self.relu1_2(x)
        x = self.pool1(x)

        # conv2
        x = self.conv2_1(x)
        x = self.relu2_1(x)
        x = self.conv2_2(x)
        x = self.relu2_2(x)
        x = self.pool2(x)

        # conv3
        x = self.conv3_1(x)
        x = self.relu3_1(x)
        x = self.conv3_2(x)
        x = self.relu3_2(x)
        x = self.conv3_3(x)
        x = self.relu3_3(x)
        x = self.pool3(x)

        # conv4
        x = self.conv4_1(x)
        x = self.relu4_1(x)
        x = self.conv4_2(x)
        x = self.relu4_2(x)
        x = self.conv4_3(x)
        x = self.relu4_3(x)
        pool4 = self.pool4(x)

        # conv5
        x = self.conv5_1(pool4)
        x = self.relu5_1(x)
        x = self.conv5_2(x)
        x = self.relu5_2(x)
        x = self.conv5_3(x)
        x = self.relu5_3(x)
        pool5 = self.pool5(x)

        # fc6
        x = self.fc6(pool5)
        x = self.relu6(x)
        x = self.drop6(x)

        # fc7
        x = self.fc7(x)
        x = self.relu7(x)
        x = self.drop7(x)

        # score_fr
        x = self.score_fr(x)

        # upscore2
        upscore2 = self.upscore2(x)

        # upscore_pool4
        pool4 = 0.01 * self.upscore_pool4(pool4[:, :, 5:5 + upscore2.size()[2], 5:5 + upscore2.size()[3]])
        fuse_pool4 = upscore2 + pool4

        # upscore8
        upscore8 = self.upscore8(fuse_pool4)

        return upscore8[:, :, 31:31 + x.size()[2], 31:31 + x.size()[3]]

以上就是FCN8s的PyTorch代码实现。需要注意的是，在实现过程中，我们使用了反卷积（ConvTranspose2d）来进行上采样，同时还需要注意输入输出张量的大小。