├── CH_noisy_spectral.npy ├── CH_nonoise_spectral.npy ├── Demo_for_NNF.ipynb ├── Demo_for_training.ipynb └── FilterNet_utils.py /CH_noisy_spectral.npy: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:9fa2c3af8e8268af8d2a39012eac09f4c8f9199aa9bfd5e6fc29da27cc4ac2b1 3 | size 8888128 4 | -------------------------------------------------------------------------------- /CH_nonoise_spectral.npy: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:07034097a9d1569582d9f179828117fabdeb657b15dc63a56595f4ebfa2f342e 3 | size 8888128 4 | -------------------------------------------------------------------------------- /Demo_for_NNF.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "fc25cc64-ae15-41e0-a42f-f07a9309d5dd", 6 | "metadata": {}, 7 | "source": [ 8 | "# 用NNF进行滤波的一个展示" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "d85f2cde-8486-41b7-b828-79fe5e985c9f", 14 | "metadata": {}, 15 | "source": [ 16 | "# A demo for evaluting the NNF filtering performance" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 4, 22 | "id": "34417e42-3a16-4329-a100-075036f13984", 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "import numpy as np\n", 27 | "import torch\n", 28 | "import torch.nn as nn\n", 29 | "import torch.nn.functional as F\n", 30 | "#from torchsummary import summary\n", 31 | "import pickle\n", 32 | "import torch.utils.data as Data\n", 33 | "import matplotlib.pyplot as plt\n", 34 | "import numpy.fft as fft\n", 35 | "from FilterNet_utils import ConvBNReLU, pooling1d, global_average_pooling1d, Filter5, read_pickle_to_array, Data_set, training_1, \\\n", 36 | " training_2, array_to_tensor\n", 37 | "\n", 38 | "def compute_snr(pure_signal, noisy_signal): #SNR\n", 39 | " signal_to_noise_ratio = 10 * (np.log10(np.std(pure_signal)/np.std(pure_signal-noisy_signal)))\n", 40 | " return signal_to_noise_ratio\n", 41 | "\n", 42 | "def smoothing(array, threshold=0.5):\n", 43 | " anomaly_indices = np.where(array < threshold) #当条件成立时，where返回的是每个符合condition条件元素的坐标,返回的是以元组的形式\n", 44 | " array = np.delete(array, anomaly_indices)\n", 45 | " return array\n", 46 | "\n", 47 | "\n", 48 | "def smoothing_n_comparision(array, label, threshold=0.5):\n", 49 | " anomaly_indices = np.where(array < threshold)\n", 50 | " array = np.delete(array, anomaly_indices)\n", 51 | " label = np.delete(label, anomaly_indices)\n", 52 | " return array, label\n", 53 | "\n", 54 | "def fourier_transform(sample, mode=\"p\"):\n", 55 | " if mode == \"p\":\n", 56 | " N = len(sample) # 1111\n", 57 | " sample_ft = fft.fft(sample) # 信号的傅里叶变换 (复数)\n", 58 | " frequencies = fft.fftfreq(sample_ft.size, 1/N) # 傅里叶变换后的每种频率分量的频率值\n", 59 | " amplitude = np.abs(sample_ft) # 傅里叶变换的振幅\n", 60 | " p = 20*np.log10(amplitude)\n", 61 | " frequency = frequencies[frequencies > 0]\n", 62 | " p = p[frequencies > 0]\n", 63 | " return p, frequency\n", 64 | " elif mode == \"a\":\n", 65 | " N = len(sample) # 1111\n", 66 | " sample_ft = fft.fft(sample) # 信号的傅里叶变换 (复数)\n", 67 | " frequencies = fft.fftfreq(sample_ft.size, 1 / N) # 傅里叶变换后的每种频率分量的频率值\n", 68 | " amplitude = np.abs(sample_ft) # 傅里叶变换的振幅\n", 69 | " frequency = frequencies[frequencies > 0]\n", 70 | " amplitude = amplitude[frequencies > 0]\n", 71 | " return amplitude, frequency" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 6, 77 | "id": "553dfe65-180d-43c4-9ad8-3202e7985c0d", 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "name": "stdout", 82 | "output_type": "stream", 83 | "text": [ 84 | "input_data shape: (1000, 1111)\n", 85 | "CH4_noisy_spectral shape: (1000, 1111)\n", 86 | "CH4_noisy_spectral.shape torch.Size([1000, 1111])\n", 87 | "CH4_no_noise_spectral.shape torch.Size([1000, 1111])\n" 88 | ] 89 | } 90 | ], 91 | "source": [ 92 | "no_noise_path = r\"D:\\PYHTON\\python3.7\\DeepLearningProgram\\科研项目\\深度学习滤波器/CH_nonoise_spectral.npy\"\n", 93 | "CH4_no_noise_spectral = np.load(no_noise_path) # (1000, 1111) 透射谱（吸收谱）\n", 94 | "noisy_path = r\"D:\\PYHTON\\python3.7\\DeepLearningProgram\\科研项目\\深度学习滤波器/CH_noisy_spectral.npy\"\n", 95 | "CH4_noisy_spectral = np.load(noisy_path) # (1000, 1111) 透射谱（吸收谱）\n", 96 | "\n", 97 | "input_data = CH4_noisy_spectral\n", 98 | "label_data = CH4_no_noise_spectral\n", 99 | "# input_data = input_data[:, np.newaxis] # (1000,1,1111)，np.newaxis的作用就是增加一个新的维度\n", 100 | "\n", 101 | "print(\"input_data shape: \",input_data.shape)\n", 102 | "print(\"CH4_noisy_spectral shape: \",CH4_noisy_spectral.shape)\n", 103 | "\n", 104 | "\"\"\"转化为torch类型\"\"\"\n", 105 | "#input_data\n", 106 | "CH4_noisy_spectral = torch.from_numpy(input_data)\n", 107 | "CH4_noisy_spectral = CH4_noisy_spectral.type(torch.cuda.FloatTensor)\n", 108 | "#label_data\n", 109 | "CH4_no_noise_spectral = torch.from_numpy(label_data)\n", 110 | "CH4_no_noise_spectral = CH4_no_noise_spectral.type(torch.cuda.FloatTensor)\n", 111 | "\n", 112 | "print(\"CH4_noisy_spectral.shape\", CH4_noisy_spectral .shape)\n", 113 | "print(\"CH4_no_noise_spectral.shape\", CH4_no_noise_spectral.shape)\n", 114 | "\n", 115 | "\n", 116 | "#从样本总和中抽取几个\n", 117 | "\n", 118 | "sample3 = CH4_noisy_spectral[600]\n", 119 | "sample3 = sample3.reshape((1,1111))\n", 120 | "\n", 121 | "\n", 122 | "CH4_no_noise_spectral = np.squeeze(CH4_no_noise_spectral.cpu().numpy())\n", 123 | "Gpu = torch.device(\"cuda\")" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 10, 129 | "id": "2ec94e4e-f491-4f34-938c-db68a4d372e4", 130 | "metadata": {}, 131 | "outputs": [ 132 | { 133 | "data": { 134 | "text/plain": [ 135 | "Filter5(\n", 136 | " (fc1): Linear(in_features=1111, out_features=500, bias=True)\n", 137 | " (fc2): Linear(in_features=500, out_features=100, bias=True)\n", 138 | " (dropout1): Dropout(p=0.2, inplace=False)\n", 139 | " (fc3): Linear(in_features=100, out_features=1111, bias=True)\n", 140 | ")" 141 | ] 142 | }, 143 | "execution_count": 10, 144 | "metadata": {}, 145 | "output_type": "execute_result" 146 | } 147 | ], 148 | "source": [ 149 | "#加载模型\n", 150 | "Gpu = torch.device(\"cuda\")\n", 151 | "model = Filter5().to(Gpu)\n", 152 | "model_save_path = r\"D:\\PYHTON\\python3.7\\DeepLearningProgram\\科研项目\\深度学习滤波器\\滤波模型\\透射谱的滤波模型\\DNN_filter2.pt\"\n", 153 | "model.load_state_dict(torch.load(model_save_path))\n", 154 | "model.eval()" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 16, 160 | "id": "5ad9a64c-8900-4dca-9baa-188944bfdb71", 161 | "metadata": {}, 162 | "outputs": [ 163 | { 164 | "name": "stdout", 165 | "output_type": "stream", 166 | "text": [ 167 | "sample3.shape torch.Size([1, 1, 1, 1, 1, 1, 1111])\n", 168 | "restored31: (1111,)\n", 169 | "CH4_no_noise_spectral.shape (1111,)\n" 170 | ] 171 | }, 172 | { 173 | "data": { 174 | "image/png": "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\n", 175 | "text/plain": [ 176 | "
" 177 | ] 178 | }, 179 | "metadata": { 180 | "needs_background": "light" 181 | }, 182 | "output_type": "display_data" 183 | } 184 | ], 185 | "source": [ 186 | "sample3 = sample3.to(Gpu)\n", 187 | "print(\"sample3.shape\", sample3.shape)\n", 188 | "sample3 = torch.unsqueeze(sample3, 0)\n", 189 | "restored3 = model(sample3)\n", 190 | "restored3 = np.squeeze(restored3.cpu().detach().numpy())\n", 191 | "\n", 192 | "print(\"restored31:\",restored3.shape)#(1111,)\n", 193 | "pure_signal = CH4_no_noise_spectral[600]\n", 194 | "print(\"CH4_no_noise_spectral.shape\", pure_signal.shape)\n", 195 | "\n", 196 | "restored3 = smoothing(restored3)\n", 197 | "\n", 198 | "#第二张图片\n", 199 | "plt.figure(figsize=(9,7))\n", 200 | "x_list = np.arange(6046.4, 6047.5, (6047.5 - 6046.4) / 1111)\n", 201 | "x_list1 = np.arange(6046.4, 6047.5, 0.1)\n", 202 | "plt.title(\"sample prediction signal\")\n", 203 | "plt.plot(x_list, np.squeeze(sample3.cpu().detach().numpy()))\n", 204 | "plt.plot(x_list,restored3,label=\"sample3\", linewidth=3)\n", 205 | "plt.xticks(x_list1, rotation=60)\n", 206 | "plt.xlabel('wavenumber')\n", 207 | "plt.ylabel('Transmission')\n", 208 | "plt.legend()\n", 209 | "plt.show()" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": null, 215 | "id": "cef59628-d965-48ce-9390-78ed5f98a122", 216 | "metadata": {}, 217 | "outputs": [], 218 | "source": [] 219 | } 220 | ], 221 | "metadata": { 222 | "kernelspec": { 223 | "display_name": "Python 3 (ipykernel)", 224 | "language": "python", 225 | "name": "python3" 226 | }, 227 | "language_info": { 228 | "codemirror_mode": { 229 | "name": "ipython", 230 | "version": 3 231 | }, 232 | "file_extension": ".py", 233 | "mimetype": "text/x-python", 234 | "name": "python", 235 | "nbconvert_exporter": "python", 236 | "pygments_lexer": "ipython3", 237 | "version": "3.7.4" 238 | } 239 | }, 240 | "nbformat": 4, 241 | "nbformat_minor": 5 242 | } 243 | -------------------------------------------------------------------------------- /FilterNet_utils.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | from torchsummary import summary 5 | import numpy as np 6 | import torch 7 | import pickle 8 | import torch.utils.data as Data 9 | import torch.optim.lr_scheduler as lr_scheduler 10 | import matplotlib.pyplot as plt 11 | 12 | 13 | def array_to_tensor(array): 14 | tensor = torch.from_numpy(array) 15 | tensor = tensor.type(torch.cuda.FloatTensor) 16 | return tensor 17 | 18 | 19 | def ConvBNReLU(in_channels, out_channels, kernel_size, stride): 20 | """ 21 | 自定义包括BN ReLU的卷积层，输入(N,in_channels,in_Length) 22 | 输出(N, out_channels, out_Length)，卷积后进行批归一化， 23 | 然后进行RELU激活。 24 | :param in_channels: 输入张量的通道数 25 | :param out_channels: 输出张量的通道数 26 | :param kernel_size: 卷积核尺寸 27 | :param stride: 卷积核滑动步长 28 | :return: BN RELU后的卷积输出 29 | """ 30 | return nn.Sequential( 31 | nn.Conv1d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride), 32 | nn.BatchNorm1d(out_channels), 33 | nn.ReLU() 34 | ) 35 | 36 | 37 | def pooling1d(input_tensor, kernel_size=3, stride=2): 38 | """ 39 | 最大池化函数，输入形如(N, Channels, Length), 40 | 输出形如(N, Channels, Length)的功能。 41 | :param input_tensor:要被最大池化的输入张量 42 | :param kernel_size:池化尺寸。在多大尺寸内进行最大池化操作 43 | :param stride:池化层滑动补偿 44 | :return:池化后输出张量 45 | """ 46 | result = F.max_pool1d(input_tensor, kernel_size=kernel_size, stride=stride) 47 | return result 48 | 49 | 50 | def average_pool1d(input_tensor, kernel_size=3, stride=2): 51 | result = F.avg_pool1d(input_tensor, kernel_size=kernel_size, stride=stride) 52 | return result 53 | 54 | 55 | def global_average_pooling1d(input_tensor, output_size=1): 56 | """ 57 | 全局平均池化函数，将length压缩成output_size。 58 | 输入(N, C, Input_size) 59 | 输出(N, C, output_size) 60 | :param input_tensor: 输入张量 61 | :param output_size: 输出张量 62 | :return:全剧平均池化输出 63 | """ 64 | result = F.adaptive_max_pool1d(input_tensor, output_size) 65 | return result 66 | 67 | 68 | class Filter(nn.Module): 69 | """ 70 | 神经网络滤波器 71 | input - Conv1 - Maxpool - Conv2 - Maxpool - Conv3 - Maxpool - Conv4 - Conv5 - Globaverg 72 | (1, 2000) - (10, 999) - (10, 498)- (100, 248) - (100, 122) - (500, 60) - (500, 29) - (1000, 14)-(2000, 6)-(2000,1) 73 | """ 74 | def __init__(self): 75 | super(Filter, self).__init__() 76 | self.conv1 = ConvBNReLU(in_channels=1, out_channels=10, kernel_size=7, stride=2) 77 | self.conv2 = ConvBNReLU(in_channels=10, out_channels=100, kernel_size=7, stride=2) 78 | self.conv3 = ConvBNReLU(in_channels=100, out_channels=500, kernel_size=7, stride=2) 79 | self.conv4 = ConvBNReLU(in_channels=500, out_channels=1000, kernel_size=7, stride=2) 80 | self.conv5 = ConvBNReLU(in_channels=1000, out_channels=2000, kernel_size=7, stride=2) 81 | self.globavgpool1 = nn.AdaptiveAvgPool1d(output_size=1) 82 | 83 | def forward(self, x): 84 | x = pooling1d(self.conv1(x)) 85 | x = pooling1d(self.conv2(x)) 86 | x = pooling1d(self.conv3(x)) 87 | x = self.conv4(x) 88 | x = self.conv5(x) 89 | out = self.globavgpool1(x) 90 | return out 91 | 92 | 93 | class Filter2(nn.Module): 94 | """ 95 | 神经网络滤波器 96 | input - Conv1 - Maxpool - Conv2 - Maxpool - Conv3 - Maxpool - Conv4 - Conv5 - Globaverg 97 | (1, 2000) - (10, 997) - (10, 498)- (100, 248) - (100, 122) - (500, 60) - (500, 29) - (1000, 14)-(2000, 6)-(2000,1) 98 | """ 99 | def __init__(self): 100 | super(Filter2, self).__init__() 101 | self.conv1 = ConvBNReLU(in_channels=1, out_channels=10, kernel_size=32, stride=2) 102 | self.maxpool1 = nn.AvgPool1d(kernel_size=10, stride=2) 103 | self.conv2 = ConvBNReLU(in_channels=10, out_channels=50, kernel_size=16, stride=2) 104 | self.maxpool2 = nn.AvgPool1d(kernel_size=5, stride=2) 105 | self.conv3 = ConvBNReLU(in_channels=50, out_channels=100, kernel_size=8, stride=2) 106 | self.maxpool3 = nn.AvgPool1d(kernel_size=3, stride=2) 107 | self.fc1 = nn.Linear(in_features=117*50, out_features=2000) 108 | # self.fc2 = nn.Linear(in_features=4000, out_features=2000) 109 | 110 | def forward(self, x): 111 | x = self.conv1(x) 112 | x = self.maxpool1(x) 113 | x = self.conv2(x) 114 | x = self.maxpool2(x) 115 | x = x.view(-1, self.flatten_features(x)) 116 | x = self.fc1(x) 117 | # x = F.relu(x) 118 | # x = self.fc2(x) 119 | x = x.unsqueeze(-1) 120 | return x 121 | 122 | @staticmethod 123 | def flatten_features(x): 124 | size = x.size()[1:] 125 | num_features = 1 126 | for s in size: 127 | num_features *= s 128 | return num_features 129 | 130 | 131 | class Filter3(nn.Module): 132 | """ 133 | 神经网络滤波器 134 | input - Conv1 - Maxpool - Conv2 - Maxpool - Conv3 - Maxpool - Conv4 - Conv5 - Globaverg 135 | (1, 2000) - (10, 997) - (10, 498)- (100, 248) - (100, 122) - (500, 60) - (500, 29) - (1000, 14)-(2000, 6)-(2000,1) 136 | """ 137 | def __init__(self): 138 | super(Filter3, self).__init__() 139 | self.conv1 = ConvBNReLU(in_channels=1, out_channels=10, kernel_size=32, stride=2) 140 | self.maxpool1 = nn.MaxPool1d(kernel_size=10, stride=2) 141 | self.conv2 = ConvBNReLU(in_channels=10, out_channels=50, kernel_size=16, stride=2) 142 | self.maxpool2 = nn.MaxPool1d(kernel_size=5, stride=2) 143 | self.conv3 = ConvBNReLU(in_channels=50, out_channels=100, kernel_size=8, stride=2) 144 | self.maxpool3 = nn.MaxPool1d(kernel_size=3, stride=2) 145 | self.fc1 = nn.Linear(in_features=2700, out_features=2000) 146 | # self.fc2 = nn.Linear(in_features=4000, out_features=2000) 147 | 148 | def forward(self, x): 149 | x = self.conv1(x) 150 | x = self.maxpool1(x) 151 | x = self.conv2(x) 152 | x = self.maxpool2(x) 153 | x = self.conv3(x) 154 | x = self.maxpool3(x) 155 | x = x.view(-1, self.flatten_features(x)) 156 | x = self.fc1(x) 157 | x = F.relu(x) 158 | # x = x.unsqueeze(-1) 159 | return x 160 | 161 | @staticmethod 162 | def flatten_features(x): 163 | size = x.size()[1:] 164 | num_features = 1 165 | for s in size: 166 | num_features *= s 167 | return num_features 168 | 169 | 170 | class Filter6(nn.Module): 171 | 172 | def __init__(self): 173 | super(Filter, self).__init__() 174 | self.conv1 = ConvBNReLU(in_channels=1, out_channels=10, kernel_size=3, stride=2) 175 | self.conv2 = ConvBNReLU(in_channels=10, out_channels=100, kernel_size=3, stride=2) 176 | self.conv3 = ConvBNReLU(in_channels=100, out_channels=500, kernel_size=3, stride=2) 177 | self.conv4 = ConvBNReLU(in_channels=500, out_channels=1111, kernel_size=3, stride=2) 178 | # self.fc1 = nn.Linear(in_features=1111, out_features=1111) 179 | # self.conv5 = ConvBNReLU(in_channels=1000, out_channels=2000, kernel_size=3, stride=2) 180 | self.globavgpool1 = nn.AdaptiveAvgPool1d(output_size=1) 181 | 182 | def forward(self, x): 183 | x = pooling1d(self.conv1(x)) 184 | x = pooling1d(self.conv2(x)) 185 | x = pooling1d(self.conv3(x)) 186 | x = self.conv4(x) 187 | # x=x.view(-1,1111) 188 | # x=self.fc1(x) 189 | out = self.globavgpool1(x) 190 | # x = self.conv5(x) 191 | 192 | # print(out.shape) 193 | return out 194 | 195 | 196 | 197 | 198 | class Filter4(nn.Module): # 否决了。全连接就算只有四层参数也太多了 199 | """ 200 | 神经网络滤波器 201 | input - Conv1 - Maxpool - Conv2 - Maxpool - Conv3 - Maxpool - Conv4 - Conv5 - Globaverg 202 | (1, 2000) - (10, 997) - (10, 498)- (100, 248) - (100, 122) - (500, 60) - (500, 29) - (1000, 14)-(2000, 6)-(2000,1) 203 | """ 204 | def __init__(self): 205 | super(Filter4, self).__init__() 206 | self.fc1 = nn.Linear(in_features=2000, out_features=500) 207 | self.fc2 = nn.Linear(in_features=500, out_features=500) 208 | self.dropout1 = nn.Dropout(p=0.2) 209 | self.fc3 = nn.Linear(in_features=500, out_features=2000) 210 | 211 | def forward(self, x): 212 | x = self.fc1(x) 213 | x = F.relu(x) 214 | x = self.fc2(x) 215 | x = F.relu(x) 216 | x = self.dropout1(x) 217 | x = self.fc3(x) 218 | x = F.relu(x) 219 | return x 220 | 221 | @staticmethod 222 | def flatten_features(x): 223 | size = x.size()[1:] 224 | num_features = 1 225 | for s in size: 226 | num_features *= s 227 | return num_features 228 | 229 | 230 | class Filter5(nn.Module): # 三层 hidden layer 效果好像很不错的亚子 2000-500-100-2000 231 | """ 232 | 神经网络滤波器 233 | input - Conv1 - Maxpool - Conv2 - Maxpool - Conv3 - Maxpool - Conv4 - Conv5 - Globaverg 234 | (1, 2000) - (10, 997) - (10, 498)- (100, 248) - (100, 122) - (500, 60) - (500, 29) - (1000, 14)-(2000, 6)-(2000,1) 235 | """ 236 | def __init__(self): 237 | super(Filter5, self).__init__() 238 | self.fc1 = nn.Linear(in_features=2000, out_features=500) 239 | self.fc2 = nn.Linear(in_features=500, out_features=100) 240 | self.dropout1 = nn.Dropout(p=0.2) 241 | self.fc3 = nn.Linear(in_features=100, out_features=2000) 242 | 243 | def forward(self, x): 244 | x = self.fc1(x) 245 | x = F.relu(x) 246 | x = self.fc2(x) 247 | x = F.relu(x) 248 | x = self.dropout1(x) 249 | x = self.fc3(x) 250 | x = F.relu(x) 251 | return x 252 | 253 | 254 | def read_pickle_to_array(path, name): 255 | """ 256 | 读取二进制文件并创建为np array类型 257 | :param path: 读取文件的路径 258 | :param name: 读取文件的文件名 259 | :return: ndarray类型的数据 260 | """ 261 | file = open(path + name, "rb") 262 | array = pickle.load(file) 263 | array = np.array(array) 264 | return array 265 | 266 | 267 | def Data_set(input_data, label_data, batch_size): 268 | """ 269 | 生成data_loader实例。可以定义batch_size 270 | :param input_data: 希望作为训练input的数据，tensor类型 271 | :param label_data: 希望作为训练label的数据，tensor类型 272 | :param batch_size: batch size 273 | :return: data_loader实例 274 | """ 275 | data_set = Data.TensorDataset(input_data, label_data) 276 | data_loader = Data.DataLoader(dataset=data_set, 277 | shuffle=True, 278 | batch_size=batch_size, 279 | num_workers=0) 280 | return data_loader 281 | 282 | 283 | def training_1(model, train_loader, test_x, test_y, device, optimizer, criterion, epochs, plot_ch4, plot_label, 284 | adjust=False, plot=False): 285 | """ 286 | 训练模型，输入模型，数据集，GPU设备，选择的优化器以及损失函数，在设置的epoch内进行模型优化。 287 | adjust开启时将根据epoch自适应的调整learning rate。 288 | 只有当adjust开启时，plot才能开启。否则plot功能永远关闭。 289 | plot开启时，将绘制输入的plot_ch4以及plot_label。每一代之后根据更新优化的参数，模型计算plot_ch4，并绘制输出与plot_label进行 290 | 对比 291 | 与training 2不用，1需要输入测试集，可以计算测试误差。 292 | :param model: 输入的训练模型, untrained model 293 | :param train_loader: 输入的训练数据集 294 | :param test_x: using for compute test error 295 | :param test_y: same as above 296 | :param device: GPU or cpu 297 | :param optimizer: the chosen optimizer 298 | :param criterion: the loss function 299 | :param epochs: iteration running on models 300 | :param plot_ch4: a sample chosen from dataset to be computed and plotted 301 | :param plot_label: a sample label chosen from dataset to be plotted 302 | :param adjust: adaptive learning rate along with epochs when switch to True 303 | :param plot: only adjust = True will switch on. 304 | :return: trained loss & test loss 305 | """ 306 | model.train() 307 | model.to(device) 308 | iteration_loss_list = [] 309 | test_error_list = [] 310 | if adjust is False: 311 | for e in range(epochs): 312 | for index, (batch_x, batch_y) in enumerate(train_loader): 313 | batch_x = batch_x.to(device) 314 | batch_y = batch_y.to(device) 315 | test_x = test_x.to(device) 316 | test_y = test_y.to(device) 317 | optimizer.zero_grad() 318 | prediction1 = model(batch_x) 319 | prediction2 = model(test_x) 320 | loss = criterion(prediction1, batch_y) 321 | iteration_loss_list.append(float(loss)) 322 | test_error = criterion(prediction2, test_y) 323 | test_error_list.append(float(test_error)) 324 | loss.backward() 325 | optimizer.step() 326 | print("epoch: {} [{}/{} {:.2f}%] train loss: {} test loss: {}".format(e, index*len(batch_x), 327 | len(train_loader.dataset), 328 | 100*index/len(train_loader), 329 | loss.item(), test_error.item()) 330 | ) 331 | # epoch_loss_list.append(loss) 332 | 333 | elif adjust is True: 334 | schuduler = lr_scheduler.StepLR(optimizer, step_size=1000, gamma=0.1) 335 | if plot is True: 336 | plt.figure() 337 | plt.ion() 338 | plt.show() 339 | for e in range(epochs): 340 | for index, (batch_x, batch_y) in enumerate(train_loader): 341 | batch_x = batch_x.to(device) 342 | batch_y = batch_y.to(device) 343 | test_x = test_x.to(device) 344 | test_y = test_y.to(device) 345 | optimizer.zero_grad() 346 | prediction1 = model(batch_x) 347 | prediction2 = model(test_x) 348 | loss = criterion(prediction1, batch_y) 349 | iteration_loss_list.append(float(loss)) 350 | test_error = criterion(prediction2, test_y) 351 | test_error_list.append(float(test_error)) 352 | loss.backward() 353 | optimizer.step() 354 | schuduler.step() 355 | print("epoch: {} [{}/{} {:.2f}%] train loss: {} test loss: {}".format(e, index * len(batch_x), 356 | len(train_loader.dataset), 357 | 100 * index / len( 358 | train_loader), 359 | loss.item(), test_error.item()) 360 | ) 361 | sample = plot_ch4[9999] 362 | sample = sample.reshape((1, 1, 2000)) 363 | sample = array_to_tensor(sample) 364 | plot_prediction = model(sample) 365 | plot_prediction = np.squeeze(plot_prediction.cpu().detach().numpy()) 366 | CH4_label = np.squeeze(plot_label) 367 | plt.cla() 368 | plt.plot(CH4_label[9999]) 369 | plt.plot(plot_prediction) 370 | plt.pause(0.1) 371 | plt.ioff() 372 | plt.show() 373 | return iteration_loss_list, test_error_list # , epoch_loss_list 374 | 375 | 376 | def training_2(model, train_loader, device, optimizer, criterion, epochs, plot_ch4, plot_label, 377 | adjust=False, plot=False): 378 | """ 379 | 训练模型，输入模型，数据集，GPU设备，选择的优化器以及损失函数，在设置的epoch内进行模型优化。 380 | adjust开启时将根据epoch自适应的调整learning rate。 381 | 只有当adjust开启时，plot才能开启。否则plot功能永远关闭。 382 | plot开启时，将绘制输入的plot_ch4以及plot_label。每一代之后根据更新优化的参数，模型计算plot_ch4，并绘制输出与plot_label进行 383 | 对比 384 | :param model: 输入的训练模型, untrained model 385 | :param train_loader: 输入的训练数据集 386 | :param test_x: using for compute test error 387 | :param optimizer: the chosen optimizer 388 | :param criterion: the loss function 389 | :param epochs: iteration running on models 390 | :param plot_ch4: a sample chosen from dataset to be computed and plotted 391 | :param plot_label: a sample label chosen from dataset to be plotted 392 | :param adjust: adaptive learning rate along with epochs when switch to True 393 | :param plot: only adjust = True will switch on. 394 | :return: trained loss & test loss 395 | """ 396 | model.train() 397 | model.to(device) 398 | iteration_loss_list = [] 399 | if adjust is False: 400 | for e in range(epochs): 401 | for index, (batch_x, batch_y) in enumerate(train_loader): 402 | batch_x = batch_x.to(device) 403 | batch_y = batch_y.to(device) 404 | optimizer.zero_grad() 405 | prediction1 = model(batch_x) 406 | loss = criterion(prediction1, batch_y) 407 | iteration_loss_list.append(float(loss)) 408 | loss.backward() 409 | optimizer.step() 410 | print("epoch: {} [{}/{} {:.2f}%] train loss: {}".format(e, index*len(batch_x), 411 | len(train_loader.dataset), 412 | 100*index/len(train_loader), 413 | loss.item()) 414 | ) 415 | # epoch_loss_list.append(loss) 416 | 417 | elif adjust is True: 418 | schuduler = lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.1) 419 | if plot is True: 420 | plt.figure() 421 | plt.ion() 422 | plt.show() 423 | for e in range(epochs): 424 | for index, (batch_x, batch_y) in enumerate(train_loader): 425 | batch_x = batch_x.to(device) 426 | batch_y = batch_y.to(device) 427 | optimizer.zero_grad() 428 | prediction1 = model(batch_x) 429 | loss = criterion(prediction1, batch_y) 430 | iteration_loss_list.append(float(loss)) 431 | loss.backward() 432 | optimizer.step() 433 | schuduler.step() 434 | print("epoch: {} [{}/{} {:.2f}%] train loss: {}".format(e, index * len(batch_x), 435 | len(train_loader.dataset), 436 | 100 * index / len(train_loader), 437 | loss.item()) 438 | ) 439 | sample = plot_ch4[9999] 440 | sample = sample.reshape((1, 1, 2000)) 441 | plot_prediction = model(sample) 442 | plot_prediction = np.squeeze(plot_prediction.cpu().detach().numpy()) 443 | CH4_label = np.squeeze(plot_label.cpu().numpy()) 444 | plt.cla() 445 | plt.plot(CH4_label[9999]) 446 | plt.plot(plot_prediction) 447 | plt.pause(0.1) 448 | plt.ioff() 449 | plt.show() 450 | return iteration_loss_list # , epoch_loss_list 451 | 452 | 453 | if __name__ == "__main__": 454 | 455 | Gpu = torch.device("cuda") 456 | Cpu = torch.device("cpu") 457 | filter_net = Filter4().to(Gpu) # 模型加载到GPU上 458 | print(filter_net) # torch的print(model)只能打印层的细节，不包括每层的输出维度 有点遗憾 459 | summary(filter_net, (1, 2000)) # summary()很像keras的model.summary() 460 | # x = torch.randn((2, 2000)) 461 | # y = filter_net(x) 462 | # print(y.shape) --------------------------------------------------------------------------------