{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": [
    "# 定义函数来找到最大值\n",
    "def find_max_pixel_value(image_dir):\n",
    "    max_pixel_value = 0.0\n",
    "    for filename in os.listdir(image_dir):\n",
    "        if filename.endswith('.npy'):\n",
    "            image_path = os.path.join(image_dir, filename)\n",
    "            image = np.load(image_path).astype(np.float32)\n",
    "            max_pixel_value = max(max_pixel_value, image[:, :, 0].max())\n",
    "    return max_pixel_value\n",
    "\n",
    "# 计算图像数据中的最大像素值\n",
    "image_dir = './out_mat/96/train/' \n",
    "max_pixel_value = find_max_pixel_value(image_dir)\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",
    "        \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/10/'\n",
    "\n",
    "print(f\"checkpoint before Generator is OK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "41da7319-9795-441d-bde8-8cf390365099",
   "metadata": {},
   "outputs": [],
   "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": 7,
   "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": 8,
   "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": 9,
   "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": 10,
   "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": 11,
   "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": 12,
   "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": 13,
   "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": 14,
   "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": 15,
   "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": 16,
   "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": 17,
   "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": 18,
   "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": 19,
   "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": 20,
   "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": 21,
   "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": 39,
   "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'train_losses' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[39], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m tr_ind \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[43mtrain_losses\u001b[49m)))\n\u001b[1;32m      2\u001b[0m val_ind \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(val_losses)))\n\u001b[1;32m      3\u001b[0m plt\u001b[38;5;241m.\u001b[39mplot(train_losses[\u001b[38;5;241m1\u001b[39m:], label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_loss\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'train_losses' is not defined"
     ]
    }
   ],
   "source": [
    "tr_ind = list(range(len(train_losses)))\n",
    "val_ind = list(range(len(val_losses)))\n",
    "plt.plot(train_losses[1:], label='train_loss')\n",
    "plt.plot(val_losses[1:], label='val_loss')\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bb9e09a-d317-49a6-b413-f0159539ac86",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model, './models/MAE/final_10.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "858b0940-fa98-4863-a1e4-2f5603b5c19d",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = torch.load('./models/MAE/final_10.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 23,
   "id": "6d8fddd7-8728-43ec-8c72-bd068f0002d4",
   "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": 25,
   "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": 26,
   "id": "d5b01834-ca18-4ec3-bc9d-64382d0fab34",
   "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>75.000000</td>\n",
       "      <td>75.000000</td>\n",
       "      <td>75.000000</td>\n",
       "      <td>75.000000</td>\n",
       "      <td>75.000000</td>\n",
       "      <td>75.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.092253</td>\n",
       "      <td>1.720153</td>\n",
       "      <td>0.134480</td>\n",
       "      <td>0.932102</td>\n",
       "      <td>0.981798</td>\n",
       "      <td>0.966130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.078788</td>\n",
       "      <td>0.170601</td>\n",
       "      <td>0.009332</td>\n",
       "      <td>0.012611</td>\n",
       "      <td>0.003674</td>\n",
       "      <td>0.006333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.961178</td>\n",
       "      <td>1.460930</td>\n",
       "      <td>0.118522</td>\n",
       "      <td>0.891069</td>\n",
       "      <td>0.969307</td>\n",
       "      <td>0.945610</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.039787</td>\n",
       "      <td>1.628992</td>\n",
       "      <td>0.127926</td>\n",
       "      <td>0.928341</td>\n",
       "      <td>0.980775</td>\n",
       "      <td>0.964158</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.094167</td>\n",
       "      <td>1.696594</td>\n",
       "      <td>0.134129</td>\n",
       "      <td>0.934846</td>\n",
       "      <td>0.982724</td>\n",
       "      <td>0.967207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.121535</td>\n",
       "      <td>1.772920</td>\n",
       "      <td>0.139542</td>\n",
       "      <td>0.940266</td>\n",
       "      <td>0.984235</td>\n",
       "      <td>0.970309</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.388302</td>\n",
       "      <td>2.337924</td>\n",
       "      <td>0.161247</td>\n",
       "      <td>0.950963</td>\n",
       "      <td>0.987079</td>\n",
       "      <td>0.975622</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             mae       rmse       mape         r2        ioa          r\n",
       "count  75.000000  75.000000  75.000000  75.000000  75.000000  75.000000\n",
       "mean    1.092253   1.720153   0.134480   0.932102   0.981798   0.966130\n",
       "std     0.078788   0.170601   0.009332   0.012611   0.003674   0.006333\n",
       "min     0.961178   1.460930   0.118522   0.891069   0.969307   0.945610\n",
       "25%     1.039787   1.628992   0.127926   0.928341   0.980775   0.964158\n",
       "50%     1.094167   1.696594   0.134129   0.934846   0.982724   0.967207\n",
       "75%     1.121535   1.772920   0.139542   0.940266   0.984235   0.970309\n",
       "max     1.388302   2.337924   0.161247   0.950963   0.987079   0.975622"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d0a8f2f8-6e44-4b01-a390-1b80c4059d5f",
   "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": 29,
   "id": "65ffcff5-4b1f-4d52-878f-c7323ce895c9",
   "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.081396</td>\n",
       "      <td>1.521876</td>\n",
       "      <td>0.134078</td>\n",
       "      <td>0.740742</td>\n",
       "      <td>0.915243</td>\n",
       "      <td>0.874727</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.503237</td>\n",
       "      <td>0.752737</td>\n",
       "      <td>0.082727</td>\n",
       "      <td>0.203443</td>\n",
       "      <td>0.083132</td>\n",
       "      <td>0.099583</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.354667</td>\n",
       "      <td>0.447099</td>\n",
       "      <td>0.043627</td>\n",
       "      <td>-1.035759</td>\n",
       "      <td>-0.034988</td>\n",
       "      <td>0.159654</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.709801</td>\n",
       "      <td>0.979624</td>\n",
       "      <td>0.093325</td>\n",
       "      <td>0.672060</td>\n",
       "      <td>0.898100</td>\n",
       "      <td>0.842776</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.983843</td>\n",
       "      <td>1.372613</td>\n",
       "      <td>0.118378</td>\n",
       "      <td>0.793777</td>\n",
       "      <td>0.939622</td>\n",
       "      <td>0.901160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.329353</td>\n",
       "      <td>1.873745</td>\n",
       "      <td>0.152530</td>\n",
       "      <td>0.871634</td>\n",
       "      <td>0.964235</td>\n",
       "      <td>0.939917</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>6.657323</td>\n",
       "      <td>12.205771</td>\n",
       "      <td>1.874481</td>\n",
       "      <td>0.991835</td>\n",
       "      <td>0.997919</td>\n",
       "      <td>0.996090</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.081396     1.521876     0.134078     0.740742     0.915243   \n",
       "std       0.503237     0.752737     0.082727     0.203443     0.083132   \n",
       "min       0.354667     0.447099     0.043627    -1.035759    -0.034988   \n",
       "25%       0.709801     0.979624     0.093325     0.672060     0.898100   \n",
       "50%       0.983843     1.372613     0.118378     0.793777     0.939622   \n",
       "75%       1.329353     1.873745     0.152530     0.871634     0.964235   \n",
       "max       6.657323    12.205771     1.874481     0.991835     0.997919   \n",
       "\n",
       "                 r  \n",
       "count  4739.000000  \n",
       "mean      0.874727  \n",
       "std       0.099583  \n",
       "min       0.159654  \n",
       "25%       0.842776  \n",
       "50%       0.901160  \n",
       "75%       0.939917  \n",
       "max       0.996090  "
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "67fbca5e-faec-48db-901c-c3105bf60492",
   "metadata": {},
   "outputs": [],
   "source": [
    "best_mask_cp = np.where(best_mask == 0, np.nan, best_mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "098ceaa3-e072-431d-8e42-5d5b988e2628",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f700ec465b0>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(best_img*best_mask_cp, cmap='RdYlGn_r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "0d26de20-dc8f-4324-8a38-a368c66e5cca",
   "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.title(title + \" Input\")\n",
    "    plt.subplot(1, 4, 2)\n",
    "    plt.imshow(masked_feature, cmap='gray')\n",
    "    plt.gca().axis('off')  # 获取当前坐标轴并关闭\n",
    "    # plt.title(title + \" Mask\")\n",
    "    plt.subplot(1, 4, 3)\n",
    "    plt.imshow(recov_region, cmap='RdYlGn_r')\n",
    "    plt.gca().axis('off')  # 获取当前坐标轴并关闭\n",
    "    # plt.title(title + \" Recovery Region\")\n",
    "    plt.subplot(1, 4, 4)\n",
    "    plt.imshow(output_feature, cmap='RdYlGn_r')\n",
    "    # plt.title(title + \" Recovery Result\")\n",
    "    plt.gca().axis('off')  # 获取当前坐标轴并关闭\n",
    "    plt.savefig('./figures/result/10_samples.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "072a4712-c490-4037-94d5-e345f1fc190c",
   "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": "05458c88-9907-4b25-b32e-8d5acfb3224f",
   "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
}