写出u-net网络模型

U-Net是一个基于卷积神经网络的图像分割模型，它的网络结构如下：

U-Net模型结构：
    Contracting Path（收缩路径）:
        2 * [Convolutional layer -> ReLU -> Convolutional layer -> ReLU -> Max pooling]
    Expansive Path（扩张路径）:
        [Transposed convolutional layer -> Concatenation with the cropped feature map from the contracting path -> 
        Convolutional layer -> ReLU -> Convolutional layer -> ReLU]
    Output Layer:
        Convolutional layer -> Softmax

下面是U-Net的Python代码实现：

import torch
import torch.nn as nn

class UNet(nn.Module):
    def __init__(self, in_channels=1, out_channels=2):
        super(UNet, self).__init__()
        
        # Contracting Path
        self.conv1_1 = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
        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)

        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)

        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.pool3 = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)

        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.pool4 = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)

        self.conv5_1 = nn.Conv2d(512, 1024, kernel_size=3, padding=1)
        self.relu5_1 = nn.ReLU(inplace=True)
        self.conv5_2 = nn.Conv2d(1024, 1024, kernel_size=3, padding=1)
        self.relu5_2 = nn.ReLU(inplace=True)

        # Expansive Path
        self.upconv6_1 = nn.ConvTranspose2d(1024, 512, kernel_size=2, stride=2)
        self.conv6_2 = nn.Conv2d(1024, 512, kernel_size=3, padding=1)
        self.relu6_2 = nn.ReLU(inplace=True)
        self.conv6_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1)
        self.relu6_1 = nn.ReLU(inplace=True)

        self.upconv7_1 = nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2)
        self.conv7_2 = nn.Conv2d(512, 256, kernel_size=3, padding=1)
        self.relu7_2 = nn.ReLU(inplace=True)
        self.conv7_1 = nn.Conv2d(256, 256, kernel_size=3, padding=1)
        self.relu7_1 = nn.ReLU(inplace=True)

        self.upconv8_1 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)
        self.conv8_2 = nn.Conv2d(256, 128, kernel_size=3, padding=1)
        self.relu8_2 = nn.ReLU(inplace=True)
        self.conv8_1 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
        self.relu8_1 = nn.ReLU(inplace=True)

        self.upconv9_1 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)
        self.conv9_2 = nn.Conv2d(128, 64, kernel_size=3, padding=1)
        self.relu9_2 = nn.ReLU(inplace=True)
        self.conv9_1 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
        self.relu9_1 = nn.ReLU(inplace=True)

        self.conv10 = nn.Conv2d(64, out_channels, kernel_size=1)

    def forward(self, x):
        # Contracting Path
        x1 = self.conv1_1(x)
        x1 = self.relu1_1(x1)
        x1 = self.conv1_2(x1)
        x1 = self.relu1_2(x1)
        x2 = self.pool1(x1)

        x2 = self.conv2_1(x2)
        x2 = self.relu2_1(x2)
        x2 = self.conv2_2(x2)
        x2 = self.relu2_2(x2)
        x3 = self.pool2(x2)

        x3 = self.conv3_1(x3)
        x3 = self.relu3_1(x3)
        x3 = self.conv3_2(x3)
        x3 = self.relu3_2(x3)
        x4 = self.pool3(x3)

        x4 = self.conv4_1(x4)
        x4 = self.relu4_1(x4)
        x4 = self.conv4_2(x4)
        x4 = self.relu4_2(x4)
        x5 = self.pool4(x4)

        x5 = self.conv5_1(x5)
        x5 = self.relu5_1(x5)
        x5 = self.conv5_2(x5)
        x5 = self.relu5_2(x5)

        # Expansive Path
        x6 = self.upconv6_1(x5)
        x6 = torch.cat((x6, x4), dim=1)
        x6 = self.conv6_2(x6)
        x6 = self.relu6_2(x6)
        x6 = self.conv6_1(x6)
        x6 = self.relu6_1(x6)

        x7 = self.upconv7_1(x6)
        x7 = torch.cat((x7, x3), dim=1)
        x7 = self.conv7_2(x7)
        x7 = self.relu7_2(x7)
        x7 = self.conv7_1(x7)
        x7 = self.relu7_1(x7)

        x8 = self.upconv8_1(x7)
        x8 = torch.cat((x8, x2), dim=1)
        x8 = self.conv8_2(x8)
        x8 = self.relu8_2(x8)
        x8 = self.conv8_1(x8)
        x8 = self.relu8_1(x8)

        x9 = self.upconv9_1(x8)
        x9 = torch.cat((x9, x1), dim=1)
        x9 = self.conv9_2(x9)
        x9 = self.relu9_2(x9)
        x9 = self.conv9_1(x9)
        x9 = self.relu9_1(x9)

        x10 = self.conv10(x9)

        return x10

注：这里的U-Net模型是一个基本的实现，不同的问题可能需要根据实际情况作出适当的调整。