D-LinkNet的一个优势特点是有Dense Feature Linking，请你帮我在segnet网络结构的基础上，引入Dense Feature Linking，写出完整的代码

好的，我们可以在SegNet的Decoder部分引入Dense Feature Linking。具体来说，我们可以在Decoder的每一层的输出上，都接入一个1x1的卷积层来产生额外的特征图。然后，将这些额外的特征图与Encoder对应层的输出进行concatenate操作，得到Dense Feature Linking后的特征图。最后，再通过卷积层进行特征融合并得到最终的分割结果。

以下是参考代码：

import torch
import torch.nn as nn

class SegNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(SegNet, self).__init__()
        
        # Encoder部分
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        
        # Decoder部分
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(512, 512, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(512, 512, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(512, 512, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(256, 256, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
        )
        
        # Dense Feature Linking
        self.linker_1 = nn.Conv2d(512, 256, kernel_size=1)
        self.linker_2 = nn.Conv2d(256, 128, kernel_size=1)
        self.linker_3 = nn.Conv2d(128, 64, kernel_size=1)
        
        # 分类器
        self.classifier = nn.Conv2d(64, out_channels, kernel_size=1)
        
    def forward(self, x):
        # Encoder部分
        enc_outputs = []
        enc_outputs.append(x)
        
        x = self.encoder[0:4](x)
        enc_outputs.append(x)
        x = self.encoder[4:9](x)
        enc_outputs.append(x)
        x = self.encoder[9:16](x)
        enc_outputs.append(x)
        x = self.encoder[16:23](x)
        enc_outputs.append(x)
        x = self.encoder[23:](x)
        enc_outputs.append(x)
        
        # Decoder部分
        x = self.decoder[0](x)
        x = torch.cat((x, enc_outputs[5], self.linker_1(enc_outputs[5])), dim=1)
        x = self.decoder[1:4](x)
        x = torch.cat((x, enc_outputs[4], self.linker_2(enc_outputs[4])), dim=1)
        x = self.decoder[4:7](x)
        x = torch.cat((x, enc_outputs[3], self.linker_3(enc_outputs[3])), dim=1)
        x = self.decoder[7:](x)
        
        # 分类器
        x = self.classifier(x)
        
        return x