请提供代码满足使用pytorch训练的基于多尺度自编码网络的红外与可见光图像融合的模型，实现红外与可见光图像的融合

以下是一个基于多尺度自编码网络的红外与可见光图像融合模型的PyTorch代码：

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

class Encoder(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(Encoder, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        
    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        x = self.pool(x)
        return x
        
class Decoder(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(Decoder, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        
    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.upsample(x)
        x = F.relu(self.conv2(x))
        return x
        
class FusionNet(nn.Module):
    def __init__(self, in_channels):
        super(FusionNet, self).__init__()
        self.encoder1 = Encoder(in_channels, 64)
        self.encoder2 = Encoder(64, 128)
        self.encoder3 = Encoder(128, 256)
        self.decoder1 = Decoder(256, 128)
        self.decoder2 = Decoder(128, 64)
        self.decoder3 = Decoder(64, in_channels)
        
    def forward(self, x1, x2):
        # Encoding
        x1_e1 = self.encoder1(x1)
        x1_e2 = self.encoder2(x1_e1)
        x1_e3 = self.encoder3(x1_e2)
        
        x2_e1 = self.encoder1(x2)
        x2_e2 = self.encoder2(x2_e1)
        x2_e3 = self.encoder3(x2_e2)
        
        # Decoding
        x3_d1 = self.decoder1(torch.cat([x1_e3, x2_e3], dim=1))
        x3_d2 = self.decoder2(torch.cat([x1_e2, x2_e2, x3_d1], dim=1))
        x3_d3 = self.decoder3(torch.cat([x1_e1, x2_e1, x3_d2], dim=1))
        
        return x3_d3

在上面的代码中，我们定义了一个 `Encoder` 类和一个 `Decoder` 类，它们分别用于提取图像的特征和重建图像。然后，我们定义了一个 `FusionNet` 类，它将两个输入图像分别编码为特征向量，然后将它们进行级联并传递给解码器，最终生成融合图像。

我们可以使用以下代码来进行训练：

import torch.optim as optim

# 初始化模型
model = FusionNet(in_channels=3)
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.MSELoss()

# 训练模型
for epoch in range(num_epochs):
    running_loss = 0.0
    for data in dataloader:
        inputs1, inputs2, labels = data
        optimizer.zero_grad()
        outputs = model(inputs1, inputs2)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * inputs1.size(0)
    epoch_loss = running_loss / len(dataset)
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, epoch_loss))

在上面的代码中，我们首先定义了优化器和损失函数。然后，我们通过迭代训练数据集来训练模型。每个batch的输入包括两个图像，我们将它们作为模型的输入并计算输出。然后，我们计算输出与标签之间的均方误差，反向传播误差并更新模型参数。最后，我们计算并打印出当前的损失。