UnET+aspp的可运行代码

以下是使用PyTorch实现的UnET和ASPP模块的示例代码：

import torch
import torch.nn as nn

class Unet(nn.Module):
    def __init__(self):
        super(Unet, self).__init__()
        
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu1 = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.relu2 = nn.ReLU(inplace=True)

        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.relu3 = nn.ReLU(inplace=True)

        self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
        self.bn4 = nn.BatchNorm2d(128)
        self.relu4 = nn.ReLU(inplace=True)

        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.conv5 = nn.Conv2d(128, 256, kernel_size=3, padding=1)
        self.bn5 = nn.BatchNorm2d(256)
        self.relu5 = nn.ReLU(inplace=True)

        self.conv6 = nn.Conv2d(256, 256, kernel_size=3, padding=1)
        self.bn6 = nn.BatchNorm2d(256)
        self.relu6 = nn.ReLU(inplace=True)

        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.conv7 = nn.Conv2d(256, 512, kernel_size=3, padding=1)
        self.bn7 = nn.BatchNorm2d(512)
        self.relu7 = nn.ReLU(inplace=True)

        self.conv8 = nn.Conv2d(512, 512, kernel_size=3, padding=1)
        self.bn8 = nn.BatchNorm2d(512)
        self.relu8 = nn.ReLU(inplace=True)

        self.up1 = nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2)
        self.conv9 = nn.Conv2d(512, 256, kernel_size=3, padding=1)
        self.bn9 = nn.BatchNorm2d(256)
        self.relu9 = nn.ReLU(inplace=True)

        self.conv10 = nn.Conv2d(256, 256, kernel_size=3, padding=1)
        self.bn10 = nn.BatchNorm2d(256)
        self.relu10 = nn.ReLU(inplace=True)

        self.up2 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)
        self.conv11 = nn.Conv2d(256, 128, kernel_size=3, padding=1)
        self.bn11 = nn.BatchNorm2d(128)
        self.relu11 = nn.ReLU(inplace=True)

        self.conv12 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
        self.bn12 = nn.BatchNorm2d(128)
        self.relu12 = nn.ReLU(inplace=True)

        self.up3 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)
        self.conv13 = nn.Conv2d(128, 64, kernel_size=3, padding=1)
        self.bn13 = nn.BatchNorm2d(64)
        self.relu13 = nn.ReLU(inplace=True)

        self.conv14 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
        self.bn14 = nn.BatchNorm2d(64)
        self.relu14 = nn.ReLU(inplace=True)

        self.conv15 = nn.Conv2d(64, 2, kernel_size=1)
        
    def forward(self, x):
        x1 = self.conv1(x)
        x1 = self.bn1(x1)
        x1 = self.relu1(x1)

        x1 = self.conv2(x1)
        x1 = self.bn2(x1)
        x1 = self.relu2(x1)

        x2 = self.pool1(x1)

        x2 = self.conv3(x2)
        x2 = self.bn3(x2)
        x2 = self.relu3(x2)

        x2 = self.conv4(x2)
        x2 = self.bn4(x2)
        x2 = self.relu4(x2)

        x3 = self.pool2(x2)

        x3 = self.conv5(x3)
        x3 = self.bn5(x3)
        x3 = self.relu5(x3)

        x3 = self.conv6(x3)
        x3 = self.bn6(x3)
        x3 = self.relu6(x3)

        x4 = self.pool3(x3)

        x4 = self.conv7(x4)
        x4 = self.bn7(x4)
        x4 = self.relu7(x4)

        x4 = self.conv8(x4)
        x4 = self.bn8(x4)
        x4 = self.relu8(x4)

        x5 = self.up1(x4)
        x5 = torch.cat((x5, x3), dim=1)

        x5 = self.conv9(x5)
        x5 = self.bn9(x5)
        x5 = self.relu9(x5)

        x5 = self.conv10(x5)
        x5 = self.bn10(x5)
        x5 = self.relu10(x5)

        x6 = self.up2(x5)
        x6 = torch.cat((x6, x2), dim=1)

        x6 = self.conv11(x6)
        x6 = self.bn11(x6)
        x6 = self.relu11(x6)

        x6 = self.conv12(x6)
        x6 = self.bn12(x6)
        x6 = self.relu12(x6)

        x7 = self.up3(x6)
        x7 = torch.cat((x7, x1), dim=1)

        x7 = self.conv13(x7)
        x7 = self.bn13(x7)
        x7 = self.relu13(x7)

        x7 = self.conv14(x7)
        x7 = self.bn14(x7)
        x7 = self.relu14(x7)

        x8 = self.conv15(x7)
        
        return x8

class ASPP(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.conv1x1 = nn.Conv2d(in_channels, out_channels, kernel_size=1)
        self.conv3x3_1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, dilation=6, padding=6)
        self.conv3x3_2 = nn.Conv2d(in_channels, out_channels, kernel_size=3, dilation=12, padding=12)
        self.conv3x3_3 = nn.Conv2d(in_channels, out_channels, kernel_size=3, dilation=18, padding=18)
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv1x1_out = nn.Conv2d(out_channels * 5, out_channels, kernel_size=1)

    def forward(self, x):
        x1 = self.conv1x1(x)
        x2 = self.conv3x3_1(x)
        x3 = self.conv3x3_2(x)
        x4 = self.conv3x3_3(x)
        x5 = self.avg_pool(x)
        x5 = self.conv1x1(x5)
        x5 = nn.functional.interpolate(x5, size=x.shape[2:], mode='bilinear', align_corners=False)
        out = torch.cat([x1, x2, x3, x4, x5], dim=1)
        out = self.conv1x1_out(out)
        return out

这个代码包含了一个Unet和一个ASPP模块，你可以将它们结合使用来进行语义分割任务。如果你想要训练和评估这个模型，你需要提供一个数据集和训练代码。