{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6603a8fc-d9da-4037-b845-d9c38bae4ce4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, Dataset, random_split\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c28cc123-71be-47ff-b78f-3a4d5592df39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum pixel value in the dataset: 107.49169921875\n"
     ]
    }
   ],
   "source": [
    "max_pixel_value = 107.49169921875\n",
    "\n",
    "print(f\"Maximum pixel value in the dataset: {max_pixel_value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dbfe80ce-4394-449c-a9a4-22ed15b2b8f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "checkpoint before Generator is OK\n"
     ]
    }
   ],
   "source": [
    "class NO2Dataset(Dataset):\n",
    "    \n",
    "    def __init__(self, image_dir, mask_dir):\n",
    "        \n",
    "        self.image_dir = image_dir\n",
    "        self.mask_dir = mask_dir\n",
    "        self.image_filenames = [f for f in os.listdir(image_dir) if f.endswith('.npy')]  # 仅加载 .npy 文件\n",
    "        self.mask_filenames = [f for f in os.listdir(mask_dir) if f.endswith('.jpg')]  # 仅加载 .jpg 文件\n",
    "        print(len(self.mask_filenames))\n",
    "        \n",
    "    def __len__(self):\n",
    "        \n",
    "        return len(self.image_filenames)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        \n",
    "        image_path = os.path.join(self.image_dir, self.image_filenames[idx])\n",
    "        mask_idx = np.random.choice(self.mask_filenames)\n",
    "        mask_path = os.path.join(self.mask_dir, mask_idx)\n",
    "\n",
    "        # 加载图像数据 (.npy 文件)\n",
    "        image = np.load(image_path).astype(np.float32)[:,:,:1] / max_pixel_value  # 形状为 (96, 96, 1)\n",
    "\n",
    "        # 加载掩码数据 (.jpg 文件)\n",
    "        mask = np.array(Image.open(mask_path).convert('L')).astype(np.float32)\n",
    "\n",
    "        # 将掩码数据中非0值设为1，0值保持不变\n",
    "        mask = np.where(mask != 0, 1.0, 0.0)\n",
    "\n",
    "        # 保持掩码数据形状为 (96, 96, 1)\n",
    "        mask = mask[:, :, np.newaxis]  # 将形状调整为 (96, 96, 1)\n",
    "\n",
    "        # 应用掩码\n",
    "        masked_image = image.copy()\n",
    "        masked_image[:, :, 0] = image[:, :, 0] * mask.squeeze()  # 遮盖NO2数据\n",
    "\n",
    "        # cGAN的输入和目标\n",
    "        X = masked_image[:, :, :1]  # 形状为 (96, 96, 8)\n",
    "        y = image[:, :, 0:1]  # 目标输出为NO2数据，形状为 (96, 96, 1)\n",
    "\n",
    "        # 转换形状为 (channels, height, width)\n",
    "        X = np.transpose(X, (2, 0, 1))  # 转换为 (1, 96, 96)\n",
    "        y = np.transpose(y, (2, 0, 1))  # 转换为 (1, 96, 96)\n",
    "        mask = np.transpose(mask, (2, 0, 1))  # 转换为 (1, 96, 96)\n",
    "\n",
    "        return torch.tensor(X, dtype=torch.float32), torch.tensor(y, dtype=torch.float32), torch.tensor(mask, dtype=torch.float32)\n",
    "\n",
    "# 实例化数据集和数据加载器\n",
    "image_dir = './out_mat/96/train/'\n",
    "mask_dir = './out_mat/96/mask/30/'\n",
    "\n",
    "print(f\"checkpoint before Generator is OK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "41da7319-9795-441d-bde8-8cf390365099",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3849\n",
      "3849\n",
      "3849\n"
     ]
    }
   ],
   "source": [
    "dataset = NO2Dataset(image_dir, mask_dir)\n",
    "dataloader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=8)\n",
    "val_set = NO2Dataset('./out_mat/96/valid/', mask_dir)\n",
    "val_loader = DataLoader(val_set, batch_size=64, shuffle=False, num_workers=4)\n",
    "test_set = NO2Dataset('./out_mat/96/test/', mask_dir)\n",
    "test_loader = DataLoader(test_set, batch_size=64, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "70797703-1619-4be7-b965-5506b3d1e775",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 可视化特定特征的函数\n",
    "def visualize_feature(input_feature,masked_feature, output_feature, title):\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    plt.subplot(1, 3, 1)\n",
    "    plt.imshow(input_feature[0].cpu().numpy(), cmap='RdYlGn_r')\n",
    "    plt.title(title + \" Input\")\n",
    "    plt.subplot(1, 3, 2)\n",
    "    plt.imshow(masked_feature[0].cpu().numpy(), cmap='RdYlGn_r')\n",
    "    plt.title(title + \" Masked\")\n",
    "    plt.subplot(1, 3, 3)\n",
    "    plt.imshow(output_feature[0].detach().cpu().numpy(), cmap='RdYlGn_r')\n",
    "    plt.title(title + \" Recovery\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "645114e8-65a4-4867-b3fe-23395288e855",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Conv(nn.Sequential):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1, stride=1, bias=False):\n",
    "        super(Conv, self).__init__(\n",
    "            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, bias=bias,\n",
    "                      dilation=dilation, stride=stride, padding=((stride - 1) + dilation * (kernel_size - 1)) // 2)\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2af52d0e-b785-4a84-838c-6fcfe2568722",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvBNReLU(nn.Sequential):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1, stride=1, norm_layer=nn.BatchNorm2d,\n",
    "                 bias=False):\n",
    "        super(ConvBNReLU, self).__init__(\n",
    "            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, bias=bias,\n",
    "                      dilation=dilation, stride=stride, padding=((stride - 1) + dilation * (kernel_size - 1)) // 2),\n",
    "            norm_layer(out_channels),\n",
    "            nn.ReLU()\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "31ecf247-e98b-4977-a145-782914a042bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SeparableBNReLU(nn.Sequential):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1, norm_layer=nn.BatchNorm2d):\n",
    "        super(SeparableBNReLU, self).__init__(\n",
    "            nn.Conv2d(in_channels, in_channels, kernel_size=kernel_size, stride=stride, dilation=dilation,\n",
    "                      padding=((stride - 1) + dilation * (kernel_size - 1)) // 2, groups=in_channels, bias=False),\n",
    "            # 分离卷积，仅调整空间信息\n",
    "            norm_layer(in_channels),  # 对输入通道进行归一化\n",
    "            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),  # 这里进行升维操作\n",
    "            nn.ReLU6()\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7827bee2-74f7-4e47-b8c6-e41d5670e8b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualBlock(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, stride=1, downsample=None):\n",
    "        super(ResidualBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False)\n",
    "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
    "\n",
    "        # 如果输入和输出通道不一致，进行降采样操作\n",
    "        self.downsample = downsample\n",
    "        if in_channels != out_channels or stride != 1:\n",
    "            self.downsample = nn.Sequential(\n",
    "                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),\n",
    "                nn.BatchNorm2d(out_channels)\n",
    "            )\n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "        if self.downsample is not None:\n",
    "            identity = self.downsample(x)\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "\n",
    "        out += identity\n",
    "        out = self.relu(out)\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7853bf62-02f5-4917-b950-6fdfe467df4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mlp(nn.Module):\n",
    "    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.ReLU6, drop=0.):\n",
    "        super().__init__()\n",
    "        out_features = out_features or in_features\n",
    "        hidden_features = hidden_features or in_features\n",
    "        self.fc1 = nn.Conv2d(in_features, hidden_features, 1, 1, 0, bias=True)\n",
    "\n",
    "        self.act = act_layer()\n",
    "        self.fc2 = nn.Conv2d(hidden_features, out_features, 1, 1, 0, bias=True)\n",
    "        self.drop = nn.Dropout(drop, inplace=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.act(x)\n",
    "        x = self.drop(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.drop(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e2375881-a11b-47a7-8f56-2eadb25010b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiHeadAttentionBlock(nn.Module):\n",
    "    def __init__(self, embed_dim, num_heads, dropout=0.1):\n",
    "        super(MultiHeadAttentionBlock, self).__init__()\n",
    "        self.attention = nn.MultiheadAttention(embed_dim, num_heads, dropout=dropout)\n",
    "        self.norm = nn.LayerNorm(embed_dim)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # (B, C, H, W) -> (HW, B, C) for MultiheadAttention compatibility\n",
    "        B, C, H, W = x.shape\n",
    "        x = x.view(B, C, H * W).permute(2, 0, 1)  # (B, C, H, W) -> (HW, B, C)\n",
    "\n",
    "        # Apply multihead attention\n",
    "        attn_output, _ = self.attention(x, x, x)\n",
    "\n",
    "        # Apply normalization and dropout\n",
    "        attn_output = self.norm(attn_output)\n",
    "        attn_output = self.dropout(attn_output)\n",
    "\n",
    "        # Reshape back to (B, C, H, W)\n",
    "        attn_output = attn_output.permute(1, 2, 0).view(B, C, H, W)\n",
    "\n",
    "        return attn_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "82a15d3d-2f8d-42ec-9146-87c8a4abe384",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SpatialAttentionBlock(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SpatialAttentionBlock, self).__init__()\n",
    "        self.conv = nn.Conv2d(2, 1, kernel_size=7, padding=3, bias=False)\n",
    "\n",
    "    def forward(self, x): #(B, 64, H, W)\n",
    "        avg_out = torch.mean(x, dim=1, keepdim=True) #(B, 1, H, W)\n",
    "        max_out, _ = torch.max(x, dim=1, keepdim=True)#(B, 1, H, W)\n",
    "        out = torch.cat([avg_out, max_out], dim=1)#(B, 2, H, W)\n",
    "        out = torch.sigmoid(self.conv(out))#(B, 1, H, W)\n",
    "        return x * out #(B, C, H, W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "497bb9f1-1ac5-4d7f-a930-0ea222b9d1d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderAttentionBlock(nn.Module):\n",
    "    def __init__(self, in_channels):\n",
    "        super(DecoderAttentionBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels, in_channels // 2, kernel_size=1)\n",
    "        self.conv2 = nn.Conv2d(in_channels // 2, in_channels, kernel_size=1)\n",
    "        self.spatial_attention = SpatialAttentionBlock()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 通道注意力\n",
    "        b, c, h, w = x.size()\n",
    "        avg_pool = F.adaptive_avg_pool2d(x, 1)\n",
    "        max_pool = F.adaptive_max_pool2d(x, 1)\n",
    "\n",
    "        avg_out = self.conv1(avg_pool)\n",
    "        max_out = self.conv1(max_pool)\n",
    "\n",
    "        out = avg_out + max_out\n",
    "        out = torch.sigmoid(self.conv2(out))\n",
    "\n",
    "        # 添加空间注意力\n",
    "        out = x * out\n",
    "        out = self.spatial_attention(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "15b9d453-d8d9-43b8-aca2-904735fb3a99",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SEBlock(nn.Module):\n",
    "    def __init__(self, in_channels, reduced_dim):\n",
    "        super(SEBlock, self).__init__()\n",
    "        self.se = nn.Sequential(\n",
    "            nn.AdaptiveAvgPool2d(1),  # 全局平均池化\n",
    "            nn.Conv2d(in_channels, reduced_dim, kernel_size=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(reduced_dim, in_channels, kernel_size=1),\n",
    "            nn.Sigmoid()  # 使用Sigmoid是因为我们要对通道进行权重归一化\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return x * self.se(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6379adb7-8a87-4dd8-a695-4013a7b37830",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 定义Masked Autoencoder模型\n",
    "class MaskedAutoencoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MaskedAutoencoder, self).__init__()\n",
    "        self.encoder = nn.Sequential(\n",
    "            Conv(1, 32, kernel_size=3, stride=2),\n",
    "            \n",
    "            nn.ReLU(),\n",
    "            \n",
    "            SEBlock(32,32),\n",
    "            \n",
    "            ConvBNReLU(32, 64, kernel_size=3, stride=2),\n",
    "            \n",
    "            ResidualBlock(64,64),\n",
    "            \n",
    "            SeparableBNReLU(64, 128, kernel_size=3, stride=2),\n",
    "            \n",
    "            MultiHeadAttentionBlock(embed_dim=128, num_heads=4),\n",
    "            \n",
    "            SEBlock(128, 128)\n",
    "        )\n",
    "        self.mlp = Mlp(in_features=128, hidden_features=256, out_features=128, act_layer=nn.ReLU6, drop=0.1)\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.ConvTranspose2d(128, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            DecoderAttentionBlock(32),\n",
    "            nn.ConvTranspose2d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            DecoderAttentionBlock(16),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.ConvTranspose2d(16, 1, kernel_size=3, stride=2, padding=1, output_padding=1),  # 修改为 output_padding=1\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        encoded = self.encoder(x)\n",
    "        decoded = self.decoder(encoded)\n",
    "        return decoded\n",
    "\n",
    "# 实例化模型、损失函数和优化器\n",
    "model = MaskedAutoencoder()\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e9c804e0-6f5c-40a7-aba7-a03a496cf427",
   "metadata": {},
   "outputs": [],
   "source": [
    "def masked_mse_loss(preds, target, mask):\n",
    "    loss = (preds - target) ** 2\n",
    "    loss = loss.mean(dim=-1)  # 对每个像素点求平均\n",
    "    loss = (loss * mask).sum() / mask.sum()  # 只计算被mask的像素点的损失\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "404a8bfb-4976-4cce-b989-c5e401bce0d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练函数\n",
    "def train_epoch(model, device, data_loader, criterion, optimizer):\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    for batch_idx, (X, y, mask) in enumerate(data_loader):\n",
    "        X, y, mask = X.to(device), y.to(device), mask.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        reconstructed = model(X)\n",
    "        loss = masked_mse_loss(reconstructed, y, mask)\n",
    "        # loss = criterion(reconstructed, y)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        running_loss += loss.item()\n",
    "    return running_loss / (batch_idx + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "94457c6b-4c6e-4aff-946d-fe4c670bfe16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 评估函数\n",
    "def evaluate(model, device, data_loader, criterion):\n",
    "    model.eval()\n",
    "    running_loss = 0.0\n",
    "    with torch.no_grad():\n",
    "        for batch_idx, (X, y, mask) in enumerate(data_loader):\n",
    "            X, y, mask = X.to(device), y.to(device), mask.to(device)\n",
    "            reconstructed = model(X)\n",
    "            if batch_idx == 8:\n",
    "                rand_ind = np.random.randint(0, len(y))\n",
    "                # visualize_feature(y[rand_ind], X[rand_ind], reconstructed[rand_ind], title='NO_2')\n",
    "            loss = masked_mse_loss(reconstructed, y, mask)\n",
    "            running_loss += loss.item()\n",
    "    return running_loss / (batch_idx + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "296ba6bd-2239-4948-b278-7edcb29bfd14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# 数据准备\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "743d1000-561e-4444-8b49-88346c14f28b",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.to(device)\n",
    "\n",
    "num_epochs = 150\n",
    "train_losses = list()\n",
    "val_losses = list()\n",
    "for epoch in range(num_epochs):\n",
    "    train_loss = train_epoch(model, device, dataloader, criterion, optimizer)\n",
    "    train_losses.append(train_loss)\n",
    "    val_loss = evaluate(model, device, val_loader, criterion)\n",
    "    val_losses.append(val_loss)\n",
    "    print(f'Epoch {epoch+1}, Train Loss: {train_loss}, Val Loss: {val_loss}')\n",
    "\n",
    "# 测试模型\n",
    "test_loss = evaluate(model, device, test_loader, criterion)\n",
    "print(f'Test Loss: {test_loss}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f43384faca0>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5kUlEQVR4nO3deXhU9d3//9c5M8kkgSwsJgEMSysgCAZkM+H+KWoUASloSy3lLmAr/dqCBam20laqeGlsvVGsG+X2Vm5bEZcCeuNWBFHBiIDEilasioBKAmpJSIAkM+fz+2OWTJRgJsscYJ6P6zoXZOYs7/kQJq98zjnvsYwxRgAAAC6x3S4AAAAkNsIIAABwFWEEAAC4ijACAABcRRgBAACuIowAAABXEUYAAICrCCMAAMBVXrcLaArHcfTZZ58pPT1dlmW5XQ4AAGgCY4wOHjyorl27yrYbn/84IcLIZ599pry8PLfLAAAAzbBnzx6deuqpjT5/QoSR9PR0ScEXk5GR4XI1AACgKSorK5WXlxf5Od6YEyKMhE/NZGRkEEYAADjBfNMlFlzACgAAXEUYAQAAriKMAAAAV50Q14wAAE4+gUBAdXV1bpeBFvB4PPJ6vS1uu0EYAQDEXVVVlT755BMZY9wuBS2UlpamLl26KDk5udn7IIwAAOIqEAjok08+UVpamk455RSaWZ6gjDGqra3V/v37tXPnTvXu3fuYjc2OhTACAIiruro6GWN0yimnKDU11e1y0AKpqalKSkrSrl27VFtbq5SUlGbthwtYAQCuYEbk5NDc2ZAG+2iFOgAAAJqNMAIAAFxFGAEAIM569uypRYsWtcq+1q9fL8uydODAgVbZnxu4gBUAgCYYNWqUBg0a1CohYvPmzWrXrl3LizpJJHQYeeDVj/TJvw9r8vDu6pt77E8UBADgWIwxCgQC8nq/+UfrKaecEoeKThwJfZrmmbf3aulrH2vXF9VulwIACcsYo0O1fleWpjZdmz59ul5++WXdddddsixLlmVp6dKlsixLzz33nIYMGSKfz6cNGzboww8/1IQJE5STk6P27dtr2LBhevHFFxvs76unaSzL0gMPPKBLL71UaWlp6t27t55++ulmj+nf/vY3nXHGGfL5fOrZs6cWLlzY4Pn77rtPvXv3VkpKinJycvS9730v8tyTTz6pgQMHKjU1VZ06dVJRUZGqq9v252RCz4x47eBtZQ4dAAHANYfrAuo//wVXjv3ugtFKS/7mH4V33XWX3n//fQ0YMEALFiyQJL3zzjuSpOuvv17/9V//pW9961vq0KGD9uzZo7Fjx+qWW26Rz+fTww8/rPHjx2vHjh3q3r17o8e46aab9Mc//lG333677r77bk2ZMkW7du1Sx44dY3pNW7du1fe//33deOONuvzyy/Xaa6/p5z//uTp16qTp06dry5Yt+sUvfqG//OUvKiws1JdffqlXX31VkrR3715NnjxZf/zjH3XppZfq4MGDevXVV9u8U25ChxE7dI+73yGMAAAal5mZqeTkZKWlpSk3N1eS9N5770mSFixYoAsvvDCybseOHZWfnx/5+uabb9bKlSv19NNPa9asWY0eY/r06Zo8ebIk6dZbb9Wf/vQnvfHGG7r44otjqvWOO+7QBRdcoBtuuEGS1KdPH7377ru6/fbbNX36dO3evVvt2rXTJZdcovT0dPXo0UODBw+WFAwjfr9fl112mXr06CFJGjhwYEzHb46EDiNeTzCMBAgjAOCa1CSP3l0w2rVjt9TQoUMbfF1VVaUbb7xRzzzzTOSH++HDh7V79+5j7ufMM8+M/L1du3bKyMjQvn37Yq7nn//8pyZMmNDgsZEjR2rRokUKBAK68MIL1aNHD33rW9/SxRdfrIsvvjhyeig/P18XXHCBBg4cqNGjR+uiiy7S9773PXXo0CHmOmKR0NeMhGdGCCMA4B7LspSW7HVlaY0usF+9K+baa6/VypUrdeutt+rVV19VaWmpBg4cqNra2mPuJykp6Wvj4jhOi+v7qvT0dL355pt69NFH1aVLF82fP1/5+fk6cOCAPB6P1qxZo+eee079+/fX3Xffrb59+2rnzp2tXke0hA4j4WtGCCMAgG+SnJysQCDwjett3LhR06dP16WXXqqBAwcqNzdXH3/8cdsXGNKvXz9t3LjxazX16dNHHk9wJsjr9aqoqEh//OMf9Y9//EMff/yx1q1bJykYgkaOHKmbbrpJ27ZtU3JyslauXNmmNSf0aRoPYQQA0EQ9e/bUpk2b9PHHH6t9+/aNzlr07t1bK1as0Pjx42VZlm644YY2meFozC9/+UsNGzZMN998sy6//HKVlJTonnvu0X333SdJWr16tT766COdc8456tChg5599lk5jqO+fftq06ZNWrt2rS666CJlZ2dr06ZN2r9/v/r169emNSf0zEgkjHA3DQDgG1x77bXyeDzq37+/TjnllEavAbnjjjvUoUMHFRYWavz48Ro9erTOOuusuNV51lln6fHHH9fy5cs1YMAAzZ8/XwsWLND06dMlSVlZWVqxYoXOP/989evXT4sXL9ajjz6qM844QxkZGXrllVc0duxY9enTR7/73e+0cOFCjRkzpk1rtkxb36/TCiorK5WZmamKigplZGS02n5//shWPft2mRZMOENTC3q22n4BAI07cuSIdu7cqV69ejX7I+dx/DjWv2dTf34n+MxI8OX7A8d9HgMA4KSV0GGEpmcAgOPdVVddpfbt2x91ueqqq9wur1Uk9AWsND0DABzvFixYoGuvvfaoz7XmpQtuSugwwq29AIDjXXZ2trKzs90uo00l9GkamzACAIDrEjqMMDMCAID7EjqM0PQMAAD3xRRG7r//fp155pnKyMhQRkaGCgoK9Nxzzx1zmyeeeEKnn366UlJSNHDgQD377LMtKrg10fQMAAD3xRRGTj31VN12223aunWrtmzZovPPP18TJkzQO++8c9T1X3vtNU2ePFk/+clPtG3bNk2cOFETJ07U9u3bW6X4luI0DQAA7ospjIwfP15jx45V79691adPH91yyy1q3769Xn/99aOuf9ddd+niiy/Wddddp379+unmm2/WWWedpXvuuadVim+p8AWsND0DAMRDz549tWjRoiata1mWVq1a1ab1HC+afc1IIBDQ8uXLVV1drYKCgqOuU1JSoqKiogaPjR49WiUlJc09bKui6RkAAO6Luc/I22+/rYKCAh05ckTt27fXypUr1b9//6OuW1ZWppycnAaP5eTkqKys7JjHqKmpUU1NTeTrysrKWMtskvqmZ/H7NEUAANBQzDMjffv2VWlpqTZt2qSf/exnmjZtmt59991WLaq4uFiZmZmRJS8vr1X3H1Z/zUib7B4A0BTGSLXV7iwxzIwvWbJEXbt2lfOVX2AnTJigH//4x/rwww81YcIE5eTkqH379ho2bJhefPHFVhumt99+W+eff75SU1PVqVMn/fSnP1VVVVXk+fXr12v48OFq166dsrKyNHLkSO3atUuS9NZbb+m8885Tenq6MjIyNGTIEG3ZsqXVamupmGdGkpOTddppp0mShgwZos2bN+uuu+7Sn//856+tm5ubq/Ly8gaPlZeXKzc395jHmDdvnubOnRv5urKysk0CSX3TM9IIALim7pB0a1d3jv2bz6Tkdk1addKkSbr66qv10ksv6YILLpAkffnll3r++ef17LPPqqqqSmPHjtUtt9win8+nhx9+WOPHj9eOHTvUvXv3FpVZXV2t0aNHq6CgQJs3b9a+fft05ZVXatasWVq6dKn8fr8mTpyoGTNm6NFHH1Vtba3eeOMNWaEzAFOmTNHgwYN1//33y+PxqLS0VElJSS2qqTW1uB284zgNTqlEKygo0Nq1azVnzpzIY2vWrGn0GpMwn88nn8/X0tK+ETMjAICm6tChg8aMGaNly5ZFwsiTTz6pzp0767zzzpNt28rPz4+sf/PNN2vlypV6+umnNWvWrBYde9myZTpy5IgefvhhtWsXDE/33HOPxo8frz/84Q9KSkpSRUWFLrnkEn3729+WJPXr1y+y/e7du3Xdddfp9NNPlyT17t27RfW0tpjCyLx58zRmzBh1795dBw8e1LJly7R+/Xq98MILkqSpU6eqW7duKi4uliTNnj1b5557rhYuXKhx48Zp+fLl2rJli5YsWdL6r6QZPMyMAID7ktKCMxRuHTsGU6ZM0YwZM3TffffJ5/PpkUce0Q9+8APZtq2qqirdeOONeuaZZ7R37175/X4dPnxYu3fvbnGZ//znP5Wfnx8JIpI0cuRIOY6jHTt26JxzztH06dM1evRoXXjhhSoqKtL3v/99denSRZI0d+5cXXnllfrLX/6ioqIiTZo0KRJajgcxXTOyb98+TZ06VX379tUFF1ygzZs364UXXtCFF14oKZi89u7dG1m/sLBQy5Yt05IlS5Sfn68nn3xSq1at0oABA1r3VTRTfdMzlwsBgERmWcFTJW4sodMYTTV+/HgZY/TMM89oz549evXVVzVlyhRJ0rXXXquVK1fq1ltv1auvvqrS0lINHDhQtbW1bTFqX/PQQw+ppKREhYWFeuyxx9SnT59I640bb7xR77zzjsaNG6d169apf//+WrlyZVzqaoqYZkb+53/+55jPr1+//muPTZo0SZMmTYqpqHjxMjMCAIhBSkqKLrvsMj3yyCP64IMP1LdvX5111lmSpI0bN2r69Om69NJLJUlVVVX6+OOPW+W4/fr109KlS1VdXR2ZHdm4caNs21bfvn0j6w0ePFiDBw/WvHnzVFBQoGXLlunss8+WJPXp00d9+vTRNddco8mTJ+uhhx6K1Oq2hP5sGpqeAQBiNWXKFD3zzDN68MEHI7MiUvA6jBUrVqi0tFRvvfWWfvjDH37tzpuWHDMlJUXTpk3T9u3b9dJLL+nqq6/Wj370I+Xk5Gjnzp2aN2+eSkpKtGvXLv3973/Xv/71L/Xr10+HDx/WrFmztH79eu3atUsbN27U5s2bG1xT4rYWX8B6IqPpGQAgVueff746duyoHTt26Ic//GHk8TvuuEM//vGPVVhYqM6dO+vXv/51q/XJSktL0wsvvKDZs2dr2LBhSktL03e/+13dcccdkeffe+89/e///q+++OILdenSRTNnztT/+3//T36/X1988YWmTp2q8vJyde7cWZdddpluuummVqmtNVjGHP8/iSsrK5WZmamKigplZGS02n6f2LJH1z35D43qe4qWXjG81fYLAGjckSNHtHPnTvXq1UspKSlul4MWOta/Z1N/fif0aRqvhw/KAwDAbQkdRsLt4AkjAIB4euSRR9S+ffujLmeccYbb5cVdgl8zEsxihBEAQDx95zvf0YgRI4763PHUGTVeEjqMeELzQoQRAEA8paenKz093e0yjhsJfZrGE5oZ8RNGACDuToD7J9AErfHvmNBhhFt7ASD+PB6PJMWtMyna1qFDhyS17PRSQp+moekZAMSf1+tVWlqa9u/fr6SkJNl2Qv9efMIyxujQoUPat2+fsrKyIiGzORI6jDAzAgDxZ1mWunTpop07d2rXrl1ul4MWysrKUm5ubov2kdBhJHxrL9eMAEB8JScnq3fv3pyqOcElJSW1aEYkLKHDSLjpmUMYAYC4s22bDqyQlOAXsDIzAgCA+xI6jISvGaHPCAAA7knoMOIhjAAA4DrCiDhNAwCAmxI6jHBrLwAA7kvoMFLf9MxxuRIAABJXQoeR+pkRlwsBACCBJXQYqb+1l5kRAADcktBhpL7pmcuFAACQwBI6jHiYGQEAwHWJHUairhkx3FEDAIArCCMhND4DAMAdhJEQGp8BAOCOhA4jXrv+5dP4DAAAdyR0GInKIsyMAADgkoQOIw1mRggjAAC4IqHDSNQlI8yMAADgkoQOI5Zl1d/eSxgBAMAVCR1GpOjGZ4QRAADcQBgJzYzQZwQAAHcQRggjAAC4ijBic5oGAAA3JXwY8UY+n4YwAgCAGxI+jNjhmZEAYQQAADckfBhhZgQAAHclfBixubUXAABXJXwY8Xq4mwYAADclfBgJNz0jjAAA4A7CCH1GAABwVUxhpLi4WMOGDVN6erqys7M1ceJE7dix45jbLF26VJZlNVhSUlJaVHRrIowAAOCumMLIyy+/rJkzZ+r111/XmjVrVFdXp4suukjV1dXH3C4jI0N79+6NLLt27WpR0a2pvumZ43IlAAAkJm8sKz///PMNvl66dKmys7O1detWnXPOOY1uZ1mWcnNzm1dhG+PWXgAA3NWia0YqKiokSR07djzmelVVVerRo4fy8vI0YcIEvfPOOy05bKui6RkAAO5qdhhxHEdz5szRyJEjNWDAgEbX69u3rx588EE99dRT+utf/yrHcVRYWKhPPvmk0W1qampUWVnZYGkrzIwAAOCumE7TRJs5c6a2b9+uDRs2HHO9goICFRQURL4uLCxUv3799Oc//1k333zzUbcpLi7WTTfd1NzSYkLTMwAA3NWsmZFZs2Zp9erVeumll3TqqafGtG1SUpIGDx6sDz74oNF15s2bp4qKisiyZ8+e5pTZJDQ9AwDAXTHNjBhjdPXVV2vlypVav369evXqFfMBA4GA3n77bY0dO7bRdXw+n3w+X8z7bg6bpmcAALgqpjAyc+ZMLVu2TE899ZTS09NVVlYmScrMzFRqaqokaerUqerWrZuKi4slSQsWLNDZZ5+t0047TQcOHNDtt9+uXbt26corr2zll9I8XvqMAADgqpjCyP333y9JGjVqVIPHH3roIU2fPl2StHv3btl2/dmff//735oxY4bKysrUoUMHDRkyRK+99pr69+/fsspbiSdUK2EEAAB3xHya5pusX7++wdd33nmn7rzzzpiKiidPKDdxASsAAO5I+M+m8YZmRri1FwAAdyR8GKHpGQAA7kr4MELTMwAA3JXwYYSmZwAAuCvhwwi39gIA4K6EDyM2YQQAAFclfBhhZgQAAHclfBjxEEYAAHAVYcTmAlYAANyU8GGEW3sBAHBXwocRmp4BAOCuhA8jzIwAAOCuhA8j9U3PHJcrAQAgMSV8GKm/tdflQgAASFAJH0bqm56RRgAAcEPChxFmRgAAcFfChxEPMyMAALiKMELTMwAAXJXwYYRbewEAcFfChxGangEA4K6EDyPMjAAA4K6EDyP1Tc8IIwAAuCHhw4jXE76bhjACAIAbEj6MhGdGCCMAALgj4cOI1w4OAadpAABwR8KHkXCfEYcwAgCAKwgjND0DAMBVCR9GuLUXAAB3JXwYoekZAADuSvgwwswIAADuSvgwQtMzAADclfBhJNz0jLtpAABwR8KHEe6mAQDAXYQROrACAOAqwohNGAEAwE2EEU7TAADgqoQPI9zaCwCAuxI+jNQ3PXNcrgQAgMSU8GGkfmbE5UIAAEhQCR9G6pueMTMCAIAbEj6M1Dc9c7kQAAASVMKHkfq7aUgjAAC4IaYwUlxcrGHDhik9PV3Z2dmaOHGiduzY8Y3bPfHEEzr99NOVkpKigQMH6tlnn212wa0t3PTMMZLhjhoAAOIupjDy8ssva+bMmXr99de1Zs0a1dXV6aKLLlJ1dXWj27z22muaPHmyfvKTn2jbtm2aOHGiJk6cqO3bt7e4+NbgteuHgMZnAADEn2VaMB2wf/9+ZWdn6+WXX9Y555xz1HUuv/xyVVdXa/Xq1ZHHzj77bA0aNEiLFy9u0nEqKyuVmZmpiooKZWRkNLfcozp4pE4Db/y7JOm9my9WSpKnVfcPAECiaurP7xZdM1JRUSFJ6tixY6PrlJSUqKioqMFjo0ePVklJSaPb1NTUqLKyssHSVqJnRmh8BgBA/DU7jDiOozlz5mjkyJEaMGBAo+uVlZUpJyenwWM5OTkqKytrdJvi4mJlZmZGlry8vOaW+Y2isggt4QEAcEGzw8jMmTO1fft2LV++vDXrkSTNmzdPFRUVkWXPnj2tfoywBjMjhBEAAOLO25yNZs2apdWrV+uVV17Rqaeeesx1c3NzVV5e3uCx8vJy5ebmNrqNz+eTz+drTmkxC93ZK4mZEQAA3BDTzIgxRrNmzdLKlSu1bt069erV6xu3KSgo0Nq1axs8tmbNGhUUFMRWaRuxLCvSa4SZEQAA4i+mmZGZM2dq2bJleuqpp5Senh657iMzM1OpqamSpKlTp6pbt24qLi6WJM2ePVvnnnuuFi5cqHHjxmn58uXasmWLlixZ0sovpfk8tqWAY5gZAQDABTHNjNx///2qqKjQqFGj1KVLl8jy2GOPRdbZvXu39u7dG/m6sLBQy5Yt05IlS5Sfn68nn3xSq1atOuZFr/EWbnxGnxEAAOIvppmRprQkWb9+/dcemzRpkiZNmhTLoeIq/Mm9hBEAAOIv4T+bRpLsyOfTEEYAAIg3wojqZ0ZoegYAQPwRRhQ1MxIgjAAAEG+EETEzAgCAmwgjkmyLa0YAAHALYUSS18PdNAAAuIUwIkU6sBJGAACIP8KI6pue+R3H5UoAAEg8hBEp6rNpXC4EAIAERBhRfRhhZgQAgPgjjIhbewEAcBNhRDQ9AwDATYQRMTMCAICbCCOi6RkAAG4ijIimZwAAuIkwIsljB4eBMAIAQPwRRiSFJkY4TQMAgAsII6qfGXEIIwAAxB1hRJInNArMjAAAEH+EEUne8MwIt/YCABB3hBHR9AwAADcRRkTTMwAA3EQYUfQH5RFGAACIN8KIJI9F0zMAANxCGJHkoQMrAACuIYyofmaE0zQAAMQfYUT114zQ9AwAgPgjjIgLWAEAcBNhRNzaCwCAmwgjoukZAABuIoyImREAANxEGFH0NSOOy5UAAJB4CCOi6RkAAG4ijIimZwAAuIkwIpqeAQDgJsKIaHoGAICbCCOi6RkAAG4ijIhbewEAcBNhRDQ9AwDATYQRMTMCAICbCCOSPHZwGLhmBACA+COMSPKERoE+IwAAxF/MYeSVV17R+PHj1bVrV1mWpVWrVh1z/fXr18uyrK8tZWVlza251YVnRggjAADEX8xhpLq6Wvn5+br33ntj2m7Hjh3au3dvZMnOzo710G2GpmcAALjHG+sGY8aM0ZgxY2I+UHZ2trKysmLeLh5oegYAgHvids3IoEGD1KVLF1144YXauHHjMdetqalRZWVlg6Ut0fQMAAD3tHkY6dKlixYvXqy//e1v+tvf/qa8vDyNGjVKb775ZqPbFBcXKzMzM7Lk5eW1aY3c2gsAgHtiPk0Tq759+6pv376RrwsLC/Xhhx/qzjvv1F/+8pejbjNv3jzNnTs38nVlZWWbBhKangEA4J42DyNHM3z4cG3YsKHR530+n3w+X9zqYWYEAAD3uNJnpLS0VF26dHHj0EfFNSMAALgn5pmRqqoqffDBB5Gvd+7cqdLSUnXs2FHdu3fXvHnz9Omnn+rhhx+WJC1atEi9evXSGWecoSNHjuiBBx7QunXr9Pe//731XkULhcMIfUYAAIi/mMPIli1bdN5550W+Dl/bMW3aNC1dulR79+7V7t27I8/X1tbql7/8pT799FOlpaXpzDPP1IsvvthgH24jjAAA4B7LmOP/QonKykplZmaqoqJCGRkZrb7/t/Yc0IR7N6pbVqo2Xn9+q+8fAIBE1NSf33w2jZgZAQDATYQRcQErAABuIoyIW3sBAHATYUTRTc8clysBACDxEEYUPTPiciEAACQgwoiirxlhZgQAgHgjjIi7aQAAcBNhRIQRAADcRBiR5LHqrxk5AXrAAQBwUiGMSPLa9cPA7AgAAPFFGJEUlUVofAYAQJwRRtRwZoTGZwAAxBdhRPUXsErMjAAAEG+EETUMIw5hBACAuCKMSIrKIsyMAAAQZ4QRSZZl0WsEAACXEEZCCCMAALiDMBISbnxGGAEAIL4IIyFeZkYAAHAFYSTEjnxyL2EEAIB4IoyEhGdGaHoGAEB8EUZCwhew+gOEEQAA4okwEuJhZgQAAFcQRkI8XDMCAIArCCMh9X1GHJcrAQAgsRBGQurDiMuFAACQYAgjIeGmZ35mRgAAiCvCSEjkAlayCAAAcUUYCam/gJU0AgBAPBFGQmh6BgCAOwgjITQ9AwDAHYSREJqeAQDgDsJICE3PAABwB2EkpL7PCGEEAIB4IoyEeOzgUBBGAACIL8JIiCc4McJpGgAA4owwEhKeGXEIIwAAxBVhJMQTGglmRgAAiC/CSIg3PDPCrb0AAMQVYSSEpmcAALiDMBLCrb0AALiDMBISCSOcpgEAIK5iDiOvvPKKxo8fr65du8qyLK1ateobt1m/fr3OOuss+Xw+nXbaaVq6dGkzSm1bHouZEQAA3BBzGKmurlZ+fr7uvffeJq2/c+dOjRs3Tuedd55KS0s1Z84cXXnllXrhhRdiLrYteTyEEQAA3OCNdYMxY8ZozJgxTV5/8eLF6tWrlxYuXChJ6tevnzZs2KA777xTo0ePjvXwbSY8M8KtvQAAxFebXzNSUlKioqKiBo+NHj1aJSUljW5TU1OjysrKBktbi3xqL2EEAIC4avMwUlZWppycnAaP5eTkqLKyUocPHz7qNsXFxcrMzIwseXl5bV0mn9oLAIBLjsu7aebNm6eKiorIsmfPnjY/pjc8M8LdNAAAxFXM14zEKjc3V+Xl5Q0eKy8vV0ZGhlJTU4+6jc/nk8/na+vSGqDpGQAA7mjzmZGCggKtXbu2wWNr1qxRQUFBWx86JvVNzxyXKwEAILHEHEaqqqpUWlqq0tJSScFbd0tLS7V7925JwVMsU6dOjax/1VVX6aOPPtKvfvUrvffee7rvvvv0+OOP65prrmmdV9BKaHoGAIA7Yg4jW7Zs0eDBgzV48GBJ0ty5czV48GDNnz9fkrR3795IMJGkXr166ZlnntGaNWuUn5+vhQsX6oEHHjiubuuVaHoGAIBbYr5mZNSoUTLHmD04WnfVUaNGadu2bbEeKq5oegYAgDuOy7tp3EDTMwAA3EEYCaHpGQAA7iCMhND0DAAAdxBGQmh6BgCAOwgjIR47OBQ0PQMAIL4IIyGe0EhwNw0AAPFFGAkJz4zQ9AwAgPgijIQwMwIAgDsIIyGRmRHCCAAAcUUYCaHpGQAA7iCMhND0DAAAdxBGQrw0PQMAwBWEkRAPTc8AAHAFYSQk0g6epmcAAMQVYSQkHEa4mwYAgPgijIREwginaQAAiCvCSAgzIwAAuIMwEkIYAQDAHYSRkHDTM8IIAADxRRgJYWYEAAB3EEZCvB6angEA4AbCSEj4NA1NzwAAiC/CSEh90zPH5UoAAEgshJEQrhkBAMAdhJEQmp4BAOAOwkgIMyMAALiDMBJCGAEAwB2EkZD6u2kkw6kaAADihjAS4rXrh4LZEQAA4ocwEuIJNT2TaHwGAEA8EUZCwqdpJBqfAQAQT4SRkPAFrBIzIwAAxBNhJCQ6jAQChBEAAOKFMBISlUVofAYAQBwRRkIsy6LXCAAALiCMRCGMAAAQf4SRKOE7aggjAADED2EkipeZEQAA4o4wEiXc+IxbewEAiB/CSJT6z6chjAAAEC+EkSjhC1j99BkBACBuCCNRuJsGAID4a1YYuffee9WzZ0+lpKRoxIgReuONNxpdd+nSpbIsq8GSkpLS7ILbUiSMcJoGAIC4iTmMPPbYY5o7d65+//vf680331R+fr5Gjx6tffv2NbpNRkaG9u7dG1l27drVoqLbSv3MiONyJQAAJI6Yw8gdd9yhGTNm6IorrlD//v21ePFipaWl6cEHH2x0G8uylJubG1lycnJaVHRbqQ8jLhcCAEACiSmM1NbWauvWrSoqKqrfgW2rqKhIJSUljW5XVVWlHj16KC8vTxMmTNA777xzzOPU1NSosrKywRIP4btp/MyMAAAQNzGFkc8//1yBQOBrMxs5OTkqKys76jZ9+/bVgw8+qKeeekp//etf5TiOCgsL9cknnzR6nOLiYmVmZkaWvLy8WMpstvDMCFkEAID4afO7aQoKCjR16lQNGjRI5557rlasWKFTTjlFf/7znxvdZt68eaqoqIgse/bsaesyJUleDzMjAADEmzeWlTt37iyPx6Py8vIGj5eXlys3N7dJ+0hKStLgwYP1wQcfNLqOz+eTz+eLpbRWQdMzAADiL6aZkeTkZA0ZMkRr166NPOY4jtauXauCgoIm7SMQCOjtt99Wly5dYqs0Dmh6BgBA/MU0MyJJc+fO1bRp0zR06FANHz5cixYtUnV1ta644gpJ0tSpU9WtWzcVFxdLkhYsWKCzzz5bp512mg4cOKDbb79du3bt0pVXXtm6r6QV0PQMAID4izmMXH755dq/f7/mz5+vsrIyDRo0SM8//3zkotbdu3fLtusnXP79739rxowZKisrU4cOHTRkyBC99tpr6t+/f+u9ilZC0zMAAOLPMub4/8lbWVmpzMxMVVRUKCMjo82OM+WB17Xxgy901w8GacKgbm12HAAAEkFTf37z2TRRPKEZHU7TAAAQP4SRKN7wBayEEQAA4oYwEsUO39pLGAEAIG4II1GYGQEAIP4II1G4tRcAgPgjjEQhjAAAEH+EkSiEEQAA4o8wEoWmZwAAxB9hJEr4g/KYGQEAIH4II1E8HsIIAADxRhiJwq29AADEH2EkCk3PAACIP8JIFGZGAACIP8JIlPpbex2XKwEAIHEQRqLUhxGXCwEAIIEQRqIwMwIAQPwRRqLQ9AwAgPgjjESh6RkAAPFHGIlC0zMAAOKPMBKFW3sBAIg/wkgUmp4BABB/hJEozIwAABB/hJEo9bf2EkYAAIgXwkgUjx0cDsIIAADxQxiJ4gmNBmEEAID4IYxEicyM0PQMAIC4IYxEYWYEAID4I4xE4ZoRAADijzAShVt7AQCIP8JIxaeRv9L0DACA+EvcMOKvkZ6YLt2VL33xoSRmRgAAcEPihhGvT6qpkpw6ae0CSTQ9AwDADYkbRiTpwpskWdK7q6RPthJGAABwQWKHkZwzpEE/DP59zXx5glmEMAIAQBwldhiRpPN+I3lTpF0b1GnvS5JoegYAQDwRRjJPlUZcJUnq/ubtsuXocG2A2REAAOKEMCJJ/3GNlNpBaQfe1yTvK/r0wGFdsXSzDhyqdbsyAABOeoQRSUrNkv6/ayVJN7ZfpaykOr3y/n6Nv2eD3v2s0t3aAAA4yRFGwobPkDK7K/XIPq0b+KKGZFVrz5eHddn9G7Vq26c0QgMAoI1Yxhz/V2tWVlYqMzNTFRUVysjIaLsD/eNxacWMyJe7kr6tpw4P1PrAIO319dRpeV01KC9Lg/Ky1Dc3XbkZKfJ6yHMAABxNU39+E0aiGSNtfUh6a7m05w1JDYfmc5Ohj02udpkc7TdZOiyfklLayZeWrrR26bJSO8hOy5K3XUclte+o5HYZSkpKkc/nky/Jq5QkW2nJXrX3edXO51FasjfS20SOI9UdCi7J7YLL0dQclKr2SUmpUvtcySYMAQCOT4SRlqr+QvpgjbTjOZldG2VV72/R7mqNR3555ZdHAdnyy1ZAHtkyam8dVppqGqx/RD5V2Fk66MmU30pWlvNvZQW+VIo5HFnHb3lVmZStiuRcVfs6y7JseWRkW448kizbkmyvZHskyyvL45WSUmUlpchKSpOdnCrbmyyvZeSxjLyWZNuWPO06ypORq6TMXHnSc6W0jpInWQp9ds83MkZy/MFjN3UbAMBJp03DyL333qvbb79dZWVlys/P1913363hw4c3uv4TTzyhG264QR9//LF69+6tP/zhDxo7dmyTj+dKGPmqI5XSv3cGP8fmyw9lqr/U4UMHdfjQQdUcqlLgSJW8tZVKrqtQiv+gUp0q2XLapJQqk6IU1cprtc3+G1Mnb2hJkmPZMrLkyJaxbFkySjZ1Slatkk2tbDlyZKnWStFhO1U1VqpqLJ8sWbIsI1uSZRk5VpLqPKnye1Ll96TJ8aZIkqyoWSlj2TIeX9SSLNkeWZYty7Iky5Zl25IVWmRJti2PcWTLkUdOMAKagCxTJ8sJyHb8kvHL8aTIn5Quf1J7+ZMzFPCmybY98thWcLEs2XZw/7btkW1boeMGZ6QsS7JCfzGyg39aliRLtmXJ9njksW1ZtiXb8kRqDNZrSaFtwqHNsiTbBGQ7dbJMQLZxgiNh2zKWV7I8ku2Rbdvyejyy7NA+I4MV9d85/JztCW5n2ZJxJJngesapX5xA6LnQdra3ftvw804gGDKNUz/W4cW2JTtJ8iTVB+DoWoyRTEAK1AU/giG8P483GHQ9yfXHdALBdcN/WnZ9/bYntD+n/nnjNDxWeCA9ycF6PL7gn7IavnaZ+m3D42B7Qq8juX7W0ZjgZ1n5jwT/lEL7jao7UCv5Dwefrzsc3Lc3JbT4gjXYnrYL58Y0HDfLCr6O1jymMcF/v8j3FL9o4Js19ee3N9YdP/bYY5o7d64WL16sESNGaNGiRRo9erR27Nih7Ozsr63/2muvafLkySouLtYll1yiZcuWaeLEiXrzzTc1YMCAWA/vnpQMqUt+cFHwbS0ttByV4wTfvJy64H/gQG3wjco4MoE61dbV6XBNjY7UGdV40lRjp+qIlaYaJSlwpEo6tF9W9eeyD30h1R1SVXInVSWfoipvJx2yUhWoq5XvyD6lHNqrdoc/U0rNFwoYyW8kv2Mp4ASbt1lOnYzjyHL8klMnT6BGnsAReZ0j8jo1shy/6owtxxj5jSU5jrJ0UKdYB3SKVaFOqpDHCr7RJ8mvJPklHWl4BquROGvLKMUcVkrg8NFXAI5jAdlyZIe+51uPo2BYdUJh3rE8wT8VDPhSOOBGbxN8zsgOBmzjl0d+2SYgb6jSxvjlVcDyfv1YUSHWRI4sWcYo/J/aliOv8ctr6pSkugb7rVOSApZHAcsrI1uOFZztNZZHlnGCc7/GL48J1hfcqy0TCu5GVqQeYwVr+srLjtQWftTIkhVVa3CPjiwT/IUj/GdAwbr8VlLotXtkh/9FQ7XZJvQvYJzQPp2oMfLIsTyRI1uqH5PwUU2oWmNF/V22TPgXFGNC+zWR2sPrhl+/sTyhX+yCX3vkD41ZcAlvE6nHCn8fWPV1hMczalyDYx8cf9sEZIW+P6J/yQvXpMgzlgKXPaDcvo1PLLSlmGdGRowYoWHDhumee+6RJDmOo7y8PF199dW6/vrrv7b+5Zdfrurqaq1evTry2Nlnn61BgwZp8eLFTTrmcTEzkkACjlGNP6CaOkdHamtVd6hSgboa1dXWKlBXo0DdEQUCfhnHkeME5DgBBQJGtXayapSsGpOkGpMk29QpKXBISYFDSg4clidwOBh6HClgLPkdR8ZfJ9UdklVXLbvukGx/MLhE/yeR8csO1EpOrTyBWtlOTeS3WSv8G61M6E3UkWWCbywB2QoYW3555Df1p8YC8sgfenP2qVbtTLXSzCG1M9VKNYeDuzbBt8Dg/47g/sL7tWSi3pfq34bq3wrCb1WhN/RQfZHnrOCfHjmyvvJ2IEl18ihgPPKr/g3aE57hsQLyhmsI7dMjJ+rNqf4NO/xceLHkRCpzQn8GVD/DFWhwrEBkOyfqtKJfoZmn0J7Cx7DlKCk0useasYs+XenIkkeOkkMh17YavhX5jS1HlqxQTV99PnodE6o9vIYlI5/VuiFCkhwTHOej1RJ+/oiSZaTg67ICrV4D0Fbeu2SFTh96Qavus01mRmpra7V161bNmzcv8pht2yoqKlJJSclRtykpKdHcuXMbPDZ69GitWrWq0ePU1NSopqb+GorKSnp9xJPHtpSW7FVasqR2yVKH9m6XdMIzxih8d3g4/x/tx5ljTHDG3RgFHCPHkWTVnw6yrPoPc/QHHAUcoyOOCYanr5wVCc+iB88CWZFjR+/ftqzgjH7UlHvk2MYoEMoVJvq3wq8Ubkzw+fDjxnFkjF/GfPV3yuAprHDAc0JnTBxj5DiOTMAvy5JM6JRMpKLw6zCqP71i1Z8mMKFwaL5aizGyjF+WUyfbqasPmLJkjCVjhWsKnmpyQjODMn5ZgZrgKSnHkeNJkmMnK2D75Fje4FiagDxOrWzHL1t+yU5SwOOT7OTIWNu2ZDsBWaZWnsARGcdRIODIMaE/HSfyW71t/LJCp+TC3x9OKBSHR9AKnYoxlkeO7ZWxvJE/jWVHfnOOzDA4flmmLlij4w8F97rQ8QLBGVPLCkZXOzzM9TMQ4bFx7KTIErCSgqHcqQvOtpo6WQG/ZAKyTPA0ke34G9Ro7GB9Cv27yziynEAo4DuyTCBUW/D0UvDl13+/hs9iWqG/m9C/tWOCs0yOCX7PBGcZgmNgGUcepy440xA65emEZhgazDREnWo2soKnSBWsyWPqg6QT/l4xwdPM4X8PK/x6wqf/FP4eDX2vR82rhGecgusGQq896vXLkWN55VeSHDs4myUFf5kJnrINzXBEfilSaLvQXElopscYRWapwjNE4VPIVvjf1qqvJ/w9ZozRqLyBcktMYeTzzz9XIBBQTk5Og8dzcnL03nvvHXWbsrKyo65fVlbW6HGKi4t10003xVIacFyzLCvyQYxfn4gGgMR2XN4XOm/ePFVUVESWPXv2uF0SAABoIzHNjHTu3Fkej0fl5eUNHi8vL1dubu5Rt8nNzY1pfUnBvhw+XyylAQCAE1RMMyPJyckaMmSI1q5dG3nMcRytXbtWBQUFR92moKCgwfqStGbNmkbXBwAAiSXmW3vnzp2radOmaejQoRo+fLgWLVqk6upqXXHFFZKkqVOnqlu3biouLpYkzZ49W+eee64WLlyocePGafny5dqyZYuWLFnSuq8EAACckGIOI5dffrn279+v+fPnq6ysTIMGDdLzzz8fuUh19+7dsqNalBcWFmrZsmX63e9+p9/85jfq3bu3Vq1adWL1GAEAAG2GdvAAAKBNNPXn93F5Nw0AAEgchBEAAOAqwggAAHAVYQQAALiKMAIAAFxFGAEAAK4ijAAAAFfF3PTMDeFWKJWVlS5XAgAAmir8c/ubWpqdEGHk4MGDkqS8vDyXKwEAALE6ePCgMjMzG33+hOjA6jiOPvvsM6Wnp8uyrFbbb2VlpfLy8rRnzx46u7Yxxjp+GOv4Yrzjh7GOn9Yaa2OMDh48qK5duzb4qJivOiFmRmzb1qmnntpm+8/IyOAbO04Y6/hhrOOL8Y4fxjp+WmOsjzUjEsYFrAAAwFWEEQAA4KqEDiM+n0+///3v5fP53C7lpMdYxw9jHV+Md/ww1vET77E+IS5gBQAAJ6+EnhkBAADuI4wAAABXEUYAAICrCCMAAMBVCR1G7r33XvXs2VMpKSkaMWKE3njjDbdLOuEVFxdr2LBhSk9PV3Z2tiZOnKgdO3Y0WOfIkSOaOXOmOnXqpPbt2+u73/2uysvLXar45HDbbbfJsizNmTMn8hjj3Lo+/fRT/ed//qc6deqk1NRUDRw4UFu2bIk8b4zR/Pnz1aVLF6WmpqqoqEj/+te/XKz4xBQIBHTDDTeoV69eSk1N1be//W3dfPPNDT7bhLFunldeeUXjx49X165dZVmWVq1a1eD5pozrl19+qSlTpigjI0NZWVn6yU9+oqqqqpYXZxLU8uXLTXJysnnwwQfNO++8Y2bMmGGysrJMeXm526Wd0EaPHm0eeughs337dlNaWmrGjh1runfvbqqqqiLrXHXVVSYvL8+sXbvWbNmyxZx99tmmsLDQxapPbG+88Ybp2bOnOfPMM83s2bMjjzPOrefLL780PXr0MNOnTzebNm0yH330kXnhhRfMBx98EFnntttuM5mZmWbVqlXmrbfeMt/5zndMr169zOHDh12s/MRzyy23mE6dOpnVq1ebnTt3mieeeMK0b9/e3HXXXZF1GOvmefbZZ81vf/tbs2LFCiPJrFy5ssHzTRnXiy++2OTn55vXX3/dvPrqq+a0004zkydPbnFtCRtGhg8fbmbOnBn5OhAImK5du5ri4mIXqzr57Nu3z0gyL7/8sjHGmAMHDpikpCTzxBNPRNb55z//aSSZkpISt8o8YR08eND07t3brFmzxpx77rmRMMI4t65f//rX5j/+4z8afd5xHJObm2tuv/32yGMHDhwwPp/PPProo/Eo8aQxbtw48+Mf/7jBY5dddpmZMmWKMYaxbi1fDSNNGdd3333XSDKbN2+OrPPcc88Zy7LMp59+2qJ6EvI0TW1trbZu3aqioqLIY7Ztq6ioSCUlJS5WdvKpqKiQJHXs2FGStHXrVtXV1TUY+9NPP13du3dn7Jth5syZGjduXIPxlBjn1vb0009r6NChmjRpkrKzszV48GD993//d+T5nTt3qqysrMF4Z2ZmasSIEYx3jAoLC7V27Vq9//77kqS33npLGzZs0JgxYyQx1m2lKeNaUlKirKwsDR06NLJOUVGRbNvWpk2bWnT8E+KD8lrb559/rkAgoJycnAaP5+Tk6L333nOpqpOP4ziaM2eORo4cqQEDBkiSysrKlJycrKysrAbr5uTkqKyszIUqT1zLly/Xm2++qc2bN3/tOca5dX300Ue6//77NXfuXP3mN7/R5s2b9Ytf/ELJycmaNm1aZEyP9p7CeMfm+uuvV2VlpU4//XR5PB4FAgHdcsstmjJliiQx1m2kKeNaVlam7OzsBs97vV517NixxWOfkGEE8TFz5kxt375dGzZscLuUk86ePXs0e/ZsrVmzRikpKW6Xc9JzHEdDhw7VrbfeKkkaPHiwtm/frsWLF2vatGkuV3dyefzxx/XII49o2bJlOuOMM1RaWqo5c+aoa9eujPVJLCFP03Tu3Fkej+drdxaUl5crNzfXpapOLrNmzdLq1av10ksv6dRTT408npubq9raWh04cKDB+ox9bLZu3ap9+/bprLPOktfrldfr1csvv6w//elP8nq9ysnJYZxbUZcuXdS/f/8Gj/Xr10+7d++WpMiY8p7Sctddd52uv/56/eAHP9DAgQP1ox/9SNdcc42Ki4slMdZtpSnjmpubq3379jV43u/368svv2zx2CdkGElOTtaQIUO0du3ayGOO42jt2rUqKChwsbITnzFGs2bN0sqVK7Vu3Tr16tWrwfNDhgxRUlJSg7HfsWOHdu/ezdjH4IILLtDbb7+t0tLSyDJ06FBNmTIl8nfGufWMHDnya7eov//+++rRo4ckqVevXsrNzW0w3pWVldq0aRPjHaNDhw7Jthv+aPJ4PHIcRxJj3VaaMq4FBQU6cOCAtm7dGlln3bp1chxHI0aMaFkBLbr89QS2fPly4/P5zNKlS827775rfvrTn5qsrCxTVlbmdmkntJ/97GcmMzPTrF+/3uzduzeyHDp0KLLOVVddZbp3727WrVtntmzZYgoKCkxBQYGLVZ8cou+mMYZxbk1vvPGG8Xq95pZbbjH/+te/zCOPPGLS0tLMX//618g6t912m8nKyjJPPfWU+cc//mEmTJjA7abNMG3aNNOtW7fIrb0rVqwwnTt3Nr/61a8i6zDWzXPw4EGzbds2s23bNiPJ3HHHHWbbtm1m165dxpimjevFF19sBg8ebDZt2mQ2bNhgevfuza29LXX33Xeb7t27m+TkZDN8+HDz+uuvu13SCU/SUZeHHnooss7hw4fNz3/+c9OhQweTlpZmLr30UrN37173ij5JfDWMMM6t6//+7//MgAEDjM/nM6effrpZsmRJg+cdxzE33HCDycnJMT6fz1xwwQVmx44dLlV74qqsrDSzZ8823bt3NykpKeZb3/qW+e1vf2tqamoi6zDWzfPSSy8d9f152rRpxpimjesXX3xhJk+ebNq3b28yMjLMFVdcYQ4ePNji2ixjotraAQAAxFlCXjMCAACOH4QRAADgKsIIAABwFWEEAAC4ijACAABcRRgBAACuIowAAABXEUYAAICrCCMAAMBVhBEAAOAqwggAAHAVYQQAALjq/wdMo79Kv+lL1AAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tr_ind = list(range(len(train_losses)))\n",
    "val_ind = list(range(len(val_losses)))\n",
    "plt.plot(train_losses, label='train_loss')\n",
    "plt.plot(val_losses, label='val_loss')\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "290edd23-b3ce-474d-b654-2e1096be9866",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model, './models/MAE/final_30.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9d0f3b92-58c2-4794-ae98-7e10546dfb0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = torch.load('./models/MAE/final_30.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a8467686-0655-4056-8e01-56299eb89d7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "59997827-2df9-4593-92b1-4fdc7b6307b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_ioa(y_true, y_pred):\n",
    "    # 计算平均值\n",
    "    mean_observed = np.mean(y_true)\n",
    "    mean_predicted = np.mean(y_pred)\n",
    "\n",
    "    # 计算IoA\n",
    "    numerator = np.sum((y_true - y_pred) ** 2)\n",
    "    denominator = np.sum((np.abs(y_true - mean_observed) + np.abs(y_pred - mean_predicted)) ** 2)\n",
    "    IoA = 1 - (numerator / denominator)\n",
    "\n",
    "    return IoA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dae7427e-548e-4276-a4ea-bc9b279d44e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "eva_list = list()\n",
    "device = 'cpu'\n",
    "model = model.to(device)\n",
    "with torch.no_grad():\n",
    "    for batch_idx, (X, y, mask) in enumerate(test_loader):\n",
    "        X, y, mask = X.to(device), y.to(device), mask.to(device)\n",
    "        mask_rev = (torch.squeeze(mask, dim=1)==0) * 1 # mask取反获得修复区域\n",
    "        reconstructed = model(X)\n",
    "        rev_data = y * max_pixel_value\n",
    "        rev_recon = reconstructed * max_pixel_value\n",
    "        # todo: 这里需要只评估修补出来的模块\n",
    "        data_label = torch.squeeze(rev_data, dim=1) * mask_rev\n",
    "        data_label = data_label[mask_rev==1]\n",
    "        recon_no2 = torch.squeeze(rev_recon, dim=1) * mask_rev\n",
    "        recon_no2 = recon_no2[mask_rev==1]\n",
    "        mae = mean_absolute_error(data_label, recon_no2)\n",
    "        rmse = np.sqrt(mean_squared_error(data_label, recon_no2))\n",
    "        mape = mean_absolute_percentage_error(data_label, recon_no2)\n",
    "        r2 = r2_score(data_label, recon_no2)\n",
    "        ioa = cal_ioa(data_label.detach().numpy(), recon_no2.detach().numpy())\n",
    "        r = np.corrcoef(data_label, recon_no2)[0, 1]\n",
    "        eva_list.append([mae, rmse, mape, r2, ioa, r])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5b01834-ca18-4ec3-bc9d-64382d0fab34",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "984650d0-880c-476f-9b7d-e47e8d0fea23",
   "metadata": {},
   "outputs": [],
   "source": [
    "eva_list_frame = list()\n",
    "device = 'cpu'\n",
    "model = model.to(device)\n",
    "best_mape = 1\n",
    "best_img = None\n",
    "best_mask = None\n",
    "best_recov = None\n",
    "with torch.no_grad():\n",
    "    for batch_idx, (X, y, mask) in enumerate(test_loader):\n",
    "        X, y, mask = X.to(device), y.to(device), mask.to(device)\n",
    "        mask_rev = (torch.squeeze(mask, dim=1)==0) * 1 # mask取反获得修复区域\n",
    "        reconstructed = model(X)\n",
    "        rev_data = y * max_pixel_value\n",
    "        rev_recon = reconstructed * max_pixel_value\n",
    "        # todo: 这里需要只评估修补出来的模块\n",
    "        for i, sample in enumerate(rev_data):\n",
    "            used_mask = mask_rev[i]\n",
    "            data_label = sample[0] * used_mask\n",
    "            recon_no2 = rev_recon[i][0] * used_mask\n",
    "            data_label = data_label[used_mask==1]\n",
    "            recon_no2 = recon_no2[used_mask==1]\n",
    "            mae = mean_absolute_error(data_label, recon_no2)\n",
    "            rmse = np.sqrt(mean_squared_error(data_label, recon_no2))\n",
    "            mape = mean_absolute_percentage_error(data_label, recon_no2)\n",
    "            r2 = r2_score(data_label, recon_no2)\n",
    "            ioa = cal_ioa(data_label.detach().numpy(), recon_no2.detach().numpy())\n",
    "            r = np.corrcoef(data_label, recon_no2)[0, 1]\n",
    "            eva_list_frame.append([mae, rmse, mape, r2, ioa, r])\n",
    "            if mape < best_mape:\n",
    "                best_recov = rev_recon[i][0].numpy()\n",
    "                best_mask = used_mask.numpy()\n",
    "                best_img = sample[0].numpy()\n",
    "                best_mape = mape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ff73a2d5-56b6-4636-8729-a71b69ed5503",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mae</th>\n",
       "      <th>rmse</th>\n",
       "      <th>mape</th>\n",
       "      <th>r2</th>\n",
       "      <th>ioa</th>\n",
       "      <th>r</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>4739.000000</td>\n",
       "      <td>4739.000000</td>\n",
       "      <td>4739.000000</td>\n",
       "      <td>4739.000000</td>\n",
       "      <td>4739.000000</td>\n",
       "      <td>4739.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.399060</td>\n",
       "      <td>1.979731</td>\n",
       "      <td>0.182714</td>\n",
       "      <td>0.642942</td>\n",
       "      <td>0.872402</td>\n",
       "      <td>0.816624</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.638751</td>\n",
       "      <td>0.875072</td>\n",
       "      <td>0.104177</td>\n",
       "      <td>0.219567</td>\n",
       "      <td>0.101818</td>\n",
       "      <td>0.117307</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.492277</td>\n",
       "      <td>0.624609</td>\n",
       "      <td>0.060600</td>\n",
       "      <td>-1.963828</td>\n",
       "      <td>0.092951</td>\n",
       "      <td>0.060861</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.907458</td>\n",
       "      <td>1.280065</td>\n",
       "      <td>0.126618</td>\n",
       "      <td>0.535003</td>\n",
       "      <td>0.835822</td>\n",
       "      <td>0.758542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.266889</td>\n",
       "      <td>1.857223</td>\n",
       "      <td>0.158806</td>\n",
       "      <td>0.694635</td>\n",
       "      <td>0.902473</td>\n",
       "      <td>0.846662</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.737844</td>\n",
       "      <td>2.467742</td>\n",
       "      <td>0.204469</td>\n",
       "      <td>0.799663</td>\n",
       "      <td>0.941083</td>\n",
       "      <td>0.901914</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>5.556955</td>\n",
       "      <td>8.550211</td>\n",
       "      <td>1.397686</td>\n",
       "      <td>0.983735</td>\n",
       "      <td>0.995918</td>\n",
       "      <td>0.992068</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               mae         rmse         mape           r2          ioa  \\\n",
       "count  4739.000000  4739.000000  4739.000000  4739.000000  4739.000000   \n",
       "mean      1.399060     1.979731     0.182714     0.642942     0.872402   \n",
       "std       0.638751     0.875072     0.104177     0.219567     0.101818   \n",
       "min       0.492277     0.624609     0.060600    -1.963828     0.092951   \n",
       "25%       0.907458     1.280065     0.126618     0.535003     0.835822   \n",
       "50%       1.266889     1.857223     0.158806     0.694635     0.902473   \n",
       "75%       1.737844     2.467742     0.204469     0.799663     0.941083   \n",
       "max       5.556955     8.550211     1.397686     0.983735     0.995918   \n",
       "\n",
       "                 r  \n",
       "count  4739.000000  \n",
       "mean      0.816624  \n",
       "std       0.117307  \n",
       "min       0.060861  \n",
       "25%       0.758542  \n",
       "50%       0.846662  \n",
       "75%       0.901914  \n",
       "max       0.992068  "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e3861bd5-cfef-458c-a3f0-97635f99b981",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 可视化特定特征的函数\n",
    "def visualize_rst(input_feature,masked_feature, recov_region, output_feature, title):\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    plt.subplot(1, 4, 1)\n",
    "    plt.imshow(input_feature, cmap='RdYlGn_r')\n",
    "    plt.gca().axis('off')  # 获取当前坐标轴并关闭\n",
    "    plt.subplot(1, 4, 2)\n",
    "    plt.imshow(masked_feature, cmap='gray')\n",
    "    plt.gca().axis('off')  # 获取当前坐标轴并关闭\n",
    "    plt.subplot(1, 4, 3)\n",
    "    plt.imshow(recov_region, cmap='RdYlGn_r')\n",
    "    plt.gca().axis('off')  # 获取当前坐标轴并关闭\n",
    "    plt.subplot(1, 4, 4)\n",
    "    plt.imshow(output_feature, cmap='RdYlGn_r')\n",
    "    plt.gca().axis('off')  # 获取当前坐标轴并关闭\n",
    "    plt.savefig('./figures/result/30_samples.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "dd306e5c-7251-4385-b096-b189d0146e0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "best_mask_cp = np.where(best_mask == 0, np.nan, best_mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "40da0e1c-04de-4523-9caf-ab85b5b474e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_rst(best_img, best_mask, best_recov*best_mask_cp, best_img * (1-best_mask) + best_recov*best_mask, '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97163937-4d78-40fc-b385-1d27b01a0647",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}