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

以下是一个基于 PyTorch 的不规则掩膜图像修复生成器的示例代码，其结构类似于 edge-connect 中的原版上下文编解码器：

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

class InpaintingGenerator(nn.Module):
    def __init__(self, latent_dim=256, num_channels=3):
        super(InpaintingGenerator, self).__init__()

        self.encoder = nn.Sequential(
            nn.Conv2d(num_channels, 64, kernel_size=5, stride=2, padding=2),
            nn.InstanceNorm2d(64),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(64, 128, kernel_size=5, stride=2, padding=2),
            nn.InstanceNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(128, 256, kernel_size=5, stride=2, padding=2),
            nn.InstanceNorm2d(256),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(256, 512, kernel_size=5, stride=2, padding=2),
            nn.InstanceNorm2d(512),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(512, 512, kernel_size=5, stride=2, padding=2),
            nn.InstanceNorm2d(512),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(512, 512, kernel_size=5, stride=2, padding=2),
            nn.InstanceNorm2d(512),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(512, 512, kernel_size=5, stride=2, padding=2),
            nn.InstanceNorm2d(512),
            nn.LeakyReLU(0.2, inplace=True)
        )

        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(512, 512, kernel_size=4, stride=2, padding=1),
            nn.InstanceNorm2d(512),
            nn.ReLU(inplace=True),

            nn.ConvTranspose2d(512, 512, kernel_size=4, stride=2, padding=1),
            nn.InstanceNorm2d(512),
            nn.ReLU(inplace=True),

            nn.ConvTranspose2d(512, 512, kernel_size=4, stride=2, padding=1),
            nn.InstanceNorm2d(512),
            nn.ReLU(inplace=True),

            nn.ConvTranspose2d(512, 512, kernel_size=4, stride=2, padding=1),
            nn.InstanceNorm2d(512),
            nn.ReLU(inplace=True),

            nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1),
            nn.InstanceNorm2d(256),
            nn.ReLU(inplace=True),

            nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1),
            nn.InstanceNorm2d(128),
            nn.ReLU(inplace=True),

            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),
            nn.InstanceNorm2d(64),
            nn.ReLU(inplace=True),

            nn.ConvTranspose2d(64, num_channels, kernel_size=5, stride=1, padding=2),
            nn.Tanh()
        )

        self.latent_dim = latent_dim

    def forward(self, x, mask):
        masked_x = x * mask
        encoding = self.encoder(masked_x)
        encoding = encoding.view(-1, 512*4*4)

        # Generate random latent vector
        latent = torch.randn(encoding.size(0), self.latent_dim, device=x.device)

        # Concatenate encoding with latent vector
        encoding = torch.cat([encoding, latent], dim=1)

        # Decode to generate inpainting result
        inpainting = self.decoder(encoding.view(-1, 512, 4, 4))

        # Use mask to combine inpainting result and original image
        return x * (1 - mask) + inpainting * mask

# Load the trained generator model from file
generator = InpaintingGenerator()
generator.load_state_dict(torch.load("InpaintingModel_gen.pth", map_location=torch.device('cpu')))

# Perform inpainting on a sample image with random mask
img = torch.randn((1, 3, 128, 128))
mask = torch.randint(0, 2, size=(1, 1, 128, 128), dtype=torch.float32)
inpainting = generator(img, mask)

其中 `InpaintingGenerator` 类定义了一个基于卷积神经网络的生成器模型，包含了一个编码器和一个解码器，用于对不规则掩膜图像进行修复。在前向传播时，输入图像 `x` 和掩膜 `mask` 首先按掩膜进行裁剪，然后通过编码器生成潜在表示，随机采样潜在向量后将其与编码器输出拼接，最后通过解码器生成修复结果，并将原始图像与修复结果结合起来，得到最终的修复图像。

对于修复部分的代码，可以使用以下方法根据掩膜生成一个与原始图像相同大小的掩膜区域的图像，然后将其插入到原始图像中：

def apply_mask(image, mask):
    return image * (1 - mask)

def remove_mask(image, mask):
    return image * mask

def replace_mask(image, mask, replace):
    return apply_mask(image, 1 - mask) + remove_mask(replace, mask)

# Load a sample image and mask
img = torch.randn((1, 3, 128, 128))
mask = torch.randint(0, 2, size=(1, 1, 128, 128), dtype=torch.float32)

# Generate a replacement image for the masked region
replace = torch.randn((1, 3, 128, 128))
masked_replace = apply_mask(replace, mask)

# Replace the masked region with the generated image
result = replace_mask(img, mask, masked_replace)