From bfe09d5318f216f186d9329d33be5ecb057a946e Mon Sep 17 00:00:00 2001 From: zhaojinghao Date: Thu, 21 Nov 2024 14:02:33 +0800 Subject: [PATCH] update code --- build_data.ipynb | 527 +++++++++++ build_gan-1d.ipynb | 723 ++++++++++++++++ build_gan.ipynb | 869 +++++++++++++++++++ build_ppt.ipynb | 277 ++++++ torch_GAN_1d_baseline.ipynb | 1010 ++++++++++++++++++++++ torch_MAE.ipynb | 589 +++++++++++++ torch_MAE_1d_20_patch_mask.ipynb | 1039 ++++++++++++++++++++++ torch_MAE_1d_ViT-Copy1.ipynb | 1276 +++++++++++++++++++++++++++ torch_MAE_1d_ViT.ipynb | 608 +++++++++++++ torch_MAE_1d_baseline.ipynb | 895 +++++++++++++++++++ torch_MAE_1d_decoder.ipynb | 1048 ++++++++++++++++++++++ torch_MAE_1d_encoder.ipynb | 982 +++++++++++++++++++++ torch_MAE_1d_final.ipynb | 1068 +++++++++++++++++++++++ torch_MAE_1d_final_10.ipynb | 1093 +++++++++++++++++++++++ torch_MAE_1d_final_20.ipynb | 1297 ++++++++++++++++++++++++++++ torch_MAE_1d_final_20_2021.ipynb | 1169 +++++++++++++++++++++++++ torch_MAE_1d_final_30.ipynb | 943 ++++++++++++++++++++ torch_MAE_1d_final_40.ipynb | 957 ++++++++++++++++++++ torch_MAE_1d_final_mixed.ipynb | 1201 ++++++++++++++++++++++++++ torch_MAE_1d_final_real_test.ipynb | 1054 ++++++++++++++++++++++ 未命名1.ipynb | 425 +++++++++ 论文绘图.ipynb | 1064 +++++++++++++++++++++++ 22 files changed, 20114 insertions(+) create mode 100644 build_data.ipynb create mode 100644 build_gan-1d.ipynb create mode 100644 build_gan.ipynb create mode 100644 build_ppt.ipynb create mode 100644 torch_GAN_1d_baseline.ipynb create mode 100644 torch_MAE.ipynb create mode 100644 torch_MAE_1d_20_patch_mask.ipynb create mode 100644 torch_MAE_1d_ViT-Copy1.ipynb create mode 100644 torch_MAE_1d_ViT.ipynb create mode 100644 torch_MAE_1d_baseline.ipynb create mode 100644 torch_MAE_1d_decoder.ipynb create mode 100644 torch_MAE_1d_encoder.ipynb create mode 100644 torch_MAE_1d_final.ipynb create mode 100644 torch_MAE_1d_final_10.ipynb create mode 100644 torch_MAE_1d_final_20.ipynb create mode 100644 torch_MAE_1d_final_20_2021.ipynb create mode 100644 torch_MAE_1d_final_30.ipynb create mode 100644 torch_MAE_1d_final_40.ipynb create mode 100644 torch_MAE_1d_final_mixed.ipynb create mode 100644 torch_MAE_1d_final_real_test.ipynb create mode 100644 未命名1.ipynb create mode 100644 论文绘图.ipynb diff --git a/build_data.ipynb b/build_data.ipynb new file mode 100644 index 0000000..5d97127 --- /dev/null +++ b/build_data.ipynb @@ -0,0 +1,527 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6f914d38-ee6e-4418-bfdd-44fbb7d4e0cf", + "metadata": {}, + "source": [ + "# 数据集构建\n", + "### 写一个筛选空值的代码，用于构建数据集" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7f26956d-c06a-4c61-a029-2095b0372799", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7fb503fb-b22d-4839-804c-c6326ce2a5be", + "metadata": {}, + "outputs": [], + "source": [ + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "27f9906b-e831-4995-87ba-6178746b8b77", + "metadata": {}, + "outputs": [], + "source": [ + "npy_list = os.listdir('./np_data/')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "801bb7b5-ebbc-47e0-8749-0d6b76d89a68", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "361" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(npy_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "35fc93fd-93d3-48c1-8b36-d932a39d7662", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(os.listdir('./out_mat/96/'))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d3c87665-b690-4ec6-82bb-8313db9b55d3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def sliding_window(matrix, window_size):\n", + " rows = len(matrix) - window_size + 1\n", + " cols = len(matrix[0]) - window_size + 1\n", + " \n", + " for i in range(rows):\n", + " for j in range(cols):\n", + " sub_matrix = matrix[i : i+window_size, j : j+window_size, :-3]\n", + " yield sub_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "696e49df-5e49-40d0-8e44-63ac066febef", + "metadata": {}, + "outputs": [], + "source": [ + "window_size = 96" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "204d8ee2-7668-4f47-9980-cfbd36ff3bd5", + "metadata": {}, + "outputs": [], + "source": [ + "data = np.load(f\"./np_data/{npy_list[0]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "275f62b5-8084-4370-a0ef-a27bcc293c12", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(110, 190, 11)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4192b9d4-b66e-4fb5-97ea-380284079ca2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ nan, 2.90520200e+02, 9.77973000e+01, 2.80806000e+02,\n", + " 4.36411383e+05, -1.35540000e+00, 2.04530000e+00, nan,\n", + " 6.93860000e+00, 0.00000000e+00, 0.00000000e+00])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[0][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2fe94edd-425c-43d9-8d27-3d8b7f0120e6", + "metadata": {}, + "outputs": [], + "source": [ + "num_samples = len(npy_list)\n", + "valid_list = np.random.choice(npy_list, size=int(num_samples * 0.2), replace=False)\n", + "train_list = [x for x in npy_list if x not in valid_list]\n", + "test_list = np.random.choice(valid_list, size=int(num_samples * 0.1), replace=False)\n", + "val_list = [x for x in valid_list if x not in test_list]\n", + "for file in npy_list:\n", + " data = np.load(f\"./np_data/{file}\")\n", + " file_id = file.split('.')[0]\n", + " for ind, mat in enumerate(sliding_window(data, window_size)):\n", + " if (np.isnan(mat) * 1).sum() != 0:\n", + " continue\n", + " else:\n", + " if file in train_list:\n", + " np.save(f'./out_mat/{window_size}/train/{file_id}-{ind}.npy', mat)\n", + " elif file in val_list:\n", + " np.save(f'./out_mat/{window_size}/test/{file_id}-{ind}.npy', mat)\n", + " else:\n", + " np.save(f'./out_mat/{window_size}/valid/{file_id}-{ind}.npy', mat)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1ddcf0c4-2c46-4b91-85f1-4181b879f723", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "36798a50-0890-43dd-9feb-d10dc774472b", + "metadata": {}, + "source": [ + "筛选mask" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f419d8e3-8d01-4efe-81e5-60e18b40a1d7", + "metadata": {}, + "outputs": [], + "source": [ + "import cv2" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "176eb78d-0137-4f6b-8555-e83e891fd9b8", + "metadata": {}, + "outputs": [], + "source": [ + "mask_list = {}\n", + "for file in npy_list:\n", + " data = np.load(f\"./np_data/{file}\")\n", + " file_id = file.split('.')[0]\n", + " count = 0\n", + " for ind, mat in enumerate(sliding_window(data, window_size)):\n", + " cur_no2 = np.isnan(mat[:,:,0])\n", + " na_sums = (cur_no2 * 1).sum()\n", + " miss_rate = round(na_sums / (window_size**2), 2) * 100\n", + " if (miss_rate % 10 == 0) and miss_rate > 0:\n", + " fold_path = str(int(miss_rate))\n", + " if not os.path.exists(f\"./out_mat/96/mask/{fold_path}\"):\n", + " os.mkdir(f\"./out_mat/96/mask/{fold_path}\")\n", + " if fold_path not in mask_list:\n", + " mask_list[fold_path] = 1\n", + " else:\n", + " mask_list[fold_path] += 1\n", + " msk = 1 - (cur_no2 * 1)\n", + " # cv2.imwrite(f'./out_mat/96/mask/{fold_path}/{file_id}-{ind}.jpg', msk)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2b21b80f-d0f6-4c75-ab0c-be692b5e0cdd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dd = cur_no2 * 1\n", + "dd.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "de6093f7-1296-438a-a2e5-6770350760f1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dd.min()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8c610f19-ec49-4592-8647-bc957e716546", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(1 - dd).max()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d220cc78-985c-4a45-be53-11039cc8d279", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "d = plt.imread(\"./out_mat/96/mask/70/20200110-1145.jpg\")\n", + "plt.imshow(d, cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c0064319-6185-4f80-9140-2f70233bd549", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 7, 3],\n", + " [ 7, 4],\n", + " [ 7, 5],\n", + " [33, 47],\n", + " [56, 48],\n", + " [56, 49],\n", + " [64, 15],\n", + " [71, 3],\n", + " [71, 4]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.argwhere(d==2)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "80881971-c661-47c5-8e08-9136528f6e22", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e110e873-7ac4-48af-8608-be18cebabbbb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'10': 7033,\n", + " '20': 4791,\n", + " '40': 3699,\n", + " '30': 3849,\n", + " '50': 4245,\n", + " '90': 2494,\n", + " '80': 2549,\n", + " '60': 3831,\n", + " '70': 3144,\n", + " '100': 17936}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mask_list" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d1338b0d-134b-4694-bdca-a7016c4f207f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'10': 7033,\n", + " '20': 4791,\n", + " '40': 3699,\n", + " '30': 3849,\n", + " '50': 4245,\n", + " '90': 2494,\n", + " '80': 2549,\n", + " '60': 3831,\n", + " '70': 3144,\n", + " '100': 17936}" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mask_list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dae31feb-ce59-43ca-b736-585618437081", + "metadata": {}, + "outputs": [], + "source": [ + "mask_list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3de4d61f-0e3c-4303-8668-8b9fa3b51862", + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow('2', mat[:,:,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "7897f563-8c5f-4db8-9b36-b6af8b03100d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4679" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(np.isnan(mat[:,:,0]) * 1).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "116c5a81-5396-4b27-89e0-30afaf2828d4", + "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 +} diff --git a/build_gan-1d.ipynb b/build_gan-1d.ipynb new file mode 100644 index 0000000..a79e399 --- /dev/null +++ b/build_gan-1d.ipynb @@ -0,0 +1,723 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3a2c33ed-8f78-4ce4-b5cd-7b7ffc5c8273", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n" + ] + } + ], + "source": [ + "import os\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader, Dataset\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "os.environ[\"CUDA_VISIBLE_DEVICE\"] = \"0\" \n", + "\n", + "\n", + "# 设置CUDA设备\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(f\"Using device: {device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "85459fd1-6835-41cd-b645-553611c358e8", + "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": 8, + "id": "3fc0918e-103c-40a3-93bc-6171e934a7e4", + "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", + "train_dir = './out_mat/96/train/'\n", + "valid_dir = './out_mat/96/valid/'\n", + "test_dir = './out_mat/96/test/'\n", + "mask_dir = './out_mat/96/mask/20/'\n", + "\n", + "print(f\"checkpoint before Generator is OK\")\n", + "\n", + "dataset = NO2Dataset(train_dir, mask_dir)\n", + "train_loader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=8)\n", + "\n", + "validset = NO2Dataset(valid_dir, mask_dir)\n", + "val_loader = DataLoader(validset, batch_size=64, shuffle=False, num_workers=8)\n", + "\n", + "testset = NO2Dataset(test_dir, mask_dir)\n", + "test_loader = DataLoader(testset, batch_size=64, shuffle=False, num_workers=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a60b7019-f231-4ccb-9195-c459f3a1521d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generator is on: cpu\n", + "Discriminator is on: cpu\n" + ] + } + ], + "source": [ + "# 生成器模型\n", + "class Generator(nn.Module):\n", + " \n", + " def __init__(self):\n", + " super(Generator, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Conv2d(1, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(128),\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.ReLU(inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.ConvTranspose2d(64, 1, kernel_size=4, stride=2, padding=1),\n", + " nn.Tanh(),\n", + " )\n", + "\n", + " def forward(self, x, mask):\n", + " x_encoded = self.encoder(x)\n", + " x_decoded = self.decoder(x_encoded)\n", + "\n", + "# x_decoded = (x_decoded + 1) / 2\n", + "\n", + "# x_output = (1 - mask) * x_decoded + mask * x[:, :1, :, :]\n", + " return x_decoded\n", + "\n", + "# 判别器模型\n", + "class Discriminator(nn.Module):\n", + " \n", + " def __init__(self):\n", + " super(Discriminator, self).__init__()\n", + " self.model = nn.Sequential(\n", + " nn.Conv2d(2, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(128),\n", + " nn.Conv2d(128, 1, kernel_size=4, stride=2, padding=1),\n", + " nn.Sigmoid(),\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.model(x)\n", + "\n", + "# 将模型加载到GPU\n", + "generator = Generator().to(device)\n", + "discriminator = Discriminator().to(device)\n", + "\n", + "# 定义优化器和损失函数\n", + "optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n", + "optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n", + "adversarial_loss = nn.BCELoss().to(device)\n", + "\n", + "# 确认模型是否在GPU上\n", + "print(f\"Generator is on: {next(generator.parameters()).device}\")\n", + "print(f\"Discriminator is on: {next(discriminator.parameters()).device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fd2f0816-7301-4381-99e4-05905ce8b093", + "metadata": {}, + "outputs": [], + "source": [ + "def masked_mse_loss(preds, target, mask):\n", + " loss = (preds - target) ** 2\n", + " loss = loss.mean(dim=-1) # 对每个像素点求平均\n", + " loss = (loss * (1-mask)).sum() / (1-mask).sum() # 只计算被mask的像素点的损失\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "edf26d05-7fd6-404b-8f9d-3d2054593f7b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "generator.load_state_dict(torch.load('./models/GAN/generator-1d.pth'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "645dd325-fc70-4234-8279-bc8cbc4c5dde", + "metadata": {}, + "outputs": [], + "source": [ + "# 开始训练\n", + "epochs = 100\n", + "for epoch in range(epochs):\n", + " for i, (X, y, mask) in enumerate(train_loader):\n", + " # 将数据移到 GPU 上\n", + " X, y, mask = X.to(device), y.to(device), mask.to(device)\n", + " # print(f\"X is on: {X.device}, y is on: {y.device}, mask is on: {mask.device}, i = {i}\") #checkpoint\n", + " \n", + " valid = torch.ones((X.size(0), 1, 12, 12)).to(device)\n", + " fake = torch.zeros((X.size(0), 1, 12, 12)).to(device)\n", + "\n", + " # 生成器生成图像\n", + " optimizer_G.zero_grad()\n", + " generated_images = generator(X, mask)\n", + " g_loss = adversarial_loss(discriminator(torch.cat((generated_images, X), dim=1)), valid) + 100 * masked_mse_loss(\n", + " generated_images, y, mask)\n", + " g_loss.backward()\n", + " optimizer_G.step()\n", + "\n", + " # 判别器训练\n", + " optimizer_D.zero_grad()\n", + " real_loss = adversarial_loss(discriminator(torch.cat((y, X), dim=1)), valid)\n", + " fake_loss = adversarial_loss(discriminator(torch.cat((generated_images.detach(), X), dim=1)), fake)\n", + " d_loss = 0.5 * (real_loss + fake_loss)\n", + " d_loss.backward()\n", + " optimizer_D.step()\n", + "\n", + " print(f\"Epoch [{epoch}/{epochs}] [D loss: {d_loss.item()}] [G loss: {g_loss.item()}]\")\n", + "\n", + "# 保存训练好的模型\n", + "torch.save(generator.state_dict(), './models/GAN/generator-1d.pth')\n", + "torch.save(discriminator.state_dict(), './models/GAN/discriminator-1d.pth')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9ab6849f-740a-49e4-9afd-23aafdc16725", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8997686a-5812-4a92-972c-11376dfc1686", + "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": 19, + "id": "78db8f70-3cdb-444f-8bb5-49126957a0b6", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list = list()\n", + "device = 'cpu'\n", + "generator = generator.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 = generator(X, mask)\n", + " rev_data = torch.squeeze(y * max_pixel_value, dim=1)\n", + " rev_recon = torch.squeeze(reconstructed * max_pixel_value, dim=1)\n", + " # todo: 这里需要只评估修补出来的模块\n", + " data_label = rev_data * mask_rev\n", + " data_label = data_label[mask_rev==1]\n", + " recon_no2 = rev_recon * mask_rev\n", + " recon_no2 = recon_no2[mask_rev==1]\n", + " y_true = rev_data.flatten()\n", + " y_pred = rev_recon.flatten()\n", + " mae = mean_absolute_error(y_true, y_pred)\n", + " rmse = np.sqrt(mean_squared_error(y_true, y_pred))\n", + " mape = mean_absolute_percentage_error(y_true, y_pred)\n", + " r2 = r2_score(y_true, y_pred)\n", + " ioa = cal_ioa(data_label.detach().numpy(), recon_no2.detach().numpy())\n", + " eva_list.append([mae, rmse, mape, r2, ioa])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ffc83338-9b0f-4934-9cba-406a5e1fb0ca", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "33eb7a86-242a-4488-9d9b-93548e72c98b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioa
count75.00000075.00000075.00000075.00000075.000000
mean1.6856092.8245790.2238520.8074830.894409
std0.5202850.6132990.0668270.1075660.024969
min1.1087562.0409640.1434610.3361930.812887
25%1.3381432.4626480.1761700.7809060.883027
50%1.5098212.6082270.2062740.8504170.900165
75%1.9631033.0675600.2576670.8667050.910917
max3.7294345.3632880.4614650.9122400.935183
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa\n", + "count 75.000000 75.000000 75.000000 75.000000 75.000000\n", + "mean 1.685609 2.824579 0.223852 0.807483 0.894409\n", + "std 0.520285 0.613299 0.066827 0.107566 0.024969\n", + "min 1.108756 2.040964 0.143461 0.336193 0.812887\n", + "25% 1.338143 2.462648 0.176170 0.780906 0.883027\n", + "50% 1.509821 2.608227 0.206274 0.850417 0.900165\n", + "75% 1.963103 3.067560 0.257667 0.866705 0.910917\n", + "max 3.729434 5.363288 0.461465 0.912240 0.935183" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "3844152b-c853-4311-a0a4-f57275ea78fc", + "metadata": {}, + "outputs": [], + "source": [ + "rst = pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).sort_values(by='mape', ascending=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "8f98d947-5a20-49f5-84a1-5ae5a0f4693e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
35231.8346642.5792960.1039110.8550560.9608410.931334
35441.5001941.9628850.1068160.8496880.9609700.924187
19521.7866392.2905600.1093830.7041220.9288290.869446
6022.2229572.9347340.1127510.7351780.9336390.877028
35312.0931652.7266980.1157550.7605300.9376620.889606
11141.9517482.5914480.1165780.6969700.9145010.843026
19792.0830012.6862310.1167620.5975120.8868770.791842
25682.6305873.6368900.1170440.4919520.8939280.833221
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa r\n", + "3523 1.834664 2.579296 0.103911 0.855056 0.960841 0.931334\n", + "3544 1.500194 1.962885 0.106816 0.849688 0.960970 0.924187\n", + "1952 1.786639 2.290560 0.109383 0.704122 0.928829 0.869446\n", + "602 2.222957 2.934734 0.112751 0.735178 0.933639 0.877028\n", + "3531 2.093165 2.726698 0.115755 0.760530 0.937662 0.889606\n", + "1114 1.951748 2.591448 0.116578 0.696970 0.914501 0.843026\n", + "1979 2.083001 2.686231 0.116762 0.597512 0.886877 0.791842\n", + "2568 2.630587 3.636890 0.117044 0.491952 0.893928 0.833221" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rst.head(8)" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "a72b4ec5-b72d-43d0-8178-954f8edcb0dd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'1114', '1952', '2568', '3523', '602'}" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "find_ex = set([x.split('-')[0].strip() for x in os.listdir('./test_img/') if 'npy' in x])\n", + "find_ex" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "819950e1-d16d-42e9-a0f9-57878ebc8f89", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for j in find_ex:\n", + " ori = np.load(f'./test_img/{j}-real.npy')[0]\n", + " pred = np.load(f'./test_img/{j}-gan-recom.npy')[0]\n", + " mask = np.load(f'./test_img/{j}-mask.npy')\n", + " plt.imshow(ori, cmap='RdYlGn_r')\n", + " plt.gca().axis('off')\n", + " plt.savefig(f'./test_img/out_fig/{j}-truth.png', bbox_inches='tight')\n", + " plt.clf()\n", + " \n", + " plt.imshow(mask, cmap='gray')\n", + " plt.gca().axis('off')\n", + " plt.savefig(f'./test_img/out_fig/{j}-mask.png', bbox_inches='tight')\n", + " plt.clf()\n", + " \n", + " mask_cp = np.where((1-mask) == 0, np.nan, (1-mask))\n", + " plt.imshow(ori * mask_cp, cmap='RdYlGn_r')\n", + " plt.gca().axis('off')\n", + " plt.savefig(f'./test_img/out_fig/{j}-masked_ori.png', bbox_inches='tight')\n", + " plt.clf()\n", + " \n", + " out = ori * mask + pred * (1 - mask)\n", + " plt.imshow(out, cmap='RdYlGn_r')\n", + " plt.gca().axis('off')\n", + " plt.savefig(f'./test_img/out_fig/{j}-gan_out.png', bbox_inches='tight')\n", + " plt.clf()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2926f4b3-0a15-48ae-bdaa-4e290e11b49d", + "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 +} diff --git a/build_gan.ipynb b/build_gan.ipynb new file mode 100644 index 0000000..a306325 --- /dev/null +++ b/build_gan.ipynb @@ -0,0 +1,869 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3a2c33ed-8f78-4ce4-b5cd-7b7ffc5c8273", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n" + ] + } + ], + "source": [ + "import os\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader, Dataset\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "os.environ[\"CUDA_VISIBLE_DEVICE\"] = \"0\" \n", + "\n", + "\n", + "# 设置CUDA设备\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(f\"Using device: {device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "85459fd1-6835-41cd-b645-553611c358e8", + "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": "3fc0918e-103c-40a3-93bc-6171e934a7e4", + "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 = idx % len(self.mask_filenames)\n", + " mask_path = os.path.join(self.mask_dir, self.mask_filenames[mask_idx])\n", + "\n", + " # 加载图像数据 (.npy 文件)\n", + " image = np.load(image_path).astype(np.float32) / max_pixel_value # 形状为 (96, 96, 8)\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 = np.concatenate([masked_image[:, :, :1], image[:, :, 1:]], axis=-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)) # 转换为 (8, 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", + "train_dir = './out_mat/96/train/'\n", + "valid_dir = './out_mat/96/valid/'\n", + "test_dir = './out_mat/96/test/'\n", + "mask_dir = './out_mat/96/mask/20/'\n", + "\n", + "print(f\"checkpoint before Generator is OK\")\n", + "\n", + "dataset = NO2Dataset(train_dir, mask_dir)\n", + "train_loader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=8)\n", + "\n", + "validset = NO2Dataset(valid_dir, mask_dir)\n", + "val_loader = DataLoader(validset, batch_size=64, shuffle=False, num_workers=8)\n", + "\n", + "testset = NO2Dataset(test_dir, mask_dir)\n", + "test_loader = DataLoader(testset, batch_size=64, shuffle=False, num_workers=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a60b7019-f231-4ccb-9195-c459f3a1521d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generator is on: cuda:0\n", + "Discriminator is on: cuda:0\n" + ] + } + ], + "source": [ + "# 生成器模型\n", + "class Generator(nn.Module):\n", + " \n", + " def __init__(self):\n", + " super(Generator, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Conv2d(8, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(128),\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.ReLU(inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.ConvTranspose2d(64, 1, kernel_size=4, stride=2, padding=1),\n", + " nn.Tanh(),\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x_encoded = self.encoder(x)\n", + " x_decoded = self.decoder(x_encoded)\n", + "\n", + "# x_decoded = (x_decoded + 1) / 2\n", + "\n", + "# x_output = (1 - mask) * x_decoded + mask * x[:, :1, :, :]\n", + " return x_output\n", + "\n", + "# 判别器模型\n", + "class Discriminator(nn.Module):\n", + " \n", + " def __init__(self):\n", + " super(Discriminator, self).__init__()\n", + " self.model = nn.Sequential(\n", + " nn.Conv2d(1, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(128),\n", + " nn.Conv2d(128, 1, kernel_size=4, stride=2, padding=1),\n", + " nn.Sigmoid(),\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.model(x)\n", + "\n", + "# 将模型加载到GPU\n", + "generator = Generator().to(device)\n", + "discriminator = Discriminator().to(device)\n", + "\n", + "# 定义优化器和损失函数\n", + "optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n", + "optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n", + "adversarial_loss = nn.BCELoss().to(device)\n", + "pixelwise_loss = nn.MSELoss().to(device)\n", + "\n", + "# 确认模型是否在GPU上\n", + "print(f\"Generator is on: {next(generator.parameters()).device}\")\n", + "print(f\"Discriminator is on: {next(discriminator.parameters()).device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "645dd325-fc70-4234-8279-bc8cbc4c5dde", + "metadata": {}, + "outputs": [], + "source": [ + "# 开始训练\n", + "epochs = 150\n", + "for epoch in range(epochs):\n", + " for i, (X, y, mask) in enumerate(train_loader):\n", + " # 将数据移到 GPU 上\n", + " X, y, mask = X.to(device), y.to(device), mask.to(device)\n", + " # print(f\"X is on: {X.device}, y is on: {y.device}, mask is on: {mask.device}, i = {i}\") #checkpoint\n", + " \n", + " valid = torch.ones((X.size(0), 1, 12, 12)).to(device)\n", + " fake = torch.zeros((X.size(0), 1, 12, 12)).to(device)\n", + "\n", + " # 生成器生成图像\n", + " optimizer_G.zero_grad()\n", + " generated_images = generator(X, mask)\n", + " g_loss = adversarial_loss(discriminator(torch.cat((generated_images, X), dim=1)), valid) + 100 * pixelwise_loss(\n", + " generated_images, y)\n", + " g_loss.backward()\n", + " optimizer_G.step()\n", + "\n", + " # 判别器训练\n", + " optimizer_D.zero_grad()\n", + " real_loss = adversarial_loss(discriminator(torch.cat((y, X), dim=1)), valid)\n", + " fake_loss = adversarial_loss(discriminator(torch.cat((generated_images.detach(), X), dim=1)), fake)\n", + " d_loss = 0.5 * (real_loss + fake_loss)\n", + " d_loss.backward()\n", + " optimizer_D.step()\n", + "\n", + " print(f\"Epoch [{epoch}/{epochs}] [D loss: {d_loss.item()}] [G loss: {g_loss.item()}]\")\n", + "\n", + "# 保存训练好的模型\n", + "torch.save(generator.state_dict(), './models/GAN/generator.pth')\n", + "torch.save(discriminator.state_dict(), './models/GAN/discriminator.pth')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2d889a53-5415-4895-99ff-fc63745884a5", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "37f2df19-492c-4231-a388-13182ce515db", + "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": 11, + "id": "0b93a2e7-c4fb-4611-9967-4e33f9982ad5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "eva_list = list()\n", + "device = 'cpu'\n", + "generator = generator.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 = generator(X, mask)\n", + " rev_data = torch.squeeze(y * max_pixel_value, dim=1)\n", + " rev_recon = torch.squeeze(reconstructed * max_pixel_value, dim=1)\n", + " # todo: 这里需要只评估修补出来的模块\n", + " data_label = rev_data * mask_rev\n", + " data_label = data_label[mask_rev==1]\n", + " recon_no2 = rev_recon * mask_rev\n", + " recon_no2 = recon_no2[mask_rev==1]\n", + " y_true = rev_data.flatten()\n", + " y_pred = rev_recon.flatten()\n", + " mae = mean_absolute_error(y_true, y_pred)\n", + " rmse = np.sqrt(mean_squared_error(y_true, y_pred))\n", + " mape = mean_absolute_percentage_error(y_true, y_pred)\n", + " r2 = r2_score(y_true, y_pred)\n", + " ioa = cal_ioa(data_label.detach().numpy(), recon_no2.detach().numpy())\n", + " eva_list.append([mae, rmse, mape, r2, ioa])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e7b3323f-7116-4d4e-8483-2fd605e2fb57", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioa
count75.00000075.00000075.00000075.00000075.000000
mean0.3993661.2467610.0471880.9639910.939587
std0.0712950.2206160.0050350.0180810.026807
min0.3480721.0739660.0407160.8131810.719442
25%0.3727621.1546840.0437510.9633540.938713
50%0.3887681.2079490.0458600.9663560.943430
75%0.4023511.2748360.0500510.9689190.947026
max0.9592512.9664760.0662560.9728400.956998
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa\n", + "count 75.000000 75.000000 75.000000 75.000000 75.000000\n", + "mean 0.399366 1.246761 0.047188 0.963991 0.939587\n", + "std 0.071295 0.220616 0.005035 0.018081 0.026807\n", + "min 0.348072 1.073966 0.040716 0.813181 0.719442\n", + "25% 0.372762 1.154684 0.043751 0.963354 0.938713\n", + "50% 0.388768 1.207949 0.045860 0.966356 0.943430\n", + "75% 0.402351 1.274836 0.050051 0.968919 0.947026\n", + "max 0.959251 2.966476 0.066256 0.972840 0.956998" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "3c881732-b18f-4b6f-802a-1204d0ffa70f", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list_frame = list()\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 = generator(X, mask)\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": 24, + "id": "d3f6851c-eba3-48d5-bf6e-f94290b3d56e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.9778562.5053940.2367660.4442340.8261850.795505
std0.9661371.1569470.0751390.3090370.1121860.109227
min0.5885990.7825540.106112-5.779783-2.7540700.284676
25%1.1955411.5515670.1872310.3004010.7817120.735376
50%1.6060922.0940270.2200130.5067330.8495490.822590
75%2.6582433.3387080.2665740.6585280.8990100.876813
max9.4287549.9825980.9038470.8893510.9692850.960868
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.977856 2.505394 0.236766 0.444234 0.826185 \n", + "std 0.966137 1.156947 0.075139 0.309037 0.112186 \n", + "min 0.588599 0.782554 0.106112 -5.779783 -2.754070 \n", + "25% 1.195541 1.551567 0.187231 0.300401 0.781712 \n", + "50% 1.606092 2.094027 0.220013 0.506733 0.849549 \n", + "75% 2.658243 3.338708 0.266574 0.658528 0.899010 \n", + "max 9.428754 9.982598 0.903847 0.889351 0.969285 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.795505 \n", + "std 0.109227 \n", + "min 0.284676 \n", + "25% 0.735376 \n", + "50% 0.822590 \n", + "75% 0.876813 \n", + "max 0.960868 " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "02827026-b34d-4859-a663-f799b88d4b54", + "metadata": {}, + "outputs": [], + "source": [ + "real_test = NO2Dataset('./out_mat/96/test/', mask_dir)\n", + "real_loader = DataLoader(real_test, batch_size=1, shuffle=True, num_workers=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "80fe1990-44c1-43c6-9c89-fba8f0f1b0ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 8, 96, 96]) torch.Size([1, 1, 96, 96]) torch.Size([1, 1, 96, 96])\n", + "torch.Size([1, 8, 96, 96]) torch.Size([1, 1, 96, 96]) torch.Size([1, 1, 96, 96])\n", + "torch.Size([1, 8, 96, 96]) torch.Size([1, 1, 96, 96]) torch.Size([1, 1, 96, 96])\n", + "torch.Size([1, 8, 96, 96]) torch.Size([1, 1, 96, 96]) torch.Size([1, 1, 96, 96])\n", + "torch.Size([1, 8, 96, 96]) torch.Size([1, 1, 96, 96]) torch.Size([1, 1, 96, 96])\n" + ] + } + ], + "source": [ + "for batch_idx, (X, y, mask) in enumerate(real_loader):\n", + " print(X.shape, y.shape, mask.shape)\n", + " np.save(f'./test_img/{batch_idx}-img.npy', X[0])\n", + " np.save(f'./test_img/{batch_idx}-mask.npy', mask[0])\n", + " np.save(f'./test_img/{batch_idx}-real.npy', y[0])\n", + " if batch_idx >=4:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "65241f09-7c50-48e1-a701-a3c4ba5e060c", + "metadata": {}, + "outputs": [], + "source": [ + "test_imgs = [x for x in os.listdir('./test_img/') if 'img' in x]\n", + "test_imgs.sort()\n", + "test_masks = [x for x in os.listdir('./test_img/') if 'mask' in x]\n", + "test_masks.sort()\n", + "for img_npy, mask_npy in zip(test_imgs, test_masks):\n", + " img = np.load(f'./test_img/{img_npy}')\n", + " img_in = torch.tensor(np.expand_dims(img, 0), dtype=torch.float32)\n", + " mask = np.load(f'./test_img/{mask_npy}')\n", + " mask_in = torch.tensor(np.expand_dims(mask, 0), dtype=torch.float32)\n", + " out = generator(img_in, mask_in).detach().cpu().numpy() * max_pixel_value" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "d8594321-a526-4476-b72a-b377acdf10d7", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "449919c5-a05d-42d5-9461-cecb860f8d5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(out[0][0], cmap='RdYlGn_r')" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "c9affe45-bf88-4227-9eeb-55bd0dd8532f", + "metadata": {}, + "outputs": [], + "source": [ + "test_real = [x for x in os.listdir('./test_img/') if 'real' in x]\n", + "test_real.sort()" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "ac9cb241-e3bb-44ed-aadd-b87439ae3d9b", + "metadata": {}, + "outputs": [], + "source": [ + "y_real = np.load(f'./test_img/{test_real[4]}')*max_pixel_value" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "4e8425d2-e9a9-4200-940f-3aa14c36367a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(y_real[0], cmap='RdYlGn_r')" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "f662e7a6-2edd-4602-a33b-cda8ac2fae00", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(96, 96)" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(y_real[0] * mask[0] + out[0][0] * (1-mask[0])).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "78b86ce5-296a-498a-89d0-8ee6d9cdac27", + "metadata": {}, + "outputs": [], + "source": [ + "d = y_real[0] * mask[0] + out[0][0] * (1-mask[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "756f6f85-6b07-4295-b8e4-a6dc77752a56", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(out[0][0] * (1-mask[0]), cmap='RdYlGn_r')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04034e72-02be-42ec-9aca-a5eb28141453", + "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 +} diff --git a/build_ppt.ipynb b/build_ppt.ipynb new file mode 100644 index 0000000..ccc0b30 --- /dev/null +++ b/build_ppt.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "c2149513-456d-41aa-bdde-a5c19fe0f8a6", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "f05e69a7-ac57-4ad5-8b97-363dc07b602f", + "metadata": {}, + "outputs": [], + "source": [ + "data = np.load('./np_data/20200212.npy')" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "79181a75-e142-497b-b303-8dc57c38d3a9", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "7438c5e2-58b6-4d52-90d5-c177685b911a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(110, 190, 11)" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "e23b7e6a-1c4f-4c9c-9ac1-7f78681851b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 8))\n", + "plt.imshow(data[0:64,0:64,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1e6edd78-b2d5-4f1d-8c7a-5d114e18a68f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(3, 2))\n", + "plt.imshow(data[:,:,2])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fe5b2135-e1d4-472f-bf5a-1d2c883b9fa6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(3, 2))\n", + "plt.imshow(data[:,:,3])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "dd8878fe-0ad7-4b4c-87d3-69295eff1a3c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(3, 2))\n", + "plt.imshow(data[:,:,4])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1632fd53-e8f6-4c0a-b42d-afbc570b7ef6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASAAAAC3CAYAAACyl4PPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABcV0lEQVR4nO29baxuV1U/+htzPXvvU8T2CIW2B9oCBiwQqVrk2Bu49/+XaosJQekHaPqhEgJRKYkUYuy9FwqJSX1J1KAIH65/GxNF4AMaNTaRIhBIKVAw3ivYUNLYVjhFSvoG9Jz9rDnuhznHnGOOOed61rPPOd3sc55xss+z1nyfc835W78x5ssiZmZsZCMb2cg+iNvvAmxkIxs5e2UDQBvZyEb2TTYAtJGNbGTfZANAG9nIRvZNNgC0kY1sZN9kA0Ab2chG9k02ALSRjWxk32QDQBvZyEb2TTYAtJGNbGTfZANAG9nIRvZN9g2APvCBD+B5z3seDh06hKNHj+ILX/jCfhVlIxvZyD7JvgDQRz7yEdx000245ZZb8OUvfxmXX345rr76anz729/ej+JsZCMb2Seh/diMevToUfzsz/4s/vRP/xQA4L3HxRdfjLe//e347d/+7ae6OBvZyEb2SRZPdYYnTpzA3XffjZtvvjm5Oedw1VVX4c4772zGOX78OI4fP57uvff47ne/i2c+85kgotNe5o1sZCPrCTPj8ccfx5EjR+BcX9F6ygHoO9/5DsZxxAUXXFC4X3DBBfiP//iPZpxbb70V73vf+56K4m1kIxs5hfLAAw/guc99btf/KQegvcjNN9+Mm266Kd0/+uijuOSSS/A/Ln4LFrQFjB5gDr8AMDhgMQDOgYfwi8EBRGCiYPlyLl8Tgh8AuBgG0R3RT10DABxCONK/OT5TiM8u+g3hmglgF91j3hzDBffwB4K6z/G0O8SfbHgAjgt/HoJbDi/+HOuf3RDdyDFADCIGDYxh8BgWHsPgsTWM2FkssT2MWDiPgTy2Bo8FjdgeRmy7JRbwWLgROy7c77gltmiEI48tGrEVfyn+blPwX2DEIdrFQB4LjNimEY4Y24hx4eGIMYDhwBjiNQEYYrMOALaIMIBA8dfBYVCM2RkTqIdP12O0TEh4Cetip/BgeHjs8ogRjCWH2CeYscvAEoRdduEPDt/323jUPw2P+x087s/B98Yd/MBv40m/BR87V/qFg2fCkh1GJiz9AA/CkgcsOfh55T56wugdjo8LnBgHnBgH7I4DdncH+JHA3oGZ4D2BRwJ8/GPkXwZIXYMp1FQMNC1DDbWvGYB/8kn81y2/gx/90R9tRMzylAPQ+eefj2EY8NBDDxXuDz30EC688MJmnJ2dHezs7FTuC9rCgrfCwPEjmEIrERyABUAO7CIAxb82AFEGGQGgCEqADNgO8IQMc1wn6ahwgwURBTYKfCyIZDcqQYfQBqBBx+0DUEhzAoDUL1GI5wYGDSPcwsMNHm4Y4baWGIYRzgWg2YrAs+0cdgbCgjx2HGHhCDsOOOQYW4T4x/EvXA8UAGOLgG25RgCAACQh7AC5j0BDiNdUgM9AFK8JjghbGArwCY/SqgbhXgORDufUKAsABIxM2MUIz4QRjF1mjAB2GdiVXwbOYY/Beyw8YzEydjzj+57xpOeU2xiBBWDssoNnYJedAiIX3V0FRCf8AIwLuHGAGwfQ7gI0DhhHhzGCkGMKgDTGDutR/lYgFNxpCoRi/xdhMri0wkTylM+CbW9v44orrsAdd9yR3Lz3uOOOO3DllVeul5gwH+/BzICPf9ENzKAUJriTtrmvAz5p8BvW4wAeKPwJkKwCH2E9iiFJXgIm2Y0UQMRy62vkuKdEdGdjAseOyPHeewJz+Bu9w9LXXchRYCZbTrOd8LfjdtX9svrdlnuMgVXRiAHyy9giXzEfAaIe+Ay2sdACn9JP/wtuIY2BHAZycJFRQeWDmPcQy7MFxiEasUMjDtEST3PHcYh28SPuOJ7mjuNp7gSeNsRf+Rvy345b4pxhF+e4cL0zLLHjRuy4ZQT6wD4XbsS2G7EVXwIL57EYPAYX2OowMNzgQSQvEg7sduDElIX18sDpT9w5/ZUvRtsPiz5IPbQqZV9UsJtuugk33HADXv7yl+MVr3gF/viP/xjf+9738KY3vWm9hEYP0KjAZwwDnAnkPTAGcAFz/ptAZA0+hco1qW6p8ApQCvZimQ+VD7F1H/JW/gqkcnlPHniIKTHH8PrimKh0IAL7UA7vCBRBaHSEBQe11UdAAiL4UBgUDjwBPgFYDrndDDDk1wKfLXACHmBv4OMa/j7WXfsNVALWQA6ex8Cq2GHEGPPi1OdcJBcucpxD2MW57kkM5OEoqK07vIjsKTCbEZR+d2mBXR6wSwMW7LH0IxY0YMkDFpH5bIGwSwNOEMOLejjIc4lPkBjj6EDE8GN4Q7I8Z1KPW37l5UMcqsPCijh1C1Ztk7qM3Kwh+wJAb3jDG/Df//3feM973oNjx47hp37qp3D77bdXhumVwgyGsBsffh3CL2XQIc+hMcXdx4HW6HyFrAk+CTDExlOAS2Y+mt2U96pqraI13IqHP1WVxGJUBpx6U07fU3gbInY6igOKAPaBIXoijKPDkhhEYdg5YtA4YEEjljRgSeHNO8JhFNWGHUBjvA4qEwA4CgPUGdVHxLPDQGOMkzu4l7JTm8p7Dm91AaGRGQNRUrEcXAKbVTKyL0Bo5LKsAygPYAVCQ2zXbXgcwohdWuIQCCM5wAFbPAbVCw4juwhEhF1eYHCMgT22eExA5Dyn+4EYu34AXGjPbbeML4MRo3fYGkIZfWSpWh3yFNExPl/20gkR1bLYsITwgi+AKMZLQBUTXRN8gH00Qt9444248cYbTz4hAR8ZTJ4B8oEFyb1TDCiqYcyIr6eaFWm1ax3wYcq2nCQaXBru1f0UmExgpgUYfS8kMOjznPtPBBvyFGxBkn8CaGTwIQAjwatBuGvLsgCeHLciCyo744DwxncycAlwYOzyEO+XAC8ALNVADgbZ4DcANGZWktqCy3ZJLJeLcMJQwjsq1oHagAfU4ORAFeg04xEVIDQyi/YeWdyIEQ6HaDe2C2MXA0YwHDyGCNiOGPABnHd5QMJmh+oeHhjdiCU7LMjDO8LWMCqbkkdoWQdmBjPD+fiiVGw3FDuCj4u/yqjDYFCr/U9CDsQsWE+qNZTsAU2VvU+jr2JBkMFIqdMSczYsz8nfgI+121QzZzoe0AebmUXosR/tnoBIXRPKXwAlCOlCCFohsp8REL4RNFwGjeVzsOADAFs05oHjIhuytMWAUGBM0Y2WAXzYZeCYAKERMoPFgfmAVLtGZqDBKIoYqq0husWxbJgBwRDdEwfGNjw8RnhyAVwBDOQD+6Ggfp3AgAEug41k74vE0v1IhIEEfMY4M+ax5STCAMDDsTxjD09BlYZ34YXKADmO6nYEJfntgZCWPeLQgQYgYTvJyAxENkQKaFCwn/Qn9FNYQLRnVDLBfqxU7AcNtUqDVEp/dVWTyi7g0mJDugKiYqm+xJyBhryM5Qw85KWedkDHRMZoWwAAOGBZZu+I4cYBC/IVCC3iVLoMnC0aExsa1MiSQe3hC/AJwISgwk2A0Ij4SIEKiApVU+VYtmENNFptszLal6BuDyA1vCck+9UWRoyxEA4euxjCEgG4wITIY5cbQ7MBQqN32CIPTx5jBJ+l52CAZh9mylxEfYy6ZLH2HuwdyAVGHExaeVzAzwAheQa2/82Qgw1AWpINiNI9R5VDwEizIHJBDStYkG5UUb+AWapXk/3MVb9WuFdMpwAH5IcvAGWuNdMBOiBEiLafqOubcqXoTGBmePbgoRysbOL5Id8v/JhBSaL5fL0VB8dYNMICo4y4Bgj5aJiWKXCZFZO2SMlHIBJgSowIaLR5A2gaoNQTbQvSbCipYPAxz2UAJApAMSIwopGoAp8BPv5xBUI+2uTCbCPBk8f2sEwsyMfxENp+ACc1UtWJGTKZyVAvJa9ZYw1CAGqVLKr6c+VgAxB7QIzQIsJ8hsiClBpWMiAP0JBZ0IASwCSLtP5nGnyqWaz0SzEd5ZbSrq9LN0unkDpABTQWMzRTinELzNIgREhvwJ4hkTyFtUQc/tg7sA+DneN0PS8MAKnRHWZ9ctpihHWVMTfcj3DYwjKoIqkQGYQ8OAFRAjYOADYQw0fbS48R+Th9X4BRTNeZds8zXG2R6foWSxIWNHJYxwR4gKGWEHhsY8QJGtLsl7gPYAzwQSUjX9l9gAxAPranB2WDdHwBLInh1HIJkvVyRNkwPboahOSl5FXPMQt9KruQ5NFtrVIOOAAJoAT2IzYhEjWMVBjLgoBkjE5GadtsK1rRgs869qOelPabyM60yiWMhlrhUc10EZTRWVWrACGEJiQFmHVdI45LQWTMk4MnDyyHXIcGiDkKDEUMo0sKsz0jOxxyu/DksEtDMtIO7KNtg8PUNMLgTEyJfNQKPQbmPHUewUcYEYAERrsI76XdeC8l9qrKAkoAKmDKdbFttNo4PSAzsiE+jK1UB051SSqnkRMc1FYgskQHeE/YcmOcaRzhfVj8aQ3S2e4W1DHmAYPzgA+LcYmC/YfG2NeIGy+lBgi1VK815WAD0JTo2bAWC5ozJd9xPh1SsBibr2Y6gKK6KEEphk0mHEZ8P7E2B5X5ahBCI4CEI+l3EdJix+YxeHoANDqMBOzSUIGQzIwFAHJYpoHj4EHBJgTGllumdUIaiDw5jOQw0hI+siMfeYeoJy6C0S6yvQXqeqCwTWIQsEIJSCItYEr1QAOgTDjfsQsJIxvUA3MF+Lj8C59sT4EVuXjtEuBu0YiRXVLRnLRBNEgvyWPhAuAHv/A3OA8fmSM7H4dEWCfE8rApdob0UipfPKneDDBxrbbPBKWDDUAyly7sx3vAuQAuA0qg0dcprpI4gXa6DieZVJNSfVCqWEAY7kQV+Ej/KICFUNl9gh+lirVeXEK3iYyeVhQWQf3MkBYzlLckghowMiiyGS0ugoAfwgK6nWGJXT9g6QYsncPCxRXTHFiQBSKPZQSszIYGMByH6f2stvg4tZ3XFQVVpgQkKZP4hfsgAjzWwDwgm3ElXEuN07Yfy42G4k2h1iqFGQIMkV2EJQMRiBL4UAAa8ggrsSkuahRw8XHPW7hfOA8/hrblkSLwEDwxBhfGDDHJZoCgIQi7cQweKb14Up9IHa//ZtZse5UcbABqifdg54IahiHoFmYKNalhek2Q9o9aHQbkqXnPwNBv9FliwKLpxgYkFFKkZ6/CtvyycTn+AoCe7UIDhBjQK8CtFhX6ZYLEDEIEMzs2pMkxjovitIhqkH6HsL9py8f9ZBS2Glgg2qUBh2g3saETNIRNqpoByayaAqRQovjLMkhLZtS6li0eWkSFExnjQkNtUxJZpZSFsJzAyhe/PoKsL2bgxghEAwd/n5hdAKEtGhOzceThyCWwGpyH95TAiilsMnbE8HLt4uyjjzaFNC0PpLebZUFW1jBAAwcdgOICxMR+NJIoYzSPyhzqMhuo1gQJIM3Uu9ZdN7QqbvHmKACqtAVpdgMdR4OXBqGoz4u6KaDEZTYhfkNPk/4nsINodM4ASek5+IjcSy73jPmtoAps+bBX6YQf0u+2W0Tw8YEZRfCxQOTJYYsG7Mb9Yru0SIxgkIGYjLxBHQMUE4pusvJ6gC9AyTIjpxpC7Em70UkAylMGojGFbfeJxAkJGDmA0DZ5nBBDOgPBsD4E21ZkQcEmtMAWlhiZEit0oNAuPqys9kRYxKn4wHSyDchTYEYUbXEFCyKGcxzMFWIDApIqlmx/rfVBPTkrVDArSQVTLCiuBE22IO+ynpKACM21/BYk5m57KCStzG35NdhIpYIpVSyu7hawqNKwappiQFodCwxQaDfytSpXVU6SywhC6RqRWVFUCcNbmgd1BMQCABZgDju6F85j1w3YGkYsncMJl4/x2GWHHTdgJ24r2HUBgA6BEgAF1WxI+8cy8+EMSGKnUds8CiaEtuomcT3K1dzadgQgGbnFwJ1m2uSZK6l34efnHMCSkyoGFsM6JRYEZFVsoHAMyBYC27EsaGCxBWkWxMkgvUB4KQyRBQkICSNKtj5RxcQgDSrXn7UAZq7epeRgA5CXvWC+eug6TMGbI/CQj0dTSDwNSKxHMgxVMICiBro1HAs5WAe4mrNV6KtiBVDJQnDO4VvqmLbiSJ4CRLoTaTVM8goEQ4FQ6pyc1o3wGOaJZegvEdUxAAtHGJ3D0nksvcNycPE8oQFLDoC0dGNSzXZ4iSU57PKAQ8Vm1iHttBdgcRGAEhNCBqXgn5kSgGw/UoC0hTGDkbIhAUjGbclLZtu242yWJc7CeKYWK4o4cFoDNSAAoGZBA/mkfqVFjKJekYfjUE9ZEyTG6AqMkFUvav61WVDq0LLVpKnHl/1njhxsANLSYhk9Y7RImrZXapddC9ToWD1AkXQSYGhpsB1rYG7GK+KrchpVLMWPoAM3A4QiqhR2n04nkrSBmE60CZCPpSJZvIZYswhCDGjriHcunh8UgGiMb+OFC9sREgCxw64LRuqFG7HlfWmslh31lFWw8rcBSh2mJIA1IKxA3qJlwYw08IxiQ1L94gS7gg11gUjaQO45X3sbSYmDxxhTceQBHgLYgLCbFbukxsmSB3ETVdIpNza2IAKiGtZhQVAGaekoMhBI9RvtNkPODACKahcmzp4tRDaopmv0GVSUyrLfAKZuvKlwNh0uMaAJWlCzYlyGS/fReMiREVU2IVG/LBBNNUMkf8yKDQlqes403XNMW6YVw/QxewqHmTlKQLQcHRaDx9J57HqHLTdgHJZYssMJ8jgxhK0dO8MSx/0CW27EIoLPwsXpZxIQyb9bbqnYio8bQZfxvmRKAkgCaCc4GrgjQwKg1DPK7CShvX6OnLqU7R/aMK23z42qg4yg9NcTWU5QlCtuWnWqo2oblrhTBKQRQmjCsSEuMh4XxwVH6i4sKLwsU6TcGaRXRvYEIIebIQcegIio3pSqRc2GpR3yyU+pXKBiKn7WTJhiJZldKBYEJOogSksXUCr3FSDkKRqWke04+j7NfsV7NMBHXVdvLTMNll5uerkCB3tS8FfKnVhkI+FkdlHlZXgf1puQ83DOwTnG7siRFXnsDhGIxnDs65PjAgvnsT0uw0Fb5JPBeuHGwJ7iPjMBI0eMLT92QckZUBE1TgBpm0bsKvuS2Ipk7dGogCg0MedFhZAjQ7h8gChBJ7EgEHwEHG/eVN5sAQkqYWA8AwVQ1y8MASG9t85R2IQa4kfWw5ym5BnI6hdTsgM5xxg5siDHaalFMS0vq6RZ+hzH/YSMsvf05WADkKN5OqcGDr0oEci/+dkW0jREJ/SfITOZUiveShBiA1xStQbTkb6q7T0aiABVJaULJj+oxYycwc0apZNLZF4BACmdqAeKp/GRA7kw+yJgtHTh3OldN6QT/Rbxb3Bbgf0oEFq4ACwCRDLAhCUJKAlT2uJFAUhWfRMgEvCRe0cBlGTtkQai0Kh5S0ipnkkfCz8FA4qdQthP2M8mQNTYEBtZi6xxspKXEHgskW0/iQ0pO5CPbTU4Dz8OcXFiNEYD0Q5kpuVFFYsvunR+kFbJ5N6J22o52ACkRdSwnogdSG8tMobofFZOY4OqAZLSWDzBgkRVxposSFguJkDIM9g12JOs3RCAkc3jrpGuYGl0KGY6VJWLxYzF+qIJEKKYOCGvOBdbUXxjsmOQo9DHiTEOHuPgsfSBzSyGMRzM5Ty23JBAaaDw6xQDktmeDEI+HAvrA0htcQYlAGntjGVIcjzsCVpgm5Zw7NNeK9kcO8JjG8CJ1F5j2UeK/pIHYwU8HXVrRA1CIgNKQ7Ss/tYqVwobp9y1HUhYkFwLA3Jxewacjyuja4M0tdYGOYLodEyxJ58tKhjQUMOmbEGW+Vj1TUBHz3ZFp8oOdLpEAEJAwLB5C1KVuw2r7D8JlKBeXAI8pBiSKZK80FPaMvMn5fMGhDjaBBSrSrYBnzsuU1yX5DhQfQ6n842jwzB4jN4l9WwZgWhw0W4T3R0WGJxXIDRie3CJHW2Rx4IdlnHmTIyxssBxQACq3XFIzEem+WV/mscS8IjXDlu0hOewJQQUAKXcRMppPVG5MjoCENrMJ1zn41lHdmnlt/zKzvkQ31Vp98Q1OrBemDgiMB+k1dG1QVqGR7E2KOnnVHbEGXLwAUhObltHGjYjWYhYiVXNTsWK6Ko8NWsKZYr9Rb9VYdgL8szYFAg1gcoAWAIiNMAJCPq94wKE4JTqh3j8CSPNJCZ7gX4zRlYm6llYHBnSHsewXcMN4fxiUc/GwcO5vJdpMGAk7sEgHab0BYAWzmPhIxtCnpY+QYusqnmlqunzrNVK7JFcOjhfVmKLwdrOnFkwAsqjRjIA1aADALu8KAAIAE5w2DG/ywNOcDgvOoHXzBEvTMgaoxEf2RhffgI+QGNanvPzTLNiano+MN9ZxTngACSnHzpRf/SRAzNaQK+IdsrNhwalYkBmW9A6dqCVs2C9OEDBujQwCUPK5gaOQCEHSikmQ6iN1Uo90xqm5J3YimJ+WZUTEOH0wkvpMHJHjDNhudwKfAhGTRS1LILRwBgTKwq2ojHZilj9RfCJgJTAiRi7Pqhggws2jm23xCJeaxDaSnupPLZ83Gfl82H6zm+HhZBuF8dpCzvVIfpjca8XOAooaSlAKLIXYTbils+HFlbkinOjd3lIALXLA3Z9PLzeDxGU5p9flI/myAsRZUZMwEe/lzMYKeZDuU9Ip0gfOlghBxyACOkVXDjHh2zO9mlKYyFiwVSZY7tmhE/5rAKXGVS0Ark4ULsgBHXBBmiULQqquPmojfxXABGUH3K/EvfMgHQ8QRfOcZ0uL6X0kiYbOylFRy7KFCM6Asd9CvImZRcOzKLBh2Mjor1IAGkYfJy5yYC0NQyFqnbcLQq7kewcz3YkWbzHhWFbpvy/77bDQsgISPKBRQEaRxzsRWpa3y58BDLoaCDyyS3+JvtQeVD9iAA+6asZfhHWAvFQhPNMaTuGlRZTEsBhCi9Z2d3eUsOK/tdiQemtVWXTlIMPQETJcEYe01PyWno746NakTaprrIDaV2nJ3N04pR+G4QkjAahVHyoPqFVMvEgZa+BAhgBFyrvLQsq/CoA02+/nF8BbFJeIJUt9dECnCLLSh93zAAEh/jdtXAt7MgNjHFZTus7x1iOvlDVZDaNiNPsWbpWgCS7yN2oQchjxy2LhZDJcK2YUGtGTa/K9glgMkPRbEUDhlXJik/2cDjCRH53fWA9S+9yPBZGNRMJULIgua86brIRdVhQeJpnCQA1pGI/NE1Hi5kwsfeo2a9gYMVKO1A9XT9/o2piQfp5G8AjKECAAsEGQ9IqGSTJhgpWARGv8JsCIqHr6W2Yy9f8RXkvaWQg4sSSSIBnUDNoxMDAGONH9mQmzbnAkvwQVloHVhRsSMtoM9pNU88eI2cwSsda+MyCZNp/yeWufT29b2fTWoAk4icYkJUe4ABRVYusCIACH2E/bWBrSdhWQumaiZJbtT2DjVqmjc+9GYwJOdgApGxAGKeDTopiQImBeIvq64HKyUjKxwBSF4SgwUeTshUGatVfbN9p+qm8xTit1TjNilJZU2K5n7YrHX8E1JwskkNiRuHz0hSYkaNwJOwYbEYyk8YD8gHrjjEMBO/CQWgLRyByyV5E3qVtICFvBUJgEC0SAG0PSxynBXaGZWZHPjOnLbUUQBuyBZQAFOAh4kHN6XPxE6ABkAAGQOEm9z4BFVVAJKqZiD6/uwdQLQaU+g/F/qUBSXeys8IGxB6gYf1ZsKdACqBaB7P6rLe6tuHbbKkNQtBp2qRMfgmIVLo6vcpYXbAadTGnHYQ9jYZlOUofPAnqGAIYLTgAkQszaQI8PAA0sAEi2f4Rp5+dhyNgqQAIyHum9OzaYrkVPnu89ElV0+uOtP2ovq8ZkLXFTIEQsFqV8pzZj5w6KfdLH66XPASm5F2yEQkQcUqnDVKzZc1ZlwMOQBz/1KmIUcIUMaH6VtjpKkqLGdG8Z1GEWeOZF8/aAFezHzRsSC0WVfgZxpWy02wIjbCWcglArRKuvzrFopINwpDCNhSWLQLxY+yyGZYHgP0A8j4udMyMiCjYiYJqMYTFd2gfOV8s0iOkaX9CubFTmJPcW5VOi2UwMGnp36Is6kmlL8ma8JrlCBtKRukINssITKzdET7vI+6jz+nIBwfSs1AXCbxYea4JWgcfgKDAR1ZCu/AFyARCe0g3fIZWTkucSIOmvVdmtde4DabU9NMsyKpvUyBkrpt+LTZkmZql5rqMtsySNpduYWkBxRW4sqUD4CGyIo9wNrUAEUdG5F1QzYZ4PlScPfMUDFphDqN8ObXe+pTCtoy0+Veq74y7/MoBbUANQBroJI64pzDICwetumglfSde5WdBR9xHH89u4lxGNm3ROEQi3sQw1fOc17EPOACpExG1rLMz/imUZGDVv1pOARj11DX7hY0KhCyYtNiMKmKhksGk2UrXohnK+wJ0ON7r8C7adtRaJ3gOPZgpnmiAYGxnpaIJEA2yBy2u9iVR8fTIim/76CQDMAGMeT4V6TVA1JLMIEq6SpIP5c2gGvDkepBfJ7/l5456YlUsroApg4+4sXLTcapEtbt9bivkYAOQHEgGlIeSybEAwoIam0xPSvbCqlYZr/Uz3Kuh2zCfyWsDGLOARgWu7E3ipRlVC4R0WdEHHv3Lko6suKYIRi5+JHER/ZnAQ8wofsMsAQqXM2gUf9PCSSADkOzwNvaRkxa2v7FiwqKdXAtYIqqNKNY9CTjJyvDFMFZdsvVpJKAGEQ084T6zH6t+pTKrdE5G/QIOOACxLIIT8FEqWMGCqnn0yURRvb9abui0N0UAoRXhTJx5ZVsjrCStAEAOQKtAqMN2mkCzys+CTINh6bKlcBp0fLz2eXwm0InMJX1rgAmOEYBniAGZI+AANGgQkozjRlmo55RAJ6bhgfSpmQo4dB3bD6Q5/lUZCuIlRnWpbLRvgfIvHIMGDr/FKQKM5eASSIXqxV+Tfcu25A3IauApQEipbRXzOQmEPtAAFI7WMOCzprATLj4j7IpwdjmHqFrttOKFxboZs2dNNUsNfutWqWJmir8EKVU2HR9tEKrKpJlVg1GVlc2/mvGQz3+FHUgKQfk+P/XokEAIced2ZENpkCMnaMvCCFtNIgtKaqAqnzSOtVPZa2q4Vaqlqk8oWxzkYmB3+dr+egGjtA6KVdU4FbAEJuVvH4VhNLIpWOxBWj1lH2goa9A2rHEuKB1sAJIWieDDsgPbSmsWbA3gaYqKO/Vt+PBL5l7SMNVZtzwNgGmyjspPrWdqpaHcLatp2osadUlp6EBk3PM4KcBHWJAwIAB5DZFqx9i0qmz5kDBCHFSRDSEO5uQJda3ARTOvwk2X09RB2qVfNwVaXoVX7ZP6RbzO4IPUf4JbWGKgwahgT6QKY+6TzUuB0pSwBRMLOmyuJawA+Qw52AAUGZA2Qge7jweGkzD8xNkWzJlFs525IU3jswasVenOFQMaU0ypMEqbNAqm0wClCqxsPKAJipNsQMJpENLsQ+26TwMVJQCFYBGE1JuZEnuQwrXbrgk6GnA02HSApqlWSjjfSSOWqbDlOlLMCFFNC3Vgp150Q2ZKsQgGjADZGJoYOuVzwPPLcAKQ9LObAh11zzMVkgMNQOHkB9Vw+kB5az0rXpUnwXyKNFVZ1NvVsp+enMyq6ik1q84I7UFn/Ltp9EBJs6BVQGVAyA7ApDUUQIB05HJxlhGh2OEf7IA5GwEhAa7gQeWA1xm3gENft0BFs5rJcGV9NcMzE3C5MeVeDpBTfYmVKpmutZskUsTLSxe0Wwukeuy86hxF3ai4TyrZDDnQAFRsKJ0jVu0ic9+S1MjqixRWJthMj/1Mgs8MsFjpP4MFTaXXnb2y/itEq1CVuqLDmEGrbUDEjZMfZX2pgJBcI4MQO8WEXJ2vDFbSDhYgi3vquJdl1+4WTCsAkjKZtqzYcrxOgJPYEWXwMWET02mGoQKcqDAdlOCUyoOS5dg206A899V6sAGoJXMPDFsXiKLYQZeARD+oGexHxzlpsWBjQKgZBmjagqprXdwW61JVSdkqsAHluFWZxd0AT3kfYcLHTxjpQabyI6AAoUL9Emu1qVNVRQuQPZVqHcBpABB5LuvZkVJVj3UW1SwBEApW1HzJmTBiM+oBGBMFW1MEdrbDQw2CrjH+bFDBgqIpHF1tTAVyi4VvjgAUzriFc8mvOQNGVJwb3WI3TKiAaLKYvbBT5M0WSzMOBQAp/QkQolYYyHXJ7HRYnZ0tFusbqHwa7t0qWvCpBjPnuqfCqXIwIF/GSZhpQVQD0cQz6wHkbNXKAFNhTBe3kSsW1GSF6gWgVTPNTvSLTkCpxbQT+AiYJLWOGgCmVpmnI1Fy3Ekx7UfjvAFysAEIQDHD5SiDjIuAQxFwBGzstb5Pxj2KR4TqcAh/2igtnWTFw6nUIAD5y6KdB2UHRAtwlPscEEIZTV3HssRQFOO1wsK4WT8CmmxDD34781XQeJUQk/qCqxqIaYDp9Bjll2Gh2loX1laiJaosXaPylPRYQSNMBTxQ9aH8LIryK3AJa6IyKAkIs+qzTQBSahwBaeV4DscJmEinN1PorGBAhvVohkMCLJb9hICwKhgnMELyY6I2+k+oViVT4RS2ZB0lA+lJAU4GcII/uqDTU8dSXLRAqWZDzbAK1NrptAHL1qU5C2YiyRc3ugPAMj1hFjK47DlIukCdptcvi2a5VrCfZpwpsWCkWZ5OywKQuSZ1zYopyV66ShUjAZ4A3hqMyGWDN8fV2AXwrwCjswOAgBJ8wkVkQAF4CoYj/kBWvxT7EWAKoEPqYVICo3r6slEmGQwGbMSvqdtoSQMgB2jZalaBjgYbm34FiGkQl2xIitMDl3Sv00TdLEUcO0gNsxD1IQMtzWtvoPpkkDA54jJuoY6ZNFtgOZv9NKTFcux1yQrzg7PfpCvAVvqBKnRqOyjQpQBIwnKSW48ZRTaZ9t8l8OIi36lncvYAEBT4WNVLs58QsFa/FPsp7Tw6DKDVrzQRsM40uu403BigVIbNlYs/sVOmVczRrwCdHDwn0QAmHdYCxlw2ZPOcYj+h/K3CdQLbTM395FIBoP4ooww4Wx5T4Fm2uhkgZG1ZKd4qdiTgUwCTvinj1n2IajAClBqFZFwuVKvEdFCwpEIFizNlRbtKHgphUxueFQAkNh+go3qp32GogKdiPxHteXBIdNMJA4p5mlmvKQmMQB3crYCn6IOE5tu1sPWkcAaICqaANhtCJ19djRi+AJq4167Fhio7kbonlVEXWHU87aeAwZCWPmvRzECu05s/M4Q0CFX8CpSo0UYN4OiqX6tAppFmYXSfYlo6fZtODNBqIz2DVsyeCSAlexCVADSgWGfEug31n1Au5OHBZ40RGsgzW1r1AlDNfEXAYcWC2Pwm1avJiuLFnLY1o6erLklYLZTjFPmy9pve09UEJlN0tmnG+y4QKXuWBZvCbkLm3mbcqPMq9abHTizQFiqKKasuX1VPVWFCo/wzmM8saQBjLlI2unfbQz/LHjDqsCrP8LFIhD1ewmy0qpXOR4+fpGLFjCRMF4Tyb/XinJAzA4CsaPajZQX7gQUbtbaicF9XojF6EiCK8GWerSn4XvjWgJw1e6akACINNhqIGIVhsgAeLpqyGDTt9il/K+O0bYOnQKbym2ULsnUWhhG/QRfxILSdTMczIhVR7d2SHmucKkujDsULhPN1OOaGMpgz4ie4kdUxlAAPKNCWOs2QMwqA2htRS8DRa38S64nCpNxsWns5AwjzBk4zTAtoqnjthYQ9wCoMvZIGajcYP8skCtVMAVHKSzGMybr0WJB9w68jM9ptrkzmr8vaUZuE5RRFEjbmcjxW6Wg1K3xptpFvalfObivKWy5bMF/h1YCfgIjTdgoG0qpzPbOY2FxKF7nCZx0Dclntkt9C/dKgUgGP9ssPa697tdqA0mZBOk7IU8fJYVayoFXhiwKq/KbcNFNrAAziVG8AGyrCskpPs4HC3ZbdtIWVWW1wKsSmPVGeKl4zYE6SXbwRY7MZtCxgpp5Fb61QaQfk/vOeEsV8JC8NiNUaK7OsIc04QvVrnE0MSK1sTjIFHMWMmP1V8SKONQ3Qc2XVIGn4V+DVA5UU3nwqqMN4gDYgtfpskYUBzApg0nVkRdpOJIl1wGcWw2gWynjNYJkpzXVBq8fSJspSRNftpLJP4KGBSBiRYRAtECrcGGUDJJDqF7bFgggoFnOC41dFoMovLyAX7/WiU/s7Qw40AFV4ILNfct1Tv1xtfLbql15JCnQ6eHwDrCxnGsSGBQGKvzbCQ4WpGFV2a4IQ6jhNNUH7mTL1DMnagFoZIYUVQQ2y6LeK+eSCNtxUOU+1LWjW9PscdyuJHapbBcgp88R8uGJAgGIlOm8DQile9CsYEhQYFS8f9Slvl7sUe/UIKIaJzy/NhjGSjVTbfqSiZw8Daok9gMxOv1sWpCQZn5Hf5rUxG+WAP8UDopIV6c/eztFIs6uqNQDD4ppQ9aYNSBI3+c0SnqgTqTLvhdGsUYYq6xnAoxlPy6+p3iXmQwpYMupMqmFcplNcs35WkZk2KjYJwJTZkrilauhFnyib7KwAoLmfgW9KseGUoFc+d/PTg6vyy/GrtSbpvhHZOPXWulSdRLOMKbFv3FaQFquYYmZceln1rceqWh29pyYSc1l/01BF3tSpQ5VZx3kPrKoJRobxNLM0z6MwAiv2U7BHAIXB2YKw1IGzv06ziFPR4pkV7khiZ+qFxem/1XKgAQhAOBXRnn64ziH0PZkDHnuU3nqile7Gb/ZpijOK3h2EBohahuBCRUAfeOYwiG7cmEMxgEw5TqdMrgeiqpmS9NhlkSbyINZMpvBPMyPJwdyjBDCVnAWsasJD1Cj126xMR4rn32DOUzLDgrGevPe97wXFFcnyd9lllyX/J598Em9729vwzGc+E09/+tNx7bXX4qGHHjq5TOVheF7rM812Gh5AE2jswEzHYSYdmOqwHQBrDXKmOl7TXbGeSgWkMsxeZK5RmDj/pY4vX7CQNS1yUor4+TIeaXdvwjQO7tKHk5Ey3M42ap9M3Scjlr/yzKo/c2aP9B/xkzOr7TYI+5fCDRRX7cffRrhqewWZMMpd23Jmt1cLLBvgOSWnhQG99KUvxSc+8YmcySJn8453vAP/+I//iI997GM477zzcOONN+L1r389Pve5z62fUVzUtVJW6GqFARoKUFpMoveQGixlEnyqMGV5WulWjOc0vPWbywFSARrhjf/U9Pscu4puDz39r9fUBO/6m/enRJ1opDHJfnQBVjHPKVW3MYArVUaYjXFLqhUjfugLBUBrO1GrjlV/mwAjrXIVdfhhUsEWiwUuvPDCyv3RRx/Fn//5n+Ov//qv8fM///MAgL/4i7/Ai1/8Ynz+85/Hz/3cz62dF3PshuscRD9DnbIG6N4sWBlnXvarbUWdsjT8bN4nwwK0TAKRCmOza4FPup+RlwWd1LmhBh+Jc+dg/SLxCb9OWcpFe/3y9vLptlkrXXn2BoBaQJPKp+4LUGKEvu1jggaIQHU+tlxaMjOaaONC10MCorn98JSrYADw9a9/HUeOHMELXvACXH/99bj//vsBAHfffTd2d3dx1VVXpbCXXXYZLrnkEtx5553d9I4fP47HHnus+CtkL98E0zNhWlotUi1aRJp+rx7OKvYzE3zyESBU0HYJa/9y+ab/5src8N2OxuVfpX4pNaynxlVHmnK+L6aq7b0tx2RF+3VqAUARdaqNaeIP88JbFa5S2wjlVLj8OtVPaSKey/Ftvk3AMW6zl1VMyCkHoKNHj+K2227D7bffjg9+8IO477778KpXvQqPP/44jh07hu3tbRw+fLiIc8EFF+DYsWPdNG+99Vacd9556e/iiy8OHubbH8U34tewBVViQcG4t8SCQAi/PvgU9p01O+xUh9dlm/NX1HlFWrOE23+FPUnCobxv2hvSdUnDLGBV7p08dPqFX6sqq+q9qk1MWzbbW1+bPmABygKHZS69eN1n30ijWdbkuOJ+Qk65Cvaa17wmXb/sZS/D0aNHcemll+KjH/0ozjnnnD2lefPNN+Omm25K94899lgGITmEPs0KyGEwwMp5eoHfKTVLZM5AKzqSSnMG8IT7iYfdyH82Q5kLEg2xecxKqtPsk2xJpW20k4rli0dhj2AVRkVsuenEknMv8zmyl/ad6ppTKl5UEfVzZdTVy36hT6WtGqLSdvK3L8MCDG1ZbJnJ3M+Q0z4Nf/jwYbzoRS/Cvffei1/4hV/AiRMn8MgjjxQs6KGHHmrajER2dnaws7NTuXM0Qpd2oD2SOtuoFiR0vnr2q8EKZoOPBh5Imu0yrcPGivLMC9aWHuitAhg7mLVfU+Xh6EXN6GrcVG5pcCG3YQ+YqmJ1BuRUHU8GzE+JKNABMhBV9ZNNo8lN2ja29Yp6tMBnHRV+rpwWG5CWJ554At/4xjdw0UUX4YorrsDW1hbuuOOO5H/PPffg/vvvx5VXXrm3DEQNEzvQyaheVlonIPYGZROIzHVFc0sbTxHO5bDd6ds5f43p3zl/k3m00oOh8cjupVrE5Z+atWlNsVubT98mxN1wU/GqPyh/K50BuLa9zaQ9abBtPR/l3lKboJ5TZStycdqeOn9Otiy185gE4D0MvVPOgN71rnfhta99LS699FJ885vfxC233IJhGHDdddfhvPPOw5vf/GbcdNNNeMYznoFzzz0Xb3/723HllVfuaQYsg49Rwzwjb3BZr1WqNTYiM9Bf2E9lD2oMyt7KaRuu8J9ZjmbZ1o2w8g1ZJloE12qCTtLYa7J7WcZ0CL1iJ5oBFVlbNcswHt12xephMvcwCWv/Xv1XSKsN1pLGS80u1JQyJ6tD2zulV7HUCWn1xaqIto2sKrZCTjkAPfjgg7juuuvw8MMP41nPehZe+cpX4vOf/zye9axnAQD+6I/+CM45XHvttTh+/Diuvvpq/Nmf/dmpybyYrnbZrdj7Na91rCG59qcSMKqyNJiRBp8qnxZI1XGr6zmyZqdosjlMDyarEsxBvBqgdF71iY+9NFqqWBOsVFKtcTilmmngmitVe02AbzNMI78C1DqVZFPuZh3nyB5fdutkQsxrUoQfAnnsscdw3nnn4X+412Nr2AaGIZz9MwygYQC2FoAbQIshrA1aDODFEI7uGBx4GICFAw8EOKdWlbpiZSmcuk70NV7baU7NfjSAGCCq7D1TLAjZvwcKc2Xum3ilramnPpjfSnXyNQNqlakygqZrlG0j13Ylr3o2vXi2XqsmB7ruNn6rXnPUrVXPpvesTT5TM4eryrUqv3X723j8SXztg/8nHn30UZx77rndcAd6LxjZb345lw+fd1QfRpaO55AEzDEcQOq4QNno6x5OdtLg02ROtgHWLM9ew2raoPxaKg1M0BSFADnzWAJYZjWH8teFrYlAsUpaPCgHsGpXteKaG2E1kzBqR1VcDcIN9+59S0xZ10rHUJ+ivWe28ekwPGs50ACUPr1jv4hBDiTgM7j4lQvxIzQPoQdKk7ycIaSAIuS5mv20jdI5n6aB2lxPvaEr95OR5tvOvtLFQzmZE/hKVSgHT+OH5DoCQwOIdF7d7TBVYVWwAmy4YFHi31JhKhCdAqPWILaA1GGFlf8M6QZdkWZlL1LxTjeotMrTk4MNQPJZHqKges1gP3mLRZkUq47fnMUgzDp8rEpTDQKdj/a311OUf3Kwnoz0WI/Ks2A4qcEi44iDVBuMo7diQNpdAdEejQCVEVnSZ6QzlwsgaoBPUVfCNBghX5eVM82nVJ/Zak+zgoYdrmlDWsl4ToPxZV2j+4EGICJk1ct+htkwnt4XUKtTEJW0ACRkvJr9NAHMdvQO+LRBpuVGldvaYuJNzbj1VBc5SCt9UgY1CGUGVA7sdj7lqJ56Y1cgJOCh16MiA13vEP8EkOq6yKdT3OZ4M/YYXVYbrkpQvFptDcPgWmm1vCwQTeTbtNjPzGcvM34HGoDE5pO+hCpAoz5C2P0GWE8I5aecjd9abEO9eYv0ldgBP8l6CrfGq3dNEJqyKU3N7tm3smY13e9aEdDq/+HLDznwWqqXHljGK6evQIWA4qCzVA/K6UwAUaWOoUoqh7MMaK7dJibaZD4WfPbKYHSaLb+9xtVyVqhgwwAa4hfThghGyRjtlGHagZ0La4UUC7JfQJXrYsDLC9OqX+uwH/RVr5RPR+oZGsN6VuTVlSmwWRE/jQc9YCvPtiqW3JRaM3VKn61/se6k87ZO9ihbRouAqEGJKX87vaiAPNeeetazyXQAyBrse7KKbbVsP7NkLpAUiU8kt0dgPNAARIsFsFgU0/CI0+08tMFHT72DEBjSkFeBFsZnlAxm5dqfonBt1U3LFMuYk343rU78Zn7rMChDLVoDL3yfvK+K9dwmyzqnPewARy4j2BBag+GlCmzASAKRCqvSSLYhW8Y5qpf2N0jTtDM1ANTKLPxZBRBrAtPJsLIDDUDY2gINAYA060ngI8bogQIIOZTrfgz4CPtJHVKzn+bgbcySVWEa7KcTzkqX/TQGgU1jJauZUyYdvK0/FWnIoLf5NEFIgKERpVleW5YVUjCgRnrFrJVqPw1Iybgu9dCAZMPbPBplnCw3mzL1/OaAhwXbU6gyAZ16GMCdS8QONACFhYaLGnhk+l1AR9QuAR9lG8rXUEZrZAbTYj8NFjQ1BR8Ke3J1nQs+zcGwB7aUA+c4rW0AWqWS9Fq2IKYyqmTdY0BVOdHp+B1ZuQanAcjJrlMwIvUriZoXArXavCUryt8FnRlJN7OZAz4z2vSk2n2FHGgAgnNZ5UpsJ4IRUa12Cag45a6AQ9t/7LnP68opmRpfmUe86IGPdYfxb/npYAZwujMwK8poAapIT3vxdHnqxOcF666RSQFQIqEFIwlTtS+r8LQa5NZVbfYSVdVtrzbqlNSazGkvqtjBBiDZYiEroQ3rKdQuQtvoHFUvy360rNoFPzX13pQZDGSSyUwNUlX+ldP5rfSV0bQ1fVswITOISwNzXPVsgKYJaia/Zh0tAO7BICr7y1ozdOlXg5Gqc2FHaobnOr3E/ijlPyWVMd7WaQY4a/ZTrTCfIavUxFnxzhYjNMviw8h+MtMhBUKU9nQlm42yAQn4pGt5mzXYj13705QKvNrXzfp0waj2aLKfVl49dtQpbzEA13mFzglLaIJQsxwzpadq2S+BZrLCfRDWL5om44lJanbUCmMG/irgycUow1WANAOEkrd9gRSeM6RT5NkAdVYwoK1FYEHFzJYCmhbwJHCJRudB+TfAZ5XtpyWnVf3qMTHlXxpOG3En0lg101IwEEa95sUCQJFJO832bFojT5NOufmyATg2nKSHXrso66kFo85vU1XTdVpz0Jf1Lm1OEqYbXauBtk3XfaHMyG9P4YwcaADihQNvDcnek9hOUqUawCO/g4COAh83DT5J7NqfUym99FrurUGk7ns2IWCKbZk3ZkvlmQKfxltw8q0Z81jZjr0BJODDMIBkyyY3lJMzQFIsWEzqI02roC12ZMKspQK1HGem0VpkGcpEddutSm9NQLEvnLms72AD0DCUBubBRQACZOarAh5hRgZ85G8KfLqq1+kiPBMg0bpug2X5ezKASRZgOu5zO99caTEkybN3EqIGnaJ8MaEMJFSohcU1qUE9A4wsiKWyrlHPSeY5JyGj/oW46zGpqXSrdHrhzgoVbCFn+DjFYGYAD1CBT5iORx0nigaf7lT7XsWktTZINMJPGqBb6a/TIRsDvkqjoSZ1pTfwJgZkEUyVheI3sXqqYa1GcWLL2visgSiDyzwwSlixDvtpgKyVdR5R0+7TAKe10lLpnCrmf6AByA8ObuGynUdWN68CHaAAnup+gvmsY1Q+5dJiNr17ceuAT3MqGlirl7fAp3fsahFH59kaKOiEaUkLfDwMAHGdjzxnKRNxVL1KIOoznT4Y5b60ovhrMpKTNSZXRulWOTpx1y3L3OUaBxqAeIj7uRzyQdvqUzuFmgUUb7/icLCZatfU1PhTAkZzaDhNlGVVWRtvuupes54J1euUbJrUcVtqlmfzTXkuviEPASVbBgLgFPPpAFGhtc0Ao95xsLa5U/vvtV32GK85NzIH4FtxGv7ccZ+SAw1AGKjY02XtO4ACkzT4FOPB3sHndAJOWpCne6+6Jnmh244c41CvfDGN5oK/TocpBr11T9e6F/bBZ+Xq5IZbmj5PDCfkV3w91XMBQjBhi3QjUNCIPhABYHCyEaXouu0abZnOsdZtoavUYyCnS3ps0wZbk8X0ljHQ1LPuyIEGIP0JET2lDpRAUqlaQGZK2k+n3QKffZKiY5tX6srVwx3WNAkShtnocD1DtE2nByQ9/2Y5tLtmPRpgChbEAVgUA9LlFuAgyoyFfOgLcoxrwV4IADMQVaweCKUyRjaU0tEvDAsAq/rUSYBUc/A33Loq2URa1SypSrvohzO/ln4GABDas1rIv8WeLtfwi/fF1HoLfPYARCsBAugynalwFQvaq8ztfF1AKhlGC6BOFnwo/WXwKew9mgWp74wVaXFmNHn88EoQCkWYBqEMViiehw0PqL5gWGtP1mJLa4LWOmlLfalsmO5s39nBgIzK1WQ1M4AnpTUTfCZnk9Yp+4Q037IpcsfNlskCVi89lWdd0DYgtNjOlJpWlXOVWEBTwNMEnzGCYTJAc1kGz6GvoDgafyUIhTArQAj2Oh6KL2GQE6peSI32mAXYDdlrvLlimU8LkMT9rLAB8eCKLRTalpPCVNspGsADiYsafGaAzFwVbRUbmvLvfidLv4GRO7x26xe8zDu5WdCxYVSZaqbRDjvZITvsp5xeZwVCXAJPYfdh0MjN9DDGxkpfdqUSdFogpFlOD4Sa1waEFPhbNrQKqLtsouNubXKnXOI4K2b+UNbnrGFAPfDpMp7CrbzX6bbcC7+WzGVELdquOqclM8XbWq1qtVqbZfX2RVSl12AxluHYGa/mPUx4nZ6pd0t6DCv/BsBxI0BjDT4aeHScKvt4ng97BkU2JA90CoSk6D0Q0gGaIIS67TUQ9dpnSgXuLvZcBVwnC0ipc5WdsNjkSyi+Sz8lBxqAnrLZhFMhuoP21KIGsNh7O+ULFbUHQjD5THds1EADlGtrBBQsUKGMU6TZao9WGAM8wmwEfNwYgUcBEdIsGHfBRxqFXQYhDApI0AchDSwtEKpeJoBq68ZnpleoKP0JgolILeCZ8xympBU+vvQ1+ynWRUm8s4EBNUUedOxEVUfYQ1onW5bJcnK+BTAfiMDx4VMRzYJQ7iAoOgzQfwOXQFP+amBoMaDCzaSbqtgdYDn9PI0ewU/AZyngwxmEmCMQAWJsLu13sY1cbDNhNjacFS5BqPRj6IU1Uy+WFggBZd6r1TBuums5KTW4lU6nSBX4KM/UBn5eZmcOAElnOQU70WfNXO0lvdZb0IDBXCCyb23tnvwlPxu/0TdaDGYKfEi7o47TTBswg6p0L9IuAKgEn8CCROVSwCMzYNJmRpVObEb6iY9vbbXEwbKgUM7+FH0yaLdUseIZci4DcpiupPZcA3iKeHX4NsitBgoNmAF8tBEf9Uutgdc9OTMASA1kLboTneq0p2SSbXU6aIjYAKLSOycR0wk/nNhQOqOGsn/x5q3e5PV9ATwSxgAE9B/KsHMBJ7jlCqd8G4sKaQm4JYOWPqpkHhgz6AQg4pJdOMrXyi7BA9XPtXgZGBBqtFkCoZabbu/KrT+ZYKUHPlNsqfscgAJsVqpjvZdUBN4E3IySYUvc1bgG4EwBICt7AI3TLQWrMh0UylmH1w+06ti6D0snMGyoaAd5ybeAumIiqkAN4KlUtFa8Rro5P27GyczHLC4UtWvpFQjFXw7h0+CKIEMOgKcwSIjj2VC2/HknfPEyEKBo2IM0yISfyIKUW1HdxkulYkPFs+h3iimVqtn2LcDpAUtLOm/BDDic3MKvAvyzwQgNcDWwi5miasB3DIJFkoxkYDTxgXactkpVl6N6I6JOx74VLbVtugGK9eRRkBgRTLiGVGAhwAO5Ln+bbiivpR2KdHVeTQAqFxTKTJfTqpfPIIS09odLIGIXWRCHTzaZYpC0z8jgAWIVMsCxAoQmpA1qNRualB74mGhT4NMCnjm2oV7ZwockUfRFzYzkfq7B+4ADENDSw/Xgn2WM7gDSShBa6VZOmwM5n251zH2LCWm3BEZG9UqRFRilcCsyr9b3rACeegBwv8M3gEoGTDI4e7WlQgBJgEf9QWxA8le8dX0EHspABFcUg/RIcrFtke0bFQgNZZ1y7JIFnRL2vS74NO4nbX3NtBoRbBjD3npgdFYYoXPH53bHkUFnQCjEkXA1cOgZjj2DkCoHkAFglW7cstNwy796+8R7y4jSNefrKWmwklSIHviw6rz27dcaEA3gKRiQBR8BHI9gOI7Mx4IPFQyIDAMiMHwBQkgLFgnJriFbe5C9irZBZ1asIU2GrdulYt/tNFr+c1jMpF+RFnf9Uhg9hgA92jIY6fjz8OdgA5AYHWs1CsXbSwyQxaxGRxXLICItPUMdKwAnBusAUVHMBHJ1B9AsjVQ6qQz6vvGbpkcjECW1YQYApTwtEPWAR8fR4VtpAijUAxVW7+MqVztzdtNT7t7X6pe8eR01GVABQqqQen0Qxfi5mbNtbc/S6GuKQjVlsg1t2qjbV/uV/tqtHRZAtZhQ3+vJHX02EhD67tmzEFGtai1UMf2GkYevZjWaIAQ0OgknEAJmAI4Cpyp8Ufhy8NZ14yJsqkcRiIowGmTSdfSzgNSVFohMAE+lStm4ACpjqAE5veBQwCXtelc2HwgYjQzS4ON9YkWaAYXTMaN1x8u2Cw1CHtCMiEKbhoWGqFl1b7/YBCtuSQVCDf/cdh33Ttxe2HXApwCPXv8c5cIUySG/JGbIgQYg6eg8AUJTRulemjWwMOaoZOKUhBqdRked94z6nQDmEzMJeGJZReuLY3HOFpMpA3ELeNoAxNODKIXPwJPSVqwnz4LJwkMPeB/CCQgJ64nX0vHT8bw+NgRRZMQAcQajBELM4UOWLjYGo+hPeltF9Rx0n5jymwFMhfTAZwq0Zu4Da04ONIBnrqE89bkITAmgVsjBBqCOaDZTgBBQ6LIWnKbtOvJE+mxIwld+KMPocHN15am6Vulbe4/skZsAoMKpyWjawNNTq6qy2Q5tgUfSa61w1nn7nBeAzHyK8seV1OAAROkF4kDkwXAgeLCPjIjiC2w0EDOol1rsL5lJGVuQnT1t9SHd3sZt9stoHZlQ706JFHXcW0YHH4AYWXeXDYadw7sqVQzo24MUsFQqGbAeEOn8G3KqOp8pQniLi6oX1YsywHRCrWn4VN7kxgaoOmlotxbwqLSIFfj4fD9n1a4V8gqE4h8xB7wYOYDPGEEpglA6oL6xaVWAM6vyuZsVe8R6qlgDmKbsOqdK6gkLqkCDHSrbTStckkk2N68CBxqApipZv2H2uD5IuQEGiJRalvwMIzlZNWsdscCTypYGAzcC98syrY41NqM2gAtQnVr7V3FLmw8025nqzI5qVmSkACEfK+Djw0msJ4OQnh1jBBCCAI1SxezphwGM2iDUU9P29PJp2I/0Ngm9Hqc0DtcgJLWU9NKLWT2zuZ+W1jJ3S9SBBqCuKHAI96gGnN2mMblh0LCh7K4HdP3N8XX71kkzIQs8KeH8M3ePW81kAKtm9UCnCTjqvsme0lGrYaSHmS8FctaoKbaalGDrWtXHc1S9GRh9HINRFYMrQUjS9wBA+Tm7CVVM6ooGCFlpMaMV0mRKBojWBqEYN7Ec7SZsyIRLWU+A0Tr7MQ88ABVvIaHMmuICivJ2WFAMUy0cnAFE2c88kAYgTcoedWgr3TzVrvlZYmeugAYT4jzwvHGP1/q3MlJ7VmDG+TethM5uGgDzAIsDR7EWdlTOwOh6eIDhAedWg9ASaYKMHeWNq7FzhTwyCIl7Hu8KCFssaI8gVLRjqlhu40kQivm2V9crliPF1myoArsSjPa6CfxgA9DUmO2woOYCReMPYB4QGb+UVQuQZshpMUSKtKb8e31GE7sKRAzotFhOA3CK+x7wAHF1cy6vbDJtAXxiO/pZ99pdyjAXhMhlwBUmFCcvUg6MYlKjZROyK6SnZsxyWVd499hQr+o6fAuIoN0MEPE0EIX09wY+wEEHoI5UD7n1tpEO0QChkIb5EgVQA5Hx0/nvWU4BCE3m3/KzbZXS4cp9FdOZAp10b8CsOFKjAT7d+jgAdrqX1Ejkxq8FKm2U9h7sHIiF8cSZsSEmKXm5cmo+DMz+Cum1VLGZz785g5bYjGJBsY5VePNuBmw3yOiUXsrmZInJxYYzMemMBCAtbYNySRmnQAhACUQNGtxdbNgtlMprotx7kka8OXt8mmWYWheyLujYNPT1KvARQ3S16rlR6FXMM07R80C5jGKUHhDXDXH6JUdgefMzkipGCO7ksg2o+WkfbQ8Caha0xguhWyXLcNi6lWjAJtFUlGqciHtptkjjYlDhbZlmHoNzRgCQtQPJOTCVGmZFN6oFIaBu8MbG0uA/kUXvzZfK3o/bCt+TVft5qrfVJPjVzEdfF2VeB3TsfWJTa4JPUQ9uX3crF78l1xLFhtLDTWWKZedgb5Id9MkoPVJ02wMITZa3426bwdp16iAqTW2/aZRD+jvss5YfUdP6xWY/jwIdfABq0VhMqGGWBRkQAlYDEdAAo5a0dPVW+WfKKiYztYR+as9PO7y4c+0mYsFGpVMxJe2mgCfF1+Wz4IMyfAVILRtRURljJ7IiwINyYGL04MGFvqQXKYrR2wHQhuh1QAgN5rGOdF5sLSCqgq1kWBnBUlltOLY8ynifzSuhV0oLhIDZQAR0wEBnMQegZqRTJ6zirlo6v4q9ANXAtUymitMobtNWVABKnV8FcCpeBT5epddiQ0otSzNge5gEyOpXeHNQnIIPqlZUuVJBy+Pf1gahdQ3Tc6RhYG76K5mVL5ePnTRDjP5W/DCvQgcagLqD16hhU2e19IzNwAQQTRZqRdl6MjP4XLtMCr+KybSApsVapgjGCrBp5ttjSHa9T8Pu09z9rqXV9nNnarQaFs+NprhVLMygxd1h8cRF2biapufB1RqhSRCaU6SZ4aqZrl46ewE7845ZyezPht3wLdEPdvIhKzCq1jEYoKqAaEr28OLVMusYgxXAs8ooXIZRebfsNCKzytUBOePXzXeG0XmvWzJmlV33ATFCg4JdUWbXGIBXIBQ3rkJWWwPFGiFrUN6LTWguWPXWCVngqabNp9LugdpKDWDSO8kZA0BJh19V8QYLkvgAajaEHH7uGSenTDrPeN01N6V/Iw2bbstG0ypez8Y1Y9atBDeVz1yw0bafuaC0ggWlPiRgJPUHZXuQrKj2oa8llW+gAoTA0l8i6sQNwQUTimlXINToo9XyjwmZUr+qLwevSq9rX52O2DX0GzkzAKgFKloNg3mL5F4wrZLp9FOAjntLqrfGivCmHF1RYFKtLgbKtTMdwKnAJqYR/Mr7qtydN+1KwNTSZGMd8JmreqUEs/ptZeXA8AiHlzGHmRynQIhl3Q/nAT2oldcCIi52LgqOTXUs9r3kygrQe+ZDA/iz7UYGfOwRLlqmWNg6+c6dhl/7ozWf+cxn8NrXvhZHjhwBEeFv//Zvy4yZ8Z73vAcXXXQRzjnnHFx11VX4+te/XoT57ne/i+uvvx7nnnsuDh8+jDe/+c144okn1i1KaZxUohtLz7C039Zovp31XzP8HDBhVOFt2s0/dTJg9Sc7ydV2BTm8Sw7sSrvNzRnK6aiLeKgX9DnLo8+nD+r7pQ/X+k++SmH/WnUZfT5G1XMuYwTPgvW0gGYKfFYxn3gOUPrT7iufXXz2akNsaDtftvsyt1t5djXU2UZQn5GWo0Yaz5GNO8O0U9nviv5M/T8mqsEn+ak/N5GGm//nh/A3R9YGoO9973u4/PLL8YEPfKDp//u///t4//vfjw996EO466678CM/8iO4+uqr8eSTT6Yw119/Pf793/8d//zP/4x/+Id/wGc+8xm89a1vXbcopbB0UuXWeEu2bB/pfuINfqr+mnmu8acHbbpWg1raoQCFFuCkc5YjKGggGn3+8F8TaJD9zd8U0KTyAiXA9IAGaLtJ/DWlYD8WlNSzLkBHt5+wTNV2YbretNWo21cABtUxJAUQsc6z0T9ggGhundURLPaETLYA0wCktf8GxHO155WPmPdu0SMifPzjH8cv//Ivh8oy48iRI3jnO9+Jd73rXQCARx99FBdccAFuu+02vPGNb8TXvvY1vOQlL8EXv/hFvPzlLwcA3H777filX/olPPjggzhy5MjKfB977DGcd955+N//t3djsX0o5J0QPuu4TAjL5lPDU3ZPlVhVyRX+e2691fGn7CsyENK17thavSo6tDAHHUalARtOpSOiO1aPSRQG/U4FCxtQjKbz1YBUuHFdPpXW1FGg6ZREKWM8srUoc+ojFOqq3HnIbCr3rdjvJG0XrtmF8Cz9Lw30mH5kGwUz0f1WtaHtrxZI5Lqqrzn/SfKojdIm/hyCOBWGgPHEk/h//9f/hUcffRTnnntuN+jJfje0kPvuuw/Hjh3DVVddldzOO+88HD16FHfeeScA4M4778Thw4cT+ADAVVddBecc7rrrrvUz3YNhuFrXMgUiq1jJXuI04neZAlCwhIL1qDdiAT4eme3ImzW9hbNalBiKDGofjjxNbEl9/jirVDH9mEebyfjyt/UHpHQSO2yxIV3/FeBzSiQBfMmERAXDGOqV1Vmf29WzUWv1M0AK12RDOgybfHV/6F3batjtFw3wYQN8MCDY/WuoagULsnamCTmlRuhjx44BAC644ILC/YILLkh+x44dw7Of/eyyEIsFnvGMZ6QwVo4fP47jx4+n+8ceeyxcdN+uyI2qj+hgTm+W5kppLXMacI2+v3LdBNCtT2vdjqbiFfiwAh4dxrfYkAIDmEHfKpc+IY+o2AxadvrVFe7mNQd8TFvNPQS9Epms0HUSEAKAUdiQAiY2n/yBT0w7rT+NFySHm0VWUxik4/Yf+bR2MVOm+rCeMQv30EuPkByR4/QmU6p4DZmziHFVmDNqFuzWW2/F+973vtUBOT7cHsgARUebtOyfanCx+c9NwwysFvCk6zk7yi0DAWogaKhHqgLhx6FoyyId5daVHsA1Z8Da4NMEHdu+xabjOIVOBnB0OloniC8sAR2kvsXp089h9zyHtUGipgHA0oMGte+MkLduEMJHEQUNpIiOE1ClOMVvPN9Hz+frPwAymxZzik7l11xl/ZGKUjaZbgIbSKVR+O9RTqkKduGFFwIAHnroocL9oYceSn4XXnghvv3tbxf+y+US3/3ud1MYKzfffDMeffTR9PfAAw+UAVqzYbYfWrpq36C8+q8XtpKe2qFtFa00VswWadquWU9Si1gZR73M4mg1TFSj3GbUUpfE36pfRhVL+Sojd6GGyd9Ue6j82jNgK8Cn077NZyHxpp6NeQYYffiLdaFxBHmfPw80jmEmbBn9l3mWsDT6wxj1kWfJRC3Ts2XMhbrWmzVLExOxb5QTFbm/FGoerL+0lfrV4Yr2LG/Xevk25JQC0POf/3xceOGFuOOOO5LbY489hrvuugtXXnklAODKK6/EI488grvvvjuF+eQnPwnvPY4ePdpMd2dnB+eee27xl2SODaC15kTiTnVeI03AmQAZG28V4NiwIX0UHSmxHulYxYyNdjfg0wOeCdBZCRwxnS4wTdmKoPyBOk9pnx742LZeVVYJI/F1vDlpCBDJ37IEIgEfO9Oo70Ul6wIRi+0I5ddhBUAas2YpjSbw5D7UBSG046a+h1afL2+7M8szZG0V7IknnsC9996b7u+77z7867/+K57xjGfgkksuwW/+5m/id37nd/DCF74Qz3/+8/Hud78bR44cSTNlL37xi3HNNdfgLW95Cz70oQ9hd3cXN954I974xjfOmgGbI1r/balhXfo4BUJzZnbQeFhappYFFOXQ/ly5r5zlaqlcLbuKpAHjB9TXUyLh7JnBeiancTwDtfKaCz7rlM+GJWqrY6viqfjJb3DFF1jTyYrqwTIQDjXzKL/Aar9lxwAI2UY0hnv52F/QvPqLGSXHpG4xjOplPqhowqaFlOq+ci8q1W+2ubI2AH3pS1/C//yf/zPd33TTTQCAG264Abfddht+67d+C9/73vfw1re+FY888ghe+cpX4vbbb8ehQ4dSnL/6q7/CjTfeiFe/+tVwzuHaa6/F+9///rULv5L+6UYSY+NE/El9ttNJV5ZhDuhUbxRbMOOutkokhhPDUeWmwMe4FWm2BvXahl3TxgqEuk3bAqF1wWcuEGng0CDUC27rb0AsfWnDufQp6PqbYzEflX2y80RQgdNuKGxEFRAJ3CTwEZwQaFFuGoQkXyg35S/xYOKebhA6qXVA+yWyDuj/+Ln/G8PWofxkHcw6IH3dSGimpX6WTAzWVSwnhGmDTuFngSdeVzNd2j4ytbgvxW+ATlWeGd2k2uQoz4X6YWy6Vr2aAp9W3Ja08re/vTL1rtUK67wGyAGDAzsHLFxYBzQEcJK1QWmtkFm3JuuKAKR1QPWqZUpAJO5T64hqNxuOVDoqLzTSU372urUuadx9Ev/f/7N6HdCBmAVbKYbuZ8TOG1SbM157mbqVLyR0pMuIVgGOCVP49zaHtsBH+7U2dHZVsRWDu1FeyxCqqVd5Jl5d2wGv43QYRwU+tswTZQQQbDQpX87T7lNqdY8JanUzAgrBxQ2q4UEFFSswIBCXREFnXaynif2KhIGo5SOp7aK/z8BDCCyOSLvF+Alw1LfLFAjpT3un+IBKw1xL5aQp7CNVoDV34/aZAUCrxFDFVWrTpCrWmhafytfI6tm6mcAT4+oVzZXBucjHuNmBvEK16RpuddlHW5n4RtcDXg98GXQTTLTKtweYE+WqRNpBLyUo/GekzVEfGVwwQMfRndQYIjBx+vBh0mYI+WurnkCOy/6ZfqWtgASaitkkG1NKFGmtUgK0BG4N93hfAg2XQNMCpKKM+Tepc2c7ACUDtGZBaXWYDjiVxkkU4GRBB5gFPEU8zXxsuibtmhF12IWEbwHPlBHYsgqiAExx/Qxb9mHX4Vh1sVWuKbbmTc93rg6TwtZOK9MsGFD4tE9iQ86V5R8ZRAwekUHIRXYUBz0zIkOJ6Sr1qgABay+KZajWFElcvaaoABUu4hd5AXXYwo1yRaqwSH5MnbZtyIEHoOZiQxEFQoCimOK3pwznxV2lYjXDWIaCNcFHsZ9qhqnp1gafyWlq/dtURZWbXWEMZKYwY0/ZpBG4KksHJCwgARmUqqI3QEe5aXMpSRhJy4f/Ag5Q+OYYEdh7kHMBP7wCodiRCLmNmJBWlhcqmmRYsCIUxut1WFFmPcYvVUzcYNxy3kzZEJ4YXGRC3fVxDTmQACQdYbkM2zMKPVleeLpTT7Adu1zdgsI6H107adAB1gIeQFVN7EF6dqtQWVpu6p65PRVflMHEa4UtKkvlr974SWEVcWISRT1UeXpllrANdUn6B/WenV4SIGWaSKdkaNLAeearYECOAB7AwwCwA8ZgjMYYZsQwhPpzzLvbT0V9lb7dmWCpNlzDbH7VhmZrvFZ59jbDWkN4im/KbI/78MsnyzbsyIGcBXvwwQdx8cUX73cxNrKRjayQBx54AM997nO7/gcSgLz3uOeee/CSl7wEDzzwwOQ035kkjz32GC6++OJNnc9wORPqzMx4/PHHceTIEbieyosDqoI55/Cc5zwHAOqtGWeBbOp8dshBr/N55523Mswp3Qu2kY1sZCPryAaANrKRjeybHFgA2tnZwS233IKdnZ39LspTJps6nx1yNtX5QBqhN7KRjZwZcmAZ0EY2spGDLxsA2shGNrJvsgGgjWxkI/smGwDayEY2sm9yIAHoAx/4AJ73vOfh0KFDOHr0KL7whS/sd5FOmbz3ve8FERV/l112WfJ/8skn8ba3vQ3PfOYz8fSnPx3XXntt9RGAH3b5ofq891Moq+r9q7/6q9Wzv+aaa4owB7HeU3LgAOgjH/kIbrrpJtxyyy348pe/jMsvvxxXX3119aWNgywvfelL8a1vfSv9ffazn01+73jHO/D3f//3+NjHPoZPf/rT+OY3v4nXv/71+1ja9eWH9vPep1lW1RsArrnmmuLZf/jDHy78D2K9J4UPmLziFa/gt73tbel+HEc+cuQI33rrrftYqlMnt9xyC19++eVNv0ceeYS3trb4Yx/7WHL72te+xgD4zjvvfIpKeGoFAH/84x9P9957vvDCC/kP/uAPktsjjzzCOzs7/OEPf5iZmb/61a8yAP7iF7+YwvzTP/0TExH/13/911NW9pMRW29m5htuuIFf97rXdeOcCfW2cqAY0IkTJ3D33XcXn352zuGqq65Kn34+E+TrX/86jhw5ghe84AW4/vrrcf/99wMA7r77buzu7hb1v+yyy3DJJZecMfXfl897/xDJpz71KTz72c/GT/zET+DXf/3X8fDDDye/M7HeBwqAvvOd72Acx8lPPx90OXr0KG677Tbcfvvt+OAHP4j77rsPr3rVq/D444/j2LFj2N7exuHDh4s4Z1L9T9fnvQ+CXHPNNfjLv/xL3HHHHfi93/s9fPrTn8ZrXvMajGM4pexMrPeB3A1/JstrXvOadP2yl70MR48exaWXXoqPfvSjOOecc/axZBs53fLGN74xXf/kT/4kXvayl+HHf/zH8alPfQqvfvWr97Fkp08OFAM6//zzMQzD5KefzzQ5fPgwXvSiF+Hee+/FhRdeiBMnTuCRRx4pwpxJ9T9dn/c+iPKCF7wA559/fvoQ6JlY7wMFQNvb27jiiiuKTz9773HHHXekTz+fafLEE0/gG9/4Bi666CJcccUV2NraKup/zz334P777z9j6n+6Pu99EOXBBx/Eww8/jIsuugjAGVrv/baCryt/8zd/wzs7O3zbbbfxV7/6VX7rW9/Khw8f5mPHju130U6JvPOd7+RPfepTfN999/HnPvc5vuqqq/j888/nb3/728zM/Gu/9mt8ySWX8Cc/+Un+0pe+xFdeeSVfeeWV+1zq9eTxxx/nr3zlK/yVr3yFAfAf/uEf8le+8hX+z//8T2Zm/t3f/V0+fPgw/93f/R3/27/9G7/uda/j5z//+fyDH/wgpXHNNdfwT//0T/Ndd93Fn/3sZ/mFL3whX3fddftVpVkyVe/HH3+c3/Wud/Gdd97J9913H3/iE5/gn/mZn+EXvvCF/OSTT6Y0DmK9p+TAARAz85/8yZ/wJZdcwtvb2/yKV7yCP//5z+93kU6ZvOENb+CLLrqIt7e3+TnPeQ6/4Q1v4HvvvTf5/+AHP+Df+I3f4B/7sR/jpz3tafwrv/Ir/K1vfWsfS7y+/Mu//AsjnGte/N1www3MHKbi3/3ud/MFF1zAOzs7/OpXv5rvueeeIo2HH36Yr7vuOn7605/O5557Lr/pTW/ixx9/fB9qM1+m6v3973+ff/EXf5Gf9axn8dbWFl966aX8lre8pXqxHsR6T8nmOI6NbGQj+yYHyga0kY1s5MySDQBtZCMb2TfZANBGNrKRfZMNAG1kIxvZN9kA0EY2spF9kw0AbWQjG9k32QDQRjaykX2TDQBtZCMb2TfZANBGNrKRfZMNAG1kIxvZN9kA0EY2spF9kw0AbWQjG9k3+f8BZxb6GXUilz4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(3, 2))\n", + "plt.imshow(data[:,:,5])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a6fe3d2d-5c16-4b5a-bdac-9551e86923a1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(3, 2))\n", + "plt.imshow(data[:,:,6])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "767d6d7b-a447-4a6f-b29b-998f5e1902bd", + "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 +} diff --git a/torch_GAN_1d_baseline.ipynb b/torch_GAN_1d_baseline.ipynb new file mode 100644 index 0000000..207e50b --- /dev/null +++ b/torch_GAN_1d_baseline.ipynb @@ -0,0 +1,1010 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "8252a3af-edbb-4dcf-967c-fe206e98ceab", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader, Dataset\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "os.environ[\"CUDA_VISIBLE_DEVICE\"] = \"0\" " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8f8c3fd5-f70f-45d0-886a-c572895ffcee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n" + ] + } + ], + "source": [ + "# 设置CUDA设备\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(f\"Using device: {device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d15a7732-b516-4054-905f-0e7d57e4a38e", + "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 = 107.49169921875\n", + "\n", + "print(f\"Maximum pixel value in the dataset: {max_pixel_value}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bc01ab26-2bd1-4adb-9d6d-5080e32ac1b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(42)\n", + "torch.random.manual_seed(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "69ac2ad4-0e7c-42b8-b4cf-1149b447c3e4", + "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, 8)\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 = np.concatenate([masked_image[:, :, :1], image[:, :, 1:]], axis=-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)) # 转换为 (8, 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/20/'\n", + "\n", + "print(f\"checkpoint before Generator is OK\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "305f2522-bcb0-46b1-8cb1-ebb5a821db7b", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = NO2Dataset(image_dir, mask_dir)\n", + "dataloader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=8)\n", + "\n", + "# 生成器模型\n", + "class Generator(nn.Module):\n", + " \n", + " def __init__(self):\n", + " super(Generator, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Conv2d(1, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(128),\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.ReLU(inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.ConvTranspose2d(64, 1, kernel_size=4, stride=2, padding=1),\n", + " nn.Tanh(),\n", + " )\n", + "\n", + " def forward(self, x, mask):\n", + " x_encoded = self.encoder(x)\n", + " x_decoded = self.decoder(x_encoded)\n", + "\n", + " x_decoded = (x_decoded + 1) / 2\n", + "\n", + " x_output = (1 - mask) * x_decoded + mask * x[:, :1, :, :]\n", + " return x_output\n", + "\n", + "# 判别器模型\n", + "class Discriminator(nn.Module):\n", + " \n", + " def __init__(self):\n", + " super(Discriminator, self).__init__()\n", + " self.model = nn.Sequential(\n", + " nn.Conv2d(2, 64, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(64),\n", + " nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " nn.BatchNorm2d(128),\n", + " nn.Conv2d(128, 1, kernel_size=4, stride=2, padding=1),\n", + " nn.Sigmoid(),\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.model(x)\n", + "\n", + "# 将模型加载到GPU\n", + "generator = Generator().to(device)\n", + "discriminator = Discriminator().to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "881b9b78-4e03-406c-8af3-d9a749350508", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generator is on: cuda:0\n", + "Discriminator is on: cuda:0\n" + ] + } + ], + "source": [ + "# 定义优化器和损失函数\n", + "optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n", + "optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n", + "adversarial_loss = nn.BCELoss().to(device)\n", + "pixelwise_loss = nn.MSELoss().to(device)\n", + "\n", + "# 确认模型是否在GPU上\n", + "print(f\"Generator is on: {next(generator.parameters()).device}\")\n", + "print(f\"Discriminator is on: {next(discriminator.parameters()).device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b85fcbe7-ed61-40a7-8259-19f2fa71b056", + "metadata": {}, + "outputs": [], + "source": [ + "gen = torch.load('./models/GAN/generator.pth', map_location='cpu')\n", + "generator.load_state_dict(gen)\n", + "generator = generator.to('cpu')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "55a55f48-77ff-4ef7-9b79-9e98798d7c4d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dis = torch.load('./models/GAN/discriminator.pth', map_location='cpu')\n", + "discriminator.load_state_dict(dis)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d15f91ca-1bb1-464c-a937-8bdd13c6a1ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at /opt/conda/conda-bld/pytorch_1711403590347/work/aten/src/ATen/native/cudnn/Conv_v8.cpp:80.)\n", + " return F.conv2d(input, weight, bias, self.stride,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [0/300] [D loss: 0.5392551422119141] [G loss: 0.9313964247703552]\n", + "Epoch [1/300] [D loss: 0.45492202043533325] [G loss: 1.5053317546844482]\n", + "Epoch [2/300] [D loss: 0.3420121669769287] [G loss: 1.4923288822174072]\n", + "Epoch [3/300] [D loss: 0.2960708737373352] [G loss: 1.955796480178833]\n", + "Epoch [4/300] [D loss: 0.40790891647338867] [G loss: 2.071624279022217]\n", + "Epoch [5/300] [D loss: 0.2747359275817871] [G loss: 1.917580485343933]\n", + "Epoch [6/300] [D loss: 0.47008591890335083] [G loss: 1.5003858804702759]\n", + "Epoch [7/300] [D loss: 0.19478999078273773] [G loss: 3.949864149093628]\n", + "Epoch [8/300] [D loss: 0.5340784192085266] [G loss: 0.8913870453834534]\n", + "Epoch [9/300] [D loss: 0.3194230794906616] [G loss: 1.861933946609497]\n", + "Epoch [10/300] [D loss: 0.22022968530654907] [G loss: 1.6654534339904785]\n", + "Epoch [11/300] [D loss: 0.3743482828140259] [G loss: 1.626413106918335]\n", + "Epoch [12/300] [D loss: 0.13774043321609497] [G loss: 3.187469482421875]\n", + "Epoch [13/300] [D loss: 0.4275822043418884] [G loss: 2.2269718647003174]\n", + "Epoch [14/300] [D loss: 0.22367843985557556] [G loss: 2.707667827606201]\n", + "Epoch [15/300] [D loss: 0.25350409746170044] [G loss: 1.6780041456222534]\n", + "Epoch [16/300] [D loss: 0.23647311329841614] [G loss: 1.6349072456359863]\n", + "Epoch [17/300] [D loss: 0.5604373812675476] [G loss: 2.025310754776001]\n", + "Epoch [18/300] [D loss: 0.4707084596157074] [G loss: 2.938746452331543]\n", + "Epoch [19/300] [D loss: 0.2135343998670578] [G loss: 1.438072919845581]\n", + "Epoch [20/300] [D loss: 0.08090662956237793] [G loss: 2.77827787399292]\n", + "Epoch [21/300] [D loss: 0.2995302677154541] [G loss: 2.239123821258545]\n", + "Epoch [22/300] [D loss: 0.45718979835510254] [G loss: 3.404195547103882]\n", + "Epoch [23/300] [D loss: 0.13950982689857483] [G loss: 2.7335846424102783]\n", + "Epoch [24/300] [D loss: 0.1814766675233841] [G loss: 2.7603776454925537]\n", + "Epoch [25/300] [D loss: 0.0551619790494442] [G loss: 4.066004276275635]\n", + "Epoch [26/300] [D loss: 0.1498052179813385] [G loss: 2.733922243118286]\n", + "Epoch [27/300] [D loss: 0.11236032098531723] [G loss: 3.215831756591797]\n", + "Epoch [28/300] [D loss: 0.4945942461490631] [G loss: 1.9661915302276611]\n", + "Epoch [29/300] [D loss: 0.0760776624083519] [G loss: 2.7212204933166504]\n", + "Epoch [30/300] [D loss: 0.19911707937717438] [G loss: 1.5356297492980957]\n", + "Epoch [31/300] [D loss: 0.0900304988026619] [G loss: 2.84740948677063]\n", + "Epoch [32/300] [D loss: 0.05910511314868927] [G loss: 4.071162223815918]\n", + "Epoch [33/300] [D loss: 0.0711229220032692] [G loss: 2.716848373413086]\n", + "Epoch [34/300] [D loss: 0.39897823333740234] [G loss: 1.5674937963485718]\n", + "Epoch [35/300] [D loss: 0.05552360787987709] [G loss: 3.754516124725342]\n", + "Epoch [36/300] [D loss: 0.5413599014282227] [G loss: 4.129798889160156]\n", + "Epoch [37/300] [D loss: 0.17664434015750885] [G loss: 4.226540565490723]\n", + "Epoch [38/300] [D loss: 0.15215317904949188] [G loss: 2.6023881435394287]\n", + "Epoch [39/300] [D loss: 0.07798739522695541] [G loss: 4.075980186462402]\n", + "Epoch [40/300] [D loss: 0.03936776518821716] [G loss: 4.37988805770874]\n", + "Epoch [41/300] [D loss: 0.2012120634317398] [G loss: 2.1987271308898926]\n", + "Epoch [42/300] [D loss: 0.05274203419685364] [G loss: 3.8458642959594727]\n", + "Epoch [43/300] [D loss: 0.13967157900333405] [G loss: 3.438344955444336]\n", + "Epoch [44/300] [D loss: 0.05800560116767883] [G loss: 2.941135883331299]\n", + "Epoch [45/300] [D loss: 0.14671097695827484] [G loss: 3.388277292251587]\n", + "Epoch [46/300] [D loss: 0.06439051032066345] [G loss: 2.9789438247680664]\n", + "Epoch [47/300] [D loss: 0.11101078987121582] [G loss: 2.6266937255859375]\n", + "Epoch [48/300] [D loss: 0.028554894030094147] [G loss: 4.042592525482178]\n", + "Epoch [49/300] [D loss: 0.3364626169204712] [G loss: 3.419842004776001]\n", + "Epoch [50/300] [D loss: 0.2501979470252991] [G loss: 3.319307804107666]\n", + "Epoch [51/300] [D loss: 0.2962917387485504] [G loss: 5.088353157043457]\n", + "Epoch [52/300] [D loss: 0.07700179517269135] [G loss: 3.231515884399414]\n", + "Epoch [53/300] [D loss: 0.4093267321586609] [G loss: 1.918235182762146]\n", + "Epoch [54/300] [D loss: 0.12105419486761093] [G loss: 2.3409922122955322]\n", + "Epoch [55/300] [D loss: 0.057456158101558685] [G loss: 4.047771453857422]\n", + "Epoch [56/300] [D loss: 0.250449538230896] [G loss: 1.9442336559295654]\n", + "Epoch [57/300] [D loss: 0.08125491440296173] [G loss: 2.7323458194732666]\n", + "Epoch [58/300] [D loss: 0.06671395897865295] [G loss: 3.081458330154419]\n", + "Epoch [59/300] [D loss: 0.06982511281967163] [G loss: 3.95278000831604]\n", + "Epoch [60/300] [D loss: 0.08973922580480576] [G loss: 3.9550158977508545]\n", + "Epoch [61/300] [D loss: 0.29226893186569214] [G loss: 2.2824535369873047]\n", + "Epoch [62/300] [D loss: 0.06800767779350281] [G loss: 4.67025089263916]\n", + "Epoch [63/300] [D loss: 0.017987174913287163] [G loss: 4.119121551513672]\n", + "Epoch [64/300] [D loss: 0.1278763711452484] [G loss: 4.481695652008057]\n", + "Epoch [65/300] [D loss: 0.12277506291866302] [G loss: 2.0188961029052734]\n", + "Epoch [66/300] [D loss: 0.10042040050029755] [G loss: 4.019499778747559]\n", + "Epoch [67/300] [D loss: 0.15092261135578156] [G loss: 3.0588033199310303]\n", + "Epoch [68/300] [D loss: 0.157196044921875] [G loss: 4.579256534576416]\n", + "Epoch [69/300] [D loss: 0.0256386436522007] [G loss: 4.309335708618164]\n", + "Epoch [70/300] [D loss: 0.011956267058849335] [G loss: 4.763312816619873]\n", + "Epoch [71/300] [D loss: 0.08460590243339539] [G loss: 5.456184387207031]\n", + "Epoch [72/300] [D loss: 0.07495025545358658] [G loss: 3.5078511238098145]\n", + "Epoch [73/300] [D loss: 0.13037167489528656] [G loss: 3.164292812347412]\n", + "Epoch [74/300] [D loss: 0.0830327719449997] [G loss: 5.159647464752197]\n", + "Epoch [75/300] [D loss: 0.4353921115398407] [G loss: 5.0652875900268555]\n", + "Epoch [76/300] [D loss: 0.02432486228644848] [G loss: 3.7066524028778076]\n", + "Epoch [77/300] [D loss: 0.2809848189353943] [G loss: 1.1604290008544922]\n", + "Epoch [78/300] [D loss: 0.7653636932373047] [G loss: 2.5745716094970703]\n", + "Epoch [79/300] [D loss: 0.041840165853500366] [G loss: 4.082228660583496]\n", + "Epoch [80/300] [D loss: 0.03992146998643875] [G loss: 4.9236321449279785]\n", + "Epoch [81/300] [D loss: 0.1003192886710167] [G loss: 2.683060646057129]\n", + "Epoch [82/300] [D loss: 0.1460535228252411] [G loss: 4.597597122192383]\n", + "Epoch [83/300] [D loss: 0.1408858597278595] [G loss: 1.8829160928726196]\n", + "Epoch [84/300] [D loss: 0.048089221119880676] [G loss: 3.1438090801239014]\n", + "Epoch [85/300] [D loss: 0.041934601962566376] [G loss: 3.298645257949829]\n", + "Epoch [86/300] [D loss: 0.1363355964422226] [G loss: 2.6124517917633057]\n", + "Epoch [87/300] [D loss: 0.03299988433718681] [G loss: 3.3402161598205566]\n", + "Epoch [88/300] [D loss: 0.22786922752857208] [G loss: 3.9778051376342773]\n", + "Epoch [89/300] [D loss: 0.021804900839924812] [G loss: 4.595890045166016]\n", + "Epoch [90/300] [D loss: 0.022495444864034653] [G loss: 4.2465901374816895]\n", + "Epoch [91/300] [D loss: 0.02908019907772541] [G loss: 6.379057884216309]\n", + "Epoch [92/300] [D loss: 0.6523040533065796] [G loss: 0.6009750962257385]\n", + "Epoch [93/300] [D loss: 0.007557982578873634] [G loss: 5.837783336639404]\n", + "Epoch [94/300] [D loss: 0.020063551142811775] [G loss: 4.044745445251465]\n", + "Epoch [95/300] [D loss: 0.003706925082951784] [G loss: 8.243224143981934]\n", + "Epoch [96/300] [D loss: 0.021942533552646637] [G loss: 4.662309169769287]\n", + "Epoch [97/300] [D loss: 0.005410192534327507] [G loss: 5.5743536949157715]\n", + "Epoch [98/300] [D loss: 0.07137680053710938] [G loss: 3.261455535888672]\n", + "Epoch [99/300] [D loss: 0.11327817291021347] [G loss: 3.817570686340332]\n", + "Epoch [100/300] [D loss: 0.04488084092736244] [G loss: 4.458094596862793]\n", + "Epoch [101/300] [D loss: 0.05757671222090721] [G loss: 3.695896625518799]\n", + "Epoch [102/300] [D loss: 0.04083157703280449] [G loss: 3.704172134399414]\n", + "Epoch [103/300] [D loss: 0.02816752716898918] [G loss: 4.322700023651123]\n", + "Epoch [104/300] [D loss: 0.026689285412430763] [G loss: 4.115890979766846]\n", + "Epoch [105/300] [D loss: 0.03571446239948273] [G loss: 4.080765724182129]\n", + "Epoch [106/300] [D loss: 0.020453810691833496] [G loss: 5.457651615142822]\n", + "Epoch [107/300] [D loss: 0.03774755448102951] [G loss: 5.34019136428833]\n", + "Epoch [108/300] [D loss: 0.0933525487780571] [G loss: 5.5797905921936035]\n", + "Epoch [109/300] [D loss: 0.024301748722791672] [G loss: 4.042290210723877]\n", + "Epoch [110/300] [D loss: 0.9034162759780884] [G loss: 5.52556848526001]\n", + "Epoch [111/300] [D loss: 0.0911281406879425] [G loss: 6.487083911895752]\n", + "Epoch [112/300] [D loss: 0.13892149925231934] [G loss: 3.0797510147094727]\n", + "Epoch [113/300] [D loss: 0.09627098590135574] [G loss: 3.104957103729248]\n", + "Epoch [114/300] [D loss: 0.007696065586060286] [G loss: 6.618851184844971]\n", + "Epoch [115/300] [D loss: 0.06528083980083466] [G loss: 3.4506514072418213]\n", + "Epoch [116/300] [D loss: 0.03879600390791893] [G loss: 3.3708789348602295]\n", + "Epoch [117/300] [D loss: 0.03395622968673706] [G loss: 6.2684736251831055]\n", + "Epoch [118/300] [D loss: 0.010569067671895027] [G loss: 5.944631099700928]\n", + "Epoch [119/300] [D loss: 0.024817001074552536] [G loss: 6.614266872406006]\n", + "Epoch [120/300] [D loss: 0.013173197396099567] [G loss: 6.226423263549805]\n", + "Epoch [121/300] [D loss: 0.06546411663293839] [G loss: 3.0585291385650635]\n", + "Epoch [122/300] [D loss: 0.01085597462952137] [G loss: 6.437295913696289]\n", + "Epoch [123/300] [D loss: 0.03522876650094986] [G loss: 4.0734052658081055]\n", + "Epoch [124/300] [D loss: 0.06875205039978027] [G loss: 4.0921711921691895]\n", + "Epoch [125/300] [D loss: 0.006707158405333757] [G loss: 5.244316577911377]\n", + "Epoch [126/300] [D loss: 0.03866109997034073] [G loss: 3.368199110031128]\n", + "Epoch [127/300] [D loss: 0.041117191314697266] [G loss: 4.484440326690674]\n", + "Epoch [128/300] [D loss: 0.0829429179430008] [G loss: 4.554262638092041]\n", + "Epoch [129/300] [D loss: 0.03219084441661835] [G loss: 5.4280924797058105]\n", + "Epoch [130/300] [D loss: 0.11037464439868927] [G loss: 5.89276647567749]\n", + "Epoch [131/300] [D loss: 0.029911085963249207] [G loss: 4.116299629211426]\n", + "Epoch [132/300] [D loss: 0.14276768267154694] [G loss: 2.059661626815796]\n", + "Epoch [133/300] [D loss: 0.06751281768083572] [G loss: 4.1591362953186035]\n", + "Epoch [134/300] [D loss: 0.06710615009069443] [G loss: 3.1725471019744873]\n", + "Epoch [135/300] [D loss: 0.015449777245521545] [G loss: 5.900448799133301]\n", + "Epoch [136/300] [D loss: 0.0017297605518251657] [G loss: 6.8876633644104]\n", + "Epoch [137/300] [D loss: 0.10661254078149796] [G loss: 3.035740613937378]\n", + "Epoch [138/300] [D loss: 0.04841696843504906] [G loss: 3.2598555088043213]\n", + "Epoch [139/300] [D loss: 0.13029193878173828] [G loss: 3.732114791870117]\n", + "Epoch [140/300] [D loss: 0.01422959566116333] [G loss: 4.98042106628418]\n", + "Epoch [141/300] [D loss: 0.15487617254257202] [G loss: 5.367415428161621]\n", + "Epoch [142/300] [D loss: 0.07540086656808853] [G loss: 4.3357768058776855]\n", + "Epoch [143/300] [D loss: 0.014456328004598618] [G loss: 4.569247245788574]\n", + "Epoch [144/300] [D loss: 0.012367785908281803] [G loss: 5.9672956466674805]\n", + "Epoch [145/300] [D loss: 0.05262265354394913] [G loss: 5.160377502441406]\n", + "Epoch [146/300] [D loss: 0.08042960613965988] [G loss: 3.7927441596984863]\n", + "Epoch [147/300] [D loss: 0.19245359301567078] [G loss: 3.8005473613739014]\n", + "Epoch [148/300] [D loss: 0.052174512296915054] [G loss: 5.132132053375244]\n", + "Epoch [149/300] [D loss: 0.4083835482597351] [G loss: 3.095195770263672]\n", + "Epoch [150/300] [D loss: 0.007787104230374098] [G loss: 7.455079078674316]\n", + "Epoch [151/300] [D loss: 0.011952079832553864] [G loss: 5.102141857147217]\n", + "Epoch [152/300] [D loss: 0.1612093597650528] [G loss: 3.7608675956726074]\n", + "Epoch [153/300] [D loss: 0.03018610179424286] [G loss: 3.8288230895996094]\n", + "Epoch [154/300] [D loss: 0.06719933450222015] [G loss: 4.006799697875977]\n", + "Epoch [155/300] [D loss: 0.0286514051258564] [G loss: 4.619848728179932]\n", + "Epoch [156/300] [D loss: 0.024552451446652412] [G loss: 4.437436580657959]\n", + "Epoch [157/300] [D loss: 0.011825334280729294] [G loss: 4.815029144287109]\n", + "Epoch [158/300] [D loss: 0.061660464853048325] [G loss: 7.883100509643555]\n", + "Epoch [159/300] [D loss: 0.041454415768384933] [G loss: 6.650402545928955]\n", + "Epoch [160/300] [D loss: 0.39040958881378174] [G loss: 8.09695053100586]\n", + "Epoch [161/300] [D loss: 0.0026854330208152533] [G loss: 8.107271194458008]\n", + "Epoch [162/300] [D loss: 0.16259369254112244] [G loss: 5.87791109085083]\n", + "Epoch [163/300] [D loss: 0.03663758188486099] [G loss: 4.121287822723389]\n", + "Epoch [164/300] [D loss: 0.009695476852357388] [G loss: 8.566814422607422]\n", + "Epoch [165/300] [D loss: 0.010842864401638508] [G loss: 7.692420959472656]\n", + "Epoch [166/300] [D loss: 0.010091769509017467] [G loss: 5.9158101081848145]\n", + "Epoch [167/300] [D loss: 0.005709683522582054] [G loss: 5.492888450622559]\n", + "Epoch [168/300] [D loss: 0.16688843071460724] [G loss: 3.3484747409820557]\n", + "Epoch [169/300] [D loss: 0.007227647118270397] [G loss: 6.33713960647583]\n", + "Epoch [170/300] [D loss: 0.007962928153574467] [G loss: 7.612416744232178]\n", + "Epoch [171/300] [D loss: 0.012646579183638096] [G loss: 4.420655250549316]\n", + "Epoch [172/300] [D loss: 0.01767764426767826] [G loss: 4.4174957275390625]\n", + "Epoch [173/300] [D loss: 0.006378074176609516] [G loss: 7.643772125244141]\n", + "Epoch [174/300] [D loss: 0.009910110384225845] [G loss: 5.333507061004639]\n", + "Epoch [175/300] [D loss: 0.004518002271652222] [G loss: 6.36816930770874]\n", + "Epoch [176/300] [D loss: 0.08845338225364685] [G loss: 4.761691570281982]\n", + "Epoch [177/300] [D loss: 0.038503680378198624] [G loss: 3.653679370880127]\n", + "Epoch [178/300] [D loss: 0.0021649880800396204] [G loss: 6.513932704925537]\n", + "Epoch [179/300] [D loss: 0.0054839057847857475] [G loss: 5.804437637329102]\n", + "Epoch [180/300] [D loss: 0.005088070873171091] [G loss: 5.903375148773193]\n", + "Epoch [181/300] [D loss: 0.024380924180150032] [G loss: 6.934257984161377]\n", + "Epoch [182/300] [D loss: 0.003647219855338335] [G loss: 9.193355560302734]\n", + "Epoch [183/300] [D loss: 0.8360736966133118] [G loss: 8.123100280761719]\n", + "Epoch [184/300] [D loss: 0.014819988049566746] [G loss: 4.3469648361206055]\n", + "Epoch [185/300] [D loss: 0.009622478857636452] [G loss: 5.201544761657715]\n", + "Epoch [186/300] [D loss: 0.023895107209682465] [G loss: 3.903581380844116]\n", + "Epoch [187/300] [D loss: 0.013679596595466137] [G loss: 8.605210304260254]\n", + "Epoch [188/300] [D loss: 0.0036324947141110897] [G loss: 6.411885738372803]\n", + "Epoch [189/300] [D loss: 0.006745172664523125] [G loss: 5.29392147064209]\n", + "Epoch [190/300] [D loss: 0.0007813140982761979] [G loss: 8.193427085876465]\n", + "Epoch [191/300] [D loss: 0.021813858300447464] [G loss: 4.648034572601318]\n", + "Epoch [192/300] [D loss: 0.025777161121368408] [G loss: 4.67152738571167]\n", + "Epoch [193/300] [D loss: 0.06395631283521652] [G loss: 7.985042095184326]\n", + "Epoch [194/300] [D loss: 0.034654516726732254] [G loss: 3.360792398452759]\n", + "Epoch [195/300] [D loss: 0.26737672090530396] [G loss: 6.765297889709473]\n", + "Epoch [196/300] [D loss: 0.010468905791640282] [G loss: 5.34564208984375]\n", + "Epoch [197/300] [D loss: 0.014369252137839794] [G loss: 5.097072124481201]\n", + "Epoch [198/300] [D loss: 0.003273996990174055] [G loss: 6.472024440765381]\n", + "Epoch [199/300] [D loss: 0.005874062888324261] [G loss: 8.4591646194458]\n", + "Epoch [200/300] [D loss: 0.005507076624780893] [G loss: 5.7223286628723145]\n", + "Epoch [201/300] [D loss: 0.16853176057338715] [G loss: 1.9387050867080688]\n", + "Epoch [202/300] [D loss: 0.0023364669177681208] [G loss: 8.370942115783691]\n", + "Epoch [203/300] [D loss: 0.003936069551855326] [G loss: 7.522141933441162]\n", + "Epoch [204/300] [D loss: 0.01826675795018673] [G loss: 4.6409101486206055]\n", + "Epoch [205/300] [D loss: 0.018070252612233162] [G loss: 6.2785234451293945]\n", + "Epoch [206/300] [D loss: 0.06540463864803314] [G loss: 4.250749111175537]\n", + "Epoch [207/300] [D loss: 0.005754987709224224] [G loss: 5.474653720855713]\n", + "Epoch [208/300] [D loss: 0.0024513285607099533] [G loss: 6.821662425994873]\n", + "Epoch [209/300] [D loss: 0.005051593761891127] [G loss: 8.622801780700684]\n", + "Epoch [210/300] [D loss: 0.2648685872554779] [G loss: 1.4338374137878418]\n", + "Epoch [211/300] [D loss: 0.06582126766443253] [G loss: 4.042891502380371]\n", + "Epoch [212/300] [D loss: 0.033716216683387756] [G loss: 3.6866607666015625]\n", + "Epoch [213/300] [D loss: 0.008300993591547012] [G loss: 5.592546463012695]\n", + "Epoch [214/300] [D loss: 0.10640338063240051] [G loss: 3.440943479537964]\n", + "Epoch [215/300] [D loss: 0.018705546855926514] [G loss: 8.040839195251465]\n", + "Epoch [216/300] [D loss: 0.32254651188850403] [G loss: 1.023318886756897]\n", + "Epoch [217/300] [D loss: 0.006875279359519482] [G loss: 5.205789566040039]\n", + "Epoch [218/300] [D loss: 0.01632297970354557] [G loss: 6.327811241149902]\n", + "Epoch [219/300] [D loss: 0.020900549367070198] [G loss: 6.634525299072266]\n", + "Epoch [220/300] [D loss: 0.011139878071844578] [G loss: 7.300896644592285]\n", + "Epoch [221/300] [D loss: 0.01837160252034664] [G loss: 5.964895248413086]\n", + "Epoch [222/300] [D loss: 0.016974858939647675] [G loss: 4.413552284240723]\n", + "Epoch [223/300] [D loss: 0.3439306914806366] [G loss: 5.5219573974609375]\n", + "Epoch [224/300] [D loss: 0.047548823058605194] [G loss: 6.586645603179932]\n", + "Epoch [225/300] [D loss: 0.03183538839221001] [G loss: 4.398618221282959]\n", + "Epoch [226/300] [D loss: 0.0033374489285051823] [G loss: 7.412342071533203]\n", + "Epoch [227/300] [D loss: 0.018537862226366997] [G loss: 5.484577655792236]\n", + "Epoch [228/300] [D loss: 0.03582551330327988] [G loss: 3.6857614517211914]\n", + "Epoch [229/300] [D loss: 0.11226078867912292] [G loss: 2.819861888885498]\n", + "Epoch [230/300] [D loss: 0.002012553857639432] [G loss: 7.154722690582275]\n", + "Epoch [231/300] [D loss: 0.00868014432489872] [G loss: 8.001018524169922]\n", + "Epoch [232/300] [D loss: 0.0419110469520092] [G loss: 6.980061054229736]\n", + "Epoch [233/300] [D loss: 0.006477241404354572] [G loss: 5.782578945159912]\n", + "Epoch [234/300] [D loss: 0.0016205032588914037] [G loss: 10.428010940551758]\n", + "Epoch [235/300] [D loss: 0.02312217839062214] [G loss: 4.159178733825684]\n", + "Epoch [236/300] [D loss: 0.36001917719841003] [G loss: 2.4811325073242188]\n", + "Epoch [237/300] [D loss: 0.005733223166316748] [G loss: 5.611016750335693]\n", + "Epoch [238/300] [D loss: 0.008837449364364147] [G loss: 8.30731201171875]\n", + "Epoch [239/300] [D loss: 0.011222743429243565] [G loss: 4.619396209716797]\n", + "Epoch [240/300] [D loss: 0.0060098664835095406] [G loss: 6.022060394287109]\n", + "Epoch [241/300] [D loss: 0.0011382169323042035] [G loss: 7.404472351074219]\n", + "Epoch [242/300] [D loss: 0.3661719560623169] [G loss: 7.876453399658203]\n", + "Epoch [243/300] [D loss: 0.0019019388128072023] [G loss: 7.3895263671875]\n", + "Epoch [244/300] [D loss: 0.006632590666413307] [G loss: 5.541728973388672]\n", + "Epoch [245/300] [D loss: 0.008930223993957043] [G loss: 5.2114691734313965]\n", + "Epoch [246/300] [D loss: 0.016119416803121567] [G loss: 7.121890068054199]\n", + "Epoch [247/300] [D loss: 0.001622633310034871] [G loss: 7.303770065307617]\n", + "Epoch [248/300] [D loss: 0.005070182494819164] [G loss: 6.975015640258789]\n", + "Epoch [249/300] [D loss: 0.04641895741224289] [G loss: 7.218448638916016]\n", + "Epoch [250/300] [D loss: 0.01194002851843834] [G loss: 4.6930975914001465]\n", + "Epoch [251/300] [D loss: 0.012792033143341541] [G loss: 4.67077112197876]\n", + "Epoch [252/300] [D loss: 0.008810436353087425] [G loss: 5.938291072845459]\n", + "Epoch [253/300] [D loss: 0.010516034439206123] [G loss: 4.816621780395508]\n", + "Epoch [254/300] [D loss: 0.017264991998672485] [G loss: 8.856822967529297]\n", + "Epoch [255/300] [D loss: 0.011463891714811325] [G loss: 6.232043743133545]\n", + "Epoch [256/300] [D loss: 0.08137447386980057] [G loss: 2.598818778991699]\n", + "Epoch [257/300] [D loss: 0.032363615930080414] [G loss: 4.790830135345459]\n", + "Epoch [258/300] [D loss: 0.00863250344991684] [G loss: 7.292766571044922]\n", + "Epoch [259/300] [D loss: 0.027235930785536766] [G loss: 6.844869613647461]\n", + "Epoch [260/300] [D loss: 0.008849331177771091] [G loss: 5.027510643005371]\n", + "Epoch [261/300] [D loss: 0.020822376012802124] [G loss: 4.600456714630127]\n", + "Epoch [262/300] [D loss: 1.7667120695114136] [G loss: 3.4651100635528564]\n", + "Epoch [263/300] [D loss: 0.022669170051813126] [G loss: 5.7553019523620605]\n", + "Epoch [264/300] [D loss: 0.01582598127424717] [G loss: 4.149420261383057]\n", + "Epoch [265/300] [D loss: 0.0035504011902958155] [G loss: 6.116427421569824]\n", + "Epoch [266/300] [D loss: 0.07644154131412506] [G loss: 2.720405101776123]\n", + "Epoch [267/300] [D loss: 0.030415533110499382] [G loss: 4.244810104370117]\n", + "Epoch [268/300] [D loss: 0.020068874582648277] [G loss: 6.474517822265625]\n", + "Epoch [269/300] [D loss: 0.002136750379577279] [G loss: 9.29329776763916]\n", + "Epoch [270/300] [D loss: 0.00978941936045885] [G loss: 5.02622652053833]\n", + "Epoch [271/300] [D loss: 0.08784317970275879] [G loss: 6.733256816864014]\n", + "Epoch [272/300] [D loss: 0.009109925478696823] [G loss: 5.823270797729492]\n", + "Epoch [273/300] [D loss: 0.008865194395184517] [G loss: 5.696066379547119]\n", + "Epoch [274/300] [D loss: 0.029590584337711334] [G loss: 8.216507911682129]\n", + "Epoch [275/300] [D loss: 0.0636298805475235] [G loss: 8.98292064666748]\n", + "Epoch [276/300] [D loss: 0.004769572988152504] [G loss: 6.2220025062561035]\n", + "Epoch [277/300] [D loss: 0.003883387427777052] [G loss: 6.5977911949157715]\n", + "Epoch [278/300] [D loss: 0.04028937965631485] [G loss: 4.9343485832214355]\n", + "Epoch [279/300] [D loss: 0.011857430450618267] [G loss: 6.440511703491211]\n", + "Epoch [280/300] [D loss: 0.007019379176199436] [G loss: 5.2130351066589355]\n", + "Epoch [281/300] [D loss: 0.022525882348418236] [G loss: 3.9527556896209717]\n", + "Epoch [282/300] [D loss: 0.0071130781434476376] [G loss: 6.993907928466797]\n", + "Epoch [283/300] [D loss: 0.003977011889219284] [G loss: 7.2447967529296875]\n", + "Epoch [284/300] [D loss: 0.07062061131000519] [G loss: 5.2334771156311035]\n", + "Epoch [285/300] [D loss: 0.01805986650288105] [G loss: 5.5015082359313965]\n", + "Epoch [286/300] [D loss: 0.05663669481873512] [G loss: 6.766615390777588]\n", + "Epoch [287/300] [D loss: 0.0032901568338274956] [G loss: 6.28628396987915]\n", + "Epoch [288/300] [D loss: 0.3530406653881073] [G loss: 7.906818389892578]\n", + "Epoch [289/300] [D loss: 0.004547123331576586] [G loss: 6.108604431152344]\n", + "Epoch [290/300] [D loss: 0.010472457855939865] [G loss: 6.213746070861816]\n", + "Epoch [291/300] [D loss: 0.016601260751485825] [G loss: 5.763346195220947]\n", + "Epoch [292/300] [D loss: 0.04024907946586609] [G loss: 5.658637523651123]\n", + "Epoch [293/300] [D loss: 0.07437323033809662] [G loss: 5.68184757232666]\n", + "Epoch [294/300] [D loss: 0.08150847256183624] [G loss: 6.040549278259277]\n", + "Epoch [295/300] [D loss: 0.0924491435289383] [G loss: 2.502917766571045]\n", + "Epoch [296/300] [D loss: 0.0035814237780869007] [G loss: 7.250881195068359]\n", + "Epoch [297/300] [D loss: 0.012245922349393368] [G loss: 6.780396461486816]\n", + "Epoch [298/300] [D loss: 0.004009227734059095] [G loss: 5.833404064178467]\n", + "Epoch [299/300] [D loss: 0.14272907376289368] [G loss: 7.528534889221191]\n" + ] + } + ], + "source": [ + "# 开始训练\n", + "epochs = 300\n", + "for epoch in range(epochs):\n", + " for i, (X, y, mask) in enumerate(dataloader):\n", + " # 将数据移到 GPU 上\n", + " X, y, mask = X.to(device), y.to(device), mask.to(device)\n", + " \n", + " valid = torch.ones((X.size(0), 1, 12, 12)).to(device)\n", + " fake = torch.zeros((X.size(0), 1, 12, 12)).to(device)\n", + "\n", + " # 生成器生成图像\n", + " optimizer_G.zero_grad()\n", + " generated_images = generator(X, mask)\n", + " g_loss = adversarial_loss(discriminator(torch.cat((generated_images, X), dim=1)), valid) + 100 * pixelwise_loss(\n", + " generated_images, y)\n", + " g_loss.backward()\n", + " optimizer_G.step()\n", + "\n", + " # 判别器训练\n", + " optimizer_D.zero_grad()\n", + " real_loss = adversarial_loss(discriminator(torch.cat((y, X), dim=1)), valid)\n", + " fake_loss = adversarial_loss(discriminator(torch.cat((generated_images.detach(), X), dim=1)), fake)\n", + " d_loss = 0.5 * (real_loss + fake_loss)\n", + " d_loss.backward()\n", + " optimizer_D.step()\n", + "\n", + " print(f\"Epoch [{epoch}/{epochs}] [D loss: {d_loss.item()}] [G loss: {g_loss.item()}]\")\n", + "\n", + "# 保存训练好的模型\n", + "torch.save(generator.state_dict(), './models/GAN/generator.pth')\n", + "torch.save(discriminator.state_dict(), './models/GAN/discriminator.pth')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "18482f18-a9cd-49cb-a63a-85725cc4088a", + "metadata": {}, + "outputs": [], + "source": [ + "# 结果评估与可视化\n", + "def visualize_results():\n", + " \n", + " X, y, mask = next(iter(dataloader))\n", + " X, y, mask = X.to(device), y.to(device), mask.to(device)\n", + " generated_images = generator(X, mask)\n", + "\n", + " mask = mask.squeeze(1)\n", + " generated_images = generated_images.squeeze(1)\n", + " y = y.squeeze(1)\n", + "\n", + " final_output = generated_images\n", + "\n", + " plt.figure(figsize=(15, 5))\n", + " plt.subplot(1, 3, 1)\n", + " plt.title('Masked NO2 Data')\n", + " plt.imshow(X[0, 0].cpu().detach().numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.subplot(1, 3, 2)\n", + " plt.title('Generated NO2 Data')\n", + " plt.imshow(final_output[0].cpu().detach().numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.subplot(1, 3, 3)\n", + " plt.title('Original NO2 Data')\n", + " plt.imshow(y[0].cpu().detach().numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig('results_visualizationxxx.png')\n", + " plt.close()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a02c7b46-4c53-4fff-b130-a82412f9cf06", + "metadata": {}, + "outputs": [], + "source": [ + "dataset_test = NO2Dataset('./out_mat/96/test/', './out_mat/96/mask/20/')\n", + "test_loader = DataLoader(dataset_test, batch_size=64, shuffle=False, num_workers=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "13e2180c-5615-4610-a041-6da5f5c69a5d", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3a5533e4-f24d-41ae-8de0-0ab2a383d38f", + "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": 21, + "id": "c1dd78b5-c66e-45f4-ab0f-f4b9c6f08cd2", + "metadata": {}, + "outputs": [], + "source": [ + "device = 'cpu'\n", + "generator = generator.to(device)\n", + "eva_list = list()\n", + "with torch.no_grad():\n", + " for X, y, mask in test_loader:\n", + " X, y, mask = X.to(device), y.to(device), mask.to(device)\n", + " generated_images = generator(X, mask)\n", + " mask = mask.squeeze(1).cpu().detach().numpy()\n", + " rev_mask = (mask==0)* 1\n", + " generated_images = generated_images.squeeze(1)\n", + " real = y.squeeze(1).cpu().detach().numpy() * max_pixel_value\n", + " final_output = generated_images.cpu().detach().numpy()\n", + " final_output *= max_pixel_value\n", + " # y_pred = final_output[rev_mask==1].tolist()\n", + " # y_real = real[rev_mask==1].tolist()\n", + " for i, sample in enumerate(generated_images):\n", + " used_mask = rev_mask[i]\n", + " data_label = real[i] * used_mask\n", + " recon_no2 = final_output[i] * 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, recon_no2)\n", + " r = np.corrcoef(data_label, recon_no2)[0, 1]\n", + " eva_list_frame.append([mae, rmse, mape, r2, ioa, r])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1ca21b33-753f-49ee-93d8-ede92e100b5a", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "edc3aaa3-c9b3-4094-9dea-e981f582ac09", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean2.5121443.4309410.360515-0.3421860.6804660.578431
std1.1844031.5800970.3389291.7305340.2671970.227716
min0.8957721.1892290.126946-42.147773-2.040257-0.542623
25%1.6995442.3898790.211304-0.4804350.6068810.457522
50%2.2598343.1254520.2635350.0941960.7499860.620338
75%2.9535163.9832470.3587620.4215050.8406190.745614
max10.47749714.4607134.3146350.9226790.9815250.965753
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 2.512144 3.430941 0.360515 -0.342186 0.680466 \n", + "std 1.184403 1.580097 0.338929 1.730534 0.267197 \n", + "min 0.895772 1.189229 0.126946 -42.147773 -2.040257 \n", + "25% 1.699544 2.389879 0.211304 -0.480435 0.606881 \n", + "50% 2.259834 3.125452 0.263535 0.094196 0.749986 \n", + "75% 2.953516 3.983247 0.358762 0.421505 0.840619 \n", + "max 10.477497 14.460713 4.314635 0.922679 0.981525 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.578431 \n", + "std 0.227716 \n", + "min -0.542623 \n", + "25% 0.457522 \n", + "50% 0.620338 \n", + "75% 0.745614 \n", + "max 0.965753 " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7db4bb93-198e-4163-a926-f3fabebe4510", + "metadata": {}, + "outputs": [], + "source": [ + "# 保存训练好的模型\n", + "torch.save(generator, './models/GAN/generator.pt')\n", + "torch.save(discriminator, './models/GAN/discriminator.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "598577c8-7643-41a7-ad1e-ae9c5f2664f2", + "metadata": {}, + "outputs": [], + "source": [ + "test_imgs = [x for x in os.listdir('./test_img/') if 'img' in x]\n", + "test_imgs.sort()\n", + "test_masks = [x for x in os.listdir('./test_img/') if 'mask' in x]\n", + "test_masks.sort()\n", + "for img_npy, mask_npy in zip(test_imgs, test_masks):\n", + " img = np.load(f'./test_img/{file}')\n", + " img_in = torch.tensor(np.expand_dims(img, 0), dtype=torch.float32)\n", + " mask = np.load(f'./test_img/{file}')\n", + " mask_in = torch.tensor(np.expand_dims(mask, 0), dtype=torch.float32)\n", + " out = generator(img_in, mask_in).detach().cpu().numpy() * max_pixel_value\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "11a7a089-5691-455c-9b70-1c7a306be913", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(out[0][0], cmap='RdYlGn_r')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44b063cf-d295-4dd8-b21b-1631ddae8ca1", + "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 +} diff --git a/torch_MAE.ipynb b/torch_MAE.ipynb new file mode 100644 index 0000000..e2b1de9 --- /dev/null +++ b/torch_MAE.ipynb @@ -0,0 +1,589 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "6603a8fc-d9da-4037-b845-d9c38bae4ce4", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader, TensorDataset, random_split\n", + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "adf69eb9-bedb-4db7-87c4-04c23752a7c3", + "metadata": {}, + "outputs": [], + "source": [ + "def load_data(pix, use_type='train'):\n", + " datasets = list()\n", + " file_list = [x for x in os.listdir(f\"./out_mat/{pix}/{use_type}/\") if x.endswith('.npy')]\n", + " for file in file_list:\n", + " file_img = np.load(f\"./out_mat/{pix}/{use_type}/{file}\")[:,:,:7]\n", + " datasets.append(file_img)\n", + " return np.asarray(datasets)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e0aa628f-37b7-498a-94d7-81241c20b305", + "metadata": {}, + "outputs": [], + "source": [ + "train_set = load_data(96, 'train')\n", + "val_set = load_data(96, 'valid')\n", + "test_set = load_data(96, 'test')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5d5f95cb-f40c-4ead-96fe-241068408b98", + "metadata": {}, + "outputs": [], + "source": [ + "def load_mask(mask_rate):\n", + " mask_files = os.listdir(f'./out_mat/96/mask/{mask_rate}')\n", + " masks = list()\n", + " for file in mask_files:\n", + " d = cv2.imread(f'./out_mat/96/mask/{mask_rate}/{file}', cv2.IMREAD_GRAYSCALE)\n", + " d = (d > 0) * 1\n", + " masks.append(d)\n", + " return np.asarray(masks)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "71452a77-8158-46b2-aecf-400ad7b72df5", + "metadata": {}, + "outputs": [], + "source": [ + "masks = load_mask(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1902e0f8-32bb-4376-8238-334260b12623", + "metadata": {}, + "outputs": [], + "source": [ + "maxs = train_set.max(axis=0)\n", + "mins = train_set.min(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8df9f3c3-ced8-4640-af30-b2f147dbdc96", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26749" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_set)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "53664b12-fd95-4dd0-b61d-20682f8f14f4", + "metadata": {}, + "outputs": [], + "source": [ + "norm_train = (train_set - mins) / (maxs-mins)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "05cb9dc8-c1df-48bf-a9dd-d084ce1d2068", + "metadata": {}, + "outputs": [], + "source": [ + "del train_set" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4ae39364-4cf6-49e9-b99f-6723520943b5", + "metadata": {}, + "outputs": [], + "source": [ + "norm_valid = (val_set - mins) / (maxs-mins)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7f78b981-d079-4000-ba9f-d862e34903b1", + "metadata": {}, + "outputs": [], + "source": [ + "del val_set" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f54eede6-e95a-4476-b822-79846c0b1079", + "metadata": {}, + "outputs": [], + "source": [ + "norm_test = (test_set - mins) / (maxs-mins)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e66887eb-df5e-46d3-b9c5-73af1272b27a", + "metadata": {}, + "outputs": [], + "source": [ + "del test_set" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "00afa8cd-18b4-4d71-8cab-fd140058dca3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(26749, 96, 96)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm_train.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31d91072-3878-4e3c-b6f1-09f597faf60d", + "metadata": {}, + "outputs": [], + "source": [ + "trans_train = np.transpose(norm_train, (0, 3, 1, 2))\n", + "trans_val = np.transpose(norm_valid, (0, 3, 1, 2))\n", + "trans_test = np.transpose(norm_test, (0, 3, 1, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "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())\n", + " plt.title(title + \" Input\")\n", + " plt.subplot(1, 3, 2)\n", + " plt.imshow(masked_feature[0].cpu().numpy())\n", + " plt.title(title + \" Masked\")\n", + " plt.subplot(1, 3, 3)\n", + " plt.imshow(output_feature[0].detach().cpu().numpy())\n", + " plt.title(title + \" Recovery\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aeda3567-4c4d-496b-9570-9ae757b45e72", + "metadata": {}, + "outputs": [], + "source": [ + "# 设置随机种子以确保结果的可重复性\n", + "torch.manual_seed(0)\n", + "np.random.seed(0)\n", + "\n", + "# 数据准备\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(device)\n", + "# 将numpy数组转换为PyTorch张量\n", + "tensor_train = torch.tensor(trans_train.astype(np.float32), device=device)\n", + "tensor_valid = torch.tensor(trans_val.astype(np.float32), device=device)\n", + "tensor_test = torch.tensor(trans_test.astype(np.float32), device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1569baeb-5a9e-48c1-a735-82d0cba8ad29", + "metadata": {}, + "outputs": [], + "source": [ + "# 创建一个数据集和数据加载器\n", + "train_set = TensorDataset(tensor_train, tensor_train) # 输出和标签相同，因为我们是自编码器\n", + "val_set = TensorDataset(tensor_valid, tensor_valid)\n", + "test_set = TensorDataset(tensor_test, tensor_test)\n", + "batch_size = 64\n", + "train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)\n", + "val_loader = DataLoader(val_set, batch_size=batch_size, shuffle=False)\n", + "test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c81785d-f0e6-486f-8aad-dba81d2ec146", + "metadata": {}, + "outputs": [], + "source": [ + "def mask_data(data, device, masks):\n", + " mask_inds = np.random.choice(masks.shape[0], data.shape[0])\n", + " mask = torch.from_numpy(masks[mask_inds]).to(device)\n", + " tmp_first_channel = data[:, 0, :, :] * mask\n", + " masked_data = torch.clone(data)\n", + " masked_data[:, 0, :, :] = tmp_first_channel\n", + " return masked_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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": null, + "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", + " nn.Conv2d(7, 32, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " SEBlock(128, 128)\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(128, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(),\n", + " nn.ConvTranspose2d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(),\n", + " nn.ConvTranspose2d(16, 7, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.Sigmoid() # 使用Sigmoid是因为输入数据是0-1之间的\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=0.001)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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, (data, _) in enumerate(data_loader):\n", + " masked_data = mask_data(data, device, masks)\n", + " optimizer.zero_grad()\n", + " reconstructed = model(masked_data)\n", + " loss = criterion(reconstructed, data)\n", + " loss.backward()\n", + " optimizer.step()\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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, (data, _) in enumerate(data_loader):\n", + " data = data.to(device)\n", + " masked_data = mask_data(data, device, masks)\n", + " reconstructed = model(masked_data)\n", + " if batch_idx == 8:\n", + " rand_ind = np.random.randint(0, len(data))\n", + " visualize_feature(data[rand_ind], masked_data[rand_ind], reconstructed[rand_ind], title='NO_2')\n", + " loss = criterion(reconstructed, data)\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1847c78-cbc6-4560-bb49-4dc6e9b8bbd0", + "metadata": {}, + "outputs": [], + "source": [ + "# 测试函数\n", + "def test(model, device, data_loader):\n", + " model.eval()\n", + " with torch.no_grad():\n", + " for batch_idx, (data, _) in enumerate(data_loader):\n", + " data = data.to(device)\n", + " masked_data = mask_data(data, device, masks)\n", + " masked_ind = np.argwhere(masked_data[0][0]==0)\n", + " reconstructed = model(masked_data)\n", + " recon_no2 = reconstructed[0][0]\n", + " ori_no2 = data[0][0]\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "743d1000-561e-4444-8b49-88346c14f28b", + "metadata": {}, + "outputs": [], + "source": [ + "model = model.to(device)\n", + "\n", + "num_epochs = 100\n", + "train_losses = list()\n", + "val_losses = list()\n", + "for epoch in range(num_epochs):\n", + " train_loss = train_epoch(model, device, train_loader, 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": null, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [], + "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": "cff8cba9-aba9-4347-8e1a-f169df8313c2", + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " device = 'cpu'\n", + " for batch_idx, (data, _) in enumerate(test_loader):\n", + " model = model.to(device)\n", + " data = data.to(device)\n", + " masked_data = mask_data(data, device, masks)\n", + " reconstructed = model(masked_data)\n", + " tr_maxs = np.transpose(maxs, (2, 0, 1))\n", + " tr_mins = np.transpose(mins, (2, 0, 1))\n", + " rev_data = data * (tr_maxs - tr_mins) + tr_mins\n", + " rev_recon = reconstructed * (tr_maxs - tr_mins) + tr_mins\n", + " data_label = ((rev_data!=0) * (masked_data==0) * rev_data)[:, 0]\n", + " recon_no2 = ((rev_data!=0) * (masked_data==0) * rev_recon)[:, 0]\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "565f2e0a-1689-4a03-9fc1-15519b1cdaee", + "metadata": {}, + "outputs": [], + "source": [ + "real = data_label.flatten()\n", + "pred = recon_no2.flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1e8f71e-855a-41ea-b62f-095514af66a3", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a6eea29-cd3e-4712-ad73-589bcf7b88be", + "metadata": {}, + "outputs": [], + "source": [ + "mean_squared_error(real, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a85feefb-aa3a-4bb9-86ac-7cc6938a47e8", + "metadata": {}, + "outputs": [], + "source": [ + "mean_absolute_percentage_error(real, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2bfda87-3de8-4a06-969f-d346f4447cf6", + "metadata": {}, + "outputs": [], + "source": [ + "r2_score(real, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1955fc0-490a-40d5-8b3c-dd6e5beed235", + "metadata": {}, + "outputs": [], + "source": [ + "mean_absolute_error(real, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acee2abc-2f3f-4d19-a6e4-85ad4d1aaacf", + "metadata": {}, + "outputs": [], + "source": [ + "visualize_feature(data[5], masked_data[5], reconstructed[5], 'NO2')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1ada99bf-6bea-4e46-a3bd-f62510517c8e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "62" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len('The total $R^2$ for under 40\\% missing data test set was 0.88.')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "215938c7-d514-48e7-a460-088dcd7927ae", + "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 +} diff --git a/torch_MAE_1d_20_patch_mask.ipynb b/torch_MAE_1d_20_patch_mask.ipynb new file mode 100644 index 0000000..6c4af00 --- /dev/null +++ b/torch_MAE_1d_20_patch_mask.ipynb @@ -0,0 +1,1039 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "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": 4, + "id": "b8a8cedd-536d-4a48-a1af-7c40489ef0f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(0)\n", + "torch.random.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c28cc123-71be-47ff-b78f-3a4d5592df39", + "metadata": {}, + "outputs": [], + "source": [ + "# 计算图像数据中的最大像素值\n", + "max_pixel_value = 107.49169921875" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "342d21ee-7f31-4c37-a73b-f47cac181763", + "metadata": {}, + "outputs": [], + "source": [ + "class GrayScaleDataset(Dataset):\n", + " def __init__(self, data_dir):\n", + " self.data_dir = data_dir\n", + " self.file_list = [x for x in os.listdir(data_dir) if x.endswith('npy')]\n", + "\n", + " def __len__(self):\n", + " return len(self.file_list)\n", + "\n", + " def __getitem__(self, idx):\n", + " file_path = os.path.join(self.data_dir, self.file_list[idx])\n", + " data = np.load(file_path)[:,:,0] / max_pixel_value\n", + " return torch.tensor(data, dtype=torch.float32).unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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/20/'\n", + "\n", + "print(f\"checkpoint before Generator is OK\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d3a25f29-b16e-4485-9f06-5378b910be6e", + "metadata": {}, + "outputs": [], + "source": [ + "class PatchMasking:\n", + " def __init__(self, patch_size, mask_ratio):\n", + " self.patch_size = patch_size\n", + " self.mask_ratio = mask_ratio\n", + "\n", + " def __call__(self, x):\n", + " batch_size, C, H, W = x.shape\n", + " num_patches = (H // self.patch_size) * (W // self.patch_size)\n", + " num_masked = int(num_patches * self.mask_ratio)\n", + " \n", + " # 为每个样本生成独立的mask\n", + " masks = []\n", + " for _ in range(batch_size):\n", + " mask = torch.zeros(num_patches, dtype=torch.bool, device=x.device)\n", + " mask[:num_masked] = 1\n", + " mask = mask[torch.randperm(num_patches)]\n", + " mask = mask.view(H // self.patch_size, W // self.patch_size)\n", + " mask = mask.repeat_interleave(self.patch_size, dim=0).repeat_interleave(self.patch_size, dim=1)\n", + " masks.append(mask)\n", + " \n", + " # 将所有mask堆叠成一个批量张量\n", + " masks = torch.stack(masks, dim=0)\n", + " masks = torch.unsqueeze(masks, dim=1)\n", + " \n", + " # 应用mask到输入x上\n", + " masked_x = x * (1- masks.float())\n", + " return masked_x, masks" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "41da7319-9795-441d-bde8-8cf390365099", + "metadata": {}, + "outputs": [], + "source": [ + "train_dir = './out_mat/96/train/'\n", + "train_dataset = GrayScaleDataset(train_dir)\n", + "val_dir = './out_mat/96/valid/'\n", + "val_dataset = GrayScaleDataset(val_dir)\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n", + "val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)\n", + "\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": 10, + "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": 11, + "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": 12, + "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": 13, + "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": 14, + "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": 15, + "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": 16, + "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": 17, + "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": 18, + "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": 19, + "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": 20, + "id": "c9d176a8-bbf6-4043-ab82-1648a99d772a", + "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": 25, + "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", + " Mlp(in_features=128, hidden_features=256, out_features=128, act_layer=nn.ReLU6, drop=0.1)\n", + " )\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", + " nn.ConvTranspose2d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(), \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": 22, + "id": "084f6b1e-ed3a-490b-9020-5479863e803b", + "metadata": {}, + "outputs": [], + "source": [ + "def train_model(model, train_loader, val_loader, epochs, criterion, optimizer, device):\n", + " model.to(device)\n", + " for epoch in range(epochs):\n", + " model.train()\n", + " train_loss = 0\n", + " for data in train_loader:\n", + " data = data.to(device)\n", + " optimizer.zero_grad()\n", + " masked_data, mask = PatchMasking(patch_size=8, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " loss = masked_mse_loss(output, data, mask)\n", + " loss.backward()\n", + " optimizer.step()\n", + " train_loss += loss.item()\n", + " train_loss /= len(train_loader)\n", + "\n", + " model.eval()\n", + " val_loss = 0\n", + " with torch.no_grad():\n", + " for data in val_loader:\n", + " data = data.to(device)\n", + " masked_data, mask = PatchMasking(patch_size=8, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " loss = masked_mse_loss(output, data, mask)\n", + " val_loss += loss.item()\n", + " val_loss /= len(val_loader)\n", + "\n", + " print(f'Epoch {epoch+1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "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": 27, + "id": "16673a37-02e9-4883-8288-aa0e240d6824", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 0.0185, Val Loss: 0.0199\n", + "Epoch 2, Train Loss: 0.0178, Val Loss: 0.0187\n", + "Epoch 3, Train Loss: 0.0174, Val Loss: 0.0217\n", + "Epoch 4, Train Loss: 0.0172, Val Loss: 0.0227\n", + "Epoch 5, Train Loss: 0.0167, Val Loss: 0.0180\n", + "Epoch 6, Train Loss: 0.0166, Val Loss: 0.0225\n", + "Epoch 7, Train Loss: 0.0163, Val Loss: 0.0183\n", + "Epoch 8, Train Loss: 0.0162, Val Loss: 0.0220\n", + "Epoch 9, Train Loss: 0.0161, Val Loss: 0.0181\n", + "Epoch 10, Train Loss: 0.0159, Val Loss: 0.0196\n", + "Epoch 11, Train Loss: 0.0159, Val Loss: 0.0210\n", + "Epoch 12, Train Loss: 0.0155, Val Loss: 0.0198\n", + "Epoch 13, Train Loss: 0.0154, Val Loss: 0.0212\n", + "Epoch 14, Train Loss: 0.0153, Val Loss: 0.0207\n", + "Epoch 15, Train Loss: 0.0153, Val Loss: 0.0216\n", + "Epoch 16, Train Loss: 0.0152, Val Loss: 0.0222\n", + "Epoch 17, Train Loss: 0.0152, Val Loss: 0.0225\n", + "Epoch 18, Train Loss: 0.0150, Val Loss: 0.0183\n", + "Epoch 19, Train Loss: 0.0151, Val Loss: 0.0242\n", + "Epoch 20, Train Loss: 0.0148, Val Loss: 0.0203\n", + "Epoch 21, Train Loss: 0.0148, Val Loss: 0.0211\n", + "Epoch 22, Train Loss: 0.0148, Val Loss: 0.0200\n", + "Epoch 23, Train Loss: 0.0146, Val Loss: 0.0191\n", + "Epoch 24, Train Loss: 0.0145, Val Loss: 0.0215\n", + "Epoch 25, Train Loss: 0.0145, Val Loss: 0.0196\n", + "Epoch 26, Train Loss: 0.0146, Val Loss: 0.0215\n", + "Epoch 27, Train Loss: 0.0144, Val Loss: 0.0195\n", + "Epoch 28, Train Loss: 0.0144, Val Loss: 0.0196\n", + "Epoch 29, Train Loss: 0.0143, Val Loss: 0.0182\n", + "Epoch 30, Train Loss: 0.0143, Val Loss: 0.0213\n", + "Epoch 31, Train Loss: 0.0142, Val Loss: 0.0178\n", + "Epoch 32, Train Loss: 0.0139, Val Loss: 0.0215\n", + "Epoch 33, Train Loss: 0.0135, Val Loss: 0.0171\n", + "Epoch 34, Train Loss: 0.0131, Val Loss: 0.0187\n", + "Epoch 35, Train Loss: 0.0128, Val Loss: 0.0171\n", + "Epoch 36, Train Loss: 0.0128, Val Loss: 0.0159\n", + "Epoch 37, Train Loss: 0.0127, Val Loss: 0.0170\n", + "Epoch 38, Train Loss: 0.0125, Val Loss: 0.0182\n", + "Epoch 39, Train Loss: 0.0124, Val Loss: 0.0155\n", + "Epoch 40, Train Loss: 0.0123, Val Loss: 0.0169\n", + "Epoch 41, Train Loss: 0.0122, Val Loss: 0.0160\n", + "Epoch 42, Train Loss: 0.0123, Val Loss: 0.0164\n", + "Epoch 43, Train Loss: 0.0120, Val Loss: 0.0154\n", + "Epoch 44, Train Loss: 0.0121, Val Loss: 0.0159\n", + "Epoch 45, Train Loss: 0.0119, Val Loss: 0.0152\n", + "Epoch 46, Train Loss: 0.0118, Val Loss: 0.0151\n", + "Epoch 47, Train Loss: 0.0119, Val Loss: 0.0135\n", + "Epoch 48, Train Loss: 0.0121, Val Loss: 0.0135\n", + "Epoch 49, Train Loss: 0.0118, Val Loss: 0.0162\n", + "Epoch 50, Train Loss: 0.0117, Val Loss: 0.0195\n", + "Epoch 51, Train Loss: 0.0116, Val Loss: 0.0160\n", + "Epoch 52, Train Loss: 0.0116, Val Loss: 0.0167\n", + "Epoch 53, Train Loss: 0.0116, Val Loss: 0.0149\n", + "Epoch 54, Train Loss: 0.0114, Val Loss: 0.0143\n", + "Epoch 55, Train Loss: 0.0115, Val Loss: 0.0136\n", + "Epoch 56, Train Loss: 0.0115, Val Loss: 0.0144\n", + "Epoch 57, Train Loss: 0.0115, Val Loss: 0.0158\n", + "Epoch 58, Train Loss: 0.0113, Val Loss: 0.0147\n", + "Epoch 59, Train Loss: 0.0112, Val Loss: 0.0142\n", + "Epoch 60, Train Loss: 0.0113, Val Loss: 0.0159\n", + "Epoch 61, Train Loss: 0.0112, Val Loss: 0.0153\n", + "Epoch 62, Train Loss: 0.0113, Val Loss: 0.0140\n", + "Epoch 63, Train Loss: 0.0112, Val Loss: 0.0156\n", + "Epoch 64, Train Loss: 0.0111, Val Loss: 0.0149\n", + "Epoch 65, Train Loss: 0.0112, Val Loss: 0.0154\n", + "Epoch 66, Train Loss: 0.0112, Val Loss: 0.0158\n", + "Epoch 67, Train Loss: 0.0111, Val Loss: 0.0136\n", + "Epoch 68, Train Loss: 0.0110, Val Loss: 0.0139\n", + "Epoch 69, Train Loss: 0.0110, Val Loss: 0.0142\n", + "Epoch 70, Train Loss: 0.0112, Val Loss: 0.0152\n", + "Epoch 71, Train Loss: 0.0109, Val Loss: 0.0151\n", + "Epoch 72, Train Loss: 0.0110, Val Loss: 0.0162\n", + "Epoch 73, Train Loss: 0.0110, Val Loss: 0.0162\n", + "Epoch 74, Train Loss: 0.0109, Val Loss: 0.0176\n", + "Epoch 75, Train Loss: 0.0109, Val Loss: 0.0143\n", + "Epoch 76, Train Loss: 0.0109, Val Loss: 0.0147\n", + "Epoch 77, Train Loss: 0.0108, Val Loss: 0.0141\n", + "Epoch 78, Train Loss: 0.0109, Val Loss: 0.0145\n", + "Epoch 79, Train Loss: 0.0108, Val Loss: 0.0140\n", + "Epoch 80, Train Loss: 0.0109, Val Loss: 0.0135\n", + "Epoch 81, Train Loss: 0.0108, Val Loss: 0.0145\n", + "Epoch 82, Train Loss: 0.0108, Val Loss: 0.0126\n", + "Epoch 83, Train Loss: 0.0108, Val Loss: 0.0145\n", + "Epoch 84, Train Loss: 0.0107, Val Loss: 0.0135\n", + "Epoch 85, Train Loss: 0.0108, Val Loss: 0.0140\n", + "Epoch 86, Train Loss: 0.0107, Val Loss: 0.0143\n", + "Epoch 87, Train Loss: 0.0107, Val Loss: 0.0146\n", + "Epoch 88, Train Loss: 0.0107, Val Loss: 0.0136\n", + "Epoch 111, Train Loss: 0.0094, Val Loss: 0.0120\n", + "Epoch 112, Train Loss: 0.0094, Val Loss: 0.0114\n", + "Epoch 113, Train Loss: 0.0095, Val Loss: 0.0128\n", + "Epoch 114, Train Loss: 0.0093, Val Loss: 0.0125\n", + "Epoch 115, Train Loss: 0.0093, Val Loss: 0.0124\n", + "Epoch 116, Train Loss: 0.0093, Val Loss: 0.0114\n", + "Epoch 117, Train Loss: 0.0093, Val Loss: 0.0127\n", + "Epoch 118, Train Loss: 0.0093, Val Loss: 0.0122\n", + "Epoch 119, Train Loss: 0.0093, Val Loss: 0.0116\n", + "Epoch 120, Train Loss: 0.0092, Val Loss: 0.0114\n", + "Epoch 121, Train Loss: 0.0092, Val Loss: 0.0130\n", + "Epoch 122, Train Loss: 0.0092, Val Loss: 0.0114\n", + "Epoch 123, Train Loss: 0.0093, Val Loss: 0.0113\n", + "Epoch 124, Train Loss: 0.0092, Val Loss: 0.0120\n", + "Epoch 125, Train Loss: 0.0091, Val Loss: 0.0110\n", + "Epoch 126, Train Loss: 0.0091, Val Loss: 0.0128\n", + "Epoch 127, Train Loss: 0.0091, Val Loss: 0.0129\n", + "Epoch 128, Train Loss: 0.0092, Val Loss: 0.0126\n", + "Epoch 129, Train Loss: 0.0092, Val Loss: 0.0113\n", + "Epoch 130, Train Loss: 0.0091, Val Loss: 0.0109\n" + ] + } + ], + "source": [ + "train_model(model, train_loader, val_loader, epochs=130, criterion=criterion, optimizer=optimizer, device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "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": 31, + "id": "efc96935-bbe0-4ca9-b11a-931cdcfc3bed", + "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": 32, + "id": "73a0002b-35d6-4e20-a620-5c8f5cd49296", + "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": 33, + "id": "589e6d80-228d-4e8a-968a-e7477c5e0e24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean5.2976806.2257290.489679-1.978159-0.3625090.352984
std3.9303024.1763860.1916702.4478831.0746370.201559
min0.9969531.2794050.202344-28.276637-9.562830-0.500861
25%2.1032932.7416580.353414-2.891019-0.7965810.225314
50%3.1908694.1487100.457116-1.0938230.0440200.365110
75%8.3785429.4405380.586501-0.4069740.3559920.498017
max21.32916523.0477792.2422820.5926450.8293240.839954
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 5.297680 6.225729 0.489679 -1.978159 -0.362509 \n", + "std 3.930302 4.176386 0.191670 2.447883 1.074637 \n", + "min 0.996953 1.279405 0.202344 -28.276637 -9.562830 \n", + "25% 2.103293 2.741658 0.353414 -2.891019 -0.796581 \n", + "50% 3.190869 4.148710 0.457116 -1.093823 0.044020 \n", + "75% 8.378542 9.440538 0.586501 -0.406974 0.355992 \n", + "max 21.329165 23.047779 2.242282 0.592645 0.829324 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.352984 \n", + "std 0.201559 \n", + "min -0.500861 \n", + "25% 0.225314 \n", + "50% 0.365110 \n", + "75% 0.498017 \n", + "max 0.839954 " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "5f8b2dc4-5ac4-4b52-9dea-de8d29cba6b5", + "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", + " eva_list.append([mae, rmse, mape, r2, ioa])" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "755abc3e-f4d2-4056-b01b-3fb085f95f19", + "metadata": {}, + "outputs": [], + "source": [ + "torch.save(model, './models/MAE/final_patch_20.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "76449691-74b2-43ef-b092-f71cd8116448", + "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/20_samples.png')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "82467932-3b38-4d2d-83d9-8d76c4f98a06", + "metadata": {}, + "outputs": [], + "source": [ + "best_mask_cp = np.where(best_mask == 0, np.nan, best_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "6bb568d1-07bd-49c4-9056-9ad2f2dd36a8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_rst(best_img, best_mask, best_recov*best_mask_cp, best_recov, '')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb78ecea-809d-40c6-940f-c72cd956ff84", + "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 +} diff --git a/torch_MAE_1d_ViT-Copy1.ipynb b/torch_MAE_1d_ViT-Copy1.ipynb new file mode 100644 index 0000000..522a591 --- /dev/null +++ b/torch_MAE_1d_ViT-Copy1.ipynb @@ -0,0 +1,1276 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "e247809e-7610-487b-88e0-9b4947e92c6b", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader, Dataset, random_split\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os\n", + "from PIL import Image\n", + "\n", + "MAX_VALUE = 107.49169921875" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4c4182a2-0284-4a82-a494-cbe4051ff7bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "device(type='cuda')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b7402720-de05-45e9-b076-04780a513fc3", + "metadata": {}, + "outputs": [], + "source": [ + "class GrayScaleDataset(Dataset):\n", + " def __init__(self, data_dir):\n", + " self.data_dir = data_dir\n", + " self.file_list = [x for x in os.listdir(data_dir) if x.endswith('npy')]\n", + "\n", + " def __len__(self):\n", + " return len(self.file_list)\n", + "\n", + " def __getitem__(self, idx):\n", + " file_path = os.path.join(self.data_dir, self.file_list[idx])\n", + " data = np.load(file_path)[:,:,0] / MAX_VALUE\n", + " return torch.tensor(data, dtype=torch.float32).unsqueeze(0)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3ecd7bd0-15a0-4420-95e1-066e4d023cd3", + "metadata": {}, + "outputs": [], + "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 = idx % len(self.mask_filenames)\n", + " mask_path = os.path.join(self.mask_dir, self.mask_filenames[mask_idx])\n", + "\n", + " # 加载图像数据 (.npy 文件)\n", + " image = np.load(image_path).astype(np.float32)[:,:,:1] / MAX_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)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9ec25dc1-3728-4b0b-8403-ccad10355999", + "metadata": {}, + "outputs": [], + "source": [ + "class PatchMasking:\n", + " def __init__(self, patch_size, mask_ratio):\n", + " self.patch_size = patch_size\n", + " self.mask_ratio = mask_ratio\n", + "\n", + " def __call__(self, x):\n", + " batch_size, C, H, W = x.shape\n", + " num_patches = (H // self.patch_size) * (W // self.patch_size)\n", + " num_masked = int(num_patches * self.mask_ratio)\n", + " \n", + " # 为每个样本生成独立的mask\n", + " masks = []\n", + " for _ in range(batch_size):\n", + " mask = torch.zeros(num_patches, dtype=torch.bool, device=x.device)\n", + " mask[:num_masked] = 1\n", + " mask = mask[torch.randperm(num_patches)]\n", + " mask = mask.view(H // self.patch_size, W // self.patch_size)\n", + " mask = mask.repeat_interleave(self.patch_size, dim=0).repeat_interleave(self.patch_size, dim=1)\n", + " masks.append(mask)\n", + " \n", + " # 将所有mask堆叠成一个批量张量\n", + " masks = torch.stack(masks, dim=0)\n", + " masks = torch.unsqueeze(masks, dim=1)\n", + " \n", + " # 应用mask到输入x上\n", + " masked_x = x * (1 - masks.float())\n", + " return masked_x, masks" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a1f70780-9e31-4917-9785-768140e5610e", + "metadata": {}, + "outputs": [], + "source": [ + "class MLP(nn.Module):\n", + " def __init__(self, input_dim, output_dim):\n", + " super(MLP, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, output_dim)\n", + " self.act = nn.GELU() # 使用 GELU 激活函数\n", + " self.fc2 = nn.Linear(output_dim, input_dim)\n", + "\n", + " def forward(self, x):\n", + " return self.fc2(self.act(self.fc1(x)))\n", + "\n", + "class Attention(nn.Module):\n", + " def __init__(self, dim, heads):\n", + " super(Attention, self).__init__()\n", + " self.heads = heads\n", + " self.dim = dim\n", + " self.scale = dim ** -0.5\n", + "\n", + " self.qkv = nn.Linear(dim, dim * 3)\n", + " self.attn_drop = nn.Dropout(0.1)\n", + " self.proj = nn.Linear(dim, dim)\n", + " self.proj_drop = nn.Dropout(0.1)\n", + "\n", + " def forward(self, x):\n", + " B, N, C = x.shape\n", + " qkv = self.qkv(x).reshape(B, N, 3, self.heads, C // self.heads).permute(2, 0, 3, 1, 4) # (3, B, heads, N, head_dim)\n", + " q, k, v = qkv[0], qkv[1], qkv[2]\n", + "\n", + " attn = (q @ k.transpose(-2, -1)) * self.scale\n", + " attn = attn.softmax(dim=-1)\n", + " attn = self.attn_drop(attn)\n", + "\n", + " out = (attn @ v).transpose(1, 2).reshape(B, N, C)\n", + " return self.proj_drop(self.proj(out))\n", + "\n", + "class LayerNorm(nn.Module):\n", + " def __init__(self, dim, eps=1e-6):\n", + " super(LayerNorm, self).__init__()\n", + " self.ln = nn.LayerNorm(dim, eps=eps)\n", + "\n", + " def forward(self, x):\n", + " return self.ln(x)\n", + "\n", + "class Dropout(nn.Module):\n", + " def __init__(self, p=0.1):\n", + " super(Dropout, self).__init__()\n", + " self.dropout = nn.Dropout(p)\n", + "\n", + " def forward(self, x):\n", + " return self.dropout(x)\n", + "\n", + "class ViTEncoder(nn.Module):\n", + " def __init__(self, img_size=96, patch_size=8, dim=128, depth=4, heads=4, mlp_dim=256, dropout=0.1):\n", + " super(ViTEncoder, self).__init__()\n", + " self.patch_size = patch_size\n", + " self.dim = dim\n", + " self.patch_embedding = nn.Conv2d(1, dim, kernel_size=patch_size, stride=patch_size)\n", + "\n", + " self.attention_layers = nn.ModuleList([\n", + " nn.ModuleList([\n", + " LayerNorm(dim), # Layer Normalization\n", + " Attention(dim, heads),\n", + " Dropout(dropout), # Dropout\n", + " LayerNorm(dim), # Layer Normalization\n", + " MLP(dim, mlp_dim),\n", + " Dropout(dropout) # Dropout\n", + " ]) for _ in range(depth)\n", + " ])\n", + "\n", + " def forward(self, x):\n", + " x = self.patch_embedding(x) # 形状变为 (batch_size, dim, num_patches_h, num_patches_w)\n", + " x = x.flatten(2).transpose(1, 2) # 形状变为 (batch_size, num_patches, dim)\n", + "\n", + " for norm1, attn, drop1, norm2, mlp, drop2 in self.attention_layers:\n", + " x = x + drop1(attn(norm1(x))) # 残差连接\n", + " x = x + drop2(mlp(norm2(x))) # 残差连接\n", + " return x\n", + "\n", + "\n", + "class ConvDecoder(nn.Module):\n", + " def __init__(self, dim=128, patch_size=8, img_size=96):\n", + " super(ConvDecoder, self).__init__()\n", + " self.dim = dim\n", + " self.patch_size = patch_size\n", + " self.img_size = img_size\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(self.dim, 64, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(),\n", + " \n", + " nn.ConvTranspose2d(64, 16, kernel_size=3, stride=2, padding=1, output_padding=1),\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", + " x = x.transpose(1, 2).view(-1, self.dim, self.img_size // self.patch_size, self.img_size // self.patch_size)\n", + " x = self.decoder(x)\n", + " return x\n", + "\n", + "class MAEModel(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(MAEModel, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " # self.mlp = Mlp(in_features=128, hidden_features=256, out_features=128, act_layer=nn.ReLU6, drop=0.1)\n", + "\n", + " def forward(self, x):\n", + " encoded = self.encoder(x)\n", + " decoded = self.decoder(encoded)\n", + " return decoded" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4a1427a1-bf38-483e-b92b-07631078c78a", + "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": 8, + "id": "29deee2c-5771-498a-b01b-fde5e0f387ba", + "metadata": {}, + "outputs": [], + "source": [ + "def train_model(model, train_loader, val_loader, epochs, criterion, optimizer, device):\n", + " best_model = model\n", + " best_loss = 100\n", + " model.to(device)\n", + " for epoch in range(epochs):\n", + " model.train()\n", + " train_loss = 0\n", + " for data in train_loader:\n", + " data = data.to(device)\n", + " optimizer.zero_grad()\n", + " masked_data, mask = PatchMasking(patch_size=8, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " loss = masked_mse_loss(output, data, mask)\n", + " loss.backward()\n", + " optimizer.step()\n", + " train_loss += loss.item()\n", + " train_loss /= len(train_loader)\n", + "\n", + " model.eval()\n", + " val_loss = 0\n", + " with torch.no_grad():\n", + " for data in val_loader:\n", + " data = data.to(device)\n", + " masked_data, mask = PatchMasking(patch_size=8, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " loss = masked_mse_loss(output, data, mask)\n", + " val_loss += loss.item()\n", + " val_loss /= len(val_loader)\n", + " if val_loss < best_loss:\n", + " best_loss = val_loss\n", + " best_model = model\n", + "\n", + " print(f'Epoch {epoch+1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bb524f86-aa7d-44ee-b13e-b9ba4e5b3a0b", + "metadata": {}, + "outputs": [], + "source": [ + "train_dir = './out_mat/96/train/'\n", + "train_dataset = GrayScaleDataset(train_dir)\n", + "\n", + "val_dir = './out_mat/96/valid/'\n", + "val_dataset = GrayScaleDataset(val_dir)\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=8)\n", + "val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, num_workers=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0d7e2f83-c113-4c62-91eb-d4ea3192530c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "7d6d07a4-31f1-4350-a487-b583db979381", + "metadata": {}, + "outputs": [], + "source": [ + "encoder = ViTEncoder()\n", + "decoder = ConvDecoder()\n", + "model = MAEModel(encoder, decoder)\n", + "criterion = nn.MSELoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=1e-4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09b04e16-3257-4890-b736-a6c7274561e0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 0.9251, Val Loss: 0.0869\n", + "Epoch 2, Train Loss: 0.0734, Val Loss: 0.0506\n", + "Epoch 3, Train Loss: 0.0494, Val Loss: 0.0489\n", + "Epoch 4, Train Loss: 0.0432, Val Loss: 0.0462\n", + "Epoch 5, Train Loss: 0.0390, Val Loss: 0.0400\n", + "Epoch 6, Train Loss: 0.0351, Val Loss: 0.0356\n" + ] + } + ], + "source": [ + "train_model(model, train_loader, val_loader, epochs=50, criterion=criterion, optimizer=optimizer, device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b0c5cf4b-aca2-4781-8b47-bf2a46269635", + "metadata": {}, + "outputs": [], + "source": [ + "test_set = NO2Dataset('./out_mat/96/test/', './out_mat/96/mask/20/')\n", + "test_loader = DataLoader(test_set, batch_size=32, shuffle=False, num_workers=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "56653f37-899a-47d6-8d50-e456b4ad1835", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "2504300a-ac91-453a-9bfb-ab89f56d4ff6", + "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 = 2 * 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": 24, + "id": "d55be844-0873-4d9a-8160-22603de32a81", + "metadata": {}, + "outputs": [], + "source": [ + "test_set2 = GrayScaleDataset('./out_mat/96/test/')\n", + "test_loader2 = DataLoader(test_set2, batch_size=64, shuffle=False, num_workers=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "f83dbc37-8543-45bc-ba59-ca88d4ba2a66", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([64, 96, 96])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rev_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "2655f7f4-9d88-49fd-9346-87a621320183", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list = list()\n", + "device = 'cpu'\n", + "model = model.to(device)\n", + "with torch.no_grad():\n", + " for data in test_loader2:\n", + " data = data.to(device)\n", + " masked_data, mask = PatchMasking(patch_size=8, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " rev_data = data * MAX_VALUE\n", + " rev_recon = output * MAX_VALUE\n", + " data_label = rev_data * mask\n", + " data_label = data_label[mask==1]\n", + " recon_no2 = rev_recon * mask\n", + " recon_no2 = recon_no2[mask==1]\n", + " y_true = rev_data.flatten()\n", + " y_pred = rev_recon.flatten()\n", + " mae = mean_absolute_error(y_true, y_pred)\n", + " rmse = np.sqrt(mean_squared_error(y_true, y_pred))\n", + " mape = mean_absolute_percentage_error(y_true, y_pred)\n", + " r2 = r2_score(y_true, y_pred)\n", + " ioa = cal_ioa(data_label.detach().numpy(), recon_no2.detach().numpy())\n", + " eva_list.append([mae, rmse, mape, r2, ioa])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "0327b51c-d714-4fe0-a044-d8be3ff180e0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioa
count75.00000075.00000075.00000075.00000075.000000
mean1.2080131.6006440.1427200.9419830.981683
std0.0562350.0817910.0034350.0044490.002309
min1.0915171.4463890.1348490.9118330.965708
25%1.1703051.5550510.1405190.9404250.981100
50%1.2047281.5932610.1429810.9426510.982003
75%1.2427621.6463110.1451850.9441180.982809
max1.4207212.0379030.1505660.9496630.984610
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa\n", + "count 75.000000 75.000000 75.000000 75.000000 75.000000\n", + "mean 1.208013 1.600644 0.142720 0.941983 0.981683\n", + "std 0.056235 0.081791 0.003435 0.004449 0.002309\n", + "min 1.091517 1.446389 0.134849 0.911833 0.965708\n", + "25% 1.170305 1.555051 0.140519 0.940425 0.981100\n", + "50% 1.204728 1.593261 0.142981 0.942651 0.982003\n", + "75% 1.242762 1.646311 0.145185 0.944118 0.982809\n", + "max 1.420721 2.037903 0.150566 0.949663 0.984610" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "b8669b7e-6974-418a-87fc-074734f9a1a3", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list_frame = list()\n", + "device = 'cpu'\n", + "model = model.to(device)\n", + "with torch.no_grad():\n", + " for data in test_loader2:\n", + " data = data.to(device)\n", + " masked_data, mask = PatchMasking(patch_size=8, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " rev_data = data * MAX_VALUE\n", + " rev_recon = output * MAX_VALUE\n", + " # todo: 这里需要只评估修补出来的模块\n", + " for i, sample in enumerate(rev_data):\n", + " used_mask = mask[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])" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c9079fc5-6ab3-465e-9067-6cad8f69c5a8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.7143152.3501890.2159740.6094700.9435600.823401
std0.6973440.9403450.0778930.1314960.0222610.069394
min0.6360490.8217230.0999990.0031940.8022370.405363
25%1.1216171.5766690.1709740.5330810.9316530.783616
50%1.4597202.1323160.1994190.6237690.9469520.831403
75%2.3347613.1193930.2345170.6985170.9589430.872422
max4.4062588.4701091.2426360.8951990.9869010.965110
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.714315 2.350189 0.215974 0.609470 0.943560 \n", + "std 0.697344 0.940345 0.077893 0.131496 0.022261 \n", + "min 0.636049 0.821723 0.099999 0.003194 0.802237 \n", + "25% 1.121617 1.576669 0.170974 0.533081 0.931653 \n", + "50% 1.459720 2.132316 0.199419 0.623769 0.946952 \n", + "75% 2.334761 3.119393 0.234517 0.698517 0.958943 \n", + "max 4.406258 8.470109 1.242636 0.895199 0.986901 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.823401 \n", + "std 0.069394 \n", + "min 0.405363 \n", + "25% 0.783616 \n", + "50% 0.831403 \n", + "75% 0.872422 \n", + "max 0.965110 " + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eva_frame_df = pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).sort_values(by='mape')\n", + "eva_frame_df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e840b789-bf68-4b4d-a8d3-c5362c310349", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "too many values to unpack (expected 3)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[25], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m model \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m batch_idx, (X, y, mask) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(test_loader2):\n\u001b[1;32m 6\u001b[0m X, y, mask \u001b[38;5;241m=\u001b[39m X\u001b[38;5;241m.\u001b[39mto(device), y\u001b[38;5;241m.\u001b[39mto(device), mask\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[1;32m 7\u001b[0m mask_rev \u001b[38;5;241m=\u001b[39m (torch\u001b[38;5;241m.\u001b[39msqueeze(mask, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;66;03m# mask取反获得修复区域\u001b[39;00m\n", + "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 3)" + ] + } + ], + "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_loader2):\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 = torch.squeeze(y * MAX_VALUE, dim=1)\n", + " rev_recon = torch.squeeze(reconstructed * MAX_VALUE, dim=1)\n", + " # todo: 这里需要只评估修补出来的模块\n", + " data_label = rev_data * mask_rev\n", + " data_label = data_label[mask_rev==1]\n", + " recon_no2 = rev_recon * mask_rev\n", + " recon_no2 = recon_no2[mask_rev==1]\n", + " y_true = rev_data.flatten()\n", + " y_pred = rev_recon.flatten()\n", + " mae = mean_absolute_error(y_true, y_pred)\n", + " rmse = np.sqrt(mean_squared_error(y_true, y_pred))\n", + " mape = mean_absolute_percentage_error(y_true, y_pred)\n", + " r2 = r2_score(y_true, y_pred)\n", + " ioa = cal_ioa(data_label.detach().numpy(), recon_no2.detach().numpy())\n", + " eva_list.append([mae, rmse, mape, r2, ioa])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "41fa754d-1eee-43a2-9e39-a0254719be30", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioa
count149.000000149.000000149.000000149.000000149.000000
mean2.2356624.0423490.2384940.6260600.572341
std0.1927090.3574750.0074050.0428900.042652
min1.7865673.1671430.2247960.5221570.460707
25%2.0841173.7792760.2329740.5977740.547144
50%2.2260624.0754650.2374290.6275880.570579
75%2.3614114.2845230.2438660.6562260.601233
max2.7513774.9174070.2582300.7409430.666083
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa\n", + "count 149.000000 149.000000 149.000000 149.000000 149.000000\n", + "mean 2.235662 4.042349 0.238494 0.626060 0.572341\n", + "std 0.192709 0.357475 0.007405 0.042890 0.042652\n", + "min 1.786567 3.167143 0.224796 0.522157 0.460707\n", + "25% 2.084117 3.779276 0.232974 0.597774 0.547144\n", + "50% 2.226062 4.075465 0.237429 0.627588 0.570579\n", + "75% 2.361411 4.284523 0.243866 0.656226 0.601233\n", + "max 2.751377 4.917407 0.258230 0.740943 0.666083" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "46cffa4a-37bc-4e13-9723-fc6cb244c95c", + "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_VALUE\n", + " rev_recon = reconstructed * MAX_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])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6f6a897-2f48-4958-8725-f566430c61e1", + "metadata": {}, + "outputs": [], + "source": [ + "eva_frame_df = pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).sort_values(by='mape')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "6d1920e7-b92f-414e-8273-0b4666587904", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean5.9200176.8642450.603656-2.7430170.2285800.225978
std3.5346483.8450340.2246792.0497530.3706220.227965
min1.4773801.8493920.271934-22.827546-1.899284-0.626938
25%2.9757003.6005210.502338-3.6317020.0428750.088760
50%4.1690985.0558900.558942-2.2335300.3095920.253954
75%8.6167989.8090690.632651-1.2876020.5099370.389390
max18.84077520.3710253.6898530.0242940.8353390.782481
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 5.920017 6.864245 0.603656 -2.743017 0.228580 \n", + "std 3.534648 3.845034 0.224679 2.049753 0.370622 \n", + "min 1.477380 1.849392 0.271934 -22.827546 -1.899284 \n", + "25% 2.975700 3.600521 0.502338 -3.631702 0.042875 \n", + "50% 4.169098 5.055890 0.558942 -2.233530 0.309592 \n", + "75% 8.616798 9.809069 0.632651 -1.287602 0.509937 \n", + "max 18.840775 20.371025 3.689853 0.024294 0.835339 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.225978 \n", + "std 0.227965 \n", + "min -0.626938 \n", + "25% 0.088760 \n", + "50% 0.253954 \n", + "75% 0.389390 \n", + "max 0.782481 " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eva_frame_df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "d1696b4f-1520-4201-b855-63f517022ec3", + "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/vitmae_20_samples.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "56291a37-cc49-428f-a8db-99bdd7a1f062", + "metadata": {}, + "outputs": [], + "source": [ + "torch.save(model, './models/MAE/vit.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "bb8eccaa-7409-4cce-9119-70aed5ee496e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'1114', '1952', '2568', '3523', '602'}" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "find_ex = set([x.split('-')[0].strip() for x in os.listdir('./test_img/') if 'npy' in x])\n", + "find_ex" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "b9c6cdba-e563-42e2-885d-d1df320dac02", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for j in find_ex:\n", + " ori = np.load(f'./test_img/{j}-real.npy')[0]\n", + " mask = np.load(f'./test_img/{j}-mask.npy')\n", + " mask_rev = 1 - mask\n", + " img_in = ori * mask_rev / MAX_VALUE\n", + " img_out = model(torch.tensor(img_in.reshape(1, 1, 96, 96), dtype=torch.float32)).detach().cpu().numpy()[0][0] * MAX_VALUE\n", + " out = ori * mask_rev + img_out * mask\n", + " plt.imshow(out, cmap='RdYlGn_r')\n", + " plt.gca().axis('off')\n", + " plt.savefig(f'./test_img/out_fig/{j}-mae_vit_out.png', bbox_inches='tight')\n", + " plt.clf()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3f24f2a-bc47-409d-8e46-bfa62851701b", + "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 +} diff --git a/torch_MAE_1d_ViT.ipynb b/torch_MAE_1d_ViT.ipynb new file mode 100644 index 0000000..108818c --- /dev/null +++ b/torch_MAE_1d_ViT.ipynb @@ -0,0 +1,608 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "fa295d87-946f-402b-9d97-1127ee9a33a0", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader, Dataset, random_split\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os\n", + "from PIL import Image\n", + "\n", + "MAX_VALUE = 107.49169921875" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c6dd8e35-02e3-491c-b4be-a874cf1054ba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "device(type='cuda')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2f151caf-43d1-4d59-a111-96ad5e6bc38b", + "metadata": {}, + "outputs": [], + "source": [ + "class GrayScaleDataset(Dataset):\n", + " def __init__(self, data_dir):\n", + " self.data_dir = data_dir\n", + " self.file_list = [x for x in os.listdir(data_dir) if x.endswith('npy')]\n", + "\n", + " def __len__(self):\n", + " return len(self.file_list)\n", + "\n", + " def __getitem__(self, idx):\n", + " file_path = os.path.join(self.data_dir, self.file_list[idx])\n", + " data = np.load(file_path)[:,:,0] / MAX_VALUE\n", + " return torch.tensor(data, dtype=torch.float32).unsqueeze(0)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3ecd7bd0-15a0-4420-95e1-066e4d023cd3", + "metadata": {}, + "outputs": [], + "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 = idx % len(self.mask_filenames)\n", + " mask_path = os.path.join(self.mask_dir, self.mask_filenames[mask_idx])\n", + "\n", + " # 加载图像数据 (.npy 文件)\n", + " image = np.load(image_path).astype(np.float32)[:,:,:1] / MAX_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)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "36752a6d-329a-464d-a329-f02206bf63b0", + "metadata": {}, + "outputs": [], + "source": [ + "class PatchMasking:\n", + " def __init__(self, patch_size, mask_ratio):\n", + " self.patch_size = patch_size\n", + " self.mask_ratio = mask_ratio\n", + "\n", + " def __call__(self, x):\n", + " batch_size, C, H, W = x.shape\n", + " num_patches = (H // self.patch_size) * (W // self.patch_size)\n", + " num_masked = int(num_patches * self.mask_ratio)\n", + " \n", + " # 为每个样本生成独立的mask\n", + " masks = []\n", + " for _ in range(batch_size):\n", + " mask = torch.zeros(num_patches, dtype=torch.bool, device=x.device)\n", + " mask[:num_masked] = 1\n", + " mask = mask[torch.randperm(num_patches)]\n", + " mask = mask.view(H // self.patch_size, W // self.patch_size)\n", + " mask = mask.repeat_interleave(self.patch_size, dim=0).repeat_interleave(self.patch_size, dim=1)\n", + " masks.append(mask)\n", + " \n", + " # 将所有mask堆叠成一个批量张量\n", + " masks = torch.stack(masks, dim=0)\n", + " masks = torch.unsqueeze(masks, dim=1)\n", + " \n", + " # 应用mask到输入x上\n", + " masked_x = x * (1 - masks.float())\n", + " return masked_x, masks" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0db0d920-8de2-4bad-9b99-67eed152644d", + "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": 6, + "id": "cb27d3a7-77ed-4110-96bd-bcc4880964d2", + "metadata": {}, + "outputs": [], + "source": [ + "class ViTEncoder(nn.Module):\n", + " def __init__(self, img_size=96, patch_size=8, dim=128, depth=4, heads=4, mlp_dim=256):\n", + " super(ViTEncoder, self).__init__()\n", + " self.patch_size = patch_size\n", + " self.dim = dim\n", + " self.patch_embedding = nn.Conv2d(1, dim, kernel_size=patch_size, stride=patch_size)\n", + " \n", + " # 定义 Transformer 编码器层\n", + " encoder_layer = nn.TransformerEncoderLayer(d_model=dim, nhead=heads, dim_feedforward=mlp_dim)\n", + " self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=depth)\n", + "\n", + " def forward(self, x):\n", + " x = self.patch_embedding(x)\n", + " x = x.flatten(2).transpose(1, 2) # 形状变为 (batch_size, num_patches, dim)\n", + " x = self.transformer_encoder(x)\n", + " return x\n", + "\n", + "class ConvDecoder(nn.Module):\n", + " def __init__(self, dim=128, patch_size=8, img_size=96):\n", + " super(ConvDecoder, self).__init__()\n", + " self.dim = dim\n", + " self.patch_size = patch_size\n", + " self.img_size = img_size\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(dim, 128, kernel_size=patch_size, stride=patch_size),\n", + " nn.ReLU(),\n", + " nn.ConvTranspose2d(128, 1, kernel_size=3, stride=1, padding=1)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " # x = x.transpose(1, 2).view(-1, self.dim, self.img_size // self.patch_size, self.img_size // self.patch_size)\n", + " x = self.decoder(x)\n", + " return x\n", + "\n", + "class MAEModel(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(MAEModel, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + "\n", + " def forward(self, x):\n", + " encoded = self.encoder(x)\n", + " decoded = self.decoder(encoded)\n", + " return decoded" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "783e62af-7f6a-40bd-a423-be63fe98a655", + "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": 8, + "id": "baeffdf0-cdc2-44c4-972a-e2e671635d6a", + "metadata": {}, + "outputs": [], + "source": [ + "def train_model(model, train_loader, val_loader, epochs, criterion, optimizer, device):\n", + " model.to(device)\n", + " for epoch in range(epochs):\n", + " model.train()\n", + " train_loss = 0\n", + " for data in train_loader:\n", + " data = data.to(device)\n", + " optimizer.zero_grad()\n", + " masked_data, mask = PatchMasking(patch_size=16, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " loss = masked_mse_loss(output, data, mask)\n", + " loss.backward()\n", + " optimizer.step()\n", + " train_loss += loss.item()\n", + " train_loss /= len(train_loader)\n", + "\n", + " model.eval()\n", + " val_loss = 0\n", + " with torch.no_grad():\n", + " for data in val_loader:\n", + " data = data.to(device)\n", + " masked_data, mask = PatchMasking(patch_size=16, mask_ratio=0.2)(data)\n", + " output = model(masked_data)\n", + " loss = masked_mse_loss(output, data, mask)\n", + " val_loss += loss.item()\n", + " val_loss /= len(val_loader)\n", + "\n", + " print(f'Epoch {epoch+1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bb524f86-aa7d-44ee-b13e-b9ba4e5b3a0b", + "metadata": {}, + "outputs": [], + "source": [ + "train_dir = './out_mat/96/train/'\n", + "train_dataset = GrayScaleDataset(train_dir)\n", + "\n", + "val_dir = './out_mat/96/valid/'\n", + "val_dataset = GrayScaleDataset(val_dir)\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7d6d07a4-31f1-4350-a487-b583db979381", + "metadata": {}, + "outputs": [], + "source": [ + "encoder = ViTEncoder()\n", + "decoder = ConvDecoder()\n", + "model = MAEModel(encoder, decoder)\n", + "criterion = nn.MSELoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "8ee33651-f5f0-4b92-96e9-a84e32725b44", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([128, 128, 6, 6])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.transpose(1, 2).reshape(-1, 128, 6, 6).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a5684758-bc6d-45b0-b885-da37820ca5ac", + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Given groups=1, weight of size [256, 128, 1, 1], expected input[1, 32, 144, 128] to have 128 channels, but got 32 channels instead", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m train_loader:\n\u001b[1;32m 2\u001b[0m a \u001b[38;5;241m=\u001b[39m encoder(i)\n\u001b[0;32m----> 3\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmlp\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m c \u001b[38;5;241m=\u001b[39m decoder(b)\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "Cell \u001b[0;32mIn[12], line 13\u001b[0m, in \u001b[0;36mMlp.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[0;32m---> 13\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfc1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 14\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mact(x)\n\u001b[1;32m 15\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdrop(x)\n", + "File \u001b[0;32m~/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/conv.py:460\u001b[0m, in \u001b[0;36mConv2d.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 459\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 460\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_conv_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/conv.py:456\u001b[0m, in \u001b[0;36mConv2d._conv_forward\u001b[0;34m(self, input, weight, bias)\u001b[0m\n\u001b[1;32m 452\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding_mode \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mzeros\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m 453\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m F\u001b[38;5;241m.\u001b[39mconv2d(F\u001b[38;5;241m.\u001b[39mpad(\u001b[38;5;28minput\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reversed_padding_repeated_twice, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding_mode),\n\u001b[1;32m 454\u001b[0m weight, bias, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstride,\n\u001b[1;32m 455\u001b[0m _pair(\u001b[38;5;241m0\u001b[39m), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdilation, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgroups)\n\u001b[0;32m--> 456\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv2d\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 457\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpadding\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdilation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgroups\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mRuntimeError\u001b[0m: Given groups=1, weight of size [256, 128, 1, 1], expected input[1, 32, 144, 128] to have 128 channels, but got 32 channels instead" + ] + } + ], + "source": [ + "for i in train_loader:\n", + " a = encoder(i)\n", + " b = model.mlp(a)\n", + " c = decoder(b)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09b04e16-3257-4890-b736-a6c7274561e0", + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "train_model(model, train_loader, val_loader, epochs=100, criterion=criterion, optimizer=optimizer, device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b0c5cf4b-aca2-4781-8b47-bf2a46269635", + "metadata": {}, + "outputs": [], + "source": [ + "test_set = NO2Dataset('./out_mat/96/test/', './out_mat/96/mask/20/')\n", + "test_loader = DataLoader(test_set, batch_size=32, shuffle=False, num_workers=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "56653f37-899a-47d6-8d50-e456b4ad1835", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "f1ecbd05-7aa3-43ae-8bc2-aa44d19689b9", + "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 = 2 * 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": 22, + "id": "e840b789-bf68-4b4d-a8d3-c5362c310349", + "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_VALUE\n", + " rev_recon = reconstructed * MAX_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", + " eva_list.append([mae, rmse, mape, r2, ioa])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "41fa754d-1eee-43a2-9e39-a0254719be30", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioa
count149.000000149.000000149.000000149.000000149.000000
mean7.0682079.0164650.814727-0.9527930.564749
std0.6591180.7745560.0541470.1628510.033048
min5.6093277.1135440.599120-1.4027350.461420
25%6.6133518.4996990.782008-1.0499510.544980
50%7.0864439.0458120.811261-0.9387650.567080
75%7.4953099.5304080.848900-0.8492660.586134
max8.66380110.9950040.984343-0.5917990.630479
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa\n", + "count 149.000000 149.000000 149.000000 149.000000 149.000000\n", + "mean 7.068207 9.016465 0.814727 -0.952793 0.564749\n", + "std 0.659118 0.774556 0.054147 0.162851 0.033048\n", + "min 5.609327 7.113544 0.599120 -1.402735 0.461420\n", + "25% 6.613351 8.499699 0.782008 -1.049951 0.544980\n", + "50% 7.086443 9.045812 0.811261 -0.938765 0.567080\n", + "75% 7.495309 9.530408 0.848900 -0.849266 0.586134\n", + "max 8.663801 10.995004 0.984343 -0.591799 0.630479" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b15bbdc-cb87-4648-b22f-72917b8c1e6b", + "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 +} diff --git a/torch_MAE_1d_baseline.ipynb b/torch_MAE_1d_baseline.ipynb new file mode 100644 index 0000000..4070432 --- /dev/null +++ b/torch_MAE_1d_baseline.ipynb @@ -0,0 +1,895 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 30, + "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 pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import cv2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e0afbbc4-cd35-49f7-986f-2c0a6fff5ec1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(0)\n", + "torch.random.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "95baeec7-508b-480c-b598-aecab7497a99", + "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": 6, + "id": "9a8fe22d-5029-427f-bae8-01934a0d5c35", + "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/20/'\n", + "\n", + "print(f\"checkpoint before Generator is OK\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ddbc13ba-a0e8-477e-895e-371a78085bac", + "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": 8, + "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": 9, + "id": "aeda3567-4c4d-496b-9570-9ae757b45e72", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda\n" + ] + } + ], + "source": [ + "# 设置随机种子以确保结果的可重复性\n", + "torch.manual_seed(0)\n", + "np.random.seed(0)\n", + "\n", + "# 数据准备\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f821d0a1-dfee-483e-b081-68c963bdb8a0", + "metadata": {}, + "outputs": [], + "source": [ + "# 定义Masked Autoencoder模型\n", + "class MaskedAutoencoderBase(nn.Module):\n", + " def __init__(self):\n", + " super(MaskedAutoencoderBase, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(128, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(),\n", + " nn.ConvTranspose2d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(),\n", + " nn.ConvTranspose2d(16, 1, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.Sigmoid() # 使用Sigmoid是因为输入数据是0-1之间的\n", + " )\n", + "\n", + " def forward(self, x):\n", + " encoded = self.encoder(x)\n", + " decoded = self.decoder(encoded)\n", + " return decoded" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2dc47416-511e-4874-abaf-30dd912a0e7d", + "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": 12, + "id": "2e77e837-071c-46d0-9779-80bb333db800", + "metadata": {}, + "outputs": [], + "source": [ + "# 实例化模型、损失函数和优化器\n", + "model = MaskedAutoencoderBase()\n", + "criterion = nn.MSELoss()\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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": 19, + "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", + " # loss = criterion(reconstructed, y)\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "743d1000-561e-4444-8b49-88346c14f28b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 2.4377448216936233, Val Loss: 0.1723788405087457\n", + "Epoch 2, Train Loss: 0.09637997932197374, Val Loss: 0.07621741728551353\n", + "Epoch 3, Train Loss: 0.06397618102934657, Val Loss: 0.06195200451496822\n", + "Epoch 4, Train Loss: 0.052692288621974906, Val Loss: 0.052603201690449644\n", + "Epoch 5, Train Loss: 0.045533701719529036, Val Loss: 0.0462518873721806\n", + "Epoch 6, Train Loss: 0.040426999678095564, Val Loss: 0.04118765834996949\n", + "Epoch 7, Train Loss: 0.03643315702979787, Val Loss: 0.0370612932619319\n", + "Epoch 8, Train Loss: 0.03297993362074691, Val Loss: 0.0338741072189452\n", + "Epoch 9, Train Loss: 0.030229569176595177, Val Loss: 0.03180063916231269\n", + "Epoch 10, Train Loss: 0.028299911767600827, Val Loss: 0.03058352780097456\n", + "Epoch 11, Train Loss: 0.026935207724357337, Val Loss: 0.029766072282817826\n", + "Epoch 12, Train Loss: 0.026076676769618782, Val Loss: 0.028107319638800265\n", + "Epoch 13, Train Loss: 0.02534967841821139, Val Loss: 0.027272115475428637\n", + "Epoch 14, Train Loss: 0.024701394381349166, Val Loss: 0.02684043228292643\n", + "Epoch 15, Train Loss: 0.0240272392550011, Val Loss: 0.02594853615138068\n", + "Epoch 16, Train Loss: 0.0233813104438083, Val Loss: 0.025640942656726978\n", + "Epoch 17, Train Loss: 0.02310016915273438, Val Loss: 0.02571806650775582\n", + "Epoch 18, Train Loss: 0.022718923658792054, Val Loss: 0.024644668200122778\n", + "Epoch 19, Train Loss: 0.022323213453052576, Val Loss: 0.024273945435659208\n", + "Epoch 20, Train Loss: 0.02199719715685223, Val Loss: 0.02410240029332353\n", + "Epoch 21, Train Loss: 0.021530815467024535, Val Loss: 0.02380427871066243\n", + "Epoch 22, Train Loss: 0.021460241776262743, Val Loss: 0.0232450627346537\n", + "Epoch 23, Train Loss: 0.02090326771050977, Val Loss: 0.022885078564286232\n", + "Epoch 24, Train Loss: 0.020652044475363774, Val Loss: 0.022562191390724323\n", + "Epoch 25, Train Loss: 0.02051923798985387, Val Loss: 0.022203324724044373\n", + "Epoch 26, Train Loss: 0.020149177833767743, Val Loss: 0.022744494337421744\n", + "Epoch 27, Train Loss: 0.020068248640300268, Val Loss: 0.022425833088693333\n", + "Epoch 28, Train Loss: 0.019720358143529397, Val Loss: 0.02253118777341807\n", + "Epoch 29, Train Loss: 0.01939903690288084, Val Loss: 0.021765351378873213\n", + "Epoch 30, Train Loss: 0.01943497322989922, Val Loss: 0.021345259649540062\n", + "Epoch 31, Train Loss: 0.019241397384928458, Val Loss: 0.02124041018646155\n", + "Epoch 32, Train Loss: 0.01906546402464144, Val Loss: 0.021633521083797982\n", + "Epoch 33, Train Loss: 0.01884070100512302, Val Loss: 0.021043253979131357\n", + "Epoch 34, Train Loss: 0.01874133140855785, Val Loss: 0.02059999839472237\n", + "Epoch 35, Train Loss: 0.01853996916544851, Val Loss: 0.021178998303279947\n", + "Epoch 36, Train Loss: 0.018260161060412106, Val Loss: 0.020367807639178944\n", + "Epoch 37, Train Loss: 0.01830708983233956, Val Loss: 0.020017842692670536\n", + "Epoch 38, Train Loss: 0.018042967790675362, Val Loss: 0.020187884722071798\n", + "Epoch 39, Train Loss: 0.017922898732197056, Val Loss: 0.019615614786744118\n", + "Epoch 40, Train Loss: 0.017794321282236486, Val Loss: 0.019430582606191956\n", + "Epoch 41, Train Loss: 0.017688655022656517, Val Loss: 0.019477688401603875\n", + "Epoch 42, Train Loss: 0.017460078103512383, Val Loss: 0.018902005530448993\n", + "Epoch 43, Train Loss: 0.01727662416638441, Val Loss: 0.018832763184362382\n", + "Epoch 44, Train Loss: 0.017280888195599666, Val Loss: 0.019056980081124983\n", + "Epoch 45, Train Loss: 0.017114856775012312, Val Loss: 0.018604515495696174\n", + "Epoch 46, Train Loss: 0.016909640970858234, Val Loss: 0.018437264904157438\n", + "Epoch 47, Train Loss: 0.016691252999185946, Val Loss: 0.01889144025965413\n", + "Epoch 48, Train Loss: 0.016869753608079047, Val Loss: 0.018732781104965887\n", + "Epoch 49, Train Loss: 0.01653263871179243, Val Loss: 0.01850963812043418\n", + "Epoch 50, Train Loss: 0.01653244017520875, Val Loss: 0.0178856217344083\n", + "Epoch 51, Train Loss: 0.016499577624874823, Val Loss: 0.01781756227919415\n", + "Epoch 52, Train Loss: 0.016335643743249504, Val Loss: 0.01821571894323648\n", + "Epoch 53, Train Loss: 0.016375035212406415, Val Loss: 0.017511379168327176\n", + "Epoch 54, Train Loss: 0.016288986672428948, Val Loss: 0.017456448650849398\n", + "Epoch 55, Train Loss: 0.01623404509517137, Val Loss: 0.017827068525018978\n", + "Epoch 56, Train Loss: 0.016188283936615196, Val Loss: 0.017475027326883663\n", + "Epoch 57, Train Loss: 0.01605349867359588, Val Loss: 0.017256822728955033\n", + "Epoch 58, Train Loss: 0.015958637990610022, Val Loss: 0.017457437256712522\n", + "Epoch 59, Train Loss: 0.016034694237001774, Val Loss: 0.017437012713235705\n", + "Epoch 60, Train Loss: 0.0158486066956483, Val Loss: 0.017560158175096582\n", + "Epoch 61, Train Loss: 0.015632042563275286, Val Loss: 0.01692103194211846\n", + "Epoch 62, Train Loss: 0.015540152108608677, Val Loss: 0.01698271286632143\n", + "Epoch 63, Train Loss: 0.01545496231043025, Val Loss: 0.01699626362368242\n", + "Epoch 64, Train Loss: 0.015430795162488398, Val Loss: 0.01687317063559347\n", + "Epoch 65, Train Loss: 0.015489797350732191, Val Loss: 0.017046043955123248\n", + "Epoch 66, Train Loss: 0.015236956011682179, Val Loss: 0.0172197060214717\n", + "Epoch 67, Train Loss: 0.015348140916755895, Val Loss: 0.016508253249548265\n", + "Epoch 68, Train Loss: 0.015228347097519055, Val Loss: 0.016413471842212462\n", + "Epoch 69, Train Loss: 0.01516882229025997, Val Loss: 0.01686259738600521\n", + "Epoch 70, Train Loss: 0.015173258315593574, Val Loss: 0.01757873013726811\n", + "Epoch 71, Train Loss: 0.015156847716678986, Val Loss: 0.016662339123883353\n", + "Epoch 72, Train Loss: 0.015105586064507088, Val Loss: 0.016890839868183457\n", + "Epoch 73, Train Loss: 0.014925161955887051, Val Loss: 0.015931842709655194\n", + "Epoch 74, Train Loss: 0.014886363126497947, Val Loss: 0.016006485308840204\n", + "Epoch 75, Train Loss: 0.015015289608531735, Val Loss: 0.015968994154080526\n", + "Epoch 76, Train Loss: 0.014806462892968403, Val Loss: 0.015919692327838336\n", + "Epoch 77, Train Loss: 0.014728168116962653, Val Loss: 0.015852669684855797\n", + "Epoch 78, Train Loss: 0.014845167781319914, Val Loss: 0.016079049404543726\n", + "Epoch 79, Train Loss: 0.014719554133998435, Val Loss: 0.015957326447563387\n", + "Epoch 80, Train Loss: 0.014635249268281404, Val Loss: 0.015849308388780303\n", + "Epoch 81, Train Loss: 0.014474964379800849, Val Loss: 0.015526832887597049\n", + "Epoch 82, Train Loss: 0.014369143295641007, Val Loss: 0.015485089967277512\n", + "Epoch 83, Train Loss: 0.014446225396076743, Val Loss: 0.015848276135859204\n", + "Epoch 84, Train Loss: 0.014476079110537419, Val Loss: 0.015343323600158762\n", + "Epoch 85, Train Loss: 0.014672522836378174, Val Loss: 0.015515949938501885\n", + "Epoch 86, Train Loss: 0.014440825409545568, Val Loss: 0.015224411166203556\n", + "Epoch 87, Train Loss: 0.014462759978980111, Val Loss: 0.015663697370397512\n", + "Epoch 88, Train Loss: 0.01440465696262971, Val Loss: 0.015856551353944773\n", + "Epoch 89, Train Loss: 0.014255739579146559, Val Loss: 0.015246662380757616\n", + "Epoch 90, Train Loss: 0.014205876624202756, Val Loss: 0.015011716536732752\n", + "Epoch 91, Train Loss: 0.014259663818216924, Val Loss: 0.015085076996639593\n", + "Epoch 92, Train Loss: 0.014251617286978156, Val Loss: 0.015133185506756627\n", + "Epoch 93, Train Loss: 0.014119144052302723, Val Loss: 0.015415464166496227\n", + "Epoch 94, Train Loss: 0.014192042264053554, Val Loss: 0.015254960033986995\n", + "Epoch 95, Train Loss: 0.014140318196855094, Val Loss: 0.017451592276234235\n", + "Epoch 96, Train Loss: 0.014092271857890502, Val Loss: 0.015359595265072672\n", + "Epoch 97, Train Loss: 0.01409529693843574, Val Loss: 0.015055305060388437\n", + "Epoch 98, Train Loss: 0.014136464546688578, Val Loss: 0.015083992547953307\n", + "Epoch 99, Train Loss: 0.013914715411792103, Val Loss: 0.014718598477653604\n", + "Epoch 100, Train Loss: 0.013870610982518305, Val Loss: 0.01483591334588492\n", + "Test Loss: 0.010182651478874807\n" + ] + } + ], + "source": [ + "model = model.to(device)\n", + "\n", + "num_epochs = 100\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": 24, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3U0lEQVR4nO3deXxU9b3/8fc5M8mEQBJAzIKGxQrIJjsYuD+XGkVUCtpaS7kFtNprC61KbSttpS4PjdWKtFblen0o11bEDdCLKwURkIiAxooLbkiokoBSEhKWJHO+vz/mzGSiBDIkOYcwr+fjcR4hM2f5zjch857POef7tYwxRgAAAD6x/W4AAABIboQRAADgK8IIAADwFWEEAAD4ijACAAB8RRgBAAC+IowAAABfEUYAAICvgn43oCkcx9EXX3yhjIwMWZbld3MAAEATGGO0Z88ede3aVbbdeP2jTYSRL774Qvn5+X43AwAAHIFt27bpxBNPbPT5NhFGMjIyJEVeTGZmps+tAQAATVFZWan8/PzY+3hj2kQYiZ6ayczMJIwAANDGHO4SCy5gBQAAvkoojBQVFWnEiBHKyMhQdna2Jk6cqM2bNx9ym/nz58uyrAZLWlpasxoNAACOHQmFkVdffVXTp0/X66+/rmXLlqm2tlbnnnuuqqurD7ldZmamtm/fHlu2bt3arEYDAIBjR0LXjLz44osNvp8/f76ys7O1ceNGnX766Y1uZ1mWcnNzj6yFAIBjUjgcVm1trd/NQDMEAgEFg8FmD7vRrAtYKyoqJEmdO3c+5HpVVVXq3r27HMfR0KFDddttt6l///6Nrn/gwAEdOHAg9n1lZWVzmgkAOMpUVVXpX//6l4wxfjcFzZSenq68vDylpqYe8T4sc4S/CY7j6Dvf+Y52796tNWvWNLpecXGxPvroI5166qmqqKjQn/70J61atUrvvvtuo/cc33jjjbrpppu+8XhFRQV30wBAGxcOh/XRRx8pPT1dxx9/PINZtlHGGNXU1Gjnzp0Kh8Pq1avXNwY2q6ysVFZW1mHfv484jPz0pz/VCy+8oDVr1hxyIJOvq62tVd++fTVp0iTdcsstB13nYJWR/Px8wggAHAP279+vLVu2qEePHmrXrp3fzUEz7d27V1u3blXPnj2/cYNKU8PIEZ2mmTFjhpYuXapVq1YlFEQkKSUlRUOGDNHHH3/c6DqhUEihUOhImgYAaCOoiBwbDjXMe5P3kcjKxhjNmDFDixcv1ooVK9SzZ8+EDxgOh/XOO+8oLy8v4W0BAMCxJ6HKyPTp07VgwQI988wzysjIUFlZmSQpKysrVmqbMmWKTjjhBBUVFUmSbr75Zp122mk6+eSTtXv3bt15553aunWrrrjiihZ+KQAAoC1KqDJy//33q6KiQmeeeaby8vJiy+OPPx5bp7S0VNu3b499/+9//1tXXnml+vbtq/PPP1+VlZVau3at+vXr13KvAgCANqRHjx6aO3dui+xr5cqVsixLu3fvbpH9+SGhykhTrnVduXJlg+/vvvtu3X333Qk1CgCAo82ZZ56pwYMHt0iIWL9+vdq3b9/8Rh0j2sREea3lwdWf6l//3qdJI7upT+6hZxQEAOBQjDEKh8MKBg//1nr88cd70KK2I6knynvune2av/Yzbf3q0MPZAwBajzFGe2vqfFmaOrrFtGnT9Oqrr+rPf/5zbJ616NxrL7zwgoYNG6ZQKKQ1a9bok08+0YQJE5STk6MOHTpoxIgR+sc//tFgf18/TWNZlh588EFddNFFSk9PV69evfTss88ecZ8+/fTT6t+/v0KhkHr06KG77rqrwfP33XefevXqpbS0NOXk5Oh73/te7LmnnnpKAwcOVLt27XTcccepsLDwsNO+NFdSV0aCduS2MocRAAHAN/tqw+o3+yVfjv3ezWOVnnr4t8I///nP+vDDDzVgwADdfPPNkqR3331XknT99dfrT3/6k0466SR16tRJ27Zt0/nnn69bb71VoVBIjzzyiMaPH6/NmzerW7dujR7jpptu0h133KE777xT99xzjyZPnqytW7cedpTzr9u4caO+//3v68Ybb9Sll16qtWvX6mc/+5mOO+44TZs2TRs2bNAvfvEL/e1vf9Po0aO1a9curV69WpK0fft2TZo0SXfccYcuuugi7dmzR6tXr271kXKTOozY7j3udQ5hBADQuKysLKWmpio9PT0219oHH3wgKXLX6DnnnBNbt3Pnzho0aFDs+1tuuUWLFy/Ws88+qxkzZjR6jGnTpmnSpEmSpNtuu01/+ctf9MYbb+i8885LqK1z5szR2WefrRtuuEGS1Lt3b7333nu68847NW3aNJWWlqp9+/a68MILlZGRoe7du2vIkCGSImGkrq5OF198sbp37y5JGjhwYELHPxJJHUaCgUgYCRNGAMA37VICeu/msb4du7mGDx/e4PuqqirdeOONeu6552Jv7vv27VNpaekh93PqqafG/t2+fXtlZmZqx44dCbfn/fff14QJExo8NmbMGM2dO1fhcFjnnHOOunfvrpNOOknnnXeezjvvvNjpoUGDBunss8/WwIEDNXbsWJ177rn63ve+p06dOiXcjkQk9TUj0coIYQQA/GNZltJTg74sLTEK7Nfvirnuuuu0ePFi3XbbbVq9erVKSko0cOBA1dTUHHI/KSkp3+gXx3Ga3b6vy8jI0JtvvqnHHntMeXl5mj17tgYNGqTdu3crEAho2bJleuGFF9SvXz/dc8896tOnj7Zs2dLi7YiX1GEkes0Ip2kAAIeTmpqqcDh82PVee+01TZs2TRdddJEGDhyo3NxcffbZZ63fQFffvn312muvfaNNvXv3ViAQqQQFg0EVFhbqjjvu0D//+U999tlnWrFihaRICBozZoxuuukmvfXWW0pNTdXixYtbtc1JfZom4I6n7xBGAACH0aNHD61bt06fffaZOnTo0GjVolevXlq0aJHGjx8vy7J0ww03tEqFozG//OUvNWLECN1yyy269NJLVVxcrL/+9a+67777JElLly7Vp59+qtNPP12dOnXS888/L8dx1KdPH61bt07Lly/Xueeeq+zsbK1bt047d+5U3759W7XNSV0ZCbivnsoIAOBwrrvuOgUCAfXr10/HH398o9eAzJkzR506ddLo0aM1fvx4jR07VkOHDvWsnUOHDtUTTzyhhQsXasCAAZo9e7ZuvvlmTZs2TZLUsWNHLVq0SN/+9rfVt29fzZs3T4899pj69++vzMxMrVq1Sueff7569+6t3//+97rrrrs0bty4Vm2zZVr7fp0W0NQpiBM1/dE39dw723XzhP6aUtCjxfYLAGjc/v37tWXLloNOOY+251A/z6a+fyd1ZcSOXjMSPurzGAAAx6ykDiPRC1i5mwYAcLS66qqr1KFDh4MuV111ld/NaxFJfgGrG0aO/jNVAIAkdfPNN+u666476HMteemCn5I7jDDOCADgKJedna3s7Gy/m9Gqkvo0TYARWAEA8F1yhxHmpgEAwHfJHUZiF7B6NxgNAABoKKnDSP3dND43BACAJJbUYYTKCAAA/iOMiMoIAMAbPXr00Ny5c5u0rmVZWrJkSau252hBGBGVEQAA/EQYEYOeAQDgp6QOIwwHDwBHAWOkmmp/lgQ+jD7wwAPq2rWrnK9V0ydMmKDLL79cn3zyiSZMmKCcnBx16NBBI0aM0D/+8Y8W66Z33nlH3/72t9WuXTsdd9xx+slPfqKqqqrY8ytXrtTIkSPVvn17dezYUWPGjNHWrVslSW+//bbOOussZWRkKDMzU8OGDdOGDRtarG3NldQjsDJRHgAcBWr3Srd19efYv/1CSm3fpFUvueQS/fznP9crr7yis88+W5K0a9cuvfjii3r++edVVVWl888/X7feeqtCoZAeeeQRjR8/Xps3b1a3bt2a1czq6mqNHTtWBQUFWr9+vXbs2KErrrhCM2bM0Pz581VXV6eJEyfqyiuv1GOPPaaamhq98cYbstzxtCZPnqwhQ4bo/vvvVyAQUElJiVJSUprVppaU1GEkyGkaAEATderUSePGjdOCBQtiYeSpp55Sly5ddNZZZ8m2bQ0aNCi2/i233KLFixfr2Wef1YwZM5p17AULFmj//v165JFH1L59JDz99a9/1fjx4/XHP/5RKSkpqqio0IUXXqhvfetbkqS+ffvGti8tLdWvfvUrnXLKKZKkXr16Nas9LS2pw4jN3DQA4L+U9EiFwq9jJ2Dy5Mm68sordd999ykUCunRRx/VD37wA9m2raqqKt1444167rnntH37dtXV1Wnfvn0qLS1tdjPff/99DRo0KBZEJGnMmDFyHEebN2/W6aefrmnTpmns2LE655xzVFhYqO9///vKy8uTJM2cOVNXXHGF/va3v6mwsFCXXHJJLLQcDbhmRIQRAPCVZUVOlfixuB9Km2r8+PEyxui5557Ttm3btHr1ak2ePFmSdN1112nx4sW67bbbtHr1apWUlGjgwIGqqalpjV77hocffljFxcUaPXq0Hn/8cfXu3Vuvv/66JOnGG2/Uu+++qwsuuEArVqxQv379tHjxYk/a1RRJHUYChBEAQALS0tJ08cUX69FHH9Vjjz2mPn36aOjQoZKk1157TdOmTdNFF12kgQMHKjc3V5999lmLHLdv3756++23VV1dHXvstddek23b6tOnT+yxIUOGaNasWVq7dq0GDBigBQsWxJ7r3bu3rr32Wr388su6+OKL9fDDD7dI21pCkoeRyMtnojwAQFNNnjxZzz33nB566KFYVUSKXIexaNEilZSU6O2339YPf/jDb9x505xjpqWlaerUqdq0aZNeeeUV/fznP9ePfvQj5eTkaMuWLZo1a5aKi4u1detWvfzyy/roo4/Ut29f7du3TzNmzNDKlSu1detWvfbaa1q/fn2Da0r8ltTXjERP0ziEEQBAE337299W586dtXnzZv3whz+MPT5nzhxdfvnlGj16tLp06aLf/OY3qqysbJFjpqen66WXXtLVV1+tESNGKD09Xd/97nc1Z86c2PMffPCB/vd//1dfffWV8vLyNH36dP3Xf/2X6urq9NVXX2nKlCkqLy9Xly5ddPHFF+umm25qkba1BMuYo/9WksrKSmVlZamiokKZmZkttt+nNv5L1z35ts7ofbz+9/KRLbZfAEDj9u/fry1btqhnz55KS0vzuzlopkP9PJv6/p3Up2lilZGjP48BAHDMSuowwqBnAAA/PProo+rQocNBl/79+/vdPM9xzYi4mwYA4K3vfOc7GjVq1EGfO5pGRvVKUocRJsoDAPghIyNDGRkZfjfjqJHUp2kC7mA33NoLAN5rA/dPoAla4ueY3GEkwK29AOC1QCAgSZ6NTIrWtXfvXknNO72U3KdpqIwAgOeCwaDS09O1c+dOpaSkyLaT+nNxm2WM0d69e7Vjxw517NgxFjKPRFKHkfoLWFtmhDwAwOFZlqW8vDxt2bJFW7du9bs5aKaOHTsqNze3WftI6jDC3DQA4I/U1FT16tWLUzVtXEpKSrMqIlGEERFGAMAPtm0zAiskJfsFrNzaCwCA7wgjksKMwAoAgG8II+JuGgAA/JTUYSTo3k7GRHkAAPgnqcNIwH31VEYAAPBPkoeRyMvnbhoAAPyT3GHE4tZeAAD8ltxhJMAFrAAA+C2pw0h0OHgmygMAwD9JHUZsJsoDAMB3SR1GopURieoIAAB+SeowYseFEaojAAD4I6nDSHxlhDtqAADwR1KHkUB8GGEUVgAAfEEYcTFZHgAA/kjuMGJRGQEAwG9JHUZs21I0j9Q5jr+NAQAgSSUURoqKijRixAhlZGQoOztbEydO1ObNmw+73ZNPPqlTTjlFaWlpGjhwoJ5//vkjbnBLqx/4zOeGAACQpBIKI6+++qqmT5+u119/XcuWLVNtba3OPfdcVVdXN7rN2rVrNWnSJP34xz/WW2+9pYkTJ2rixInatGlTsxvfEuoHPiONAADgB8uYI79YYufOncrOztarr76q008//aDrXHrppaqurtbSpUtjj5122mkaPHiw5s2b16TjVFZWKisrSxUVFcrMzDzS5h5U/9kvqromrFd/daa6H9e+RfcNAEAya+r7d7OuGamoqJAkde7cudF1iouLVVhY2OCxsWPHqri4uNFtDhw4oMrKygZLa4neUcM4IwAA+OOIw4jjOLrmmms0ZswYDRgwoNH1ysrKlJOT0+CxnJwclZWVNbpNUVGRsrKyYkt+fv6RNvOwCCMAAPjriMPI9OnTtWnTJi1cuLAl2yNJmjVrlioqKmLLtm3bWvwYUQE70gXc2gsAgD+CR7LRjBkztHTpUq1atUonnnjiIdfNzc1VeXl5g8fKy8uVm5vb6DahUEihUOhImpawgBvH6hj0DAAAXyRUGTHGaMaMGVq8eLFWrFihnj17HnabgoICLV++vMFjy5YtU0FBQWItbSXBaGWE0zQAAPgiocrI9OnTtWDBAj3zzDPKyMiIXfeRlZWldu3aSZKmTJmiE044QUVFRZKkq6++WmeccYbuuusuXXDBBVq4cKE2bNigBx54oIVfypGJXTPCaRoAAHyRUGXk/vvvV0VFhc4880zl5eXFlscffzy2TmlpqbZv3x77fvTo0VqwYIEeeOABDRo0SE899ZSWLFlyyItevcQFrAAA+CuhykhThiRZuXLlNx675JJLdMkllyRyKM8QRgAA8FdSz00j1U+WRxgBAMAfhBE7Ohw8YQQAAD8kfRgJBqIT5RFGAADwQ9KHkfqJ8ggjAAD4IenDSJALWAEA8FXShxGbMAIAgK+SPowEYxewOj63BACA5JT0YSR6N43DCKwAAPiCMBKtjDBRHgAAvkj6MBKkMgIAgK+SPoxway8AAP5K+jASHfSMu2kAAPBH0oeRgB3pAsIIAAD+IIxECiOEEQAAfEIYoTICAICvCCNuD3ABKwAA/iCMUBkBAMBXSR9GmCgPAAB/JX0YCRBGAADwFWEkGkYYgRUAAF8QRqiMAADgK8IIE+UBAOArwojFRHkAAPiJMBKtjDiOzy0BACA5JX0Yqb+11+eGAACQpJI+jNixMEIaAQDAD0kfRoKx0zRcMwIAgB+SPoxErxlxCCMAAPiCMEJlBAAAXyV9GImepuHWXgAA/JH0YcRm0DMAAHyV9GGEyggAAP5K+jBiW1wzAgCAn5I+jAQDTJQHAICfkj6MBOxIFxBGAADwB2GE0zQAAPiKMMKgZwAA+IowwqBnAAD4KunDSP2svYQRAAD8kPRhJEAYAQDAV4QRwggAAL4ijETDCCOwAgDgC8IIlREAAHxFGIndTeP43BIAAJJT0oeR2ER5ZBEAAHyR9GGkfqI80ggAAH5I+jBSP1Gezw0BACBJJX0Yic5NE6YyAgCALwgjDAcPAICvCCNMlAcAgK8II1RGAADwVdKHkaAd6QKHEVgBAPBF0ocRN4tQGQEAwCdJH0ailRFjuG4EAAA/JH0Yid7aKzFZHgAAfiCMBOLCCJURAAA8l/RhJDo3jUQYAQDAD0kfRuy40zRcxAoAgPcSDiOrVq3S+PHj1bVrV1mWpSVLlhxy/ZUrV8qyrG8sZWVlR9rmFkVlBAAAfyUcRqqrqzVo0CDde++9CW23efNmbd++PbZkZ2cneuhWYRNGAADwVTDRDcaNG6dx48YlfKDs7Gx17Ngx4e28ELQt1TmGMAIAgA88u2Zk8ODBysvL0znnnKPXXnvtkOseOHBAlZWVDZbWFB0Snlt7AQDwXquHkby8PM2bN09PP/20nn76aeXn5+vMM8/Um2++2eg2RUVFysrKii35+fmt2sZYGAkTRgAA8FrCp2kS1adPH/Xp0yf2/ejRo/XJJ5/o7rvv1t/+9reDbjNr1izNnDkz9n1lZWWrBpL6yfKcVjsGAAA4uFYPIwczcuRIrVmzptHnQ6GQQqGQZ+2JhhEmywMAwHu+jDNSUlKivLw8Pw59UMFYZYQwAgCA1xKujFRVVenjjz+Ofb9lyxaVlJSoc+fO6tatm2bNmqXPP/9cjzzyiCRp7ty56tmzp/r376/9+/frwQcf1IoVK/Tyyy+33Ktoptg1I4QRAAA8l3AY2bBhg84666zY99FrO6ZOnar58+dr+/btKi0tjT1fU1OjX/7yl/r888+Vnp6uU089Vf/4xz8a7MNv0cnyCCMAAHjPMubov1CisrJSWVlZqqioUGZmZovv///dsULbdu3T4p+N1pBunVp8/wAAJKOmvn8n/dw0EpURAAD8RBhR/K29hBEAALxGGJEUtCPd4BBGAADwHGFE9ZPlURkBAMB7hBHVjzPC3DQAAHiPMKL6yghz0wAA4D3CiBiBFQAAPxFGxNw0AAD4iTCi+nFGqIwAAOA9woikYMCtjBBGAADwHGFEkk1lBAAA3xBGFHdrr+P43BIAAJIPYURxt/aSRQAA8BxhRFRGAADwE2FE9bf2MmsvAADeI4yIWXsBAPATYURURgAA8BNhRPWDnjFRHgAA3iOMqH7QMybKAwDAe4QRxZ2moTICAIDnCCOKO03DNSMAAHiOMCIpYEe6gbtpAADwHmFEUsDtBSbKAwDAe4QRURkBAMBPhBHFDwdPGAEAwGuEEcVPlEcYAQDAa4QR1VdGOE0DAID3CCOqH2eEC1gBAPAeYURMlAcAgJ8II6o/TeMwAisAAJ4jjEiyLSojAAD4hTCiuInyHMfnlgAAkHwII6qvjHBrLwAA3iOMiEHPAADwE2FE9XfTEEYAAPAeYUTc2gsAgJ8II6IyAgCAnwgjIowAAOAnwoi4gBUAAD8RRhR3ay8jsAIA4DnCiOIHPSOMAADgNcKIpIAd6QbCCAAA3iOMSAowAisAAL4hjIhxRgAA8BNhRPVhxCGMAADgOcKIqIwAAOAnwogYZwQAAD8RRsQIrAAA+IkwIk7TAADgJ8KI4i5gZQRWAAA8RxhRXGUk7PjcEgAAkg9hRPUXsHKWBgAA7xFGVD9RXp1DZQQAAK8RRsREeQAA+IkwIuamAQDAT4QRxd9NIxnuqAEAwFOEEUlBu74bqI4AAOAtwoikuCzCwGcAAHiMMCIqIwAA+CnhMLJq1SqNHz9eXbt2lWVZWrJkyWG3WblypYYOHapQKKSTTz5Z8+fPP4Kmtp74ykiYa0YAAPBUwmGkurpagwYN0r333tuk9bds2aILLrhAZ511lkpKSnTNNdfoiiuu0EsvvZRwY1tLg8pImDACAICXgoluMG7cOI0bN67J68+bN089e/bUXXfdJUnq27ev1qxZo7vvvltjx45N9PCtwr2ZRhKVEQAAvNbq14wUFxersLCwwWNjx45VcXFxo9scOHBAlZWVDZbWZFlW7PZerhkBAMBbrR5GysrKlJOT0+CxnJwcVVZWat++fQfdpqioSFlZWbElPz+/tZtZP1keYQQAAE8dlXfTzJo1SxUVFbFl27ZtrX7M6CisDmEEAABPJXzNSKJyc3NVXl7e4LHy8nJlZmaqXbt2B90mFAopFAq1dtMaCFIZAQDAF61eGSkoKNDy5csbPLZs2TIVFBS09qETEmCyPAAAfJFwGKmqqlJJSYlKSkokRW7dLSkpUWlpqaTIKZYpU6bE1r/qqqv06aef6te//rU++OAD3XfffXriiSd07bXXtswraCFMlgcAgD8SDiMbNmzQkCFDNGTIEEnSzJkzNWTIEM2ePVuStH379lgwkaSePXvqueee07JlyzRo0CDdddddevDBB4+a23qj6i9gdXxuCQAAySXha0bOPPPMQ85se7DRVc8880y99dZbiR7KU7GZe8kiAAB46qi8m8YPVEYAAPAHYcQVq4wwAisAAJ4ijLhilRHmpgEAwFOEEVeQ4eABAPAFYcRlR2/t5TQNAACeIoy4ggFGYAUAwA+EERdz0wAA4A/CiItZewEA8AdhxBW0I11BZQQAAG8RRlxuFqEyAgCAxwgjrmhlhFt7AQDwFmHEZTPOCAAAviCMuBj0DAAAfxBGXNG7aRj0DAAAbxFGXNFxRriAFQAAbxFGXAF3BNZw2PG5JQAAJBfCiCsQm5vG54YAAJBkCCOu+gtYqYwAAOAlwogrdgErWQQAAE8RRlwBKiMAAPiCMOJiojwAAPxBGHFFwwgT5QEA4C3CiIvKCAAA/iCMuIKMwAoAgC8II67YRHkMNAIAgKcII64gp2kAAPAFYcQVHYHV4TQNAACeIoy4AnakK6iMAADgLcKIK+D2BLf2AgDgLcKIi8oIAAD+IIy46ifKI4wAAOAlwojLJowAAOALwoiLyggAAP4gjLiojAAA4A/CiItBzwAA8AdhxBWIVUYcn1sCAEByIYy4oiOwMjUNAADeIoy4ggEqIwAA+IEw4rItLmAFAMAPhBEXt/YCAOAPwogrwN00AAD4gjDiioYRJsoDAMBbhBEXlREAAPxBGHEFuGYEAABfEEZchBEAAPxBGHEF7UhXEEYAAPAWYcQVcHsibAgjAAB4iTDiCriVkTrGgwcAwFOEEVd0bhqHyggAAJ4ijLi4tRcAAH8QRlzRifIY9AwAAG8RRlzRifKojAAA4C3CiIuJ8gAA8AdhxMWgZwAA+IMw4iKMAADgD8KIK3aahlt7AQDwFGHEZcdVRgyBBAAAzxBGXNHKiMSpGgAAvHREYeTee+9Vjx49lJaWplGjRumNN95odN358+fLsqwGS1pa2hE3uLXY8WGEyggAAJ5JOIw8/vjjmjlzpv7whz/ozTff1KBBgzR27Fjt2LGj0W0yMzO1ffv22LJ169ZmNbo1UBkBAMAfCYeROXPm6Morr9Rll12mfv36ad68eUpPT9dDDz3U6DaWZSk3Nze25OTkNKvRrSE66JlEGAEAwEsJhZGamhpt3LhRhYWF9TuwbRUWFqq4uLjR7aqqqtS9e3fl5+drwoQJevfddw95nAMHDqiysrLB0tqojAAA4I+EwsiXX36pcDj8jcpGTk6OysrKDrpNnz599NBDD+mZZ57R3//+dzmOo9GjR+tf//pXo8cpKipSVlZWbMnPz0+kmUckEBdGGBIeAADvtPrdNAUFBZoyZYoGDx6sM844Q4sWLdLxxx+v//7v/250m1mzZqmioiK2bNu2rbWbKcuyFM0jTJYHAIB3goms3KVLFwUCAZWXlzd4vLy8XLm5uU3aR0pKioYMGaKPP/640XVCoZBCoVAiTWsRQdtWTdihMgIAgIcSqoykpqZq2LBhWr58eewxx3G0fPlyFRQUNGkf4XBY77zzjvLy8hJrqQdstze4ZgQAAO8kVBmRpJkzZ2rq1KkaPny4Ro4cqblz56q6ulqXXXaZJGnKlCk64YQTVFRUJEm6+eabddppp+nkk0/W7t27deedd2rr1q264oorWvaVtICgbUtyCCMAAHgo4TBy6aWXaufOnZo9e7bKyso0ePBgvfjii7GLWktLS2Xb9QWXf//737ryyitVVlamTp06adiwYVq7dq369evXcq+ihUQvYuU0DQAA3rFMG5iIpbKyUllZWaqoqFBmZmarHWfoLcu0q7pGL197unrnZLTacQAASAZNff9mbpo4scpI+KjPZwAAHDMII3EC7iisztFfLAIA4JhBGInDNSMAAHiPMBInGIiEkbDj+NwSAACSB2EkTvQ0TZgsAgCAZwgjcepP05BGAADwCmEkTjSMkEUAAPAOYSQOlREAALxHGIkTtKPXjHA3DQAAXiGMxLEJIwAAeI4wEofKCAAA3iOMxLGjt/YyAisAAJ4hjMSpH/SMMAIAgFcII3ECdqQ7mCgPAADvEEbiuIURTtMAAOAhwkicaGWE0zQAAHiHMBIn4PYGYQQAAO8QRuIEqYwAAOA5wkic+uHgCSMAAHiFMBKnfqI8wggAAF4hjMShMgIAgPcII3EC7gisDrf2AgDgGcJInIA70AiDngEA4B3CSJwAc9MAAOA5wkicQGzWXsfnlgAAkDwII3GCXMAKAIDnCCNxuLUXAADvEUbicGsvAADeI4zEoTICAID3CCNxqIwAAOA9wkicYOxuGsIIAABeIYzEsQkjAAB4jjASh8oIAADeI4zEsRmBFQAAzxFG4jDoGQAA3iOMxAkEIt0RZqI8AAA8QxiJw0R5AAB4L3nDiONImxZJT0yV9ldI4gJWAAD8kLxhxLKklbdL7y2RPnheErf2AgDgh+QOIwMujvz73UWSqIwAAOCH5A0jktTfDSOfrJD27oobDt7xsVEAACSX5A4jx/eWcgZKTp30/v/FTZTnc7sAAEgiyR1GJGnARZGvm56mMgIAgA8II9FTNZ+tVrsDX0mSGGYEAADvEEY695S6DpWMo9zPX5IkhamMAADgGcKIJA34riQppzRyi28dpREAADxDGJGk/hMlSVk71ytXX8lhBFYAADxDGJGkrBOlbgWSpAsC65goDwAADxFGotwLWccHilW5r077asI+NwgAgORAGInqN0HGsjXY/kRp1dv04/9dTyABAMADhJGojBxZPf5DkvTdlHVa+8lXumz+G9pbU+dzwwAAOLYRRuK5p2p+kbpEt4YeUfmWdzXtofWqPkAgAQCgtRBG4g38nnTiCAXq9mmy9aJeCf1SV31+vebcf7/e+9cuGe6yAQCgxVmmDbzDVlZWKisrSxUVFcrMzGzdgxkjfbpSWjdP+vDF+jaYdJWkDNL+Hmer1+iJ6nlSr9ZtBwAAbVxT378JI4fy1Sfa9co9Sn3vaXVwKhs8VWp11ZcZp8jknqrOJ4/QiX1PU0pGF+/aBgDAUY4w0pKcsKo/W6/Sdc8odcsK9TywWbb1zW7bbWXpy7Tu2pd5kuzje6t9Xm91OqGXMnN7ykrL8r7dAAD4iDDSmu35qlxb3lmjPVs2KmXnO8rbu1ndVH7obawM7QrmaF9aturSs6WMXKV2zFO7TrnqkNVFGR27KKV9RyktS0ppLwVSJMvy5gUBANAKCCMechyjbWU7VL5lk/Z8/r7Mzg/VrnKLOtV8rlynXJ2tqoT3GZatWiukWjtN4UBIjp0iY6fKBFKlQIqcYDs5KR3kpLSXSe0gpbaXFQy5S6rsYEh2MEV2ICA7kCI7EFQgGFQgGFIgNaRAME12SsgNPQHJsiXbjnyVItfOyP3VsGwp2E4KhqRgWuSrHZTsQGTb6FfLIkABAGKa+v4dPJKd33vvvbrzzjtVVlamQYMG6Z577tHIkSMbXf/JJ5/UDTfcoM8++0y9evXSH//4R51//vlHcuijkm1b6t41R9275kg6u8Fz+2vD+mznl9r1+ceqKvtUNRXbZfaUKbi3XGn7v1R67b/VzqlSprVXmdqrdOuAJCkgRwGzT2nhfVIbG3vNkSUjS0a2jOV+lSXHCsixAgorGPu3YwVkLFuSLeP+O/LVkrECkqy4x2wZRb7achQwdbJNWLbCsuTIKBKIoutZVqQVkhX5alkydoqMnRIJd4FUd7/1x42EMSsuWEW2tU1YlnFkKSzLGMkOyNgpkh2UsYOSFZSxbfdrZD+2HFlOnbttnSwpEv4CqTKB+iDY4NiWLUtOpMcsRbaxbDf8pcSFQFuyLFmxr5G+txTZyJIkOygrEJQVSJHlbmdblix3fUu2LMtIxqlfZEX2bwdlByIh07YDsmxbltsfkiLrOnX1i3v0aLvq+9GuX2w78hoC0dcRjPVxZHPL3W847ms4sl4gxd02NdK+qOgLN6Z+fScsycQFZftrS1z7jBNZ1zhuAD8Y0/A5y6r/eQRSGranOUx8O0zczyMY6btEOWEpXBNZHLcfg6FIH/Khoe1xwlLt3kjl/Eh+H45yCYeRxx9/XDNnztS8efM0atQozZ07V2PHjtXmzZuVnZ39jfXXrl2rSZMmqaioSBdeeKEWLFigiRMn6s0339SAAQNa5EUczdJSAurRNUc9uuZIGnPQdRzHqHJ/rb6oqtG/K6tUXbVHe/dVaf/eKh3YW6Wa/XsVrj2g2pr9cmprFK7dL7tun4J11Up19iq1bq9Snb2yTZ1sp1ZBp0ZBUyvbhCWFFXDfSIMKK9WqU6pqlao6pahOQYUjb+xyZFtGthwZ980h+jWosFJVqzTVKk01B71eJp6taFXFiRVX3B0CxyRHlvt7f/j1ov+vJEUj+2G3C8uO/I+1AnJiIzLU7yvyfzgs2zjuv+sOud8apcixApE9GCf6cUF1VorqlKJaK0W1VqrCVsA90qHVHykuWMaei/w7EuYly+2Fhs+7r8X65mPGsiPx3LJjH3Di22NJskzk71jkGI6M7MiHHQUUjvWZkR0Nn9Fju/uWFekBW07sA060LyUjy5jYR6zI/iIfqMJW5Gu0Xfraz7e+jdFjmvrvTeTnFvvwIRPJoVakhyRLqc4+tQvvUXp4j9KcakmSI1v7A+21P9BB++wM1doht28iH+CcRn5asQ917gc/y/07bUmS+/oyJvxRed86tbEfc6tK+DTNqFGjNGLECP31r3+VJDmOo/z8fP385z/X9ddf/431L730UlVXV2vp0qWxx0477TQNHjxY8+bNa9Ixj/bTNG2BMUZ1jlFd2KjWcVQXNqoLO6p13K9hR7XhyPOOiS6R7cKOUdgYOY4UdhyZcK2cujqFnToZJywnXCfjOHKMI8dxZBwjxwlHvg87Mk6dHMeRE45UCGwTluXUyTK1spz6dcJOWMapcz/hRj7pWnI/ISssyzGyFHkubOzIqSz3z65jrNgfVsu4lRIj93VY7mtxZJs6BZxa2aY28lWOAu4fsugfIMlE/mS4n1AdWXJMQI6ksCJfLRPdLhxXoXHcP2Z1suXIka1aE/ljWGsCkjEKKKygqVVQdUoxtfVBMG5xZEfaLkvGRP5wRepJ4djX+D+Q8QFSqv9Ta8tRiuoUkKMUt3oUXSv6h7X+bSjySHR/AXcJKhz781pfaVKs/yMtsuP2Wb/vuPqYApbjtqf+daS4+45sW68u8pNwe8NS0G1HiuqUYh26TOgYS2H3bdiWUdByjvj/DJBsPrhwkU4ZfvbhV0xAq5ymqamp0caNGzVr1qzYY7Ztq7CwUMXFxQfdpri4WDNnzmzw2NixY7VkyZJGj3PgwAEdOHAg9n1lZWWj66JpLMtSSsBSSkBqpxYqK+OoZ9xQGQ2Y0Y8e0aD2jfXdbYy7jnG3cdzHovsIxD/mznJtWXJPA0X25ZjIc44xqnEi6+47ZFsjLTBGseM7xjQ8BWWMZMKRuOi2xRgT+WQbPQUT21f9jo17Csc4TiT+OGEZOTLG3c597ZZVH9dir8MNhUaWwiayrZxaKVwnhWtlnLpYeHUOEgqNe5bHanC6J1o9jJ42qo9xkahpx/rWNmEFTE3klJ9TFwnoxriDMEa+Gisgx7JlrGAkYNpBOdHTkVaKHDsg26mT7dTIdmoUCB+QZcJxlQE3+Dp1ssL7ZYdrZIVrIq/T7Q9J7qf/yM/Cck8lRl9T7PfDqX+Nsc+67s+o/vSiG12NcX+WkZ6Of12R7RzJcSKn39yf/dd/wMZIsiOnZp3YqU4TqZbELfWnNetfT+z3yXFkjCPZwdipYxNX8YhULNyKlBOWZWplO3WSCcty3FDtVmXcH7bbT/WnU+o/MES+Olb052w3+DBQX1sxqrPTdCAlUweCGToQzFSNnabUcLVSa6uUWrdHobpKBZyaSHXFPdUaqeZ8vToS/XAXlpzIBzbjno6O/m5L0uCu/o2flVAY+fLLLxUOh5WTk9Pg8ZycHH3wwQcH3aasrOyg65eVlTV6nKKiIt10002JNA3AQViWpYAlBQ5baAcA/xyVV8HMmjVLFRUVsWXbtm1+NwkAALSShCojXbp0USAQUHl5wzE1ysvLlZube9BtcnNzE1pfkkKhkEKhUCJNAwAAbVRClZHU1FQNGzZMy5cvjz3mOI6WL1+ugoKCg25TUFDQYH1JWrZsWaPrAwCA5JLwrb0zZ87U1KlTNXz4cI0cOVJz585VdXW1LrvsMknSlClTdMIJJ6ioqEiSdPXVV+uMM87QXXfdpQsuuEALFy7Uhg0b9MADD7TsKwEAAG1SwmHk0ksv1c6dOzV79myVlZVp8ODBevHFF2MXqZaWlsqOG5Bl9OjRWrBggX7/+9/rt7/9rXr16qUlS5YkxRgjAADg8BgOHgAAtIqmvn8flXfTAACA5EEYAQAAviKMAAAAXxFGAACArwgjAADAV4QRAADgK8IIAADwVcKDnvkhOhRKZWWlzy0BAABNFX3fPtyQZm0ijOzZs0eSlJ+f73NLAABAovbs2aOsrKxGn28TI7A6jqMvvvhCGRkZsiyrxfZbWVmp/Px8bdu2jZFdWxl97R362lv0t3foa++0VF8bY7Rnzx517dq1wVQxX9cmKiO2bevEE09stf1nZmbyi+0R+to79LW36G/v0NfeaYm+PlRFJIoLWAEAgK8IIwAAwFdJHUZCoZD+8Ic/KBQK+d2UYx597R362lv0t3foa+943ddt4gJWAABw7ErqyggAAPAfYQQAAPiKMAIAAHxFGAEAAL5K6jBy7733qkePHkpLS9OoUaP0xhtv+N2kNq+oqEgjRoxQRkaGsrOzNXHiRG3evLnBOvv379f06dN13HHHqUOHDvrud7+r8vJyn1p8bLj99ttlWZauueaa2GP0c8v6/PPP9Z//+Z867rjj1K5dOw0cOFAbNmyIPW+M0ezZs5WXl6d27dqpsLBQH330kY8tbpvC4bBuuOEG9ezZU+3atdO3vvUt3XLLLQ3mNqGvj8yqVas0fvx4de3aVZZlacmSJQ2eb0q/7tq1S5MnT1ZmZqY6duyoH//4x6qqqmp+40ySWrhwoUlNTTUPPfSQeffdd82VV15pOnbsaMrLy/1uWps2duxY8/DDD5tNmzaZkpISc/7555tu3bqZqqqq2DpXXXWVyc/PN8uXLzcbNmwwp512mhk9erSPrW7b3njjDdOjRw9z6qmnmquvvjr2OP3ccnbt2mW6d+9upk2bZtatW2c+/fRT89JLL5mPP/44ts7tt99usrKyzJIlS8zbb79tvvOd75iePXuaffv2+djytufWW281xx13nFm6dKnZsmWLefLJJ02HDh3Mn//859g69PWRef75583vfvc7s2jRIiPJLF68uMHzTenX8847zwwaNMi8/vrrZvXq1ebkk082kyZNanbbkjaMjBw50kyfPj32fTgcNl27djVFRUU+turYs2PHDiPJvPrqq8YYY3bv3m1SUlLMk08+GVvn/fffN5JMcXGxX81ss/bs2WN69eplli1bZs4444xYGKGfW9ZvfvMb8x//8R+NPu84jsnNzTV33nln7LHdu3ebUChkHnvsMS+aeMy44IILzOWXX97gsYsvvthMnjzZGENft5Svh5Gm9Ot7771nJJn169fH1nnhhReMZVnm888/b1Z7kvI0TU1NjTZu3KjCwsLYY7Ztq7CwUMXFxT627NhTUVEhSercubMkaePGjaqtrW3Q96eccoq6detG3x+B6dOn64ILLmjQnxL93NKeffZZDR8+XJdccomys7M1ZMgQ/c///E/s+S1btqisrKxBf2dlZWnUqFH0d4JGjx6t5cuX68MPP5Qkvf3221qzZo3GjRsnib5uLU3p1+LiYnXs2FHDhw+PrVNYWCjbtrVu3bpmHb9NTJTX0r788kuFw2Hl5OQ0eDwnJ0cffPCBT6069jiOo2uuuUZjxozRgAEDJEllZWVKTU1Vx44dG6ybk5OjsrIyH1rZdi1cuFBvvvmm1q9f/43n6OeW9emnn+r+++/XzJkz9dvf/lbr16/XL37xC6Wmpmrq1KmxPj3Y3xT6OzHXX3+9KisrdcoppygQCCgcDuvWW2/V5MmTJYm+biVN6deysjJlZ2c3eD4YDKpz587N7vukDCPwxvTp07Vp0yatWbPG76Ycc7Zt26arr75ay5YtU1pamt/NOeY5jqPhw4frtttukyQNGTJEmzZt0rx58zR16lSfW3dseeKJJ/Too49qwYIF6t+/v0pKSnTNNdeoa9eu9PUxLClP03Tp0kWBQOAbdxaUl5crNzfXp1YdW2bMmKGlS5fqlVde0Yknnhh7PDc3VzU1Ndq9e3eD9en7xGzcuFE7duzQ0KFDFQwGFQwG9eqrr+ovf/mLgsGgcnJy6OcWlJeXp379+jV4rG/fviotLZWkWJ/yN6X5fvWrX+n666/XD37wAw0cOFA/+tGPdO2116qoqEgSfd1amtKvubm52rFjR4Pn6+rqtGvXrmb3fVKGkdTUVA0bNkzLly+PPeY4jpYvX66CggIfW9b2GWM0Y8YMLV68WCtWrFDPnj0bPD9s2DClpKQ06PvNmzertLSUvk/A2WefrXfeeUclJSWxZfjw4Zo8eXLs3/RzyxkzZsw3blH/8MMP1b17d0lSz549lZub26C/KysrtW7dOvo7QXv37pVtN3xrCgQCchxHEn3dWprSrwUFBdq9e7c2btwYW2fFihVyHEejRo1qXgOadflrG7Zw4UITCoXM/PnzzXvvvWd+8pOfmI4dO5qysjK/m9am/fSnPzVZWVlm5cqVZvv27bFl7969sXWuuuoq061bN7NixQqzYcMGU1BQYAoKCnxs9bEh/m4aY+jnlvTGG2+YYDBobr31VvPRRx+ZRx991KSnp5u///3vsXVuv/1207FjR/PMM8+Yf/7zn2bChAncbnoEpk6dak444YTYrb2LFi0yXbp0Mb/+9a9j69DXR2bPnj3mrbfeMm+99ZaRZObMmWPeeusts3XrVmNM0/r1vPPOM0OGDDHr1q0za9asMb169eLW3ua65557TLdu3UxqaqoZOXKkef311/1uUpsn6aDLww8/HFtn37595mc/+5np1KmTSU9PNxdddJHZvn27f40+Rnw9jNDPLev//u//zIABA0woFDKnnHKKeeCBBxo87ziOueGGG0xOTo4JhULm7LPPNps3b/aptW1XZWWlufrqq023bt1MWlqaOemkk8zvfvc7c+DAgdg69PWReeWVVw7693nq1KnGmKb161dffWUmTZpkOnToYDIzM81ll11m9uzZ0+y2WcbEDWsHAADgsaS8ZgQAABw9CCMAAMBXhBEAAOArwggAAPAVYQQAAPiKMAIAAHxFGAEAAL4ijAAAAF8RRgAAgK8IIwAAwFeEEQAA4CvCCAAA8NX/B/RM7in27jEDAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "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": 25, + "id": "8be48f80-a6e6-4b05-87ef-3adbf0bef576", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "cff8cba9-aba9-4347-8e1a-f169df8313c2", + "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", + " # tr_maxs = np.transpose(maxs, (2, 0, 1))\n", + " # tr_mins = np.transpose(mins, (2, 0, 1))\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", + " eva_list.append([mae, rmse, mape, r2])" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "edd09b0b-4496-4b88-a581-d1203aad05ce", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2
count75.00000075.00000075.00000075.000000
mean1.6691812.7223750.2286900.825025
std0.1015490.2293730.0278240.023960
min1.4569192.2064950.1474380.751642
25%1.6007872.5698440.2105640.815437
50%1.6635392.7233800.2284930.826285
75%1.7266972.8481220.2483800.837574
max1.9982063.4436900.2877970.881901
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2\n", + "count 75.000000 75.000000 75.000000 75.000000\n", + "mean 1.669181 2.722375 0.228690 0.825025\n", + "std 0.101549 0.229373 0.027824 0.023960\n", + "min 1.456919 2.206495 0.147438 0.751642\n", + "25% 1.600787 2.569844 0.210564 0.815437\n", + "50% 1.663539 2.723380 0.228493 0.826285\n", + "75% 1.726697 2.848122 0.248380 0.837574\n", + "max 1.998206 3.443690 0.287797 0.881901" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "7e0a48b0-be9a-429b-a77f-3fe413c1aae7", + "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": 33, + "id": "1263f067-2d88-4321-900d-29aa2a84df12", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list_frame = 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", + " 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])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "27289a64-0405-48e3-bec3-ad0a612988a6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.6575132.3528860.2322600.4067150.8236720.747644
std0.8976591.3187930.2340800.8773680.1847080.191853
min0.5463540.6950380.066870-30.315991-1.254103-0.392216
25%1.0428981.4723880.1372160.3138860.7827280.671206
50%1.4654362.0727180.1744300.6106840.8798750.805015
75%1.9766182.7850210.2346180.7571360.9291700.879403
max9.00795912.3984853.2908910.9736000.9932470.987535
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.657513 2.352886 0.232260 0.406715 0.823672 \n", + "std 0.897659 1.318793 0.234080 0.877368 0.184708 \n", + "min 0.546354 0.695038 0.066870 -30.315991 -1.254103 \n", + "25% 1.042898 1.472388 0.137216 0.313886 0.782728 \n", + "50% 1.465436 2.072718 0.174430 0.610684 0.879875 \n", + "75% 1.976618 2.785021 0.234618 0.757136 0.929170 \n", + "max 9.007959 12.398485 3.290891 0.973600 0.993247 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.747644 \n", + "std 0.191853 \n", + "min -0.392216 \n", + "25% 0.671206 \n", + "50% 0.805015 \n", + "75% 0.879403 \n", + "max 0.987535 " + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c72964bf-bbc5-4773-bd5f-6a0ea674934e", + "metadata": {}, + "outputs": [], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2']).describe().to_csv('./eva_files/baseline_mask_loss.csv', encoding='utf-8-sig')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "acee2abc-2f3f-4d19-a6e4-85ad4d1aaacf", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'data' 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[26], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m visualize_feature(\u001b[43mdata\u001b[49m[\u001b[38;5;241m5\u001b[39m], masked_data[\u001b[38;5;241m5\u001b[39m], reconstructed[\u001b[38;5;241m5\u001b[39m], \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mNO2\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined" + ] + } + ], + "source": [ + "visualize_feature(data[5], masked_data[5], reconstructed[5], 'NO2')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ada99bf-6bea-4e46-a3bd-f62510517c8e", + "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 +} diff --git a/torch_MAE_1d_decoder.ipynb b/torch_MAE_1d_decoder.ipynb new file mode 100644 index 0000000..a4482e5 --- /dev/null +++ b/torch_MAE_1d_decoder.ipynb @@ -0,0 +1,1048 @@ +{ + "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": "c724bfe5-69a4-441c-9571-02e736037bea", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(0)\n", + "torch.random.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5e6cd4e9-6594-4eeb-82b8-94a5fc308b4b", + "metadata": {}, + "outputs": [], + "source": [ + "max_pixel_value = 107.49169921875" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7183fc4f-d0b2-4bdc-9ed3-52933d899686", + "metadata": {}, + "outputs": [], + "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/20/'" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8f76e514-7a5e-46f2-808a-07a33f212443", + "metadata": {}, + "outputs": [], + "source": [ + "train_set = NO2Dataset(image_dir, mask_dir)\n", + "train_loader = DataLoader(train_set, 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": 6, + "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": 7, + "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": 8, + "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": 9, + "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": 10, + "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": 11, + "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": 12, + "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": 13, + "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": 14, + "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": 15, + "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": 16, + "id": "08810d47-3af3-47de-81cc-0377c5cab16e", + "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": "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", + " nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\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": "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 = criterion(reconstructed, y)\n", + " loss = masked_mse_loss(reconstructed, y, mask)\n", + " loss.backward()\n", + " optimizer.step()\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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": 20, + "id": "2cb2da06-9180-43be-95bb-4ba06654bfc8", + "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": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at /opt/conda/conda-bld/pytorch_1711403590347/work/aten/src/ATen/native/cudnn/Conv_v8.cpp:80.)\n", + " return F.conv2d(input, weight, bias, self.stride,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 2.1122538542205636, Val Loss: 0.17511643736220117\n", + "Epoch 2, Train Loss: 0.09455115371272324, Val Loss: 0.07173499481669113\n", + "Epoch 3, Train Loss: 0.05875080322142708, Val Loss: 0.05522163668230398\n", + "Epoch 4, Train Loss: 0.04709345177618083, Val Loss: 0.046923332583548416\n", + "Epoch 5, Train Loss: 0.04048821633975757, Val Loss: 0.04223129592502295\n", + "Epoch 6, Train Loss: 0.03651897717071207, Val Loss: 0.038725908567656335\n", + "Epoch 7, Train Loss: 0.03371973283606711, Val Loss: 0.03591352106252713\n", + "Epoch 8, Train Loss: 0.030995923611357737, Val Loss: 0.033181621734775714\n", + "Epoch 9, Train Loss: 0.02894393834575084, Val Loss: 0.031025866519159347\n", + "Epoch 10, Train Loss: 0.026934354539301122, Val Loss: 0.028885239290434923\n", + "Epoch 11, Train Loss: 0.025755781114422248, Val Loss: 0.027564026443148728\n", + "Epoch 12, Train Loss: 0.024294818880740535, Val Loss: 0.02660573101532993\n", + "Epoch 13, Train Loss: 0.023547336254179763, Val Loss: 0.025523469658262694\n", + "Epoch 14, Train Loss: 0.02263737249335176, Val Loss: 0.024892248685902625\n", + "Epoch 15, Train Loss: 0.02204986723389423, Val Loss: 0.02482297744101553\n", + "Epoch 16, Train Loss: 0.021457266258566005, Val Loss: 0.024080637119599242\n", + "Epoch 17, Train Loss: 0.020942402789681153, Val Loss: 0.023763289508312496\n", + "Epoch 18, Train Loss: 0.02059948215769096, Val Loss: 0.023712928865605325\n", + "Epoch 19, Train Loss: 0.020213669665050848, Val Loss: 0.022951017092190572\n", + "Epoch 20, Train Loss: 0.02002489379647246, Val Loss: 0.022396566457490424\n", + "Epoch 21, Train Loss: 0.019488899257818337, Val Loss: 0.02220052338914195\n", + "Epoch 22, Train Loss: 0.019191946226069657, Val Loss: 0.021812534682563882\n", + "Epoch 23, Train Loss: 0.018820160999894142, Val Loss: 0.021094122540150115\n", + "Epoch 24, Train Loss: 0.01841514516826808, Val Loss: 0.021011906689894732\n", + "Epoch 25, Train Loss: 0.01826861325392954, Val Loss: 0.020965722514622247\n", + "Epoch 26, Train Loss: 0.01783664010768159, Val Loss: 0.02035376571341237\n", + "Epoch 27, Train Loss: 0.01773165784883157, Val Loss: 0.020316684896599\n", + "Epoch 28, Train Loss: 0.017462643957362647, Val Loss: 0.020199675196364744\n", + "Epoch 29, Train Loss: 0.01726480335237806, Val Loss: 0.019924583983843894\n", + "Epoch 30, Train Loss: 0.017130774285412577, Val Loss: 0.019827198264981385\n", + "Epoch 31, Train Loss: 0.016821091141302192, Val Loss: 0.01998631670070228\n", + "Epoch 32, Train Loss: 0.016754478447887886, Val Loss: 0.019008648901510595\n", + "Epoch 33, Train Loss: 0.01657688988452893, Val Loss: 0.01900591877803429\n", + "Epoch 34, Train Loss: 0.016496175670613084, Val Loss: 0.019055584264891363\n", + "Epoch 35, Train Loss: 0.01644454181470583, Val Loss: 0.018636108959899908\n", + "Epoch 36, Train Loss: 0.01607896311823546, Val Loss: 0.018534055174286686\n", + "Epoch 37, Train Loss: 0.01588705154224945, Val Loss: 0.018062156513889333\n", + "Epoch 38, Train Loss: 0.015864519495962626, Val Loss: 0.018233197171296647\n", + "Epoch 39, Train Loss: 0.015855632771394755, Val Loss: 0.018038090332341727\n", + "Epoch 40, Train Loss: 0.015651265439982905, Val Loss: 0.01822574678530444\n", + "Epoch 41, Train Loss: 0.015510451237996372, Val Loss: 0.017679256400955256\n", + "Epoch 42, Train Loss: 0.015349842104436963, Val Loss: 0.018203645916794662\n", + "Epoch 43, Train Loss: 0.01543403383451358, Val Loss: 0.017195541675744663\n", + "Epoch 44, Train Loss: 0.015325402941233947, Val Loss: 0.017411370608788817\n", + "Epoch 45, Train Loss: 0.01518570597876202, Val Loss: 0.017076766354712978\n", + "Epoch 46, Train Loss: 0.014841953983182827, Val Loss: 0.016906344637608352\n", + "Epoch 47, Train Loss: 0.014843696093356068, Val Loss: 0.016789415712232022\n", + "Epoch 48, Train Loss: 0.014590430285104296, Val Loss: 0.01671677505347266\n", + "Epoch 49, Train Loss: 0.014620297918158569, Val Loss: 0.01652295997282907\n", + "Epoch 50, Train Loss: 0.014581651776654726, Val Loss: 0.01616852485866689\n", + "Epoch 51, Train Loss: 0.014414639787026569, Val Loss: 0.016296155653449138\n", + "Epoch 52, Train Loss: 0.01424450205157747, Val Loss: 0.016307457906207933\n", + "Epoch 53, Train Loss: 0.014137028997238173, Val Loss: 0.01646944234119867\n", + "Epoch 54, Train Loss: 0.014159051344939395, Val Loss: 0.016026857336844082\n", + "Epoch 55, Train Loss: 0.014192796753425347, Val Loss: 0.01584606984658028\n", + "Epoch 56, Train Loss: 0.013916373460076785, Val Loss: 0.015976423856371373\n", + "Epoch 57, Train Loss: 0.013736099040394195, Val Loss: 0.015810697172671112\n", + "Epoch 58, Train Loss: 0.013836662209276377, Val Loss: 0.015620186396721584\n", + "Epoch 59, Train Loss: 0.013784786091413367, Val Loss: 0.015319373792231972\n", + "Epoch 60, Train Loss: 0.013611769829497954, Val Loss: 0.015367041216857398\n", + "Epoch 61, Train Loss: 0.01358566418931815, Val Loss: 0.015289715783142331\n", + "Epoch 62, Train Loss: 0.013467149546093633, Val Loss: 0.015166739780289023\n", + "Epoch 63, Train Loss: 0.013366587792019668, Val Loss: 0.014960003544145556\n", + "Epoch 64, Train Loss: 0.013362093665971282, Val Loss: 0.015207788253675646\n", + "Epoch 65, Train Loss: 0.013282296849352322, Val Loss: 0.015704237049751317\n", + "Epoch 66, Train Loss: 0.013314912690553796, Val Loss: 0.015118209617351419\n", + "Epoch 67, Train Loss: 0.01314743113610448, Val Loss: 0.014853793154679128\n", + "Epoch 68, Train Loss: 0.013220271071125018, Val Loss: 0.015044791985358765\n", + "Epoch 69, Train Loss: 0.013089903819700035, Val Loss: 0.014621049485433458\n", + "Epoch 70, Train Loss: 0.013003655555591201, Val Loss: 0.015181626902142567\n", + "Epoch 71, Train Loss: 0.013071733119153377, Val Loss: 0.014468084979079553\n", + "Epoch 72, Train Loss: 0.013008178180555979, Val Loss: 0.014925862592992499\n", + "Epoch 73, Train Loss: 0.01300788912521096, Val Loss: 0.015519192122590186\n", + "Epoch 74, Train Loss: 0.012897961314001153, Val Loss: 0.014994534872361083\n", + "Epoch 75, Train Loss: 0.012850848984632766, Val Loss: 0.014727158249536557\n", + "Epoch 76, Train Loss: 0.012889095829380899, Val Loss: 0.014613447293861588\n", + "Epoch 77, Train Loss: 0.01279138982447497, Val Loss: 0.014250260944575516\n" + ] + } + ], + "source": [ + "model = model.to(device)\n", + "\n", + "num_epochs = 100\n", + "train_losses = list()\n", + "val_losses = list()\n", + "for epoch in range(num_epochs):\n", + " train_loss = train_epoch(model, device, train_loader, 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": 25, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1m0lEQVR4nO3deXxU9b3/8fc5M8mEQBa2JKBhsUYWoYBsBu7PNQqIFLW1lnILaLXXW2i11LZiK3V5aGy9WKwb1+tDuVoRawXqdUcQBYxsEisu1AUBlQSUkhAIJDPn+/tjziwRgoQk5wDzej4e8wg5c2bOZ77AzHu+53u+X8sYYwQAAOAT2+8CAABAaiOMAAAAXxFGAACArwgjAADAV4QRAADgK8IIAADwFWEEAAD4ijACAAB8FfS7gMPhOI6++OILZWVlybIsv8sBAACHwRij3bt3q2vXrrLtxvs/jokw8sUXX6iwsNDvMgAAwBHYunWrTjzxxEbvPybCSFZWlqToi8nOzva5GgAAcDiqq6tVWFgY/xxvzDERRmKnZrKzswkjAAAcY75piAUDWAEAgK8IIwAAwFeEEQAA4KtjYswIAOD4E4lEVF9f73cZaIZAIKBgMNjsaTcIIwAAz9XU1Oizzz6TMcbvUtBMmZmZ6tKli9LT04/4OQgjAABPRSIRffbZZ8rMzFTnzp2ZzPIYZYxRXV2dduzYoU2bNqmoqOiQE5sdCmEEAOCp+vp6GWPUuXNntWnTxu9y0Axt2rRRWlqaNm/erLq6OmVkZBzR8zCAFQDgC3pEjg9H2hvS4DlaoA4AAIAjRhgBAAC+IowAAOCxHj16aPbs2S3yXMuWLZNlWdq1a1eLPJ8fGMAKAMBhOOusszRw4MAWCRFr1qxR27Ztm1/UcSKlw8hDyz/RZ/+q1YRh3dSr4NArCgIAcCjGGEUiEQWD3/zR2rlzZw8qOnak9Gma597ZprlvfKrNX+3xuxQASFnGGO2tC/tyO9xJ16ZMmaLXXntNd999tyzLkmVZmjt3rizL0gsvvKDBgwcrFAppxYoV+vjjjzV+/Hjl5+erXbt2Gjp0qF555ZUGz/f10zSWZemhhx7SxRdfrMzMTBUVFemZZ5454jZ9+umndeqppyoUCqlHjx6aNWtWg/vvv/9+FRUVKSMjQ/n5+fre974Xv+9vf/ub+vfvrzZt2qhjx44qKSnRnj2t+zmZ0j0jQTt6WZnDDIAA4Jva+oj6znzJl2O/d8soZaZ/80fh3XffrX/+85/q16+fbrnlFknSu+++K0m6/vrr9V//9V866aST1L59e23dulUXXHCBbrvtNoVCIT366KMaN26cNm7cqG7dujV6jJtvvll//OMfdeedd+qee+7RxIkTtXnzZnXo0KFJr2ndunX6/ve/r5tuukmXXXaZ3njjDf30pz9Vx44dNWXKFK1du1Y///nP9dhjj2nEiBHauXOnli9fLknatm2bJkyYoD/+8Y+6+OKLtXv3bi1fvrzVZ8pN6TBiu9e4hx3CCACgcTk5OUpPT1dmZqYKCgokSR988IEk6ZZbbtF5550X37dDhw4aMGBA/Pdbb71VCxcu1DPPPKNp06Y1eowpU6ZowoQJkqTbb79df/7zn7V69WqNHj26SbXeddddOvfcc3XjjTdKkk455RS99957uvPOOzVlyhRt2bJFbdu21YUXXqisrCx1795dgwYNkhQNI+FwWJdccom6d+8uSerfv3+Tjn8kUjqMBAPRMBIhjACAb9qkBfTeLaN8O3ZzDRkypMHvNTU1uummm/Tcc8/FP9xra2u1ZcuWQz7Pt7/97fif27Ztq+zsbG3fvr3J9bz//vsaP358g20jR47U7NmzFYlEdN5556l79+466aSTNHr0aI0ePTp+emjAgAE699xz1b9/f40aNUrnn3++vve976l9+/ZNrqMpUnrMSMCdNY4wAgD+sSxLmelBX24tMQvs16+Kue6667Rw4ULdfvvtWr58ucrLy9W/f3/V1dUd8nnS0tIOaBfHcZpd39dlZWXprbfe0hNPPKEuXbpo5syZGjBggHbt2qVAIKDFixfrhRdeUN++fXXPPfeoV69e2rRpU4vXkSy1w4j7b5DTNACAb5Kenq5IJPKN+61cuVJTpkzRxRdfrP79+6ugoECffvpp6xfo6tOnj1auXHlATaeccooCgWhPUDAYVElJif74xz/qH//4hz799FMtXbpUUjQEjRw5UjfffLPWr1+v9PR0LVy4sFVrTunTNLGeEYcwAgD4Bj169NCqVav06aefql27do32WhQVFWnBggUaN26cLMvSjTfe2Co9HI355S9/qaFDh+rWW2/VZZddprKyMt177726//77JUnPPvusPvnkE51xxhlq3769nn/+eTmOo169emnVqlVasmSJzj//fOXl5WnVqlXasWOH+vTp06o1p3bPiPvq6RkBAHyT6667ToFAQH379lXnzp0bHQNy1113qX379hoxYoTGjRunUaNG6bTTTvOsztNOO01//etfNX/+fPXr108zZ87ULbfcoilTpkiScnNztWDBAp1zzjnq06eP5syZoyeeeEKnnnqqsrOz9frrr+uCCy7QKaecot/97neaNWuWxowZ06o1W6a1r9dpAdXV1crJyVFVVZWys7Nb7HmnPv6Wnntnm27+zqmaPKJHiz0vAKBx+/bt06ZNm9SzZ88jXnIeR49D/X0e7ud3iveMcDUNAAB+I4yIMAIAOHpdffXVateu3UFvV199td/ltYgUH8DqhpGj/0wVACBF3XLLLbruuusOel9LDl3wU2qHEYueEQDA0S0vL095eXl+l9GqUvs0jTvRSDhCGAEAwC9NCiOlpaUaOnSosrKylJeXp4suukgbN278xsc99dRT6t27tzIyMtS/f389//zzR1xwSwpymgYAAN81KYy89tprmjp1qt58800tXrxY9fX1Ov/88w+5tPAbb7yhCRMm6Mc//rHWr1+viy66SBdddJE2bNjQ7OKby46fpvFuMhoAANBQk8aMvPjiiw1+nzt3rvLy8rRu3TqdccYZB33M3XffrdGjR+tXv/qVpOjqhYsXL9a9996rOXPmHGHZLSPeM0IWAQDAN80aM1JVVSUpulxyY8rKylRSUtJg26hRo1RWVtboY/bv36/q6uoGt9YQCNAzAgCA3444jDiOo2uvvVYjR45Uv379Gt2voqJC+fn5Dbbl5+eroqKi0ceUlpYqJycnfissLDzSMg8pdjUN08EDALzQo0cPzZ49+7D2tSxLixYtatV6jhZHHEamTp2qDRs2aP78+S1ZjyRpxowZqqqqit+2bt3a4seQEqdpWCgPAAD/HNE8I9OmTdOzzz6r119/XSeeeOIh9y0oKFBlZWWDbZWVlSooKGj0MaFQSKFQ6EhKaxLbpmcEAAC/NalnxBijadOmaeHChVq6dKl69uz5jY8pLi7WkiVLGmxbvHixiouLm1ZpK4j3jHBpLwD4xxipbo8/tya8/z/44IPq2rWrnK+NMxw/fryuuOIKffzxxxo/frzy8/PVrl07DR06VK+88kqLNdM777yjc845R23atFHHjh31k5/8RDU1NfH7ly1bpmHDhqlt27bKzc3VyJEjtXnzZknS22+/rbPPPltZWVnKzs7W4MGDtXbt2harrbma1DMydepUzZs3T3//+9+VlZUVH/eRk5OjNm3aSJImTZqkE044QaWlpZKka665RmeeeaZmzZqlsWPHav78+Vq7dq0efPDBFn4pTRewo1mMSc8AwEf1e6Xbu/pz7Bu+kNLbHtaul156qX72s5/p1Vdf1bnnnitJ2rlzp1588UU9//zzqqmp0QUXXKDbbrtNoVBIjz76qMaNG6eNGzeqW7duzSpzz549GjVqlIqLi7VmzRpt375dV155paZNm6a5c+cqHA7roosu0lVXXaUnnnhCdXV1Wr16tSx3bOTEiRM1aNAgPfDAAwoEAiovL1daWlqzampJTQojDzzwgCTprLPOarD9kUce0ZQpUyRJW7ZskW0nOlxGjBihefPm6Xe/+51uuOEGFRUVadGiRYcc9OqVgFsm08EDAL5J+/btNWbMGM2bNy8eRv72t7+pU6dOOvvss2XbtgYMGBDf/9Zbb9XChQv1zDPPaNq0ac069rx587Rv3z49+uijats2Gp7uvfdejRs3Tn/4wx+UlpamqqoqXXjhhfrWt74lSerTp0/88Vu2bNGvfvUr9e7dW5JUVFTUrHpaWpPCiDmM7qxly5YdsO3SSy/VpZde2pRDeSLWM8IMrADgo7TMaA+FX8dugokTJ+qqq67S/fffr1AopMcff1w/+MEPZNu2ampqdNNNN+m5557Ttm3bFA6HVVtbqy1btjS7zPfff18DBgyIBxFJGjlypBzH0caNG3XGGWdoypQpGjVqlM477zyVlJTo+9//vrp06SJJmj59uq688ko99thjKikp0aWXXhoPLUeD1F6bJtp7xQBWAPCTZUVPlfhxc09jHK5x48bJGKPnnntOW7du1fLlyzVx4kRJ0nXXXaeFCxfq9ttv1/Lly1VeXq7+/furrq6uNVrtAI888ojKyso0YsQIPfnkkzrllFP05ptvSpJuuukmvfvuuxo7dqyWLl2qvn37auHChZ7UdThSO4y452kijBkBAByGjIwMXXLJJXr88cf1xBNPqFevXjrttNMkSStXrtSUKVN08cUXq3///iooKNCnn37aIsft06eP3n777QbLr6xcuVK2batXr17xbYMGDdKMGTP0xhtvqF+/fpo3b178vlNOOUW/+MUv9PLLL+uSSy7RI4880iK1tYSUDiMslAcAaKqJEyfqueee08MPPxzvFZGi4zAWLFig8vJyvf322/rhD394wJU3zTlmRkaGJk+erA0bNujVV1/Vz372M/3oRz9Sfn6+Nm3apBkzZqisrEybN2/Wyy+/rA8//FB9+vRRbW2tpk2bpmXLlmnz5s1auXKl1qxZ02BMid+OaJ6R40UgvlAeYQQAcHjOOeccdejQQRs3btQPf/jD+Pa77rpLV1xxhUaMGKFOnTrpN7/5TYstZ5KZmamXXnpJ11xzjYYOHarMzEx997vf1V133RW//4MPPtD//u//6quvvlKXLl00depU/cd//IfC4bC++uorTZo0SZWVlerUqZMuueQS3XzzzS1SW0uwzOGMSvVZdXW1cnJyVFVVpezs7BZ73qfXfaZfPvW2zjyls/73imEt9rwAgMbt27dPmzZtUs+ePZWRkeF3OWimQ/19Hu7nd2qfpgnQMwIAgN9SOozY8YXyWLUXAOCdxx9/XO3atTvo7dRTT/W7PM+l9JiRxEJ5PhcCAEgp3/nOdzR8+PCD3nc0zYzqlZQOI4mF8kgjAADvZGVlKSsry+8yjhopfZomcWmvz4UAQAo6Bq6fwGFoib/HlA4jgVgYoWcEADwTCAQkybOZSdG69u7dK6l5p5dS+jRNLIywai8AeCcYDCozM1M7duxQWlpag8VVcewwxmjv3r3avn27cnNz4yHzSBBGJDl0FQKAZyzLUpcuXbRp0yZt3rzZ73LQTLm5uSooKGjWc6R2GIlf2ksYAQAvpaenq6ioiFM1x7i0tLRm9YjEpHQYYdIzAPCPbdvMwApJKT+A1V21lzACAIBvUjuMsFAeAAC+S+0wYhNGAADwG2FEhBEAAPxEGBFX0wAA4KeUDiOJhfIIIwAA+CWlwwg9IwAA+I8wIinCDKwAAPgmpcNIkAGsAAD4LqXDiJ0URljKGgAAf6R0GIn1jEgSnSMAAPgjpcOInRRGwo7jYyUAAKSulA4jyT0jjBsBAMAfKR1GAoQRAAB8l9phxCKMAADgt9QOI/SMAADgu5QOI5ZlKZZHCCMAAPgjpcOIJAXtaBMwJTwAAP5I+TASYBZWAAB8RRghjAAA4CvCCIvlAQDgq5QPIyyWBwCAv1I+jMSmhA9HCCMAAPgh5cNIrGfE4TQNAAC+SPkwYruzsHJpLwAA/kj5MBIMxMaMsGovAAB+SPkwkri01+dCAABIUYSR+Gka0ggAAH4gjMQGsJJFAADwBWHEpmcEAAA/pXwYYdIzAAD8lfJhhLVpAADwF2GEMAIAgK8IIyyUBwCArwgj9IwAAOArwogdbQIWygMAwB8pH0aCnKYBAMBXKR9GYgvlcZoGAAB/pHwYCdqs2gsAgJ9SPowEArHp4AkjAAD4gTBi0TMCAICfUj6MBG16RgAA8FPKhxGbMSMAAPgq5cNIYqE8Vu0FAMAPKR9GEjOw+lwIAAApijBCzwgAAL4ijDADKwAAviKMcGkvAAC+Ioy4k55FWCgPAABfpHwYYaE8AAD8lfJhJMBCeQAA+IowYkebgDACAIA/Uj6MBAP0jAAA4KeUDyM2V9MAAOCrJoeR119/XePGjVPXrl1lWZYWLVp0yP2XLVsmy7IOuFVUVBxpzS2KhfIAAPBXk8PInj17NGDAAN13331NetzGjRu1bdu2+C0vL6+ph24VLJQHAIC/gk19wJgxYzRmzJgmHygvL0+5ublNflxrSyyURxgBAMAPno0ZGThwoLp06aLzzjtPK1euPOS++/fvV3V1dYNbawkQRgAA8FWrh5EuXbpozpw5evrpp/X000+rsLBQZ511lt56661GH1NaWqqcnJz4rbCwsNXqC3CaBgAAXzX5NE1T9erVS7169Yr/PmLECH388cf605/+pMcee+ygj5kxY4amT58e/726urrVAkksjDjMwAoAgC9aPYwczLBhw7RixYpG7w+FQgqFQp7UwkJ5AAD4y5d5RsrLy9WlSxc/Dn2AxKRnjs+VAACQmprcM1JTU6OPPvoo/vumTZtUXl6uDh06qFu3bpoxY4Y+//xzPfroo5Kk2bNnq2fPnjr11FO1b98+PfTQQ1q6dKlefvnllnsVzcAAVgAA/NXkMLJ27VqdffbZ8d9jYzsmT56suXPnatu2bdqyZUv8/rq6Ov3yl7/U559/rszMTH3729/WK6+80uA5/MRCeQAA+Msy5ugfuVldXa2cnBxVVVUpOzu7RZ/75Xcr9JPH1um0brla8NORLfrcAACkssP9/E75tWlYKA8AAH+lfBhhoTwAAPyV8mEkaEebgJ4RAAD8kfJhxM0ihBEAAHyS8mGEnhEAAPyV8mEkPs/I0X9REQAAxyXCSGyhvAhhBAAAP6R8GAmyUB4AAL5K+TDCpb0AAPgr5cMIk54BAOCvlA8jLJQHAIC/CCMslAcAgK8II/SMAADgK8IIYQQAAF+lfBiJXdobdhyfKwEAIDWlfBgJxOcZkQxzjQAA4DnCiBtGJE7VAADgB8JIUhhh4jMAALyX8mEktmqvxJTwAAD4IeXDSFIWoWcEAAAfpHwYadAzQhgBAMBzKR9GkoaM0DMCAIAPUj6MWJbFxGcAAPgo5cOIxCysAAD4iTAiFssDAMBPhBElpoQnjAAA4D3CiCQ7vj4NYQQAAK8RRkTPCAAAfiKMiAGsAAD4iTAiwggAAH4ijCgRRsKO43MlAACkHsKIEmNGWCgPAADvEUaUdDVNhDACAIDXCCNKupqGnhEAADxHGJFkMwMrAAC+IYxICgaY9AwAAL8QRiQF7GgzOIQRAAA8RxiR5HaM0DMCAIAPCCOSgvSMAADgG8KIJDeL0DMCAIAPCCNK9IxwNQ0AAN4jjIi1aQAA8BNhRIQRAAD8RBhR8kJ5hBEAALxGGBHTwQMA4CfCiBIL5UUijs+VAACQeggjSu4Z8bkQAABSEGFEUiC+UB49IwAAeI0wIgawAgDgJ8KIEqv2Mh08AADeI4xIsi16RgAA8AthRIkBrPSMAADgPcKIEpf20jMCAID3CCNKurSXMAIAgOcII5ICrNoLAIBvCCOSAm4rcJoGAADvEUaU6BlxWJsGAADPEUaUmIGVnhEAALxHGFFi0rMIi9MAAOA5wogS08FHOE0DAIDnCCNKXiiPMAIAgNcII2KhPAAA/EQYEQvlAQDgJ8KIkhfKc3yuBACA1EMYUfJ08D4XAgBACiKMKLFQXoSeEQAAPEcYUaJnhAGsAAB4jzCixNU0TAcPAID3CCNKurSXGVgBAPBck8PI66+/rnHjxqlr166yLEuLFi36xscsW7ZMp512mkKhkE4++WTNnTv3CEptPUF6RgAA8E2Tw8iePXs0YMAA3XfffYe1/6ZNmzR27FidffbZKi8v17XXXqsrr7xSL730UpOLbS02C+UBAOCbYFMfMGbMGI0ZM+aw958zZ4569uypWbNmSZL69OmjFStW6E9/+pNGjRrV1MO3ivhCeYQRAAA81+pjRsrKylRSUtJg26hRo1RWVtboY/bv36/q6uoGt9YUsKPNQBgBAMB7rR5GKioqlJ+f32Bbfn6+qqurVVtbe9DHlJaWKicnJ34rLCxs1RpZKA8AAP8clVfTzJgxQ1VVVfHb1q1bW/V4LJQHAIB/mjxmpKkKCgpUWVnZYFtlZaWys7PVpk2bgz4mFAopFAq1dmlxLJQHAIB/Wr1npLi4WEuWLGmwbfHixSouLm7tQx82rqYBAMA/TQ4jNTU1Ki8vV3l5uaTopbvl5eXasmWLpOgplkmTJsX3v/rqq/XJJ5/o17/+tT744APdf//9+utf/6pf/OIXLfMKWkBioTzCCAAAXmtyGFm7dq0GDRqkQYMGSZKmT5+uQYMGaebMmZKkbdu2xYOJJPXs2VPPPfecFi9erAEDBmjWrFl66KGHjprLeqXEmBHCCAAA3mvymJGzzjpL5hAzlR5sdtWzzjpL69evb+qhPMMAVgAA/HNUXk3jNaaDBwDAP4QRSXZ8oTzH50oAAEg9hBEl94z4XAgAACmIMKLkS3vpGQEAwGuEEbFQHgAAfiKMiEt7AQDwE2FEiYXyHMOU8AAAeI0wIiloJ5ohwuW9AAB4ijAiKSmLcKoGAACPEUb0tZ4RwggAAJ4ijCgxgFXiNA0AAF4jjOhrYSRCGAEAwEuEEUlJWYTF8gAA8BhhRJJlWSyWBwCATwgjrvhiefSMAADgKcKIK94zQhgBAMBThBFXwKJnBAAAPxBGXIH4Ynms3AsAgJcII65gfLE8nwsBACDFEEZcdvw0DWkEAAAvEUZciZ4RxowAAOAlwojLJowAAOALwoiLnhEAAPxBGHEFCCMAAPiCMOIijAAA4A/CiCtgR5uCSc8AAPAWYcQVHzPCQnkAAHiKMOKKX00TIYwAAOAlwoiLnhEAAPxBGHHFFspjACsAAN4ijLhiV9MwgBUAAG8RRlxBd9VehzACAICnCCOuxEJ5hBEAALxEGHElpoNn1V4AALxEGHElFsrzuRAAAFIMYcRFzwgAAP4gjLhYmwYAAH8QRlxc2gsAgD8IIy56RgAA8AdhxMV08AAA+IMw4gqwUB4AAL4gjLgC9IwAAOALwoiLhfIAAPAHYcQVsKNNwdU0AAB4izDiYqE8AAD8QRhxsVAeAAD+IIy4gswzAgCALwgjLpswAgCALwgjriDTwQMA4AvCiCs2zwgDWAEA8BZhxMVCeQAA+IMw4koMYHV8rgQAgNRCGHHFLu1laRoAALxFGHHFJj2jZwQAAG8RRlwBLu0FAMAXhBEXC+UBAOAPwoiLq2kAAPAHYcSVGDNCGAEAwEuEEZfNaRoAAHxBGHEF7WhTEEYAAPAWYcQVcFuCMAIAgLcII66A2zPCAFYAALxFGHHFpoN3DGEEAAAvEUZcduzSXuaDBwDAU4QRV5AZWAEA8AVhxJVYKI8wAgCAlwgjLiY9AwDAH4QRFwvlAQDgD8KIi4XyAADwxxGFkfvuu089evRQRkaGhg8frtWrVze679y5c2VZVoNbRkbGERfcWhIL5Tk+VwIAQGppchh58sknNX36dP3+97/XW2+9pQEDBmjUqFHavn17o4/Jzs7Wtm3b4rfNmzc3q+jWkBgz4nMhAACkmCaHkbvuuktXXXWVLr/8cvXt21dz5sxRZmamHn744UYfY1mWCgoK4rf8/PxmFd0aEqdpSCMAAHipSWGkrq5O69atU0lJSeIJbFslJSUqKytr9HE1NTXq3r27CgsLNX78eL377ruHPM7+/ftVXV3d4NbaGMAKAIA/mhRGvvzyS0UikQN6NvLz81VRUXHQx/Tq1UsPP/yw/v73v+svf/mLHMfRiBEj9NlnnzV6nNLSUuXk5MRvhYWFTSnziBBGAADwR6tfTVNcXKxJkyZp4MCBOvPMM7VgwQJ17txZ//3f/93oY2bMmKGqqqr4bevWra1dZtIAVsIIAABeCjZl506dOikQCKiysrLB9srKShUUFBzWc6SlpWnQoEH66KOPGt0nFAopFAo1pbRmC7qr9rJQHgAA3mpSz0h6eroGDx6sJUuWxLc5jqMlS5aouLj4sJ4jEononXfeUZcuXZpWaStzswg9IwAAeKxJPSOSNH36dE2ePFlDhgzRsGHDNHv2bO3Zs0eXX365JGnSpEk64YQTVFpaKkm65ZZbdPrpp+vkk0/Wrl27dOedd2rz5s268sorW/aVNFOsZ8QYyXFMfBVfAADQupocRi677DLt2LFDM2fOVEVFhQYOHKgXX3wxPqh1y5Ytsu1Eh8u//vUvXXXVVaqoqFD79u01ePBgvfHGG+rbt2/LvYoWELu0V4oulmeLMAIAgBcsY47+QRLV1dXKyclRVVWVsrOzW+UYNfvD6vf7lyRJH9w6WhlpgVY5DgAAqeJwP79Zm8YVTDotw+W9AAB4hzDispNO0zCIFQAA7xBGXPSMAADgD8KIy7YtxTpHCCMAAHiHMJIksVgeYQQAAK8QRpLE16c5+i8wAgDguEEYSRIPIxHCCAAAXiGMJEksluf4XAkAAKmDMJIkdkUNi+UBAOAdwkiSRM8IYQQAAK8QRpLEwwhjRgAA8AxhJEns0l5O0wAA4B3CSJJAgNM0AAB4jTCSJGhHm8MhjAAA4BnCSJLY8jT0jAAA4B3CSJJYzwjTwQMA4B3CSBLbZm0aAAC8RhhJEiSMAADgOcJIkgBhBAAAzxFGkjADKwAA3iOMJKFnBAAA7xFGksTHjDADKwAAniGMJEn0jDg+VwIAQOogjCRhoTwAALxHGEnCQnkAAHiPMJKEq2kAAPAeYSRJ0F21l4XyAADwDmEkiW3RMwIAgNcII0mYDh4AAO8RRpKwUB4AAN4jjCQJMoAVAADPEUaSBOxoczCAFQAA7xBGkgTc1qBnBAAA7xBGkgTdnhHGjAAA4B3CSJIAC+UBAOA5wkiSAFfTAADgOcJIEsIIAADeI4wkiS2URxgBAMA7hJEkiYXyHJ8rAQAgdRBGkiSmg/e5EAAAUghhJEliOnjSCAAAXiGMJGE6eAAAvEcYSRIbM8J08AAAeIcwkiRAzwgAAJ5L3TBijLTkVmnOv0m7tkhKnKZxmIEVAADPpG4YsSzp0+VSxTvSx69KSgxgDUcIIwAAeCV1w4gkfeuc6M+Pl0hKvrSXMAIAgFdSPIycG/35yTLJici2WCgPAACvpXYY6TpIysiR9lVJn7+lYICeEQAAvJbaYSQQlE46K/rnj5cqYEebgzACAIB3UjuMSA3GjcQWyuPSXgAAvEMYiYWRz9YqFN4tiZ4RAAC8RBjJ7SZ1LJJMRJ2/fFMSYQQAAC8RRqR470inypWSCCMAAHiJMCJJJ0cv8e1YsUKSYcwIAAAeIoxIUveRkp2mjD2fqYdVwUJ5AAB4iDAiSaF2UrfTJUln2P9Q2HF8LggAgNRBGIlxx438P/sd1bM2DQAAniGMxLjjRort97RtZ7X+tu4znwsCACA1EEZi8vtLmZ3Uztqn06wPdcPCd/TOZ1V+VwUAwHGPMBJj2/FTNZPyPlJd2NHVf1mnr2r2+1wYAADHN8JIMjeMjKl7WVflrNHnu/Zq2rz1CkcY0AoAQGshjCTrPVbq1Et27Vf67f4/aWHoZtVsWqM7XvjA78oAADhuWcaYo/7SkerqauXk5KiqqkrZ2dmte7D6fdKb90mvz5Lq98gxlp6O/D992HW8hp0xRmf37aqAbbVuDQAAHAcO9/ObMNLoQb+QXrlJ+seT8U1VJlNrAgNlTj5fp464QF26Fcmy6VwCAOBgCCMtZetq1Sx/QPYnS5QZbnh1zR5laEeoh8IditT2xH7qcGKRQp16SDndpLadJIseFABA6iKMtDQnov2bV2tT2QKlf7JUhfWblGZFGt29zgppT0a+6trkybQrUCC7izI6dFVmh64KZHeR2uVLWflSRi6hBQBwXDrcz++ghzUd2+yAQj2L1btnsSRpb22tNrz/trZ9WK7aL95TZtVH6uzs0InWDuVpl9K1X+m1W6TaLdLOxp82rKBq03K1Py1H4VB7OW06yMrsoGC7jkpr10mh7E7KyO4oK72dlN5OSm8bvaVlSsGQlNZGsgMeNQIAAC2PnpEWtGtvnTZ/tVdbtv9LO7dt0r6vtkq7KxTYW6mMfTuUVf+lOqlKedYu5Vn/Uo61t0WOG1FA9XZIYTtD4UCGIoGQwoE2Mna6FEiTAulSIF1WIE2WZcm2JMuyZdmWLDsoBdNlBdJlBUOyg+myAkHZdkB2ICDLDsi2A7IsS5Zlxx+rQFAKhKRgevRnID26zU6LHtNOi87dIkuy7MTNDkh20P1zsEF9Coaiv8tK6i1yfyb/blnRx8aPAQA4GrVqz8h9992nO++8UxUVFRowYIDuueceDRs2rNH9n3rqKd1444369NNPVVRUpD/84Q+64IILjuTQR7XczHTlZqZrQGGupJ4H3B9xjHbuqdP23fu0fvd+fbmrWrX/qlB9zZeK1OyU9n4pe9+/lF63S+l1u9QmXKUcs1s5Vo0ytV+Z1n611T5lap9CVjj+vAFFFHD2Ss5eKXzAYY9rjgKK2EE5SvQOmQZBJhFsjCwZy3ZvAUm2u6+V9DhLlowsY2TJkSUjxwoqEggpEsiQY4cUsdMly25wds2SiR8xUYctY0WDl2MHJcuSZQXcn9GbrKCMHYyHNGPbsoyR3OPLGLf+aKhrUKMUrdE40fvstHjAM3ZAtonIcsLRmwnLkiUnmCETzJATiP6UFD2eHPc1KxrwrGD0px2QbduyLVuWbUdDrOW2qWXHa4u+HsVD6wH7xANpIPparYCMbct2j29Jsiwjq0ELRv/WZIxkHPfPTrQt7KB7Szxfg2PJSnqMif6UEvfF67G+Vt/X63TD7sG+szX4B5D8b+1gz2dHa3Ai0bqMI5mIFAlLTlhy6qM/LTsR6APu32dyLcn1xJ5HJqkt3HYxjhRxnzNSHz2WHWwY/C07cb8Tjtbm1EuRusQ24ySeM/4lI7mtAw1fe3L72kHvviw4jhTel7jZaVJ6ZrQHmdPgx4Qmh5Enn3xS06dP15w5czR8+HDNnj1bo0aN0saNG5WXl3fA/m+88YYmTJig0tJSXXjhhZo3b54uuugivfXWW+rXr1+LvIhjRcC21DkrpM5ZIXdLnqSTD/mYffURVdfWq7Y+ot11EW2vj6i2LqKaffu1b+8e7avdq/21e1W/f49Mfa1UXyurvlZWuFYK75cTrpMTqZfCdVKkThFj5Dgm/lNOWAGnXgFTp6CpV8Cpi364GUe2HAXkyI5/0MbekI3SFFG6FVa66pWusNIUVpoiClrRn2kKy45+/MuSkS0Tf76AHAWsiIJyFHQfl66wQlZ9k9vUVkS20/jYHQD+irj/85NF30tMPFTLfY84GMeN3bFHSJaMZcUfbRtHaWr8vWO/laF6K93d25FtnPh7WfydzYodw71Z0XctK/m9z8RqdL+oxL4wSHIs953N/Zn8hcgkBeyGX1nMAa8sttUk1XRwDe9v0HJGSa8ncTzb/XJlm0i8LZK/dFnGqPrSJ1XQu7jRtmxNTT5NM3z4cA0dOlT33nuvJMlxHBUWFupnP/uZrr/++gP2v+yyy7Rnzx49++yz8W2nn366Bg4cqDlz5hzWMY+V0zTHE2OMHCPVRxxFksJLJHYzSX92b0aSY4yMifYCOcaoPmIUjjgKO0ZhJ/ocjvvY6E/FnzscceRE6uS42yKRiMKOkXGc6BdBRZ/bGEeKhKMhK1LnfpsLR/9LO070P6C7nzGOW1P0eSx3m2Ui0W+C7muNfYM2xsiRpbBjKaLoFy5bEQWd/Uoz+5Vu9ivo1McfZ2KPN4k3hNh8vbZxZJuIAu7bcezYJlaPiW6zTcTdLyzbOHKspBgX+0LvviXbbm+Jk3gLkWOi9wfcYwVMWAE5CstWvQlET+MpIFuOMlSnDNUppDqFVC+3T0SO+1YlEz2G7b5pBxSRZKIBVbE3tGgDWw3eTBu+7dpuK8SCaMCKVhsPo4ooIMd9lqQ3YPdRyZzEW6eM2ysUkKOgEoHWSjpmrMboa7Pj1SbXGQvHiR4ZEw/esdcf+z3xBtmg3yu+xfpaWyTf7NjNMnJM9DVE3JjuyFY4+reusIKKyJbtvq5YoA/GPsqtRj6ojftB08j9khQ2tiIKKKhwo8+T/Hz1CqouurccWW47R+J1HepYR4OwsRW0mDX7SHxw4QL1HnJuiz5nq5ymqaur07p16zRjxoz4Ntu2VVJSorKysoM+pqysTNOnT2+wbdSoUVq0aFGjx9m/f7/270+sCVNdXd2UMtECLMtSwJICDI6FKxZQnYN8fzHudidpn8a+05mkx8jd10huoDXutmj4dIwb+pIOGT9z9Q0cNyTGgm8s0DpOIthK7tkFWQ2eM3ZfIgBH/xxxEoU0eB2x/ZK2xdor9pq+qS2MDnaaKqkdHCcaoK3oKcDY6bHo440sJyKZsEy4Xsay5binAGMhz5IkE1HAqZft1MsyETl2WjRy2dFv9bIO/P8ee31O/IxXNObJRKIh1XFkWW6kNLHjOJIJJ05LOeED/tKMifYrRJzonyOxgOf+fcSawnIkIyf+pSF+Wi8ejC2FA+mKBDIUtkJy7KCM4ygQqZUdrlUgvFd2pE6yoyEwfiopqX0t97RX7IuCjCPjRGS5PTBye0riPQ6WnfjdMdEeWhORZSKyTdhtMyfp366JjreTZDf4d2YpIssNql8LtsY0qDH2l2HcLwZO7IuZJFuWLCtxjK+fnjQmGswjsuWY6BctYwUT7WFF+6ZG9Rh0wN+/V5oURr788ktFIhHl5+c32J6fn68PPjj4lOkVFRUH3b+ioqLR45SWlurmm29uSmkAWlk8oDYaMwDgyByVlyLMmDFDVVVV8dvWrVv9LgkAALSSJvWMdOrUSYFAQJWVlQ22V1ZWqqCg4KCPKSgoaNL+khQKhRQKhRq9HwAAHD+a1DOSnp6uwYMHa8mSJfFtjuNoyZIlKi4++Ajc4uLiBvtL0uLFixvdHwAApJYmX9o7ffp0TZ48WUOGDNGwYcM0e/Zs7dmzR5dffrkkadKkSTrhhBNUWloqSbrmmmt05plnatasWRo7dqzmz5+vtWvX6sEHH2zZVwIAAI5JTQ4jl112mXbs2KGZM2eqoqJCAwcO1IsvvhgfpLplyxbZSRPdjBgxQvPmzdPvfvc73XDDDSoqKtKiRYtSbo4RAABwcEwHDwAAWsXhfn4flVfTAACA1EEYAQAAviKMAAAAXxFGAACArwgjAADAV4QRAADgK8IIAADwVZMnPfNDbCqU6upqnysBAACHK/a5/U1Tmh0TYWT37t2SpMLCQp8rAQAATbV7927l5OQ0ev8xMQOr4zj64osvlJWVJcuyWux5q6urVVhYqK1btzKzayujrb1DW3uL9vYObe2dlmprY4x2796trl27Nlgq5uuOiZ4R27Z14oknttrzZ2dn8w/bI7S1d2hrb9He3qGtvdMSbX2oHpEYBrACAABfEUYAAICvUjqMhEIh/f73v1coFPK7lOMebe0d2tpbtLd3aGvveN3Wx8QAVgAAcPxK6Z4RAADgP8IIAADwFWEEAAD4ijACAAB8ldJh5L777lOPHj2UkZGh4cOHa/Xq1X6XdMwrLS3V0KFDlZWVpby8PF100UXauHFjg3327dunqVOnqmPHjmrXrp2++93vqrKy0qeKjw933HGHLMvStddeG99GO7eszz//XP/+7/+ujh07qk2bNurfv7/Wrl0bv98Yo5kzZ6pLly5q06aNSkpK9OGHH/pY8bEpEonoxhtvVM+ePdWmTRt961vf0q233tpgbRPa+si8/vrrGjdunLp27SrLsrRo0aIG9x9Ou+7cuVMTJ05Udna2cnNz9eMf/1g1NTXNL86kqPnz55v09HTz8MMPm3fffddcddVVJjc311RWVvpd2jFt1KhR5pFHHjEbNmww5eXl5oILLjDdunUzNTU18X2uvvpqU1hYaJYsWWLWrl1rTj/9dDNixAgfqz62rV692vTo0cN8+9vfNtdcc018O+3ccnbu3Gm6d+9upkyZYlatWmU++eQT89JLL5mPPvoovs8dd9xhcnJyzKJFi8zbb79tvvOd75iePXua2tpaHys/9tx2222mY8eO5tlnnzWbNm0yTz31lGnXrp25++674/vQ1kfm+eefN7/97W/NggULjCSzcOHCBvcfTruOHj3aDBgwwLz55ptm+fLl5uSTTzYTJkxodm0pG0aGDRtmpk6dGv89EomYrl27mtLSUh+rOv5s377dSDKvvfaaMcaYXbt2mbS0NPPUU0/F93n//feNJFNWVuZXmces3bt3m6KiIrN48WJz5plnxsMI7dyyfvOb35h/+7d/a/R+x3FMQUGBufPOO+Pbdu3aZUKhkHniiSe8KPG4MXbsWHPFFVc02HbJJZeYiRMnGmNo65by9TByOO363nvvGUlmzZo18X1eeOEFY1mW+fzzz5tVT0qepqmrq9O6detUUlIS32bbtkpKSlRWVuZjZcefqqoqSVKHDh0kSevWrVN9fX2Dtu/du7e6detG2x+BqVOnauzYsQ3aU6KdW9ozzzyjIUOG6NJLL1VeXp4GDRqk//mf/4nfv2nTJlVUVDRo75ycHA0fPpz2bqIRI0ZoyZIl+uc//ylJevvtt7VixQqNGTNGEm3dWg6nXcvKypSbm6shQ4bE9ykpKZFt21q1alWzjn9MLJTX0r788ktFIhHl5+c32J6fn68PPvjAp6qOP47j6Nprr9XIkSPVr18/SVJFRYXS09OVm5vbYN/8/HxVVFT4UOWxa/78+Xrrrbe0Zs2aA+6jnVvWJ598ogceeEDTp0/XDTfcoDVr1ujnP/+50tPTNXny5HibHuw9hfZumuuvv17V1dXq3bu3AoGAIpGIbrvtNk2cOFGSaOtWcjjtWlFRoby8vAb3B4NBdejQodltn5JhBN6YOnWqNmzYoBUrVvhdynFn69atuuaaa7R48WJlZGT4Xc5xz3EcDRkyRLfffrskadCgQdqwYYPmzJmjyZMn+1zd8eWvf/2rHn/8cc2bN0+nnnqqysvLde2116pr16609XEsJU/TdOrUSYFA4IArCyorK1VQUOBTVceXadOm6dlnn9Wrr76qE088Mb69oKBAdXV12rVrV4P9afumWbdunbZv367TTjtNwWBQwWBQr732mv785z8rGAwqPz+fdm5BXbp0Ud++fRts69Onj7Zs2SJJ8TblPaX5fvWrX+n666/XD37wA/Xv318/+tGP9Itf/EKlpaWSaOvWcjjtWlBQoO3btze4PxwOa+fOnc1u+5QMI+np6Ro8eLCWLFkS3+Y4jpYsWaLi4mIfKzv2GWM0bdo0LVy4UEuXLlXPnj0b3D948GClpaU1aPuNGzdqy5YttH0TnHvuuXrnnXdUXl4evw0ZMkQTJ06M/5l2bjkjR4484BL1f/7zn+revbskqWfPniooKGjQ3tXV1Vq1ahXt3UR79+6VbTf8aAoEAnIcRxJt3VoOp12Li4u1a9curVu3Lr7P0qVL5TiOhg8f3rwCmjX89Rg2f/58EwqFzNy5c817771nfvKTn5jc3FxTUVHhd2nHtP/8z/80OTk5ZtmyZWbbtm3x2969e+P7XH311aZbt25m6dKlZu3ataa4uNgUFxf7WPXxIflqGmNo55a0evVqEwwGzW233WY+/PBD8/jjj5vMzEzzl7/8Jb7PHXfcYXJzc83f//53849//MOMHz+ey02PwOTJk80JJ5wQv7R3wYIFplOnTubXv/51fB/a+sjs3r3brF+/3qxfv95IMnfddZdZv3692bx5szHm8Np19OjRZtCgQWbVqlVmxYoVpqioiEt7m+uee+4x3bp1M+np6WbYsGHmzTff9LukY56kg94eeeSR+D61tbXmpz/9qWnfvr3JzMw0F198sdm2bZt/RR8nvh5GaOeW9X//93+mX79+JhQKmd69e5sHH3ywwf2O45gbb7zR5Ofnm1AoZM4991yzceNGn6o9dlVXV5trrrnGdOvWzWRkZJiTTjrJ/Pa3vzX79++P70NbH5lXX331oO/PkydPNsYcXrt+9dVXZsKECaZdu3YmOzvbXH755Wb37t3Nrs0yJmlaOwAAAI+l5JgRAABw9CCMAAAAXxFGAACArwgjAADAV4QRAADgK8IIAADwFWEEAAD4ijACAAB8RRgBAAC+IowAAABfEUYAAICvCCMAAMBX/x/duxyKSVWRCgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "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": 26, + "id": "cadb0e00-96bb-423b-9163-7c8010011dd1", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "4510b043-7808-4679-9be4-c61dcca6ecac", + "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", + " # tr_maxs = np.transpose(maxs, (2, 0, 1))\n", + " # tr_mins = np.transpose(mins, (2, 0, 1))\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", + " eva_list.append([mae, rmse, mape, r2])" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4d80bff2-3086-4e73-a597-f2fa812e2c28", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2
count75.00000075.00000075.00000075.000000
mean1.5486392.5130430.1907120.850014
std0.1046970.2777610.0183810.021919
min1.3724612.1256860.1589940.766183
25%1.4924242.3713250.1771620.836254
50%1.5538642.4820610.1877780.851790
75%1.6005542.6300400.2012290.865281
max2.0361504.2804050.2594330.884967
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2\n", + "count 75.000000 75.000000 75.000000 75.000000\n", + "mean 1.548639 2.513043 0.190712 0.850014\n", + "std 0.104697 0.277761 0.018381 0.021919\n", + "min 1.372461 2.125686 0.158994 0.766183\n", + "25% 1.492424 2.371325 0.177162 0.836254\n", + "50% 1.553864 2.482061 0.187778 0.851790\n", + "75% 1.600554 2.630040 0.201229 0.865281\n", + "max 2.036150 4.280405 0.259433 0.884967" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "9732912d-4fa2-42c5-8c7d-27825e479faf", + "metadata": {}, + "outputs": [], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2']).describe().to_csv('./eva_files/decoder+local_loss.csv', encoding='utf-8-sig')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "1ada99bf-6bea-4e46-a3bd-f62510517c8e", + "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": 30, + "id": "699473c7-33b8-432d-861c-2628ad2614f0", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list_frame = 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", + " 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])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "79731bcf-3ec2-4a9b-a58d-74c40212f738", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.5536672.2090920.1887880.5238670.8290280.775553
std0.8210441.1938560.1217530.4207040.1825490.164661
min0.5253060.6805060.061413-4.738533-0.916011-0.197854
25%0.9600991.3337640.1316940.4290170.8026310.715950
50%1.3692561.9581600.1636520.6460980.8896640.824197
75%1.8925612.7040550.2033640.7689180.9318430.886272
max7.90526111.1960681.6712240.9724140.9931030.986316
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.553667 2.209092 0.188788 0.523867 0.829028 \n", + "std 0.821044 1.193856 0.121753 0.420704 0.182549 \n", + "min 0.525306 0.680506 0.061413 -4.738533 -0.916011 \n", + "25% 0.960099 1.333764 0.131694 0.429017 0.802631 \n", + "50% 1.369256 1.958160 0.163652 0.646098 0.889664 \n", + "75% 1.892561 2.704055 0.203364 0.768918 0.931843 \n", + "max 7.905261 11.196068 1.671224 0.972414 0.993103 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.775553 \n", + "std 0.164661 \n", + "min -0.197854 \n", + "25% 0.715950 \n", + "50% 0.824197 \n", + "75% 0.886272 \n", + "max 0.986316 " + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8b5207d-e9ad-46e7-8d57-18528beee59b", + "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 +} diff --git a/torch_MAE_1d_encoder.ipynb b/torch_MAE_1d_encoder.ipynb new file mode 100644 index 0000000..8837de8 --- /dev/null +++ b/torch_MAE_1d_encoder.ipynb @@ -0,0 +1,982 @@ +{ + "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": "15b9ced8-7282-4f97-a079-f31bf9405145", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(0)\n", + "torch.random.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7f83e6c7-8207-41b3-908b-6b1fad78ecd5", + "metadata": {}, + "outputs": [], + "source": [ + "max_pixel_value = 107.49169921875" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c66f2b9f-fcad-4237-abb2-d7f918d74116", + "metadata": {}, + "outputs": [], + "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/20/'" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e3354304-f6de-44bf-adbf-bbff557a8c93", + "metadata": {}, + "outputs": [], + "source": [ + "train_set = NO2Dataset(image_dir, mask_dir)\n", + "train_loader = DataLoader(train_set, 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": 6, + "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": 7, + "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": 8, + "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": 9, + "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": 10, + "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": 11, + "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": 12, + "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": 13, + "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": 14, + "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": 15, + "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": 16, + "id": "a382ed1b-cc88-4f03-95c2-843981ee81f1", + "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": "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", + " nn.ReLU(),\n", + " SEBlock(32,32),\n", + " ConvBNReLU(32, 64, kernel_size=3, stride=2),\n", + " ResidualBlock(64,64),\n", + " SeparableBNReLU(64, 128, kernel_size=3, stride=2),\n", + " MultiHeadAttentionBlock(embed_dim=128, num_heads=4),\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": "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 = criterion(reconstructed, y)\n", + " loss = masked_mse_loss(reconstructed, y, mask)\n", + " loss.backward()\n", + " optimizer.step()\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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 = criterion(reconstructed, y)\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": 20, + "id": "6094b6c8-8211-4557-9944-7eef977ea9ec", + "metadata": {}, + "outputs": [], + "source": [ + "def masked_mae_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": 29, + "id": "781f558e-d41c-4721-94fd-564cd6c2b347", + "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": 30, + "id": "743d1000-561e-4444-8b49-88346c14f28b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 0.013549078723781131, Val Loss: 0.014539383435204847\n", + "Epoch 2, Train Loss: 0.013641111095966192, Val Loss: 0.014635173200782555\n", + "Epoch 3, Train Loss: 0.013503858572290988, Val Loss: 0.01476309893291388\n", + "Epoch 4, Train Loss: 0.013455510417970887, Val Loss: 0.014315864057349624\n", + "Epoch 5, Train Loss: 0.01339626228704193, Val Loss: 0.01442837900023407\n", + "Epoch 6, Train Loss: 0.013295360569035608, Val Loss: 0.015184532503472336\n", + "Epoch 12, Train Loss: 0.012901031857793125, Val Loss: 0.013935101566030018\n", + "Epoch 13, Train Loss: 0.01295265725158761, Val Loss: 0.013862666924164366\n", + "Epoch 14, Train Loss: 0.013010161795149865, Val Loss: 0.013880979492148357\n", + "Epoch 15, Train Loss: 0.012936625905940977, Val Loss: 0.013813913021403463\n", + "Epoch 16, Train Loss: 0.01287072714926167, Val Loss: 0.01403502803017844\n", + "Epoch 17, Train Loss: 0.012832806871214695, Val Loss: 0.014388528165977393\n", + "Epoch 18, Train Loss: 0.012794200125992583, Val Loss: 0.01383661480147892\n", + "Epoch 19, Train Loss: 0.01294981115208003, Val Loss: 0.01408140508652623\n", + "Epoch 20, Train Loss: 0.012662894464583631, Val Loss: 0.01359965718949019\n", + "Test Loss: 0.007365767304242279\n" + ] + } + ], + "source": [ + "model = model.to(device)\n", + "\n", + "num_epochs = 20\n", + "train_losses = list()\n", + "val_losses = list()\n", + "for epoch in range(num_epochs):\n", + " train_loss = train_epoch(model, device, train_loader, 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": 31, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 32, + "id": "1f48acd7-70e8-46db-9148-6a2df3153f08", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "313fa420-c856-4db1-80ae-b543e1fb73ef", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list = list()\n", + "model = model.to('cpu')\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", + " eva_list.append([mae, rmse, mape, r2])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "5c6d5e5a-90f6-4e9a-882f-c2f160b0cb15", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2
count75.00000075.00000075.00000075.000000
mean1.2969062.0223620.1676940.904339
std0.0757610.1370410.0131710.010395
min1.1212841.7162750.1436670.875878
25%1.2383781.9179070.1564290.898060
50%1.2871932.0118280.1666790.904941
75%1.3530452.1024090.1769960.911137
max1.4460462.4145320.2021420.924070
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2\n", + "count 75.000000 75.000000 75.000000 75.000000\n", + "mean 1.296906 2.022362 0.167694 0.904339\n", + "std 0.075761 0.137041 0.013171 0.010395\n", + "min 1.121284 1.716275 0.143667 0.875878\n", + "25% 1.238378 1.917907 0.156429 0.898060\n", + "50% 1.287193 2.011828 0.166679 0.904941\n", + "75% 1.353045 2.102409 0.176996 0.911137\n", + "max 1.446046 2.414532 0.202142 0.924070" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "1ada99bf-6bea-4e46-a3bd-f62510517c8e", + "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": 36, + "id": "b4250d45-b430-40a0-ace7-f59d3451aebd", + "metadata": {}, + "outputs": [], + "source": [ + "eva_list_frame = 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", + " 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])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "039d0041-4573-4645-aeb0-686eabfe8b6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.3068171.8458190.1668760.6705190.8866460.836323
std0.6236450.9026190.1070250.2407520.1111420.121726
min0.4329910.5683190.050612-1.539424-0.2675690.022258
25%0.8355791.1723220.1133020.5837130.8647560.794922
50%1.1617101.6581950.1433860.7358600.9213410.869860
75%1.6173822.2997310.1850390.8272420.9512850.916741
max5.3382309.9369511.9299860.9832080.9957670.992588
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.306817 1.845819 0.166876 0.670519 0.886646 \n", + "std 0.623645 0.902619 0.107025 0.240752 0.111142 \n", + "min 0.432991 0.568319 0.050612 -1.539424 -0.267569 \n", + "25% 0.835579 1.172322 0.113302 0.583713 0.864756 \n", + "50% 1.161710 1.658195 0.143386 0.735860 0.921341 \n", + "75% 1.617382 2.299731 0.185039 0.827242 0.951285 \n", + "max 5.338230 9.936951 1.929986 0.983208 0.995767 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.836323 \n", + "std 0.121726 \n", + "min 0.022258 \n", + "25% 0.794922 \n", + "50% 0.869860 \n", + "75% 0.916741 \n", + "max 0.992588 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83c7e465-bbd0-4c56-8cb4-9d1122fe695f", + "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 +} diff --git a/torch_MAE_1d_final.ipynb b/torch_MAE_1d_final.ipynb new file mode 100644 index 0000000..ed22e50 --- /dev/null +++ b/torch_MAE_1d_final.ipynb @@ -0,0 +1,1068 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6603a8fc-d9da-4037-b845-d9c38bae4ce4", + "metadata": {}, + "outputs": [], + "source": [ + "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, TensorDataset, random_split\n", + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "adf69eb9-bedb-4db7-87c4-04c23752a7c3", + "metadata": {}, + "outputs": [], + "source": [ + "def load_data(pix, use_type='train'):\n", + " datasets = list()\n", + " file_list = [x for x in os.listdir(f\"./out_mat/{pix}/{use_type}/\") if x.endswith('.npy')]\n", + " for file in file_list:\n", + " file_img = np.load(f\"./out_mat/{pix}/{use_type}/{file}\")[:,:,:1]\n", + " datasets.append(file_img)\n", + " return np.asarray(datasets)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e0aa628f-37b7-498a-94d7-81241c20b305", + "metadata": {}, + "outputs": [], + "source": [ + "train_set = load_data(96, 'train')\n", + "val_set = load_data(96, 'valid')\n", + "test_set = load_data(96, 'test')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5d5f95cb-f40c-4ead-96fe-241068408b98", + "metadata": {}, + "outputs": [], + "source": [ + "def load_mask(mask_rate):\n", + " mask_files = os.listdir(f'./out_mat/96/mask/{mask_rate}')\n", + " masks = list()\n", + " for file in mask_files:\n", + " d = cv2.imread(f'./out_mat/96/mask/{mask_rate}/{file}', cv2.IMREAD_GRAYSCALE)\n", + " d = (d > 0) * 1\n", + " masks.append(d)\n", + " return np.asarray(masks)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "71452a77-8158-46b2-aecf-400ad7b72df5", + "metadata": {}, + "outputs": [], + "source": [ + "masks = load_mask(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1902e0f8-32bb-4376-8238-334260b12623", + "metadata": {}, + "outputs": [], + "source": [ + "maxs = train_set.max(axis=0)\n", + "mins = train_set.min(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8df9f3c3-ced8-4640-af30-b2f147dbdc96", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26749" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_set)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53664b12-fd95-4dd0-b61d-20682f8f14f4", + "metadata": {}, + "outputs": [], + "source": [ + "norm_train = (train_set - mins) / (maxs-mins)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05cb9dc8-c1df-48bf-a9dd-d084ce1d2068", + "metadata": {}, + "outputs": [], + "source": [ + "del train_set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ae39364-4cf6-49e9-b99f-6723520943b5", + "metadata": {}, + "outputs": [], + "source": [ + "norm_valid = (val_set - mins) / (maxs-mins)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f78b981-d079-4000-ba9f-d862e34903b1", + "metadata": {}, + "outputs": [], + "source": [ + "del val_set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f54eede6-e95a-4476-b822-79846c0b1079", + "metadata": {}, + "outputs": [], + "source": [ + "norm_test = (test_set - mins) / (maxs-mins)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e66887eb-df5e-46d3-b9c5-73af1272b27a", + "metadata": {}, + "outputs": [], + "source": [ + "del test_set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00afa8cd-18b4-4d71-8cab-fd140058dca3", + "metadata": {}, + "outputs": [], + "source": [ + "norm_train.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31d91072-3878-4e3c-b6f1-09f597faf60d", + "metadata": {}, + "outputs": [], + "source": [ + "trans_train = np.transpose(norm_train, (0, 3, 1, 2))\n", + "trans_val = np.transpose(norm_valid, (0, 3, 1, 2))\n", + "trans_test = np.transpose(norm_test, (0, 3, 1, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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": null, + "id": "aeda3567-4c4d-496b-9570-9ae757b45e72", + "metadata": {}, + "outputs": [], + "source": [ + "# 设置随机种子以确保结果的可重复性\n", + "torch.manual_seed(0)\n", + "np.random.seed(0)\n", + "\n", + "# 数据准备\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(device)\n", + "# 将numpy数组转换为PyTorch张量\n", + "tensor_train = torch.tensor(trans_train.astype(np.float32), device=device)\n", + "tensor_valid = torch.tensor(trans_val.astype(np.float32), device=device)\n", + "tensor_test = torch.tensor(trans_test.astype(np.float32), device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2353265d-91ef-4a84-b582-ea969d2ee252", + "metadata": {}, + "outputs": [], + "source": [ + "del trans_train\n", + "del trans_val\n", + "del trans_test" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1569baeb-5a9e-48c1-a735-82d0cba8ad29", + "metadata": {}, + "outputs": [], + "source": [ + "# 创建一个数据集和数据加载器\n", + "train_set = TensorDataset(tensor_train, tensor_train) # 输出和标签相同，因为我们是自编码器\n", + "val_set = TensorDataset(tensor_valid, tensor_valid)\n", + "test_set = TensorDataset(tensor_test, tensor_test)\n", + "batch_size = 64\n", + "train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)\n", + "val_loader = DataLoader(val_set, batch_size=batch_size, shuffle=False)\n", + "test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c81785d-f0e6-486f-8aad-dba81d2ec146", + "metadata": {}, + "outputs": [], + "source": [ + "def mask_data(data, device, masks):\n", + " mask_inds = np.random.choice(masks.shape[0], data.shape[0])\n", + " mask = torch.from_numpy(masks[mask_inds]).to(device)\n", + " tmp_first_channel = data[:, 0, :, :] * mask\n", + " masked_data = torch.clone(data)\n", + " masked_data[:, 0, :, :] = tmp_first_channel\n", + " return masked_data, mask" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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": null, + "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": null, + "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": null, + "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": null, + "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": null, + "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": 8, + "id": "eea9678d-e170-4dd5-bf96-d20af4d40184", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on built-in function mean in module torch:\n", + "\n", + "mean(...)\n", + " mean(input, *, dtype=None) -> Tensor\n", + " \n", + " Returns the mean value of all elements in the :attr:`input` tensor.\n", + " \n", + " Args:\n", + " input (Tensor): the input tensor.\n", + " \n", + " Keyword args:\n", + " dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.\n", + " If specified, the input tensor is casted to :attr:`dtype` before the operation\n", + " is performed. This is useful for preventing data type overflows. Default: None.\n", + " \n", + " Example::\n", + " \n", + " >>> a = torch.randn(1, 3)\n", + " >>> a\n", + " tensor([[ 0.2294, -0.5481, 1.3288]])\n", + " >>> torch.mean(a)\n", + " tensor(0.3367)\n", + " \n", + " .. function:: mean(input, dim, keepdim=False, *, dtype=None, out=None) -> Tensor\n", + " :noindex:\n", + " \n", + " Returns the mean value of each row of the :attr:`input` tensor in the given\n", + " dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,\n", + " reduce over all of them.\n", + " \n", + " \n", + " If :attr:`keepdim` is ``True``, the output tensor is of the same size\n", + " as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.\n", + " Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the\n", + " output tensor having 1 (or ``len(dim)``) fewer dimension(s).\n", + " \n", + " \n", + " Args:\n", + " input (Tensor): the input tensor.\n", + " dim (int or tuple of ints): the dimension or dimensions to reduce.\n", + " keepdim (bool): whether the output tensor has :attr:`dim` retained or not.\n", + " \n", + " Keyword args:\n", + " dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.\n", + " If specified, the input tensor is casted to :attr:`dtype` before the operation\n", + " is performed. This is useful for preventing data type overflows. Default: None.\n", + " out (Tensor, optional): the output tensor.\n", + " \n", + " .. seealso::\n", + " \n", + " :func:`torch.nanmean` computes the mean value of `non-NaN` elements.\n", + " \n", + " Example::\n", + " \n", + " >>> a = torch.randn(4, 4)\n", + " >>> a\n", + " tensor([[-0.3841, 0.6320, 0.4254, -0.7384],\n", + " [-0.9644, 1.0131, -0.6549, -1.4279],\n", + " [-0.2951, -1.3350, -0.7694, 0.5600],\n", + " [ 1.0842, -0.9580, 0.3623, 0.2343]])\n", + " >>> torch.mean(a, 1)\n", + " tensor([-0.0163, -0.5085, -0.4599, 0.1807])\n", + " >>> torch.mean(a, 1, True)\n", + " tensor([[-0.0163],\n", + " [-0.5085],\n", + " [-0.4599],\n", + " [ 0.1807]])\n", + "\n" + ] + } + ], + "source": [ + "help(torch.mean)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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": null, + "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": null, + "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": null, + "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=0.001)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fea37b5f-817d-4850-8393-36910cf64eb2", + "metadata": {}, + "outputs": [], + "source": [ + "# 定义Masked Autoencoder模型\n", + "class MaskedAutoencoderBase(nn.Module):\n", + " def __init__(self):\n", + " super(MaskedAutoencoderBase, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),\n", + " nn.ReLU(),\n", + " SEBlock(128, 128)\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.ConvTranspose2d(128, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(),\n", + " nn.ConvTranspose2d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.ReLU(),\n", + " nn.ConvTranspose2d(16, 1, kernel_size=3, stride=2, padding=1, output_padding=1),\n", + " nn.Sigmoid() # 使用Sigmoid是因为输入数据是0-1之间的\n", + " )\n", + "\n", + " def forward(self, x):\n", + " encoded = self.encoder(x)\n", + " decoded = self.decoder(encoded)\n", + " return decoded\n", + "\n", + "# 实例化模型、损失函数和优化器\n", + "model = MaskedAutoencoderBase()\n", + "criterion = nn.MSELoss()\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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, (data, _) in enumerate(data_loader):\n", + " masked_data, mask = mask_data(data, device, masks)\n", + " optimizer.zero_grad()\n", + " reconstructed = model(masked_data)\n", + " loss = criterion(reconstructed, data)\n", + " loss.backward()\n", + " optimizer.step()\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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, (data, _) in enumerate(data_loader):\n", + " data = data.to(device)\n", + " masked_data, mask = mask_data(data, device, masks)\n", + " reconstructed = model(masked_data)\n", + " if batch_idx == 8:\n", + " rand_ind = np.random.randint(0, len(data))\n", + " visualize_feature(data[rand_ind], masked_data[rand_ind], reconstructed[rand_ind], title='NO_2')\n", + " loss = criterion(reconstructed, data)\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1847c78-cbc6-4560-bb49-4dc6e9b8bbd0", + "metadata": {}, + "outputs": [], + "source": [ + "# 测试函数\n", + "def test(model, device, data_loader):\n", + " model.eval()\n", + " with torch.no_grad():\n", + " for batch_idx, (data, _) in enumerate(data_loader):\n", + " data = data.to(device)\n", + " masked_data, mask = mask_data(data, device, masks)\n", + " masked_ind = np.argwhere(masked_data[0][0]==0)\n", + " reconstructed = model(masked_data)\n", + " recon_no2 = reconstructed[0][0]\n", + " ori_no2 = data[0][0]\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "743d1000-561e-4444-8b49-88346c14f28b", + "metadata": {}, + "outputs": [], + "source": [ + "model = model.to(device)\n", + "\n", + "num_epochs = 100\n", + "train_losses = list()\n", + "val_losses = list()\n", + "for epoch in range(num_epochs):\n", + " train_loss = train_epoch(model, device, train_loader, 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": null, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [], + "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": "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": null, + "id": "dae7427e-548e-4276-a4ea-bc9b279d44e8", + "metadata": {}, + "outputs": [], + "source": [ + "real_list = list()\n", + "pred_list = list()\n", + "with torch.no_grad():\n", + " device = 'cpu'\n", + " for batch_idx, (data, _) in enumerate(test_loader):\n", + " model = model.to(device)\n", + " data = data.to(device)\n", + " masked_data, mask = mask_data(data, device, masks)\n", + " mask_rev = (mask==0) * 1 # mask取反获得修复区域\n", + " reconstructed = model(masked_data)\n", + " tr_maxs = np.transpose(maxs, (2, 0, 1))\n", + " tr_mins = np.transpose(mins, (2, 0, 1))\n", + " rev_data = data * (tr_maxs - tr_mins) + tr_mins\n", + " rev_recon = reconstructed * (tr_maxs - tr_mins) + tr_mins\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", + " real_list.extend(data_label)\n", + " pred_list.extend(recon_no2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94e58640-42a9-4d54-a851-c7fc3a6e06ce", + "metadata": {}, + "outputs": [], + "source": [ + "abs(np.asarray(real_list) - np.asarray(pred_list))" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "acee2abc-2f3f-4d19-a6e4-85ad4d1aaacf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_feature(data[5], masked_data[5], reconstructed[5], 'NO2')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ada99bf-6bea-4e46-a3bd-f62510517c8e", + "metadata": {}, + "outputs": [], + "source": [ + "# real_list = list()\n", + "# pred_list = list()\n", + "# with torch.no_grad():\n", + "# device = 'cpu'\n", + "# for batch_idx, (data, _) in enumerate(test_loader):\n", + "# model = model.to(device)\n", + "# data = data.to(device)\n", + "# masked_data, mask = mask_data(data, device, masks)\n", + "# mask_rev = (mask==0) * 1 # mask取反获得修复区域\n", + "# reconstructed = model(masked_data)\n", + "# tr_maxs = np.transpose(maxs, (2, 0, 1))\n", + "# tr_mins = np.transpose(mins, (2, 0, 1))\n", + "# rev_data = data * (tr_maxs - tr_mins) + tr_mins\n", + "# rev_recon = reconstructed * (tr_maxs - tr_mins) + tr_mins\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", + "# real_list.extend(data_label)\n", + "# pred_list.extend(recon_no2)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8332744e-5b90-4702-a3b7-66309ffb1956", + "metadata": {}, + "outputs": [], + "source": [ + "a = torch.randn(1, 1, 4, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "216bce16-246e-4431-95e7-2c3a9d894fe2", + "metadata": {}, + "outputs": [], + "source": [ + "avg_out = torch.mean(a, dim=1, keepdim=True) #(B, 1, H, W)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "0b954708-269f-4b5a-ad65-03ecf58a9549", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 1, 4, 4])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "avg_out.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "31ac2d6d-79c6-4ed8-a9e5-0ec37a6a9e4a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-0.0919, 1.9463, -0.6934, 0.1982],\n", + " [ 0.1241, 0.5442, 0.4565, 0.3567],\n", + " [ 0.8672, -0.8656, -0.4287, -0.4634],\n", + " [ 1.8194, 0.3727, 1.1409, 0.6761]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[0][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4c660fa7-851b-456c-9881-88f81079121c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-0.0919, 1.9463, -0.6934, 0.1982],\n", + " [ 0.1241, 0.5442, 0.4565, 0.3567],\n", + " [ 0.8672, -0.8656, -0.4287, -0.4634],\n", + " [ 1.8194, 0.3727, 1.1409, 0.6761]])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "avg_out[0][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5905c4ff-613b-4f08-a7a1-2bafb4fc0ba2", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "279cb531-aefc-4be2-8d98-b09c3c595a9a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[[-0.0919, 1.9463, -0.6934, 0.1982],\n", + " [ 0.1241, 0.5442, 0.4565, 0.3567],\n", + " [ 0.8672, -0.8656, -0.4287, -0.4634],\n", + " [ 1.8194, 0.3727, 1.1409, 0.6761]]]])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "avg_out" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "19ae1030-1d4d-4a0b-b307-412456f27f47", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[[-0.0919, 1.9463, -0.6934, 0.1982],\n", + " [ 0.1241, 0.5442, 0.4565, 0.3567],\n", + " [ 0.8672, -0.8656, -0.4287, -0.4634],\n", + " [ 1.8194, 0.3727, 1.1409, 0.6761]]]])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "avg_out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e10712cd-45fc-44a3-b359-5a62cae1c33c", + "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 +} diff --git a/torch_MAE_1d_final_10.ipynb b/torch_MAE_1d_final_10.ipynb new file mode 100644 index 0000000..cb93530 --- /dev/null +++ b/torch_MAE_1d_final_10.ipynb @@ -0,0 +1,1093 @@ +{ + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count75.00000075.00000075.00000075.00000075.00000075.000000
mean1.0922531.7201530.1344800.9321020.9817980.966130
std0.0787880.1706010.0093320.0126110.0036740.006333
min0.9611781.4609300.1185220.8910690.9693070.945610
25%1.0397871.6289920.1279260.9283410.9807750.964158
50%1.0941671.6965940.1341290.9348460.9827240.967207
75%1.1215351.7729200.1395420.9402660.9842350.970309
max1.3883022.3379240.1612470.9509630.9870790.975622
\n", + "
" + ], + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.0813961.5218760.1340780.7407420.9152430.874727
std0.5032370.7527370.0827270.2034430.0831320.099583
min0.3546670.4470990.043627-1.035759-0.0349880.159654
25%0.7098010.9796240.0933250.6720600.8981000.842776
50%0.9838431.3726130.1183780.7937770.9396220.901160
75%1.3293531.8737450.1525300.8716340.9642350.939917
max6.65732312.2057711.8744810.9918350.9979190.996090
\n", + "
" + ], + "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": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": [ + "
" + ] + }, + "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 +} diff --git a/torch_MAE_1d_final_20.ipynb b/torch_MAE_1d_final_20.ipynb new file mode 100644 index 0000000..384cf06 --- /dev/null +++ b/torch_MAE_1d_final_20.ipynb @@ -0,0 +1,1297 @@ +{ + "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": "b8a8cedd-536d-4a48-a1af-7c40489ef0f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(42)\n", + "torch.random.manual_seed(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c28cc123-71be-47ff-b78f-3a4d5592df39", + "metadata": {}, + "outputs": [], + "source": [ + "# 计算图像数据中的最大像素值\n", + "max_pixel_value = 107.49169921875" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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/20/'\n", + "\n", + "print(f\"checkpoint before Generator is OK\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41da7319-9795-441d-bde8-8cf390365099", + "metadata": {}, + "outputs": [], + "source": [ + "train_set = NO2Dataset(image_dir, mask_dir)\n", + "train_loader = DataLoader(train_set, 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": 6, + "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": 7, + "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": 8, + "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": 9, + "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": 10, + "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": 11, + "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": 12, + "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": 13, + "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": 14, + "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": 15, + "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": 16, + "id": "c9d176a8-bbf6-4043-ab82-1648a99d772a", + "metadata": {}, + "outputs": [], + "source": [ + "def masked_mse_loss(preds, target, mask):\n", + " loss = (preds - target) ** 2\n", + " loss = loss.mean(dim=-1) # 对每个像素点求平均\n", + " loss = (loss * (1-mask)).sum() / (1-mask).sum() # 只计算被mask的像素点的损失\n", + " return loss" + ] + }, + { + "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", + " )\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": "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.backward()\n", + " optimizer.step()\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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": 20, + "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": 21, + "id": "743d1000-561e-4444-8b49-88346c14f28b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at /opt/conda/conda-bld/pytorch_1711403590347/work/aten/src/ATen/native/cudnn/Conv_v8.cpp:80.)\n", + " return F.conv2d(input, weight, bias, self.stride,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 1.828955806274876, Val Loss: 0.08777590596408986\n", + "Epoch 2, Train Loss: 0.06457909727781012, Val Loss: 0.05018303115198861\n", + "Epoch 3, Train Loss: 0.04399169035006368, Val Loss: 0.03933813378437242\n", + "Epoch 4, Train Loss: 0.03737294341049839, Val Loss: 0.04090026577017201\n", + "Epoch 5, Train Loss: 0.03340746862947513, Val Loss: 0.029788545930563515\n", + "Epoch 6, Train Loss: 0.03127880183240158, Val Loss: 0.02878953230136366\n", + "Epoch 7, Train Loss: 0.030086695853816837, Val Loss: 0.027378849156979305\n", + "Epoch 8, Train Loss: 0.02827827861470184, Val Loss: 0.026564865748384105\n", + "Epoch 9, Train Loss: 0.026973650764014447, Val Loss: 0.026876062349374615\n", + "Epoch 10, Train Loss: 0.026198443756149145, Val Loss: 0.025235873994542593\n", + "Epoch 11, Train Loss: 0.025248640154501754, Val Loss: 0.025164278752323407\n", + "Epoch 12, Train Loss: 0.0246738152373493, Val Loss: 0.02402887423870279\n", + "Epoch 13, Train Loss: 0.02429686849446673, Val Loss: 0.02467221769490349\n", + "Epoch 14, Train Loss: 0.023617587716242915, Val Loss: 0.024100169289245535\n", + "Epoch 15, Train Loss: 0.022902602209535796, Val Loss: 0.023378314227977797\n", + "Epoch 16, Train Loss: 0.022661644239067746, Val Loss: 0.02472560463556603\n", + "Epoch 17, Train Loss: 0.02193861959154526, Val Loss: 0.02273730694580434\n", + "Epoch 18, Train Loss: 0.021775715561075645, Val Loss: 0.022977211248518814\n", + "Epoch 19, Train Loss: 0.021564541914852325, Val Loss: 0.022313175500551268\n", + "Epoch 20, Train Loss: 0.0214472935851396, Val Loss: 0.022048505606935984\n", + "Epoch 21, Train Loss: 0.020810687219340835, Val Loss: 0.02184077285563768\n", + "Epoch 22, Train Loss: 0.020310772384592647, Val Loss: 0.021513454977478554\n", + "Epoch 23, Train Loss: 0.02010334756350118, Val Loss: 0.02177375905326943\n", + "Epoch 24, Train Loss: 0.02025744297795675, Val Loss: 0.02049418441506464\n", + "Epoch 25, Train Loss: 0.019826160295995657, Val Loss: 0.023377947564890134\n", + "Epoch 26, Train Loss: 0.019065276574806875, Val Loss: 0.020193443425110917\n", + "Epoch 27, Train Loss: 0.01881279432745071, Val Loss: 0.01942526154331307\n", + "Epoch 28, Train Loss: 0.01839842515413841, Val Loss: 0.01973166508572315\n", + "Epoch 29, Train Loss: 0.018092166516555555, Val Loss: 0.021518220902601286\n", + "Epoch 30, Train Loss: 0.01789530134942543, Val Loss: 0.0191833000741343\n", + "Epoch 31, Train Loss: 0.017643442852021546, Val Loss: 0.018857373494599292\n", + "Epoch 32, Train Loss: 0.017585936365604543, Val Loss: 0.018622038858150367\n", + "Epoch 33, Train Loss: 0.017121152348513382, Val Loss: 0.018597172726112516\n", + "Epoch 34, Train Loss: 0.016807572604223872, Val Loss: 0.01907729919054615\n", + "Epoch 35, Train Loss: 0.0167503119735983, Val Loss: 0.018055098590010137\n", + "Epoch 36, Train Loss: 0.01674377040839509, Val Loss: 0.017786314029858183\n", + "Epoch 37, Train Loss: 0.016270555827641888, Val Loss: 0.01821137344770467\n", + "Epoch 38, Train Loss: 0.016271821564090166, Val Loss: 0.017419732745681236\n", + "Epoch 39, Train Loss: 0.01634730132180823, Val Loss: 0.017153916838787385\n", + "Epoch 40, Train Loss: 0.016149515664855545, Val Loss: 0.01720947952968861\n", + "Epoch 41, Train Loss: 0.015722640304331573, Val Loss: 0.01671495117636314\n", + "Epoch 42, Train Loss: 0.015584125958882165, Val Loss: 0.016605446490445243\n", + "Epoch 43, Train Loss: 0.015607581132996168, Val Loss: 0.016551834531128407\n", + "Epoch 44, Train Loss: 0.015686789721375303, Val Loss: 0.017196020681355426\n", + "Epoch 45, Train Loss: 0.0152399734099302, Val Loss: 0.016840887422770706\n", + "Epoch 46, Train Loss: 0.015122933551651296, Val Loss: 0.018965846010998114\n", + "Epoch 47, Train Loss: 0.015065566115259554, Val Loss: 0.016344470375064594\n", + "Epoch 48, Train Loss: 0.014854169773766726, Val Loss: 0.016327281677122437\n", + "Epoch 49, Train Loss: 0.014882152102459845, Val Loss: 0.015837757153186336\n", + "Epoch 50, Train Loss: 0.014656414190957848, Val Loss: 0.016042638750774645\n", + "Epoch 51, Train Loss: 0.014637816764200418, Val Loss: 0.015558397091591536\n", + "Epoch 52, Train Loss: 0.01454300198784214, Val Loss: 0.015685647628756603\n", + "Epoch 53, Train Loss: 0.014566657712691994, Val Loss: 0.01571561763090874\n", + "Epoch 54, Train Loss: 0.01434676954522729, Val Loss: 0.015356795890117758\n", + "Epoch 55, Train Loss: 0.014364799384348557, Val Loss: 0.015472657116713808\n", + "Epoch 56, Train Loss: 0.014128341450930783, Val Loss: 0.015367844809235922\n", + "Epoch 57, Train Loss: 0.014267995692878677, Val Loss: 0.016404178910958234\n", + "Epoch 58, Train Loss: 0.01399662052882773, Val Loss: 0.014956932640008962\n", + "Epoch 59, Train Loss: 0.013984658806607056, Val Loss: 0.01512009026343698\n", + "Epoch 60, Train Loss: 0.013917681792278608, Val Loss: 0.01516334629103319\n", + "Epoch 61, Train Loss: 0.013808810461811614, Val Loss: 0.015075811351746765\n", + "Epoch 62, Train Loss: 0.014042920544387051, Val Loss: 0.015152243647112776\n", + "Epoch 63, Train Loss: 0.0136711714971971, Val Loss: 0.014804388201837219\n", + "Epoch 64, Train Loss: 0.013782783121797457, Val Loss: 0.015533475858618074\n", + "Epoch 65, Train Loss: 0.013631306383669661, Val Loss: 0.014752479089396213\n", + "Epoch 66, Train Loss: 0.013644688259186357, Val Loss: 0.01469478735338841\n", + "Epoch 67, Train Loss: 0.013522711930056793, Val Loss: 0.014726998854372928\n", + "Epoch 68, Train Loss: 0.01350348583159692, Val Loss: 0.014617940202466588\n", + "Epoch 69, Train Loss: 0.013397794087644684, Val Loss: 0.014498871904033334\n", + "Epoch 70, Train Loss: 0.013320690925504888, Val Loss: 0.014324163573224153\n", + "Epoch 71, Train Loss: 0.013295841332008108, Val Loss: 0.014810262790033177\n", + "Epoch 72, Train Loss: 0.013151036726943614, Val Loss: 0.014535954208182754\n", + "Epoch 73, Train Loss: 0.01315474125409597, Val Loss: 0.014322022976937578\n", + "Epoch 74, Train Loss: 0.013201014497473337, Val Loss: 0.014625799591972757\n", + "Epoch 75, Train Loss: 0.013166735187155065, Val Loss: 0.01410402478511209\n", + "Epoch 76, Train Loss: 0.013011173492199496, Val Loss: 0.014279130234647153\n", + "Epoch 77, Train Loss: 0.012954122741131833, Val Loss: 0.015670507896079947\n", + "Epoch 78, Train Loss: 0.012964830874202497, Val Loss: 0.013965579806201493\n", + "Epoch 79, Train Loss: 0.01284469154765874, Val Loss: 0.014020084167149529\n", + "Epoch 80, Train Loss: 0.01269332727230194, Val Loss: 0.014467649356420361\n", + "Epoch 81, Train Loss: 0.012900225120779287, Val Loss: 0.014321781124975255\n", + "Epoch 82, Train Loss: 0.012758908171705795, Val Loss: 0.013745425046602292\n", + "Epoch 83, Train Loss: 0.01266205709418683, Val Loss: 0.013802579048075784\n", + "Epoch 84, Train Loss: 0.012549680232128315, Val Loss: 0.013783436657777473\n", + "Epoch 85, Train Loss: 0.012634162601689545, Val Loss: 0.01444499020867828\n", + "Epoch 86, Train Loss: 0.012543465024190086, Val Loss: 0.014219797327558495\n", + "Epoch 87, Train Loss: 0.012490486795234195, Val Loss: 0.013482047425610806\n", + "Epoch 88, Train Loss: 0.012537837625619327, Val Loss: 0.014496686354057113\n", + "Epoch 89, Train Loss: 0.012536356080786891, Val Loss: 0.013949389360956292\n", + "Epoch 90, Train Loss: 0.012426643302601776, Val Loss: 0.013645224328806152\n", + "Epoch 91, Train Loss: 0.012394862496806531, Val Loss: 0.013617335818707943\n", + "Epoch 92, Train Loss: 0.012383774110075959, Val Loss: 0.013630805342499889\n", + "Epoch 93, Train Loss: 0.012307288521749267, Val Loss: 0.013647960637932393\n", + "Epoch 94, Train Loss: 0.012298794681625218, Val Loss: 0.013733426678870151\n", + "Epoch 95, Train Loss: 0.012473734824263165, Val Loss: 0.013764488983398942\n", + "Epoch 96, Train Loss: 0.012222074678515276, Val Loss: 0.013446863671180918\n", + "Epoch 97, Train Loss: 0.012306330008120344, Val Loss: 0.013694896279319899\n", + "Epoch 98, Train Loss: 0.012166704374263019, Val Loss: 0.013338639831809855\n", + "Epoch 99, Train Loss: 0.012187617220447965, Val Loss: 0.01352898025913025\n", + "Epoch 100, Train Loss: 0.012234464256565252, Val Loss: 0.013427354033980796\n", + "Epoch 101, Train Loss: 0.012252488267122273, Val Loss: 0.013189904238861887\n", + "Epoch 102, Train Loss: 0.01208857831692225, Val Loss: 0.013358786896760785\n", + "Epoch 103, Train Loss: 0.012067412587693718, Val Loss: 0.013412703287356826\n", + "Epoch 104, Train Loss: 0.011943526178348863, Val Loss: 0.013329273687480991\n", + "Epoch 105, Train Loss: 0.012186939030457911, Val Loss: 0.013039200052396576\n", + "Epoch 106, Train Loss: 0.012064487648833739, Val Loss: 0.013328265718448518\n", + "Epoch 107, Train Loss: 0.01196315302624942, Val Loss: 0.013011285284561898\n", + "Epoch 108, Train Loss: 0.011942964125175082, Val Loss: 0.013228343076892753\n", + "Epoch 109, Train Loss: 0.011851983095862363, Val Loss: 0.012941466032791494\n", + "Epoch 110, Train Loss: 0.011892807039401035, Val Loss: 0.013264400856708413\n", + "Epoch 111, Train Loss: 0.011915889784747192, Val Loss: 0.01319889353115612\n", + "Epoch 112, Train Loss: 0.011905829402123484, Val Loss: 0.014149442662610047\n", + "Epoch 113, Train Loss: 0.011818570989455903, Val Loss: 0.013042371636673586\n", + "Epoch 114, Train Loss: 0.011752497955140743, Val Loss: 0.01301327784226012\n", + "Epoch 115, Train Loss: 0.011813209191606375, Val Loss: 0.01286677592225484\n", + "Epoch 116, Train Loss: 0.011725439075113198, Val Loss: 0.013167357391941904\n", + "Epoch 117, Train Loss: 0.011835235226721141, Val Loss: 0.01286814648157625\n", + "Epoch 118, Train Loss: 0.011680879099873835, Val Loss: 0.012708428107313256\n", + "Epoch 119, Train Loss: 0.01173722647959322, Val Loss: 0.012885383775096331\n", + "Epoch 120, Train Loss: 0.011672099965343777, Val Loss: 0.012913884747940214\n", + "Epoch 121, Train Loss: 0.011704605972866693, Val Loss: 0.012728425813143823\n", + "Epoch 122, Train Loss: 0.011705320578015021, Val Loss: 0.012817327530860012\n", + "Epoch 123, Train Loss: 0.011644495068492288, Val Loss: 0.012942980015789396\n", + "Epoch 124, Train Loss: 0.011633442955439171, Val Loss: 0.012936850551015405\n", + "Epoch 125, Train Loss: 0.011616052921558396, Val Loss: 0.012702107387803384\n", + "Epoch 126, Train Loss: 0.011607619160652588, Val Loss: 0.012658866025062639\n", + "Epoch 127, Train Loss: 0.011635440495310788, Val Loss: 0.01304104494681554\n", + "Epoch 128, Train Loss: 0.01150463111074775, Val Loss: 0.013212839975508291\n", + "Epoch 129, Train Loss: 0.011585681133293078, Val Loss: 0.01278914052492647\n", + "Epoch 130, Train Loss: 0.011392400087565896, Val Loss: 0.012796499154794572\n", + "Epoch 131, Train Loss: 0.011433751801358598, Val Loss: 0.012598757076063264\n", + "Epoch 132, Train Loss: 0.011496097840921303, Val Loss: 0.01271620902941743\n", + "Epoch 133, Train Loss: 0.011477598884815804, Val Loss: 0.013398304248034065\n", + "Epoch 134, Train Loss: 0.011365674946314552, Val Loss: 0.012668505741922713\n", + "Epoch 135, Train Loss: 0.01142354957696995, Val Loss: 0.013356663286685944\n", + "Epoch 136, Train Loss: 0.011355750374139497, Val Loss: 0.012617305616167054\n", + "Epoch 137, Train Loss: 0.011350866257877013, Val Loss: 0.012997348792850971\n", + "Epoch 138, Train Loss: 0.011416472670617715, Val Loss: 0.012524361819473665\n", + "Epoch 139, Train Loss: 0.011427981736646458, Val Loss: 0.012654973694415235\n", + "Epoch 140, Train Loss: 0.011318818902213607, Val Loss: 0.012664613897787102\n", + "Epoch 141, Train Loss: 0.011320005095247446, Val Loss: 0.012727182441905363\n", + "Epoch 142, Train Loss: 0.011245375826651827, Val Loss: 0.012474427931010723\n", + "Epoch 143, Train Loss: 0.011338526420919091, Val Loss: 0.012642348824597117\n", + "Epoch 144, Train Loss: 0.011243535689207497, Val Loss: 0.012692421772030752\n", + "Epoch 145, Train Loss: 0.011166462189023289, Val Loss: 0.01263011310861182\n", + "Epoch 146, Train Loss: 0.011227301243942178, Val Loss: 0.012461379587427894\n", + "Epoch 147, Train Loss: 0.01119774208364019, Val Loss: 0.012749987918494353\n", + "Epoch 148, Train Loss: 0.011138954723441001, Val Loss: 0.012676928915194612\n", + "Epoch 149, Train Loss: 0.011145075226122398, Val Loss: 0.012806226499378681\n", + "Epoch 150, Train Loss: 0.011238663441737731, Val Loss: 0.012608930385157244\n", + "Epoch 151, Train Loss: 0.01112103075430724, Val Loss: 0.012799791727604261\n", + "Epoch 152, Train Loss: 0.01109027168958595, Val Loss: 0.01240885794273953\n", + "Epoch 153, Train Loss: 0.011098397055721026, Val Loss: 0.012326594039019364\n", + "Epoch 154, Train Loss: 0.011026590389676356, Val Loss: 0.012310143629672811\n", + "Epoch 155, Train Loss: 0.011067607804339682, Val Loss: 0.01242478439278567\n", + "Epoch 156, Train Loss: 0.01105262930215332, Val Loss: 0.01238662200465576\n", + "Epoch 157, Train Loss: 0.010977347388097117, Val Loss: 0.012163419262575569\n", + "Epoch 158, Train Loss: 0.010957017552071924, Val Loss: 0.012397716572480415\n", + "Epoch 159, Train Loss: 0.010956506543396192, Val Loss: 0.012370292931350309\n", + "Epoch 160, Train Loss: 0.01093887382980133, Val Loss: 0.012291266110294791\n", + "Test Loss: 0.006885056002065539\n" + ] + } + ], + "source": [ + "model = model.to(device)\n", + "\n", + "num_epochs = 160\n", + "train_losses = list()\n", + "val_losses = list()\n", + "for epoch in range(num_epochs):\n", + " train_loss = train_epoch(model, device, train_loader, 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": 23, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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[1:], label='train_loss')\n", + "plt.plot(val_losses[1:], label='val_loss')\n", + "plt.legend(loc='best')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "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": 25, + "id": "efc96935-bbe0-4ca9-b11a-931cdcfc3bed", + "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": 26, + "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": 27, + "id": "73a0002b-35d6-4e20-a620-5c8f5cd49296", + "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": 28, + "id": "b7265cd0-0660-4707-be3d-0773a38228e8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.2616341.8017260.1539620.6811590.8910400.840609
std0.5722050.8610090.0657230.2497710.1104110.124012
min0.3614800.4689180.047540-2.107971-0.424296-0.070884
25%0.8284531.1493910.1112560.6004400.8689370.797875
50%1.1358051.6212940.1439290.7409370.9229530.872734
75%1.5573812.2507180.1795440.8359070.9535560.921983
max5.7334498.3560971.1169460.9855700.9962370.993398
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.261634 1.801726 0.153962 0.681159 0.891040 \n", + "std 0.572205 0.861009 0.065723 0.249771 0.110411 \n", + "min 0.361480 0.468918 0.047540 -2.107971 -0.424296 \n", + "25% 0.828453 1.149391 0.111256 0.600440 0.868937 \n", + "50% 1.135805 1.621294 0.143929 0.740937 0.922953 \n", + "75% 1.557381 2.250718 0.179544 0.835907 0.953556 \n", + "max 5.733449 8.356097 1.116946 0.985570 0.996237 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.840609 \n", + "std 0.124012 \n", + "min -0.070884 \n", + "25% 0.797875 \n", + "50% 0.872734 \n", + "75% 0.921983 \n", + "max 0.993398 " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "589e6d80-228d-4e8a-968a-e7477c5e0e24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count75.00000075.00000075.00000075.00000075.00000075.000000
mean1.2639911.9877880.1539310.9077290.9747850.953238
std0.1080350.2091850.0075920.0172800.0057820.007909
min1.0771431.6587970.1352710.7916070.9330310.905484
25%1.2089911.8929230.1490060.9015440.9729120.950092
50%1.2551511.9672650.1539290.9081830.9749390.953771
75%1.3076152.0790390.1584630.9156660.9772690.957454
max1.9568453.3207120.1750280.9317150.9818320.965467
\n", + "
" + ], + "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.263991 1.987788 0.153931 0.907729 0.974785 0.953238\n", + "std 0.108035 0.209185 0.007592 0.017280 0.005782 0.007909\n", + "min 1.077143 1.658797 0.135271 0.791607 0.933031 0.905484\n", + "25% 1.208991 1.892923 0.149006 0.901544 0.972912 0.950092\n", + "50% 1.255151 1.967265 0.153929 0.908183 0.974939 0.953771\n", + "75% 1.307615 2.079039 0.158463 0.915666 0.977269 0.957454\n", + "max 1.956845 3.320712 0.175028 0.931715 0.981832 0.965467" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "755abc3e-f4d2-4056-b01b-3fb085f95f19", + "metadata": {}, + "outputs": [], + "source": [ + "# torch.save(model, './models/MAE/final_20.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "782ba792-af34-479d-8b79-f6c544137539", + "metadata": {}, + "outputs": [], + "source": [ + "model_20 = torch.load('./models/MAE/final_20.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "76449691-74b2-43ef-b092-f71cd8116448", + "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", + " \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/20_samples.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "82467932-3b38-4d2d-83d9-8d76c4f98a06", + "metadata": {}, + "outputs": [], + "source": [ + "best_mask_cp = np.where(best_mask == 0, np.nan, best_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "6bb568d1-07bd-49c4-9056-9ad2f2dd36a8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 33, + "id": "e711bcef-0263-4948-924e-1beb6d38fbf7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'1114', '1952', '2568', '3523', '602'}" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "find_ex = set([x.split('-')[0].strip() for x in os.listdir('./test_img/') if 'npy' in x])\n", + "find_ex" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "addd6ce4-a62d-43b6-a435-d7853ccea91e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for j in find_ex:\n", + " ori = np.load(f'./test_img/{j}-real.npy')[0]\n", + " mask = np.load(f'./test_img/{j}-mask.npy')\n", + " mask_rev = 1 - mask\n", + " img_in = ori * mask_rev / max_pixel_value\n", + " img_out = model(torch.tensor(img_in.reshape(1, 1, 96, 96), dtype=torch.float32)).detach().cpu().numpy()[0][0] * max_pixel_value\n", + " out = ori * mask_rev + img_out * mask\n", + " plt.imshow(out, cmap='RdYlGn_r')\n", + " plt.gca().axis('off')\n", + " plt.savefig(f'./test_img/out_fig/{j}-mae_my_out.png', bbox_inches='tight')\n", + " plt.clf()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d51cfc0-3afd-499e-ae97-76f07b0105e7", + "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 +} diff --git a/torch_MAE_1d_final_20_2021.ipynb b/torch_MAE_1d_final_20_2021.ipynb new file mode 100644 index 0000000..03c4954 --- /dev/null +++ b/torch_MAE_1d_final_20_2021.ipynb @@ -0,0 +1,1169 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 35, + "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 pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import cv2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b8a8cedd-536d-4a48-a1af-7c40489ef0f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(42)\n", + "torch.random.manual_seed(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c28cc123-71be-47ff-b78f-3a4d5592df39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum pixel value in the dataset: 92.64960479736328\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.max())\n", + " return max_pixel_value\n", + "\n", + "# 计算图像数据中的最大像素值\n", + "image_dir = './2022data/new_train_2021/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": 4, + "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.expand_dims(np.load(image_path).astype(np.float32), axis=2) / 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 = './2022data/new_train_2021/train/'\n", + "mask_dir = './2022data/new_train_2021/mask/20/'\n", + "\n", + "print(f\"checkpoint before Generator is OK\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41da7319-9795-441d-bde8-8cf390365099", + "metadata": {}, + "outputs": [], + "source": [ + "train_set = NO2Dataset(image_dir, mask_dir)\n", + "train_loader = DataLoader(train_set, batch_size=64, shuffle=True, num_workers=8)\n", + "val_set = NO2Dataset('./2022data/new_train_2021/valid/', mask_dir)\n", + "val_loader = DataLoader(val_set, batch_size=64, shuffle=False, num_workers=4)\n", + "test_set = NO2Dataset('./2022data/new_train_2021/test/', mask_dir)\n", + "test_loader = DataLoader(test_set, batch_size=64, shuffle=False, num_workers=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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": 7, + "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": 8, + "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": 9, + "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": 10, + "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": 11, + "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": 12, + "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": 13, + "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": 14, + "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": 15, + "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": 16, + "id": "c9d176a8-bbf6-4043-ab82-1648a99d772a", + "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": "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.mlp(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": "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.backward()\n", + " optimizer.step()\n", + " running_loss += loss.item()\n", + " return running_loss / (batch_idx + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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": 20, + "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": 21, + "id": "743d1000-561e-4444-8b49-88346c14f28b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at /opt/conda/conda-bld/pytorch_1711403590347/work/aten/src/ATen/native/cudnn/Conv_v8.cpp:80.)\n", + " return F.conv2d(input, weight, bias, self.stride,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 5.541112303206351, Val Loss: 0.8067406771030832\n", + "Epoch 2, Train Loss: 0.33060450623344884, Val Loss: 0.14416445189333976\n", + "Epoch 3, Train Loss: 0.14130625223251922, Val Loss: 0.07359389453492265\n", + "Epoch 4, Train Loss: 0.10518970966866587, Val Loss: 0.054381779930058945\n", + "Epoch 5, Train Loss: 0.09058622275218148, Val Loss: 0.0465024342720813\n", + "Epoch 6, Train Loss: 0.08342431517521189, Val Loss: 0.042179942210303974\n", + "Epoch 7, Train Loss: 0.0774571797686868, Val Loss: 0.03831239916542743\n", + "Epoch 8, Train Loss: 0.0720803240385555, Val Loss: 0.03571732088606408\n", + "Epoch 9, Train Loss: 0.06799363104247413, Val Loss: 0.03523132728135332\n", + "Epoch 10, Train Loss: 0.06398953810597943, Val Loss: 0.03190892792128502\n", + "Epoch 11, Train Loss: 0.06091008874914639, Val Loss: 0.030253113742838515\n", + "Epoch 12, Train Loss: 0.058550740303718936, Val Loss: 0.03257738580887622\n", + "Epoch 13, Train Loss: 0.05582124731094085, Val Loss: 0.027309948182169426\n", + "Epoch 14, Train Loss: 0.05444160232369879, Val Loss: 0.03076436184346676\n", + "Epoch 15, Train Loss: 0.053529950248896195, Val Loss: 0.026180010566369018\n", + "Epoch 16, Train Loss: 0.05092262584375421, Val Loss: 0.02586523879398691\n", + "Epoch 17, Train Loss: 0.05036925500297265, Val Loss: 0.026086220715908295\n", + "Epoch 18, Train Loss: 0.04870546900922746, Val Loss: 0.025190358426659665\n", + "Epoch 19, Train Loss: 0.04829096387533312, Val Loss: 0.024286496195387332\n", + "Epoch 20, Train Loss: 0.047801207734552105, Val Loss: 0.024341319628218387\n", + "Epoch 21, Train Loss: 0.0463638727533958, Val Loss: 0.023777516439874122\n", + "Epoch 22, Train Loss: 0.04561143496505103, Val Loss: 0.02462407554242205\n", + "Epoch 23, Train Loss: 0.04455085273469444, Val Loss: 0.02330890230517438\n", + "Epoch 24, Train Loss: 0.04402760396489, Val Loss: 0.023676151687160453\n", + "Epoch 25, Train Loss: 0.04317896270294808, Val Loss: 0.02370590161769948\n", + "Epoch 26, Train Loss: 0.042474492900842764, Val Loss: 0.027188481287436284\n", + "Epoch 27, Train Loss: 0.0410688633324474, Val Loss: 0.022131468387360267\n", + "Epoch 28, Train Loss: 0.04015502951775504, Val Loss: 0.021191479004126913\n", + "Epoch 29, Train Loss: 0.039912018183190213, Val Loss: 0.02161621072507919\n", + "Epoch 30, Train Loss: 0.039861640131930685, Val Loss: 0.02177569658515301\n", + "Epoch 31, Train Loss: 0.03960100152038016, Val Loss: 0.02101492334870582\n", + "Epoch 32, Train Loss: 0.03872588457083632, Val Loss: 0.020859015748855916\n", + "Epoch 33, Train Loss: 0.038754463954045706, Val Loss: 0.02414150171457453\n", + "Epoch 34, Train Loss: 0.03809461849233394, Val Loss: 0.019819263804783212\n", + "Epoch 35, Train Loss: 0.03751421304952606, Val Loss: 0.021835624696092404\n", + "Epoch 36, Train Loss: 0.03734014398118915, Val Loss: 0.022214002510968674\n", + "Epoch 37, Train Loss: 0.03706552038260442, Val Loss: 0.019966345795608582\n", + "Epoch 38, Train Loss: 0.036659476251113376, Val Loss: 0.019636615555971227\n", + "Epoch 39, Train Loss: 0.036727246869586214, Val Loss: 0.01936723065978669\n", + "Epoch 40, Train Loss: 0.03633688813333666, Val Loss: 0.020286126339689216\n", + "Epoch 41, Train Loss: 0.035810444339186745, Val Loss: 0.019208339934653425\n", + "Epoch 42, Train Loss: 0.03550744545714694, Val Loss: 0.01972645398308622\n", + "Epoch 43, Train Loss: 0.035464368694651444, Val Loss: 0.019827014984602622\n", + "Epoch 44, Train Loss: 0.03506896948678128, Val Loss: 0.02004316175713184\n", + "Epoch 45, Train Loss: 0.03495936513298732, Val Loss: 0.019192911129682622\n", + "Epoch 46, Train Loss: 0.03483127771841038, Val Loss: 0.018953541115401908\n", + "Epoch 47, Train Loss: 0.03463402198171545, Val Loss: 0.018771914527454275\n", + "Epoch 48, Train Loss: 0.03408609382302712, Val Loss: 0.018758975068463923\n", + "Epoch 49, Train Loss: 0.03452993459054502, Val Loss: 0.018336334998937363\n", + "Epoch 50, Train Loss: 0.034099031547441594, Val Loss: 0.019093293062549956\n", + "Epoch 51, Train Loss: 0.03445967665947644, Val Loss: 0.018671645683811067\n", + "Epoch 52, Train Loss: 0.03385696139263544, Val Loss: 0.017988349291238378\n", + "Epoch 53, Train Loss: 0.03406877570117997, Val Loss: 0.018068110510865425\n", + "Epoch 54, Train Loss: 0.03348344178721968, Val Loss: 0.018683044398401644\n", + "Epoch 55, Train Loss: 0.033462831668094196, Val Loss: 0.01905706045316889\n", + "Epoch 56, Train Loss: 0.033128469962637686, Val Loss: 0.01867042989172834\n", + "Epoch 57, Train Loss: 0.0332745431941607, Val Loss: 0.019846445504338183\n", + "Epoch 58, Train Loss: 0.03308211129081812, Val Loss: 0.01826892614840193\n", + "Epoch 59, Train Loss: 0.03278694228766415, Val Loss: 0.022516568488580115\n", + "Epoch 60, Train Loss: 0.03246014836659122, Val Loss: 0.01806999350640368\n", + "Epoch 61, Train Loss: 0.0331528295534814, Val Loss: 0.01772232149588935\n", + "Epoch 62, Train Loss: 0.03278059815674757, Val Loss: 0.01812060377461479\n", + "Epoch 63, Train Loss: 0.032278176842141994, Val Loss: 0.01805540711242468\n", + "Epoch 64, Train Loss: 0.03201383460521874, Val Loss: 0.018378542062449963\n", + "Epoch 65, Train Loss: 0.03193402631005003, Val Loss: 0.017855498166952994\n", + "Epoch 66, Train Loss: 0.03141010671326545, Val Loss: 0.01813684691219254\n", + "Epoch 67, Train Loss: 0.03162443816969528, Val Loss: 0.017312405214823308\n", + "Epoch 68, Train Loss: 0.03134946423997569, Val Loss: 0.017035803282038964\n", + "Epoch 69, Train Loss: 0.030821436257884565, Val Loss: 0.017176391457782148\n", + "Epoch 70, Train Loss: 0.030857550524241103, Val Loss: 0.01778144468652441\n", + "Epoch 71, Train Loss: 0.03145846045935927, Val Loss: 0.017036813350909567\n", + "Epoch 72, Train Loss: 0.03082356479425522, Val Loss: 0.01754499076211706\n", + "Epoch 73, Train Loss: 0.03057446662929997, Val Loss: 0.016873343847692013\n", + "Epoch 74, Train Loss: 0.030142722530482793, Val Loss: 0.017114325763380275\n", + "Epoch 75, Train Loss: 0.0297475472960764, Val Loss: 0.017896422284080626\n", + "Epoch 76, Train Loss: 0.02986417829462912, Val Loss: 0.016979403338058197\n", + "Epoch 77, Train Loss: 0.030155790255440722, Val Loss: 0.016632370690399027\n", + "Epoch 78, Train Loss: 0.02987812078698019, Val Loss: 0.017218250702036187\n", + "Epoch 79, Train Loss: 0.02965712085761855, Val Loss: 0.016456886016307994\n", + "Epoch 80, Train Loss: 0.029867385275068537, Val Loss: 0.016108868465303107\n", + "Epoch 81, Train Loss: 0.029616706633726054, Val Loss: 0.016850862830401735\n", + "Epoch 82, Train Loss: 0.02933939000190535, Val Loss: 0.017380977188177566\n", + "Epoch 83, Train Loss: 0.028856007063591024, Val Loss: 0.016677292380878266\n", + "Epoch 84, Train Loss: 0.029245234613793088, Val Loss: 0.016243027404267738\n", + "Epoch 85, Train Loss: 0.029124773610218438, Val Loss: 0.016707272605693088\n", + "Epoch 86, Train Loss: 0.02889745979731941, Val Loss: 0.01667517395888237\n", + "Epoch 87, Train Loss: 0.028780636237522143, Val Loss: 0.015974930111081042\n", + "Epoch 88, Train Loss: 0.0290858921784479, Val Loss: 0.01647984809143112\n", + "Epoch 89, Train Loss: 0.028605496862513125, Val Loss: 0.015814711419033244\n", + "Epoch 90, Train Loss: 0.02866147620092451, Val Loss: 0.01892404787321674\n", + "Epoch 91, Train Loss: 0.028418820038174107, Val Loss: 0.01616615823846548\n", + "Epoch 92, Train Loss: 0.028970944983637437, Val Loss: 0.015930495700462066\n", + "Epoch 93, Train Loss: 0.02812033420796767, Val Loss: 0.015577566691060016\n", + "Epoch 94, Train Loss: 0.027900781900042276, Val Loss: 0.016411741838810293\n", + "Epoch 95, Train Loss: 0.028156488249215756, Val Loss: 0.015642933785281282\n", + "Epoch 96, Train Loss: 0.027669002046495413, Val Loss: 0.01564073005810063\n", + "Epoch 97, Train Loss: 0.02797757544084988, Val Loss: 0.01616466465465566\n", + "Epoch 98, Train Loss: 0.027837259815813517, Val Loss: 0.01699387704200567\n", + "Epoch 99, Train Loss: 0.02773604567291814, Val Loss: 0.015504092572534338\n", + "Epoch 100, Train Loss: 0.02741758727020746, Val Loss: 0.015247883136443634\n", + "Epoch 101, Train Loss: 0.02707562789562705, Val Loss: 0.015558899360451293\n", + "Epoch 102, Train Loss: 0.027159787612832578, Val Loss: 0.015182257392146487\n", + "Epoch 103, Train Loss: 0.027029822105239625, Val Loss: 0.014660503893615083\n", + "Epoch 104, Train Loss: 0.02699657593878497, Val Loss: 0.016841756120482658\n", + "Epoch 105, Train Loss: 0.026641362756051144, Val Loss: 0.015178967544690091\n", + "Epoch 106, Train Loss: 0.026524744587222385, Val Loss: 0.015554199926555157\n", + "Epoch 107, Train Loss: 0.026474817848289083, Val Loss: 0.015399079710403656\n", + "Epoch 108, Train Loss: 0.02636850485990269, Val Loss: 0.014777421396463476\n", + "Epoch 109, Train Loss: 0.02637453050322413, Val Loss: 0.015275213094626336\n", + "Epoch 110, Train Loss: 0.02607358055282659, Val Loss: 0.016890957614684357\n", + "Epoch 111, Train Loss: 0.026133586770709285, Val Loss: 0.015139183485286032\n", + "Epoch 112, Train Loss: 0.02617257334302924, Val Loss: 0.014704703016484038\n", + "Epoch 113, Train Loss: 0.026084138217840926, Val Loss: 0.014918764835183925\n", + "Epoch 114, Train Loss: 0.025832627078512777, Val Loss: 0.01494563212420078\n", + "Epoch 115, Train Loss: 0.02605823659307837, Val Loss: 0.014487974504207043\n", + "Epoch 116, Train Loss: 0.025865597622936103, Val Loss: 0.014469134779845147\n", + "Epoch 117, Train Loss: 0.025718001264166693, Val Loss: 0.013978753100208779\n", + "Epoch 118, Train Loss: 0.02561279770624233, Val Loss: 0.01455160214545879\n", + "Epoch 119, Train Loss: 0.025601031165295295, Val Loss: 0.015720585519646075\n", + "Epoch 120, Train Loss: 0.025754293742806685, Val Loss: 0.013814986822135906\n", + "Epoch 121, Train Loss: 0.02534578327408231, Val Loss: 0.014853738644655714\n", + "Epoch 122, Train Loss: 0.02561174121006752, Val Loss: 0.014788057021004088\n", + "Epoch 123, Train Loss: 0.02533768888859622, Val Loss: 0.014425865988782111\n", + "Epoch 124, Train Loss: 0.025395122024293847, Val Loss: 0.014166925221364549\n", + "Epoch 125, Train Loss: 0.025411863934940996, Val Loss: 0.014836331670905681\n", + "Epoch 126, Train Loss: 0.025214647187420048, Val Loss: 0.01417682920285362\n", + "Epoch 127, Train Loss: 0.024879908288079025, Val Loss: 0.014164314981787763\n", + "Epoch 128, Train Loss: 0.02494473186126501, Val Loss: 0.014208773448270685\n", + "Epoch 129, Train Loss: 0.02468084254381755, Val Loss: 0.013683844337913585\n", + "Epoch 130, Train Loss: 0.0248352900521066, Val Loss: 0.014833704508999561\n", + "Epoch 131, Train Loss: 0.024615347561231404, Val Loss: 0.016790931608448637\n", + "Epoch 132, Train Loss: 0.024628470901806445, Val Loss: 0.013669065913145846\n", + "Epoch 133, Train Loss: 0.024401855987433486, Val Loss: 0.014544136485362307\n", + "Epoch 134, Train Loss: 0.02425686465054311, Val Loss: 0.014493834742523254\n", + "Epoch 135, Train Loss: 0.02475559137552801, Val Loss: 0.013708425725394107\n", + "Epoch 136, Train Loss: 0.024078373256026818, Val Loss: 0.014549214828838693\n", + "Epoch 137, Train Loss: 0.024223965633891325, Val Loss: 0.013578887454214249\n", + "Epoch 138, Train Loss: 0.024396276563010383, Val Loss: 0.013251736344016612\n", + "Epoch 139, Train Loss: 0.024004749286161586, Val Loss: 0.013333805103568321\n", + "Epoch 140, Train Loss: 0.02389194364700697, Val Loss: 0.014107016430414737\n", + "Epoch 141, Train Loss: 0.023637132873005923, Val Loss: 0.013322851898029764\n", + "Epoch 142, Train Loss: 0.023719912169605582, Val Loss: 0.014070579683051464\n", + "Epoch 143, Train Loss: 0.02377868151418579, Val Loss: 0.013563529806251222\n", + "Epoch 144, Train Loss: 0.02362075615619312, Val Loss: 0.014379620492616867\n", + "Epoch 145, Train Loss: 0.023822628134713236, Val Loss: 0.01308334250240884\n", + "Epoch 146, Train Loss: 0.02378806389406719, Val Loss: 0.013488665500536878\n", + "Epoch 147, Train Loss: 0.023415484050821767, Val Loss: 0.01323556466067725\n", + "Epoch 148, Train Loss: 0.023618425456889434, Val Loss: 0.013999837430867744\n", + "Epoch 149, Train Loss: 0.023620333203875563, Val Loss: 0.013482759567968388\n", + "Epoch 150, Train Loss: 0.02325812268969232, Val Loss: 0.012960578988682716\n", + "Test Loss: 0.028638894522660656\n" + ] + } + ], + "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, train_loader, 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": 29, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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[1:], label='train_loss')\n", + "plt.plot(val_losses[1:], label='val_loss')\n", + "plt.legend(loc='best')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "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": 31, + "id": "efc96935-bbe0-4ca9-b11a-931cdcfc3bed", + "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 = 2 * 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": 32, + "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": 34, + "id": "589e6d80-228d-4e8a-968a-e7477c5e0e24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count76.00000076.00000076.00000076.00000076.00000076.000000
mean1.8397563.1166290.1820200.8874340.9849240.942480
std0.1413330.2182960.0096630.0107540.0014880.005507
min1.5188032.4979970.1606560.8621240.9818070.930738
25%1.7251602.9543160.1757520.8808880.9840670.939023
50%1.8193753.0840150.1806150.8877420.9849060.942333
75%1.9730803.2931170.1893750.8955220.9861350.946845
max2.1564173.5384440.2059280.9099790.9881350.954369
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa r\n", + "count 76.000000 76.000000 76.000000 76.000000 76.000000 76.000000\n", + "mean 1.839756 3.116629 0.182020 0.887434 0.984924 0.942480\n", + "std 0.141333 0.218296 0.009663 0.010754 0.001488 0.005507\n", + "min 1.518803 2.497997 0.160656 0.862124 0.981807 0.930738\n", + "25% 1.725160 2.954316 0.175752 0.880888 0.984067 0.939023\n", + "50% 1.819375 3.084015 0.180615 0.887742 0.984906 0.942333\n", + "75% 1.973080 3.293117 0.189375 0.895522 0.986135 0.946845\n", + "max 2.156417 3.538444 0.205928 0.909979 0.988135 0.954369" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "6278442c-3ecb-4e92-b901-0f0e0e43d8af", + "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", + " 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.append([mae, rmse, mape, r2, ioa, r])" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "3d095141-79e2-4f4f-b31f-54fed1996781", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4839.0000004839.0000004839.0000004839.0000004839.0000004839.000000
mean1.8334002.6180250.1814760.6314670.9378350.813992
std1.1859561.6834020.0717640.2603560.0537260.123230
min0.2489860.3379190.075559-3.7696370.1034510.020267
25%0.8435161.1793100.1389880.5377500.9241730.762655
50%1.3355561.9396050.1651660.6820160.9511860.841513
75%2.7598373.9777460.2029660.7920080.9701150.898809
max9.47460910.9882501.3440910.9782640.9972510.989095
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4839.000000 4839.000000 4839.000000 4839.000000 4839.000000 \n", + "mean 1.833400 2.618025 0.181476 0.631467 0.937835 \n", + "std 1.185956 1.683402 0.071764 0.260356 0.053726 \n", + "min 0.248986 0.337919 0.075559 -3.769637 0.103451 \n", + "25% 0.843516 1.179310 0.138988 0.537750 0.924173 \n", + "50% 1.335556 1.939605 0.165166 0.682016 0.951186 \n", + "75% 2.759837 3.977746 0.202966 0.792008 0.970115 \n", + "max 9.474609 10.988250 1.344091 0.978264 0.997251 \n", + "\n", + " r \n", + "count 4839.000000 \n", + "mean 0.813992 \n", + "std 0.123230 \n", + "min 0.020267 \n", + "25% 0.762655 \n", + "50% 0.841513 \n", + "75% 0.898809 \n", + "max 0.989095 " + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8eb4d33a-8d03-418d-bb50-f34eef4e4bf5", + "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 +} diff --git a/torch_MAE_1d_final_30.ipynb b/torch_MAE_1d_final_30.ipynb new file mode 100644 index 0000000..c50e713 --- /dev/null +++ b/torch_MAE_1d_final_30.ipynb @@ -0,0 +1,943 @@ +{ + "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": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.3990601.9797310.1827140.6429420.8724020.816624
std0.6387510.8750720.1041770.2195670.1018180.117307
min0.4922770.6246090.060600-1.9638280.0929510.060861
25%0.9074581.2800650.1266180.5350030.8358220.758542
50%1.2668891.8572230.1588060.6946350.9024730.846662
75%1.7378442.4677420.2044690.7996630.9410830.901914
max5.5569558.5502111.3976860.9837350.9959180.992068
\n", + "
" + ], + "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": [ + "
" + ] + }, + "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 +} diff --git a/torch_MAE_1d_final_40.ipynb b/torch_MAE_1d_final_40.ipynb new file mode 100644 index 0000000..7f98847 --- /dev/null +++ b/torch_MAE_1d_final_40.ipynb @@ -0,0 +1,957 @@ +{ + "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": [ + "\n", + "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", + " \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/40/'\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": 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 = 100\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": 38, + "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[38], 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": "849b1706-1a98-4571-989f-da06d949c843", + "metadata": {}, + "outputs": [], + "source": [ + "torch.save(model, './models/MAE/final_40.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "40a803b2-4891-4d47-ab61-cf88db8007a0", + "metadata": {}, + "outputs": [], + "source": [ + "model = torch.load('./models/MAE/final_40.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": "016c3045-0312-462f-82ae-7272944ed92d", + "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": "0887481a-764e-4fd5-9580-45aa813a4391", + "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": "f7355895-ffde-458f-b4e6-b8afd95ea663", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.5404012.1998790.1955540.5857990.8480160.778401
std0.6473150.9094180.0922390.2139930.1069870.127430
min0.4620700.5938540.068942-0.5515870.2185040.145717
25%1.0213851.4727570.1441700.4601840.8050110.711952
50%1.3678362.0562080.1761190.6240060.8767700.805993
75%1.9758252.7927770.2174190.7453750.9239440.871612
max5.1865179.1588840.9600810.9683760.9921960.985054
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.540401 2.199879 0.195554 0.585799 0.848016 \n", + "std 0.647315 0.909418 0.092239 0.213993 0.106987 \n", + "min 0.462070 0.593854 0.068942 -0.551587 0.218504 \n", + "25% 1.021385 1.472757 0.144170 0.460184 0.805011 \n", + "50% 1.367836 2.056208 0.176119 0.624006 0.876770 \n", + "75% 1.975825 2.792777 0.217419 0.745375 0.923944 \n", + "max 5.186517 9.158884 0.960081 0.968376 0.992196 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.778401 \n", + "std 0.127430 \n", + "min 0.145717 \n", + "25% 0.711952 \n", + "50% 0.805993 \n", + "75% 0.871612 \n", + "max 0.985054 " + ] + }, + "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": "ee712c69-2b57-4ac6-9c7d-d73ba0d1ecca", + "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/40_samples.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "e89feac0-d03a-4686-8a38-722e6a54a96f", + "metadata": {}, + "outputs": [], + "source": [ + "best_mask_cp = np.where(best_mask == 0, np.nan, best_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "a87835de-836b-411b-b4cc-68e98b6638f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[30.36338043, 30.67309189, 30.94369125, ..., 11.77855492,\n", + " 11.96412849, 11.9506712 ],\n", + " [30.04488182, 30.25416946, 30.87792015, ..., 11.70056629,\n", + " 12.05164337, 11.96099949],\n", + " [29.82366371, 30.49637985, 30.7125721 , ..., 11.49174881,\n", + " 11.77280235, 11.96125317],\n", + " ...,\n", + " [ 8.4842186 , 9.02253723, 8.97320557, ..., 5.35319471,\n", + " 5.15942717, 5.25348282],\n", + " [ 8.59376144, 8.57794476, 8.91248322, ..., 5.41437721,\n", + " 5.41615629, 5.49798965],\n", + " [ 8.4524231 , 8.80022049, 8.73760223, ..., 5.64806128,\n", + " 5.53445244, 5.61840296]])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_recov * (1-best_mask) + best_recov*best_mask" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "95e3882b-9962-4aab-be80-4240f326ef51", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": "c32a4b1f-9e2d-46cd-b117-9857dc840c7c", + "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 +} diff --git a/torch_MAE_1d_final_mixed.ipynb b/torch_MAE_1d_final_mixed.ipynb new file mode 100644 index 0000000..6dfa235 --- /dev/null +++ b/torch_MAE_1d_final_mixed.ipynb @@ -0,0 +1,1201 @@ +{ + "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 pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import cv2" + ] + }, + { + "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", + "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", + " mask_rates = [10, 20, 30, 40]\n", + " self.mask_filenames = list()\n", + " for rate in mask_rates:\n", + " local_masks = [f\"{f'{mask_dir}{rate}/{f}'}\" for f in os.listdir(f'{mask_dir}{rate}') if f.endswith('.jpg')]\n", + " self.mask_filenames.extend(local_masks)\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 = mask_idx\n", + " select_rate = mask_idx.split('/')[4]\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), select_rate\n", + "\n", + "# 实例化数据集和数据加载器\n", + "image_dir = './out_mat/96/train/'\n", + "mask_dir = './out_mat/96/mask/'\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": 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", + " miss_counts = list()\n", + " for batch_idx, (X, y, mask, miss_rate) in enumerate(data_loader):\n", + " X, y, mask = X.to(device), y.to(device), mask.to(device)\n", + " miss_counts.append(miss_rate)\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), miss_counts" + ] + }, + { + "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", + " miss_counts = list()\n", + " with torch.no_grad():\n", + " for batch_idx, (X, y, mask, miss_rate) in enumerate(data_loader):\n", + " X, y, mask = X.to(device), y.to(device), mask.to(device)\n", + " miss_counts.append(miss_rate)\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), miss_counts" + ] + }, + { + "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": 20, + "id": "743d1000-561e-4444-8b49-88346c14f28b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/miniconda3/envs/python38/lib/python3.8/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at /opt/conda/conda-bld/pytorch_1711403590347/work/aten/src/ATen/native/cudnn/Conv_v8.cpp:80.)\n", + " return F.conv2d(input, weight, bias, self.stride,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Train Loss: 3.759178739843186, Val Loss: 0.1379857260122228\n", + "Epoch 2, Train Loss: 0.09902132054764118, Val Loss: 0.066096671370428\n", + "Epoch 3, Train Loss: 0.060244543255088434, Val Loss: 0.05034376319442222\n", + "Epoch 4, Train Loss: 0.04942069527956002, Val Loss: 0.04460687851950304\n", + "Epoch 5, Train Loss: 0.04382758207940029, Val Loss: 0.0369152329417307\n", + "Epoch 6, Train Loss: 0.03961431584432365, Val Loss: 0.033898868973353015\n", + "Epoch 7, Train Loss: 0.03653587933861468, Val Loss: 0.03190647060079361\n", + "Epoch 8, Train Loss: 0.03421460006956421, Val Loss: 0.030460054360663714\n", + "Epoch 9, Train Loss: 0.03215051376434604, Val Loss: 0.03062500929765737\n", + "Epoch 10, Train Loss: 0.031739671104119724, Val Loss: 0.029085035394154378\n", + "Epoch 11, Train Loss: 0.030470874753188004, Val Loss: 0.03185694292187691\n", + "Epoch 12, Train Loss: 0.029636846623566162, Val Loss: 0.029310374951629498\n", + "Epoch 13, Train Loss: 0.028289151542851228, Val Loss: 0.02720484949314772\n", + "Epoch 14, Train Loss: 0.027910822102327666, Val Loss: 0.028894296833383504\n", + "Epoch 15, Train Loss: 0.027092363841332602, Val Loss: 0.02946079163742599\n", + "Epoch 16, Train Loss: 0.025776214282692334, Val Loss: 0.024672900368251018\n", + "Epoch 17, Train Loss: 0.025803192848402063, Val Loss: 0.02488229790730263\n", + "Epoch 18, Train Loss: 0.025352436108915716, Val Loss: 0.02426056825180552\n", + "Epoch 19, Train Loss: 0.024724755284675, Val Loss: 0.023613420885000656\n", + "Epoch 20, Train Loss: 0.02373662724663196, Val Loss: 0.023868454147630662\n", + "Epoch 21, Train Loss: 0.023606173005668026, Val Loss: 0.022293920976234907\n", + "Epoch 22, Train Loss: 0.02291965261814697, Val Loss: 0.0231649547036904\n", + "Epoch 23, Train Loss: 0.022957429811180208, Val Loss: 0.022116250789432385\n", + "Epoch 24, Train Loss: 0.022525311819763416, Val Loss: 0.02422845282994989\n", + "Epoch 25, Train Loss: 0.02231395777101009, Val Loss: 0.02212312592388089\n", + "Epoch 26, Train Loss: 0.02209535693420035, Val Loss: 0.02158943160589951\n", + "Epoch 27, Train Loss: 0.021671999831857722, Val Loss: 0.022256974825885758\n", + "Epoch 28, Train Loss: 0.021378441671417517, Val Loss: 0.021293755787522045\n", + "Epoch 29, Train Loss: 0.021532584222381194, Val Loss: 0.021740848698945187\n", + "Epoch 30, Train Loss: 0.02089789963625906, Val Loss: 0.022172707369300857\n", + "Epoch 31, Train Loss: 0.020911543732553578, Val Loss: 0.020904658445671423\n", + "Epoch 32, Train Loss: 0.020589363574090472, Val Loss: 0.021264061137144245\n", + "Epoch 33, Train Loss: 0.02011841800037112, Val Loss: 0.022388043521500346\n", + "Epoch 34, Train Loss: 0.020350060138281025, Val Loss: 0.020872680664952122\n", + "Epoch 35, Train Loss: 0.019910728570038193, Val Loss: 0.02008631487668895\n", + "Epoch 36, Train Loss: 0.01966284622291201, Val Loss: 0.02018301992385245\n", + "Epoch 37, Train Loss: 0.019478668659283785, Val Loss: 0.020117887351383913\n", + "Epoch 38, Train Loss: 0.019168558606262983, Val Loss: 0.020217864148652377\n", + "Epoch 39, Train Loss: 0.018900538525102956, Val Loss: 0.019784750694881625\n", + "Epoch 40, Train Loss: 0.019068713380139695, Val Loss: 0.020406662806201337\n", + "Epoch 41, Train Loss: 0.01922704772488994, Val Loss: 0.019463480088804195\n", + "Epoch 42, Train Loss: 0.018683298484257392, Val Loss: 0.019570431866641366\n", + "Epoch 43, Train Loss: 0.018411033715535863, Val Loss: 0.019696261789371717\n", + "Epoch 44, Train Loss: 0.018502752826901142, Val Loss: 0.0193116083574384\n", + "Epoch 45, Train Loss: 0.01851825592772028, Val Loss: 0.021103291230192826\n", + "Epoch 46, Train Loss: 0.01816361720125641, Val Loss: 0.020114433075954664\n", + "Epoch 47, Train Loss: 0.018051497934555464, Val Loss: 0.020221358179045256\n", + "Epoch 48, Train Loss: 0.01811225383885597, Val Loss: 0.01961083782475386\n", + "Epoch 49, Train Loss: 0.017867776890548224, Val Loss: 0.018948225665893128\n", + "Epoch 50, Train Loss: 0.01761771424152135, Val Loss: 0.01865902607009482\n", + "Epoch 51, Train Loss: 0.01793021524467608, Val Loss: 0.018359918592136298\n", + "Epoch 52, Train Loss: 0.017610817650805393, Val Loss: 0.018650228838756014\n", + "Epoch 53, Train Loss: 0.017737194443451305, Val Loss: 0.018363466583637158\n", + "Epoch 54, Train Loss: 0.017543190524302886, Val Loss: 0.019013355055184505\n", + "Epoch 55, Train Loss: 0.01778105637236859, Val Loss: 0.018212769875553116\n", + "Epoch 56, Train Loss: 0.017451271454861576, Val Loss: 0.018818481644587732\n", + "Epoch 57, Train Loss: 0.017273589150989026, Val Loss: 0.01801557773585195\n", + "Epoch 58, Train Loss: 0.01728663447816549, Val Loss: 0.01771288837737112\n", + "Epoch 59, Train Loss: 0.017209396768878237, Val Loss: 0.018658861782012592\n", + "Epoch 60, Train Loss: 0.017015971490694434, Val Loss: 0.01875163140748419\n", + "Epoch 61, Train Loss: 0.01697286305744112, Val Loss: 0.01831459281827087\n", + "Epoch 62, Train Loss: 0.01689975440466518, Val Loss: 0.018071504671182206\n", + "Epoch 63, Train Loss: 0.016585711293974133, Val Loss: 0.01783462390025605\n", + "Epoch 64, Train Loss: 0.016933080276839756, Val Loss: 0.018715852857636873\n", + "Epoch 65, Train Loss: 0.016899143777894633, Val Loss: 0.019256604974394412\n", + "Epoch 66, Train Loss: 0.016631374423031173, Val Loss: 0.018876284666693034\n", + "Epoch 67, Train Loss: 0.016569798094839855, Val Loss: 0.018378769520169765\n", + "Epoch 68, Train Loss: 0.016539438030544366, Val Loss: 0.018459608500350767\n", + "Epoch 69, Train Loss: 0.01645555520323261, Val Loss: 0.01851357322241833\n", + "Epoch 70, Train Loss: 0.01667448620726332, Val Loss: 0.017527391814362647\n", + "Epoch 71, Train Loss: 0.01630861950708491, Val Loss: 0.01862382395331984\n", + "Epoch 72, Train Loss: 0.016292595119621053, Val Loss: 0.01898773131308271\n", + "Epoch 73, Train Loss: 0.016312802497867904, Val Loss: 0.017515668033886312\n", + "Epoch 74, Train Loss: 0.01634560936714331, Val Loss: 0.017603496631690814\n", + "Epoch 75, Train Loss: 0.016150180214757556, Val Loss: 0.0177685193606277\n", + "Epoch 76, Train Loss: 0.016183897565479912, Val Loss: 0.01790037954142734\n", + "Epoch 77, Train Loss: 0.016441928089092794, Val Loss: 0.0177356356671497\n", + "Epoch 78, Train Loss: 0.016029272553773875, Val Loss: 0.01720855048676925\n", + "Epoch 79, Train Loss: 0.015830894611312443, Val Loss: 0.017439508657735674\n", + "Epoch 80, Train Loss: 0.015893817865891318, Val Loss: 0.017185933985260884\n", + "Epoch 81, Train Loss: 0.01587246311160081, Val Loss: 0.017182132229208946\n", + "Epoch 82, Train Loss: 0.015938340017848322, Val Loss: 0.01732705053942862\n", + "Epoch 83, Train Loss: 0.015770130625894767, Val Loss: 0.01730423010607709\n", + "Epoch 84, Train Loss: 0.015774958316931886, Val Loss: 0.01693567380642713\n", + "Epoch 85, Train Loss: 0.015681640634928166, Val Loss: 0.01731172299929964\n", + "Epoch 86, Train Loss: 0.015522310860080725, Val Loss: 0.01708351758155805\n", + "Epoch 87, Train Loss: 0.015825702162664473, Val Loss: 0.01767030195680572\n", + "Epoch 88, Train Loss: 0.015465608916053789, Val Loss: 0.0169600204689734\n", + "Epoch 89, Train Loss: 0.015413585239263812, Val Loss: 0.016799337550330518\n", + "Epoch 90, Train Loss: 0.015661140533975153, Val Loss: 0.017084516890680614\n", + "Epoch 91, Train Loss: 0.015471032805045684, Val Loss: 0.017242409135979502\n", + "Epoch 92, Train Loss: 0.015306838647725337, Val Loss: 0.016721693103882804\n", + "Epoch 93, Train Loss: 0.01516885641721661, Val Loss: 0.01838143560479381\n", + "Epoch 94, Train Loss: 0.015182504183100314, Val Loss: 0.017020777451680666\n", + "Epoch 95, Train Loss: 0.01524644939264541, Val Loss: 0.01649292297105291\n", + "Epoch 96, Train Loss: 0.015118425159434382, Val Loss: 0.017190173087613798\n", + "Epoch 97, Train Loss: 0.015101557916128322, Val Loss: 0.016093250461367527\n", + "Epoch 98, Train Loss: 0.01503138992775, Val Loss: 0.016338717831826922\n", + "Epoch 99, Train Loss: 0.015078757967550361, Val Loss: 0.016478037350435754\n", + "Epoch 100, Train Loss: 0.014985626251503611, Val Loss: 0.01633207424919107\n", + "Epoch 101, Train Loss: 0.014759322786570023, Val Loss: 0.01683194490511026\n", + "Epoch 102, Train Loss: 0.014856852341496774, Val Loss: 0.016027600129148854\n", + "Epoch 103, Train Loss: 0.014765939864655289, Val Loss: 0.016350745793376396\n", + "Epoch 104, Train Loss: 0.01478316887330852, Val Loss: 0.016033862258738547\n", + "Epoch 105, Train Loss: 0.014725807853684755, Val Loss: 0.015603851276769568\n", + "Epoch 106, Train Loss: 0.014806732724746021, Val Loss: 0.015736672651967896\n", + "Epoch 107, Train Loss: 0.014543344516253642, Val Loss: 0.015925641963953404\n", + "Epoch 108, Train Loss: 0.014782626121683696, Val Loss: 0.016552887453850525\n", + "Epoch 109, Train Loss: 0.014329457426060472, Val Loss: 0.01566976616020078\n", + "Epoch 110, Train Loss: 0.014614671502155408, Val Loss: 0.016271342245389276\n", + "Epoch 111, Train Loss: 0.014544662480291567, Val Loss: 0.01549402935736215\n", + "Epoch 112, Train Loss: 0.01446673739478705, Val Loss: 0.015960639662373422\n", + "Epoch 113, Train Loss: 0.014492520645849015, Val Loss: 0.015249295007270663\n", + "Epoch 114, Train Loss: 0.014440985597028402, Val Loss: 0.01671606713711326\n", + "Epoch 115, Train Loss: 0.014369557464593336, Val Loss: 0.016106587264742424\n", + "Epoch 116, Train Loss: 0.01432103816972395, Val Loss: 0.015263923374352171\n", + "Epoch 117, Train Loss: 0.014226941607945987, Val Loss: 0.015028324297893404\n", + "Epoch 118, Train Loss: 0.01423997960485625, Val Loss: 0.014743029529145404\n", + "Epoch 119, Train Loss: 0.014351020645100677, Val Loss: 0.01581134552608675\n", + "Epoch 120, Train Loss: 0.014202667741131696, Val Loss: 0.015378265266320598\n", + "Epoch 121, Train Loss: 0.013911791727321142, Val Loss: 0.01487369868737548\n", + "Epoch 122, Train Loss: 0.013906272411186017, Val Loss: 0.01551159023682573\n", + "Epoch 123, Train Loss: 0.013943794016329723, Val Loss: 0.015357211718697156\n", + "Epoch 124, Train Loss: 0.01389588224233694, Val Loss: 0.015303193772239472\n", + "Epoch 125, Train Loss: 0.014016644986854359, Val Loss: 0.014799274629287755\n", + "Epoch 126, Train Loss: 0.013944415422379258, Val Loss: 0.014797273328277603\n", + "Epoch 127, Train Loss: 0.013957360926480812, Val Loss: 0.014890457517397938\n", + "Epoch 128, Train Loss: 0.013801010133939211, Val Loss: 0.015028401750570802\n", + "Epoch 129, Train Loss: 0.013806760874821952, Val Loss: 0.016021162049094245\n", + "Epoch 130, Train Loss: 0.014049455859925616, Val Loss: 0.015217644565585834\n", + "Epoch 131, Train Loss: 0.013769885206497029, Val Loss: 0.015085379940582745\n", + "Epoch 132, Train Loss: 0.013684874973103903, Val Loss: 0.014550712029102133\n", + "Epoch 133, Train Loss: 0.013696547392666625, Val Loss: 0.014757407259251645\n", + "Epoch 134, Train Loss: 0.01369966242827796, Val Loss: 0.014638274657859732\n", + "Epoch 135, Train Loss: 0.013533816318602511, Val Loss: 0.014734907506673193\n", + "Epoch 136, Train Loss: 0.013603145677738926, Val Loss: 0.014580759831440093\n", + "Epoch 137, Train Loss: 0.013541612814238482, Val Loss: 0.01570955854354065\n", + "Epoch 138, Train Loss: 0.013723757467789656, Val Loss: 0.016205344780056335\n", + "Epoch 139, Train Loss: 0.013546007516031916, Val Loss: 0.0152104031572591\n", + "Epoch 140, Train Loss: 0.013532601969771123, Val Loss: 0.015342667142846692\n", + "Epoch 141, Train Loss: 0.013450533512569786, Val Loss: 0.014644546336980898\n", + "Epoch 142, Train Loss: 0.013607010434706959, Val Loss: 0.014687455078559135\n", + "Epoch 143, Train Loss: 0.013542775672962934, Val Loss: 0.014521264234807953\n", + "Epoch 144, Train Loss: 0.013417973114026078, Val Loss: 0.014601941859877822\n", + "Epoch 145, Train Loss: 0.013331704906691489, Val Loss: 0.01485029947179467\n", + "Epoch 146, Train Loss: 0.013418046530318316, Val Loss: 0.014630124362102195\n", + "Epoch 147, Train Loss: 0.013351045589020663, Val Loss: 0.01494142015589707\n", + "Epoch 148, Train Loss: 0.013260266191045348, Val Loss: 0.015414885175761893\n", + "Epoch 149, Train Loss: 0.013240087648149598, Val Loss: 0.014419331771335494\n", + "Epoch 150, Train Loss: 0.01334052808297593, Val Loss: 0.01435606328965123\n", + "Test Loss: 0.008245683658557634\n" + ] + } + ], + "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_counts = train_epoch(model, device, dataloader, criterion, optimizer)\n", + " train_losses.append(train_loss)\n", + " val_loss, val_counts = 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[0]}')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "cdc0d608-6f0a-43dc-8cc1-8acf68215d18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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[1:], label='train_loss')\n", + "plt.plot(val_losses[1:], label='val_loss')\n", + "plt.legend(loc='best')" + ] + }, + { + "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": "dae7427e-548e-4276-a4ea-bc9b279d44e8", + "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": 28, + "id": "2744f422-bdd2-4101-9c45-197ad32e8c22", + "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", + "test_miss_counts = list()\n", + "with torch.no_grad():\n", + " for batch_idx, (X, y, mask, r) 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", + " test_miss_counts.append(r)\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": 25, + "id": "e959a28a-840f-4b34-befc-c233f20635cc", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6ef3ffdf-72ea-4c88-8118-1103a81205f3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count4739.0000004739.0000004739.0000004739.0000004739.0000004739.000000
mean1.2647911.7980690.1613840.6806430.8892220.836726
std0.6012220.8947350.0924270.2274770.1043770.122876
min0.3778900.4878590.045982-2.265916-0.1467660.002855
25%0.8313401.1491410.1101990.5791730.8590470.785617
50%1.1261141.6096030.1423980.7362360.9223700.869874
75%1.5417142.2210090.1852160.8407570.9555710.922865
max4.7658548.6943161.2853740.9887380.9971250.994878
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa \\\n", + "count 4739.000000 4739.000000 4739.000000 4739.000000 4739.000000 \n", + "mean 1.264791 1.798069 0.161384 0.680643 0.889222 \n", + "std 0.601222 0.894735 0.092427 0.227477 0.104377 \n", + "min 0.377890 0.487859 0.045982 -2.265916 -0.146766 \n", + "25% 0.831340 1.149141 0.110199 0.579173 0.859047 \n", + "50% 1.126114 1.609603 0.142398 0.736236 0.922370 \n", + "75% 1.541714 2.221009 0.185216 0.840757 0.955571 \n", + "max 4.765854 8.694316 1.285374 0.988738 0.997125 \n", + "\n", + " r \n", + "count 4739.000000 \n", + "mean 0.836726 \n", + "std 0.122876 \n", + "min 0.002855 \n", + "25% 0.785617 \n", + "50% 0.869874 \n", + "75% 0.922865 \n", + "max 0.994878 " + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(eva_list_frame, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "403385cd-0a5a-46ee-84a5-5c37848b87bf", + "metadata": {}, + "outputs": [], + "source": [ + "train_counts_int = [int(y) for x in train_counts for y in x]\n", + "val_counts_int = [int(y) for x in val_counts for y in x]\n", + "test_counts_int = [int(y) for x in test_miss_counts for y in x]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "e5a52567-71d1-4438-b89c-12ee499e3fb7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26749" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_counts_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "dbc0d21e-f303-4838-b9a5-8a3976c311ab", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import Counter" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "c674e143-5f70-4628-9adf-97f080617730", + "metadata": {}, + "outputs": [], + "source": [ + "counts_train = Counter(train_counts_int)\n", + "counts_valid = Counter(val_counts_int)\n", + "counts_test = Counter(test_counts_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "03bff9cc-8c7a-4cb9-bdf0-c163ed4763a7", + "metadata": {}, + "outputs": [], + "source": [ + "counts_df_train = pd.DataFrame.from_dict(dict(counts_train), orient='index').sort_index()\n", + "counts_df_test = pd.DataFrame.from_dict(dict(counts_test), orient='index').sort_index()\n", + "counts_df_valid = pd.DataFrame.from_dict(dict(counts_valid), orient='index').sort_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "a8f0bcf8-e33a-4603-a3a1-0676594ec54f", + "metadata": {}, + "outputs": [], + "source": [ + "rst = pd.concat([counts_df_train, counts_df_valid, counts_df_test], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "b91c40dc-9d20-400a-866e-472c9e4d81c3", + "metadata": {}, + "outputs": [], + "source": [ + "rst.columns = ['train', 'validation', 'test']" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "528dd935-881e-4e37-95dd-89c1ae23566e", + "metadata": {}, + "outputs": [], + "source": [ + "rst.to_csv('./mix_eva.csv', index=False, encoding='utf-8-sig')" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "f0c39db0-92f7-4fe3-a826-8185186c78c2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
trainvalidationtest
10962415001743
20653411171150
305380840956
405211818890
\n", + "
" + ], + "text/plain": [ + " train validation test\n", + "10 9624 1500 1743\n", + "20 6534 1117 1150\n", + "30 5380 840 956\n", + "40 5211 818 890" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rst" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "9b900f09-65b3-45d8-99fd-486a80b51a3d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6095f434-bc4d-4c90-9abd-e6e12c555f16", + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure(figsize=(16, 9))\n", + "rst.plot.bar()\n", + "plt.xlabel('Missing Rate(%)', fontsize=16, fontproperties='Times New Roman')\n", + "plt.ylabel('Sample Counts', fontsize=16, fontproperties='Times New Roman')\n", + "plt.xticks(rotation=45, fontproperties='Times New Roman')\n", + "plt.tight_layout()\n", + "plt.legend(loc='best', fontsize=16)\n", + "plt.savefig('./miss_counts.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72bb4d0c-3fce-4b20-b5fa-7fca52cbb511", + "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 +} diff --git a/torch_MAE_1d_final_real_test.ipynb b/torch_MAE_1d_final_real_test.ipynb new file mode 100644 index 0000000..c13fe9b --- /dev/null +++ b/torch_MAE_1d_final_real_test.ipynb @@ -0,0 +1,1054 @@ +{ + "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": [ + "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": [], + "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.expand_dims(np.load(image_path).astype(np.float32), axis=2) / 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)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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": 5, + "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": 6, + "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": 7, + "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": 8, + "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": 9, + "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": 10, + "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": 11, + "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": 12, + "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": 13, + "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": 14, + "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": 15, + "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": 16, + "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": 17, + "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": 18, + "id": "775bb9b8-1d6a-40f0-82e5-e1d6bc369e7a", + "metadata": {}, + "outputs": [], + "source": [ + "model10 = torch.load('./models/MAE/final_10.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "44b36101-69a1-4b12-823b-8653110863c5", + "metadata": {}, + "outputs": [], + "source": [ + "model20 = torch.load('./models/MAE/final_20.pt')\n", + "model30 = torch.load('./models/MAE/final_30.pt')\n", + "model40 = torch.load('./models/MAE/final_40.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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": 21, + "id": "9d13fb84-65e2-4e67-91a2-d6a4b36a0842", + "metadata": {}, + "outputs": [], + "source": [ + "# 实例化数据集和数据加载器\n", + "image_dir = './2022data/selected_data/'" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5bb0c2d4-e05d-4611-b247-4b8b000e6fc9", + "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": 26, + "id": "cab43bce-4d37-4f13-9153-9b9ced72fdaa", + "metadata": {}, + "outputs": [], + "source": [ + "def predict_frame(model, mask_dir):\n", + " test_set = NO2Dataset(image_dir, mask_dir)\n", + " test_loader = DataLoader(test_set, batch_size=32, shuffle=False, num_workers=4)\n", + " eva_list_frame = 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", + " 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", + " return eva_list_frame" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7d791903-c6eb-4170-b816-07c127471aa3", + "metadata": {}, + "outputs": [], + "source": [ + "def predict_batch(model, mask_dir):\n", + " test_set = NO2Dataset(image_dir, mask_dir)\n", + " test_loader = DataLoader(test_set, batch_size=32, shuffle=False, num_workers=4)\n", + " 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])\n", + " return eva_list" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0174210e-a771-47ed-a719-65c18e0185fe", + "metadata": {}, + "outputs": [], + "source": [ + "eva_10 = predict_batch(model10, './out_mat/96/mask/10/')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "1e9a5196-b8a6-42d8-b1fc-8f37decead81", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maermsemaper2ioar
count944.000000944.000000944.000000944.000000944.000000944.000000
mean1.0914351.8007760.1449010.9215020.9785280.961399
std0.1219880.2770840.0139610.0219900.0064710.011300
min0.7806211.2034250.1127690.8141690.9380120.912011
25%1.0103651.6048890.1346380.9086990.9748350.954552
50%1.0844951.7780220.1439430.9247480.9795030.962814
75%1.1673331.9438340.1530040.9366590.9830790.969209
max1.6633023.6382900.1952960.9664770.9911800.984394
\n", + "
" + ], + "text/plain": [ + " mae rmse mape r2 ioa r\n", + "count 944.000000 944.000000 944.000000 944.000000 944.000000 944.000000\n", + "mean 1.091435 1.800776 0.144901 0.921502 0.978528 0.961399\n", + "std 0.121988 0.277084 0.013961 0.021990 0.006471 0.011300\n", + "min 0.780621 1.203425 0.112769 0.814169 0.938012 0.912011\n", + "25% 1.010365 1.604889 0.134638 0.908699 0.974835 0.954552\n", + "50% 1.084495 1.778022 0.143943 0.924748 0.979503 0.962814\n", + "75% 1.167333 1.943834 0.153004 0.936659 0.983079 0.969209\n", + "max 1.663302 3.638290 0.195296 0.966477 0.991180 0.984394" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame.from_records(eva_10, columns=['mae', 'rmse', 'mape', 'r2', 'ioa', 'r']).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "a34173c5-b193-4f5f-9a2a-8f577c013156", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345
count944.000000944.000000944.000000944.000000944.000000944.000000
mean1.3557412.2987900.1873850.8740660.9643840.936755
std0.1757650.4201520.0215700.0366640.0112270.019697
min0.9375161.4913210.1352320.6703710.8992520.821530
25%1.2277702.0030570.1724650.8529180.9585020.925009
50%1.3389802.2332780.1847340.8796770.9663220.939587
75%1.4616512.5170450.2009110.9006810.9723580.950725
max2.2339364.2655920.2896570.9494710.9865600.976791
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5\n", + "count 944.000000 944.000000 944.000000 944.000000 944.000000 944.000000\n", + "mean 1.355741 2.298790 0.187385 0.874066 0.964384 0.936755\n", + "std 0.175765 0.420152 0.021570 0.036664 0.011227 0.019697\n", + "min 0.937516 1.491321 0.135232 0.670371 0.899252 0.821530\n", + "25% 1.227770 2.003057 0.172465 0.852918 0.958502 0.925009\n", + "50% 1.338980 2.233278 0.184734 0.879677 0.966322 0.939587\n", + "75% 1.461651 2.517045 0.200911 0.900681 0.972358 0.950725\n", + "max 2.233936 4.265592 0.289657 0.949471 0.986560 0.976791" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eva_20 = predict_batch(model20, './out_mat/96/mask/20/')\n", + "pd.DataFrame.from_records(eva_20).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "c8a2ecdc-ef09-4fe2-a95e-9ede1a6a5e32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345
count944.000000944.000000944.000000944.000000944.000000944.000000
mean1.5390122.5922090.1981950.8497430.9568170.924245
std0.1990990.4579440.0211950.0370780.0118420.020082
min1.0720831.7136040.1530920.6747280.8788250.837543
25%1.4043732.2804560.1830940.8292490.9509520.912680
50%1.5098112.4942750.1958100.8539370.9583790.926343
75%1.6498922.8144000.2115180.8757200.9648660.938508
max2.4273945.0869260.2815820.9366120.9825760.969190
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5\n", + "count 944.000000 944.000000 944.000000 944.000000 944.000000 944.000000\n", + "mean 1.539012 2.592209 0.198195 0.849743 0.956817 0.924245\n", + "std 0.199099 0.457944 0.021195 0.037078 0.011842 0.020082\n", + "min 1.072083 1.713604 0.153092 0.674728 0.878825 0.837543\n", + "25% 1.404373 2.280456 0.183094 0.829249 0.950952 0.912680\n", + "50% 1.509811 2.494275 0.195810 0.853937 0.958379 0.926343\n", + "75% 1.649892 2.814400 0.211518 0.875720 0.964866 0.938508\n", + "max 2.427394 5.086926 0.281582 0.936612 0.982576 0.969190" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eva_30 = predict_batch(model30, './out_mat/96/mask/30/')\n", + "pd.DataFrame.from_records(eva_30).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "478ad241-6774-4fb2-ae72-9abea0ca2a98", + "metadata": {}, + "outputs": [], + "source": [ + "eva_40 = predict_batch(model40, './out_mat/96/mask/40/')\n", + "pd.DataFrame.from_records(eva_40).describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "946d8ee3-608b-4327-b576-88bf723449d7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14be731a-0334-4912-9d7b-5d040bcffa33", + "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 +} diff --git a/未命名1.ipynb b/未命名1.ipynb new file mode 100644 index 0000000..12c5da7 --- /dev/null +++ b/未命名1.ipynb @@ -0,0 +1,425 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b22d5573-7d43-47f4-83ab-dcbc2772136a", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b5474ec4-e68f-428d-a1f5-446055c07a16", + "metadata": {}, + "outputs": [], + "source": [ + "rst_mix = pd.read_csv('./mix_eva.csv')\n", + "rst_mix.index = [10, 20, 30, 40]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9790e6fc-1cdb-4376-a63a-3f2eb7f2e555", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "17916ba4-aab6-43f1-b97f-be7f44d068a4", + "metadata": {}, + "outputs": [], + "source": [ + "colors = [(211, 65, 51), (240, 155, 39), (25, 152, 128)]\n", + "rgb_colors = [tuple(c/255 for c in color) for color in colors]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "68df39d6-c0f8-4fe8-9d49-6ce3ca8d6682", + "metadata": {}, + "outputs": [], + "source": [ + "# 设置字体为Times new Roman\n", + "plt.rcParams['font.sans-serif'] = ['Times New Roman']" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "bb9d01de-c270-4578-b358-66366857da0b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 9))\n", + "rst_mix.plot.bar(color=rgb_colors, width=0.75)\n", + "plt.xlabel('Missing Rate(%)', fontsize=14)\n", + "plt.ylabel('Sample Counts', fontsize=14)\n", + "plt.xticks(rotation=-45, fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "plt.tight_layout()\n", + "plt.legend(loc='best', fontsize=16)\n", + "plt.savefig('./miss_counts.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ed3eca73-9607-4c32-af5a-918b07f5abfe", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib as mpl" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f3e6fbc9-97bd-4bb5-9cfa-7bb86fd8c59b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/root/.cache/matplotlib'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mpl.get_cachedir()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0a6c359-293e-40ab-842b-9eecd2b7d29f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "5b1001ae-d846-4841-bd0c-0af673103e62", + "metadata": {}, + "outputs": [], + "source": [ + "draw_data = pd.read_csv('./data_count.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "fe12a6da-ad4d-45b8-9d66-96398e98e6b9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
monthcountmeanstdmin25%50%75%max
02022-0131.00.3758940.2787280.0244020.1536360.3114350.5413881.000000
12022-0227.00.2233230.2476660.0000000.0315310.1105740.3599280.904019
22022-0331.00.3469380.3267580.0000000.0550480.2806220.5822251.000000
32022-0430.00.2416670.2556290.0005260.0313160.1183490.4027270.823110
42022-0531.00.2611530.2913430.0000000.0421530.0990430.3776790.899809
52022-0630.00.3074100.2497770.0259330.0977870.2162680.5388280.885215
62022-0731.00.4718890.2580720.0044020.2864590.5025840.6389470.914545
72022-0831.00.4114850.2864030.0090430.1942110.3547850.6030860.945215
82022-0930.00.2406350.2506890.0000480.0394620.1361960.3774160.910239
92022-1031.00.3343960.2746840.0000000.1168180.2910530.4948330.883923
102022-1129.00.4058540.3088610.0166030.1070810.4761720.6294740.941579
112022-1231.00.2233860.1944960.0069380.0605020.1827270.2711720.680622
\n", + "
" + ], + "text/plain": [ + " month count mean std min 25% 50% \\\n", + "0 2022-01 31.0 0.375894 0.278728 0.024402 0.153636 0.311435 \n", + "1 2022-02 27.0 0.223323 0.247666 0.000000 0.031531 0.110574 \n", + "2 2022-03 31.0 0.346938 0.326758 0.000000 0.055048 0.280622 \n", + "3 2022-04 30.0 0.241667 0.255629 0.000526 0.031316 0.118349 \n", + "4 2022-05 31.0 0.261153 0.291343 0.000000 0.042153 0.099043 \n", + "5 2022-06 30.0 0.307410 0.249777 0.025933 0.097787 0.216268 \n", + "6 2022-07 31.0 0.471889 0.258072 0.004402 0.286459 0.502584 \n", + "7 2022-08 31.0 0.411485 0.286403 0.009043 0.194211 0.354785 \n", + "8 2022-09 30.0 0.240635 0.250689 0.000048 0.039462 0.136196 \n", + "9 2022-10 31.0 0.334396 0.274684 0.000000 0.116818 0.291053 \n", + "10 2022-11 29.0 0.405854 0.308861 0.016603 0.107081 0.476172 \n", + "11 2022-12 31.0 0.223386 0.194496 0.006938 0.060502 0.182727 \n", + "\n", + " 75% max \n", + "0 0.541388 1.000000 \n", + "1 0.359928 0.904019 \n", + "2 0.582225 1.000000 \n", + "3 0.402727 0.823110 \n", + "4 0.377679 0.899809 \n", + "5 0.538828 0.885215 \n", + "6 0.638947 0.914545 \n", + "7 0.603086 0.945215 \n", + "8 0.377416 0.910239 \n", + "9 0.494833 0.883923 \n", + "10 0.629474 0.941579 \n", + "11 0.271172 0.680622 " + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bde6046e-7a70-4a0c-ac83-fdf4d0a3b0d5", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(16, 9))\n", + "# plt.plot(range(1, 13), des['mean'].values, '*-')\n", + "bp = ax.boxplot(draw_data, showmeans=True, patch_artist=False, widths=0.5, boxprops=dict(linewidth=2),\n", + " medianprops=dict(color='red', linewidth=2),\n", + " meanprops=dict(marker='*', markersize=8, linewidth=2),\n", + " # whiskerprops=dict(color='black', linewidth=1.5),\n", + " # capprops=dict(color='black', linewidth=1.5)\n", + " )\n", + "# 创建一个仅包含标记的图例项\n", + "circle = mlines.Line2D([], [], color='green', marker='*', linestyle='None', markersize=8, label='Mean Point')\n", + "median_line = mlines.Line2D([], [], color='red', marker='', linestyle='-', linewidth=2, label='Median Line')\n", + "ax.set_xlabel('Month', fontsize=16)\n", + "ax.set_ylabel('Missing Rate', fontsize=16)\n", + "ax.set_xticklabels(months, fontsize=16)\n", + "# 获取当前的y轴标签\n", + "yticklabels = ax.get_yticklabels()\n", + "\n", + "# 设置y轴标签的字体大小\n", + "for label in yticklabels:\n", + " label.set_fontsize(16)\n", + "# 添加图例\n", + "ax.legend(handles=[median_line, circle], fontsize=16)\n", + "plt.show()" + ] + } + ], + "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 +} diff --git a/论文绘图.ipynb b/论文绘图.ipynb new file mode 100644 index 0000000..3597211 --- /dev/null +++ b/论文绘图.ipynb @@ -0,0 +1,1064 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 139, + "id": "eea46721-2898-411d-a80c-a908030c6977", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import geopandas as gpd\n", + "import pandas as pd\n", + "from shapely.geometry import Point, Polygon" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "17f63fe2-e5f6-48a3-94f8-74ef660b2868", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ori_data = np.load('./np_data/20200220.npy')\n", + "data = ori_data[:,:,0].copy()\n", + "plt.imshow(data, cmap='RdYlGn_r')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "326b7241-afc8-43ce-b15e-3154fbeaa2d6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d9248def-25ef-4ae9-8425-d3a4e851afda", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = ori_data[:,:,0].copy()\n", + "plt.imshow(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d41b956d-03af-46df-8ec1-ef9fa5503ccf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.clf()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "bef156fa-d565-4ce8-ab33-4da917342eb1", + "metadata": {}, + "outputs": [], + "source": [ + "# 创建一个190x110的经纬度网格\n", + "lon_min, lat_min = 114.025, 33.525\n", + "lon_max, lat_max = 123.475, 38.975\n", + "lon_step = (lon_max - lon_min) / 190\n", + "lat_step = (lat_max - lat_min) / 110" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1eb83907-4dff-497a-b481-3624a062a134", + "metadata": {}, + "outputs": [], + "source": [ + "lons = np.linspace(lon_min, lon_max, 190)\n", + "lats = np.linspace(lat_min, lat_max, 110)\n", + "lon_grid, lat_grid = np.meshgrid(lons, lats)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9bf5b19f-0776-4562-a194-039e10e4c5e3", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# 初始化一个空的GeoDataFrame\n", + "gdf = gpd.GeoDataFrame(columns=['geometry', 'value'])\n", + "\n", + "# 将网格转换为多边形并添加到GeoDataFrame\n", + "for i in range(lat_grid.shape[0] - 1):\n", + " for j in range(lat_grid.shape[1] - 1):\n", + " polygon = Polygon([\n", + " (lon_grid[i, j], lat_grid[i, j]),\n", + " (lon_grid[i, j+1], lat_grid[i, j+1]),\n", + " (lon_grid[i+1, j+1], lat_grid[i+1, j+1]),\n", + " (lon_grid[i+1, j], lat_grid[i+1, j])\n", + " ])\n", + " # 使用concat而不是append\n", + " gdf = pd.concat([gdf, gpd.GeoDataFrame({'geometry': [polygon], 'value': [data[i, j]]})], ignore_index=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "68817ef0-79d8-49e6-ada4-152f746d5e3c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_7233/3979395723.py:2: FutureWarning: The geopandas.dataset module is deprecated and will be removed in GeoPandas 1.0. You can get the original 'naturalearth_lowres' data from https://www.naturalearthdata.com/downloads/110m-cultural-vectors/.\n", + " world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))\n" + ] + } + ], + "source": [ + "# 读取世界地图\n", + "world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8157b80b-a758-44f2-9739-62439b254786", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(10, 10))\n", + "world.plot(ax=ax, color='white', edgecolor='black')\n", + "\n", + "# 绘制网格\n", + "gdf.plot(ax=ax, column='value', legend=False, cmap='RdYlGn_r')\n", + "# 设置地图范围\n", + "ax.set_xlim(lon_min, lon_max)\n", + "ax.set_ylim(lat_min, lat_max)\n", + "plt.savefig('./origin.png', bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f98c3cb6-a13e-4b59-93f7-17706c5ef975", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "93c8c793-10bd-4e8c-aab8-7317103979b1", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "show_list = os.listdir('./out_mat/96/train/')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "79d57a73-909c-4c69-aa1a-82c04233b50e", + "metadata": {}, + "outputs": [], + "source": [ + "val_list = [x for x in show_list if '20201106' in x]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6f213fe-5f61-4c32-a475-25d421b7f440", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "0306308d-d578-4114-9bfb-e2ffc2e87219", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i, p in enumerate(val_list):\n", + " if i >= 10:\n", + " break\n", + " val_data = np.load(f'./out_mat/96/train/{p}')[:,:,0]\n", + " plt.imshow(val_data, cmap='RdYlGn_r')\n", + " plt.savefig(f'./figures/full/{i}.png', bbox_inches='tight')\n", + " plt.clf()" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "0e9bf439-bc45-4ffd-823c-153e0361d360", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['20200503-439.jpg',\n", + " '20201212-1053.jpg',\n", + " '20200416-1333.jpg',\n", + " '20200505-626.jpg',\n", + " '20200516-624.jpg']" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "masks = [x for x in os.listdir('./out_mat/96/mask/30/')][:5]\n", + "masks" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "4a69e0ab-cf00-402e-84f6-821ea5edd1e2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['20201106-859.npy',\n", + " '20201106-866.npy',\n", + " '20201106-1088.npy',\n", + " '20201106-1142.npy',\n", + " '20201106-1238.npy']" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_miss = val_list[5:10]\n", + "new_miss" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "cc86d982-d861-490c-9e5a-b94e9d18d9b1", + "metadata": {}, + "outputs": [], + "source": [ + "import cv2" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "847c5cce-8109-48e1-8041-7132e5f9c3b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for img, msk in zip(new_miss, masks):\n", + " img_np = np.load(f'./out_mat/96/train/{img}')[:,:,0]\n", + " msk_np = cv2.cvtColor(cv2.imread(f'./out_mat/96/mask/30/{msk}'), cv2.COLOR_BGR2GRAY)\n", + " msk_np_2 = msk_np.astype(float)\n", + " msk_np_2[msk_np_2 == 0] = np.nan\n", + " miss = img_np * msk_np_2\n", + " plt.imshow(miss, cmap='RdYlGn_r')\n", + " plt.savefig(f'./figures/miss/{img}.png', bbox_inches='tight')\n", + " plt.clf()\n", + " plt.imshow(msk_np_2, cmap='gray')\n", + " plt.savefig(f'./figures/mask/{img}.png', bbox_inches='tight')\n", + " plt.clf()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "3aab440a-32d8-4ba3-a729-daebaef80edd", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "data_list = [x for x in os.listdir('./np_data/') if 'npy' in x]\n", + "dates = list()\n", + "miss_rate_list = list()\n", + "for path in data_list:\n", + " dates.append(path.split('.')[0].strip())\n", + " data = np.load(f\"./np_data/{path}\")[:,:,0]\n", + " miss_rate = (np.isnan(data) * 1).sum() / (data.shape[0] * data.shape[1])\n", + " miss_rate_list.append(miss_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "904c5576-cdfa-4dc9-b824-21bef037fc7d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
daterate
0202011160.14933
1202001200.054163
2202007240.124641
3202006220.364641
4202007110.896986
\n", + "
" + ], + "text/plain": [ + " date rate\n", + "0 20201116 0.14933\n", + "1 20200120 0.054163\n", + "2 20200724 0.124641\n", + "3 20200622 0.364641\n", + "4 20200711 0.896986" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "miss_df = pd.DataFrame([dates, miss_rate_list]).T\n", + "miss_df.columns = ['date', 'rate']\n", + "miss_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "1efb840f-b749-41fa-96d8-35a2f9aa1b9e", + "metadata": {}, + "outputs": [], + "source": [ + "miss_df.date = pd.to_datetime(miss_df.date)\n", + "miss_df['month'] = miss_df.date.apply(lambda x: x.month)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "45ddaec0-d868-4946-9d6a-e30246b2fdd1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "month\n", + "1 0.496714\n", + "2 0.445747\n", + "3 0.246096\n", + "4 0.232876\n", + "5 0.349770\n", + "6 0.427705\n", + "7 0.523877\n", + "8 0.510536\n", + "9 0.295989\n", + "10 0.393019\n", + "11 0.345657\n", + "12 0.313314\n", + "Name: rate, dtype: float64" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "miss_df.groupby('month')['rate'].mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "5b7fea10-889f-448f-b1c4-7900ad3fc202", + "metadata": {}, + "outputs": [], + "source": [ + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "72fc40d6-fd5a-4709-9ab9-f64cd3c9db1d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4245" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(os.listdir('./out_mat/96/mask/50/'))" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "4623918e-1970-4fc4-8914-23357eb3bbb6", + "metadata": {}, + "outputs": [], + "source": [ + "with open('./POMINO_data/POMINO_v2.1_daily_20200220.txt', 'r', encoding='utf-8') as fr:\n", + " d = fr.readlines()\n", + " dd = [float(x.strip()) for x in d]\n", + " vcd = np.zeros([160,280])\n", + " ct = 0\n", + " for j in range(280):\n", + " for i in range(160):\n", + " vcd[i,j] = dd[ct]\n", + " ct += 1\n", + " if i == 159:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "b513f7b7-41e9-461d-9e0d-daf985014c10", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(vcd)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "1a285b44-13a9-47c4-873b-d832d54c623e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(110, 190)" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img1.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "1f1f9fbe-66a6-4f23-980b-2dd74867419c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img1 = np.load('./np_data/20200320.npy')[:,:,0]\n", + "data = img1[:96, -96:].copy()\n", + "plt.imshow(data, cmap='RdYlGn_r')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/a.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "1e015fff-aaaa-44eb-846c-34079ea633fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.isnan(data) * 1, cmap='gray')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/a-mask.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "f86a7a59-4b71-4f39-ae7f-6394daae5308", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img2 = np.load('./np_data/20200621.npy')\n", + "data = img2[:,:,0][110-96:110, 20:116].copy()\n", + "plt.imshow(data, cmap='RdYlGn_r')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/b.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "d45ac436-0e5b-4860-a763-265b84914b7d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.isnan(data) * 1, cmap='gray')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/b-mask.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "02b56763-e1f5-4091-a708-4d11dbb2ad15", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img3 = np.load('./np_data/20200922.npy')\n", + "data = img3[:,:,0][10:106, :96].copy()\n", + "plt.imshow(data, cmap='RdYlGn_r')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/c.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "45053672-473c-4001-acad-3572f68b3225", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.isnan(data) * 1, cmap='gray')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/c-mask.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "40cfca7f-21ed-49b4-aedd-afc0d2ba8b10", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img4 = np.load('./np_data/20201221.npy')\n", + "data = img4[:,:,0][:96, -96:].copy()\n", + "plt.imshow(data, cmap='RdYlGn_r')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/d.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "264fc468-fc1f-4298-923a-4e0174c052d8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.isnan(data) * 1, cmap='gray')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.savefig('./figures/fig4-ori_and_miss/d-mask.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "605f263e-1ef3-4fa7-be74-142c6918d682", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ori_data_16 = np.load('./np_data/20200220.npy')\n", + "data = ori_data_16[25:55,65:95,0].copy()\n", + "plt.imshow(data, cmap='RdYlGn_r')\n", + "plt.gca().axis('off') # 获取当前坐标轴并关闭\n", + "plt.savefig('./figures/fig1/color.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "b7c0d144-b0f4-427c-b07c-3bb4d4d4be96", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.clf()\n", + "plt.imshow(data, cmap='gray')\n", + "plt.gca().axis('off') # 获取当前坐标轴并关闭\n", + "plt.savefig('./figures/fig1/gray.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "7cfe14e9-1f71-4db2-bedf-4ce036c7496a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(30, 30)" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "id": "d2e09df0-a482-4c03-aa3a-bbcca4024c45", + "metadata": {}, + "outputs": [], + "source": [ + "pd.DataFrame(data.astype(int)).to_csv('./numeric.csv', index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "2bde0a43-b1ab-4bb4-b77a-6b74373127a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8 7 7 7 7 7 6 6 8 9 9 10 10 10 10 9 10 9 9 9 8 8 9 9 8 9 9 9 9 10 \n", + "8 8 7 7 7 7 7 7 8 9 9 10 10 10 9 9 9 10 10 9 9 9 9 10 9 9 10 10 10 10 \n", + "8 8 7 8 8 8 8 8 8 8 9 9 10 10 9 9 9 9 10 9 9 9 10 10 10 10 10 11 12 13 \n", + "9 9 10 9 8 9 9 9 9 9 9 9 9 10 9 9 9 9 8 9 9 9 10 10 10 11 12 14 15 16 \n", + "10 9 9 10 9 10 11 11 10 11 12 10 11 11 11 10 9 9 8 9 9 9 10 12 12 14 15 17 18 20 \n", + "8 8 8 10 10 11 12 11 11 13 12 10 11 12 12 11 10 9 8 9 9 10 12 15 16 17 19 22 25 24 \n", + "8 8 8 9 9 10 11 11 11 13 11 11 11 13 14 13 12 11 10 10 10 12 15 16 18 19 20 21 21 20 \n", + "7 8 9 9 9 9 10 10 11 10 11 12 16 17 18 19 16 15 13 12 14 15 15 15 16 16 17 18 18 16 \n", + "7 8 8 9 9 10 10 10 10 11 12 13 16 19 22 25 25 22 16 18 19 18 15 15 15 15 15 15 15 14 \n", + "8 8 7 8 9 10 12 11 10 11 13 13 15 21 22 24 25 23 19 21 22 19 16 15 14 13 13 12 12 12 \n", + "10 9 7 8 8 9 10 10 10 11 11 12 15 19 21 22 24 23 22 20 18 16 14 13 12 12 11 11 12 13 \n", + "9 8 8 9 8 9 10 11 11 12 12 14 17 19 21 20 22 23 23 19 16 15 14 12 12 12 12 11 12 12 \n", + "10 10 10 10 11 11 11 12 13 14 17 21 24 25 22 22 24 26 25 20 18 19 15 13 12 12 13 13 13 13 \n", + "10 10 10 12 12 13 13 14 15 17 21 25 28 28 26 25 28 32 27 20 15 17 17 16 15 13 13 13 13 13 \n", + "10 9 9 13 14 15 15 16 18 22 25 28 31 32 32 28 27 24 20 17 15 16 18 18 17 15 14 14 13 13 \n", + "10 10 12 14 16 17 17 23 27 30 29 30 33 37 35 30 27 23 18 15 15 16 17 17 17 18 17 17 14 13 \n", + "10 11 10 12 15 18 25 33 43 41 36 36 36 37 36 35 29 22 19 17 15 15 16 17 18 19 19 18 16 14 \n", + "12 13 11 13 15 20 30 39 47 46 39 30 28 30 34 39 31 25 21 18 17 17 17 17 17 17 17 15 16 14 \n", + "15 14 14 14 16 20 26 38 36 31 26 22 20 21 30 40 36 27 21 20 18 17 17 16 16 15 13 13 13 13 \n", + "16 15 15 15 16 17 17 18 19 20 17 15 13 16 24 28 30 22 18 17 15 15 15 15 15 14 14 14 14 13 \n", + "18 17 16 16 16 14 12 10 10 13 11 10 10 12 15 18 18 16 13 13 12 11 12 13 15 14 14 15 17 16 \n", + "18 16 17 16 15 10 8 8 8 9 10 9 10 11 12 12 11 10 8 10 9 8 8 11 13 14 14 16 17 16 \n", + "15 12 12 11 9 7 6 7 7 6 7 9 10 9 9 8 7 6 6 6 6 6 7 7 9 12 14 14 14 13 \n", + "9 7 5 6 6 6 6 6 6 5 6 8 10 8 6 5 4 5 5 4 5 6 6 7 7 10 11 11 10 7 \n", + "4 3 4 4 5 6 7 7 8 7 8 9 11 8 5 5 4 4 4 4 5 6 6 6 7 9 9 6 6 4 \n", + "4 2 4 5 6 8 10 8 9 9 10 12 11 9 5 4 4 4 3 4 5 5 6 6 6 7 7 5 4 4 \n", + "3 3 3 5 7 11 15 11 11 11 11 11 12 8 5 4 3 3 3 4 5 5 6 5 5 5 6 6 5 5 \n", + "4 4 5 7 9 13 14 14 14 11 10 11 15 9 6 4 3 3 4 4 4 4 5 6 6 5 5 7 6 6 \n", + "4 4 6 8 9 14 16 18 14 10 10 15 17 12 6 4 3 4 3 4 4 3 5 5 5 4 4 6 7 6 \n", + "4 4 5 5 9 11 13 19 14 10 14 17 15 9 5 4 3 5 5 4 4 4 4 5 5 4 3 4 5 5 \n" + ] + } + ], + "source": [ + "for i in range(data.shape[0]):\n", + " for j in range(data.shape[1]):\n", + " print(int(data[i][j]), end=' ')\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "bc1b4e5e-52b5-462c-8fbf-e1ebaeca382f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
trainvalidationtest
0962415001743
1653411171150
25380840956
35211818890
\n", + "
" + ], + "text/plain": [ + " train validation test\n", + "0 9624 1500 1743\n", + "1 6534 1117 1150\n", + "2 5380 840 956\n", + "3 5211 818 890" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "534dd823-08b2-419f-bb83-10f211fc2533", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0db4e06f-4027-4e45-809c-b63a2cdfe15b", + "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 +}