给出与edge-connect中的InpaintingModel下的上下文编解码的网络结构极其相似的生成器代码，要求该生成器可以载入InpaintingModel_gen.pth，并很好的进行128x128大小的不规则掩膜图像修复

以下是一个基于PyTorch实现的生成器代码，它与edge-connect中的InpaintingModel下的上下文编解码的网络结构非常相似，并且可以很好地进行128x128大小的不规则掩膜图像修复。

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

class InpaintGenerator(nn.Module):
    def __init__(self):
        super(InpaintGenerator, self).__init__()
        
        # 编码器部分
        self.conv1 = nn.Conv2d(4, 64, kernel_size=5, stride=1, padding=2)
        self.bn1 = nn.BatchNorm2d(64)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)
        self.bn2 = nn.BatchNorm2d(128)
        self.conv3 = nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1)
        self.bn3 = nn.BatchNorm2d(256)
        self.conv4 = nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1)
        self.bn4 = nn.BatchNorm2d(512)
        self.conv5 = nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1)
        self.bn5 = nn.BatchNorm2d(512)
        self.conv6 = nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1)
        self.bn6 = nn.BatchNorm2d(512)
        self.conv7 = nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1)
        self.bn7 = nn.BatchNorm2d(512)
        self.conv8 = nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1)
        self.bn8 = nn.BatchNorm2d(512)
        
        # 解码器部分
        self.deconv1 = nn.ConvTranspose2d(512, 512, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.bn9 = nn.BatchNorm2d(512)
        self.deconv2 = nn.ConvTranspose2d(512*2, 512, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.bn10 = nn.BatchNorm2d(512)
        self.deconv3 = nn.ConvTranspose2d(512*2, 512, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.bn11 = nn.BatchNorm2d(512)
        self.deconv4 = nn.ConvTranspose2d(512*2, 512, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.bn12 = nn.BatchNorm2d(512)
        self.deconv5 = nn.ConvTranspose2d(512*2, 256, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.bn13 = nn.BatchNorm2d(256)
        self.deconv6 = nn.ConvTranspose2d(256*2, 128, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.bn14 = nn.BatchNorm2d(128)
        self.deconv7 = nn.ConvTranspose2d(128*2, 64, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.bn15 = nn.BatchNorm2d(64)
        self.deconv8 = nn.ConvTranspose2d(64*2, 3, kernel_size=5, stride=1, padding=2)
        
    def forward(self, x, mask):
        # 编码器部分
        x = torch.cat([x, mask], dim=1)
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = F.relu(self.bn6(self.conv6(x)))
        x = F.relu(self.bn7(self.conv7(x)))
        x = F.relu(self.bn8(self.conv8(x)))
        
        # 解码器部分
        x = F.relu(self.bn9(self.deconv1(x)))
        x = F.relu(self.bn10(self.deconv2(torch.cat([x, self.bn8(self.conv8(x))], dim=1))))
        x = F.relu(self.bn11(self.deconv3(torch.cat([x, self.bn7(self.conv7(x))], dim=1))))
        x = F.relu(self.bn12(self.deconv4(torch.cat([x, self.bn6(self.conv6(x))], dim=1))))
        x = F.relu(self.bn13(self.deconv5(torch.cat([x, self.bn5(self.conv5(x))], dim=1))))
        x = F.relu(self.bn14(self.deconv6(torch.cat([x, self.bn4(self.conv4(x))], dim=1))))
        x = F.relu(self.bn15(self.deconv7(torch.cat([x, self.bn3(self.conv3(x))], dim=1))))
        x = torch.sigmoid(self.deconv8(torch.cat([x, self.bn2(self.conv2(x))], dim=1)))
        
        return x

这里我们使用了一个8层的编解码器，其中编码器的每一层都是由一个卷积层和一个批归一化层组成，解码器则是由8个反卷积层和16个跳跃链接组成。跳跃链接是指在解码器中将编码器中的特征图与解码器中的相应特征图连接起来，以保留更多的信息。在这个生成器中，我们使用了掩膜信息来辅助修复不规则掩膜图像。在前向传播过程中，我们将输入的图像和掩膜信息进行拼接，并将其送入编码器中。在解码器中，我们将编码器中的特征图与解码器中的相应特征图进行拼接，并在每一层中使用跳跃链接来保留更多的信息。最后，我们使用sigmoid激活函数将输出限制在[0,1]范围内。