写出unet的代码不要封装

Unet是一种经典的卷积神经网络结构，常用于图像分割任务，尤其是医学图像分割。下面是一个简单的U-Net的基本框架代码示例，未进行封装，直接展示了核心部分的结构。这里假设我们正在使用PyTorch库：

import torch.nn as nn

# 定义上采样层
class Up(nn.Module):
    def __init__(self, in_channels, out_channels, bilinear=True):
        super(Up, self).__init__()
        if bilinear:
            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
        else:
            self.up = nn.ConvTranspose2d(in_channels // 2, in_channels // 2, kernel_size=2, stride=2)

        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

    def forward(self, x1, x2):
        x1 = self.up(x1)
        # input is CHW
        diffY = x2.size()[2] - x1.size()[2]
        diffX = x2.size()[3] - x1.size()[3]

        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
                        diffY // 2, diffY - diffY // 2])
        x = torch.cat([x2, x1], dim=1)
        return self.conv(x)

# U-Net模型主体
class UNet(nn.Module):
    def __init__(self, num_classes):
        super(UNet, self).__init__()
        self.pool = nn.MaxPool2d(2, 2)
        self.in_channels = 3
        self.out_channels = 64
        self.num_classes = num_classes

        self.conv1 = nn.Conv2d(self.in_channels, self.out_channels, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(self.out_channels, self.out_channels * 2, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(self.out_channels * 2, self.out_channels * 4, kernel_size=3, padding=1)
        self.conv4 = nn.Conv2d(self.out_channels * 4, self.out_channels * 8, kernel_size=3, padding=1)
        self.center = nn.Conv2d(self.out_channels * 8, self.out_channels * 16, kernel_size=3, padding=1)

        self.up_concat4 = Up(self.out_channels * 16, self.out_channels * 8)
        self.up_concat3 = Up(self.out_channels * 8, self.out_channels * 4)
        self.up_concat2 = Up(self.out_channels * 4, self.out_channels * 2)
        self.up_concat1 = Up(self.out_channels * 2, self.out_channels)

        self.conv5 = nn.Conv2d(self.out_channels, num_classes, kernel_size=1)

    def forward(self, x):
        conv1 = self.pool(F.relu(self.conv1(x)))
        conv2 = self.pool(F.relu(self.conv2(conv1)))
        conv3 = self.pool(F.relu(self.conv3(conv2)))
        conv4 = self.pool(F.relu(self.conv4(conv3)))

        center = F.relu(self.center(conv4))
        up4 = self.up_concat4(center, conv4)
        up3 = self.up_concat3(up4, conv3)
        up2 = self.up_concat2(up3, conv2)
        up1 = self.up_concat1(up2, conv1)

        out = self.conv5(F.relu(up1))

        return out