请定义上下文编码的生成器代码，要求该生成器能够匹配edge connect的InpaintingModel_gen.pth的键值，并对128x128的不规则掩膜图像进行修复

上下文编码生成器是指在图像修复任务中用于生成修复结果的神经网络模型。以下是一个可以匹配edge connect的InpaintingModel_gen.pth的键值，且能够对128x128的不规则掩膜图像进行修复的上下文编码生成器代码：

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

class Generator(nn.Module):
    def __init__(self, num_channels=3, num_features=64, num_blocks=6):
        super(Generator, self).__init__()
        
        # Encoder
        self.conv1 = nn.Conv2d(num_channels, num_features, kernel_size=7, stride=1, padding=3, bias=True)
        self.norm1 = nn.InstanceNorm2d(num_features, affine=True)
        self.conv2 = nn.Conv2d(num_features, num_features*2, kernel_size=4, stride=2, padding=1, bias=True)
        self.norm2 = nn.InstanceNorm2d(num_features*2, affine=True)
        self.conv3 = nn.Conv2d(num_features*2, num_features*4, kernel_size=4, stride=2, padding=1, bias=True)
        self.norm3 = nn.InstanceNorm2d(num_features*4, affine=True)
        
        # Residual blocks
        self.res_blocks = nn.Sequential(*[
            ResidualBlock(num_features*4) for i in range(num_blocks)
        ])
        
        # Decoder
        self.deconv1 = nn.ConvTranspose2d(num_features*4, num_features*2, kernel_size=4, stride=2, padding=1, bias=True)
        self.norm4 = nn.InstanceNorm2d(num_features*2, affine=True)
        self.deconv2 = nn.ConvTranspose2d(num_features*2, num_features, kernel_size=4, stride=2, padding=1, bias=True)
        self.norm5 = nn.InstanceNorm2d(num_features, affine=True)
        self.conv4 = nn.Conv2d(num_features, num_channels, kernel_size=7, stride=1, padding=3, bias=True)
        
    def forward(self, x, mask):
        # Encoder
        x = self.conv1(x)
        x = self.norm1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = self.norm2(x)
        x = F.relu(x)
        x = self.conv3(x)
        x = self.norm3(x)
        x = F.relu(x)
        
        # Residual blocks
        x = self.res_blocks(x)
        
        # Decoder
        x = self.deconv1(x)
        x = self.norm4(x)
        x = F.relu(x)
        x = self.deconv2(x)
        x = self.norm5(x)
        x = F.relu(x)
        x = self.conv4(x)
        
        # Masked fill
        x_masked = x * mask + x * (1 - mask) * nn.Sigmoid()(self.conv1(mask))
        
        return x_masked
      
class ResidualBlock(nn.Module):
    def __init__(self, num_features):
        super(ResidualBlock, self).__init__()
        
        self.conv1 = nn.Conv2d(num_features, num_features, kernel_size=3, stride=1, padding=1, bias=True)
        self.norm1 = nn.InstanceNorm2d(num_features, affine=True)
        self.conv2 = nn.Conv2d(num_features, num_features, kernel_size=3, stride=1, padding=1, bias=True)
        self.norm2 = nn.InstanceNorm2d(num_features, affine=True)
        
    def forward(self, x):
        residual = x
        x = self.conv1(x)
        x = self.norm1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = self.norm2(x)
        x = x + residual
        x = F.relu(x)
        return x

使用该模型进行不规则掩膜图像的修复，可以按如下步骤进行：

# 加载模型
model = Generator()
model.load_state_dict(torch.load('InpaintingModel_gen.pth'))

# 加载图像和掩膜
image = Image.open('image.png').convert('RGB')
mask = Image.open('mask.png').convert('L').resize(image.size)

# 转换为张量
image_tensor = transforms.ToTensor()(image)
mask_tensor = transforms.ToTensor()(mask)

# 处理掩膜
mask_tensor = (mask_tensor > 0.5).float()

# 添加批次维度
image_tensor = image_tensor.unsqueeze(0)
mask_tensor = mask_tensor.unsqueeze(0)

# 修复图像
with torch.no_grad():
    image_masked_tensor = image_tensor * (1 - mask_tensor)
    output_tensor = model(image_masked_tensor, mask_tensor)
    output_tensor = output_tensor * mask_tensor + image_tensor * (1 - mask_tensor)

# 转换为图像
output_image = transforms.ToPILImage()(output_tensor.squeeze(0))
output_image.save('output.png')