sdnet

2. from __future__ import absolute_import
3. from __future__ import division
4. from __future__ import print_function
6. import math
7. import numpy as np
9. import torch
10. import torch.nn as nn
11. import torch._utils
12. import torch.nn.functional as F
13. import torch.nn.init as init
14. import torch.optim as optim
15. from Lib.config import config
16. import random
17. import scipy.io as scio
18. from torch.utils.data import TensorDataset, DataLoader
19. import csv
20. import matplotlib.pyplot as plt
22. #  定义一个3x3卷积！kernel_initializer='he_normal','glorot_normal'
23. def regularized_padded_conv(in_channels, out_channels, kernel_size, stride=1):
24.     conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding=kernel_size // 2, bias=False)
25.     # 使用 kaiming_normal_ 进行初始化
26.     nn.init.kaiming_normal_(conv.weight, mode='fan_out', nonlinearity='leaky_relu')
27.     return conv
30. ####################### 通道注意力机制 ##########################
31. class ChannelAttention(nn.Module):
32.     def __init__(self, in_planes, ratio=16):
33.         super(ChannelAttention, self).__init__()
34.         self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
35.         self.max_pool = nn.AdaptiveMaxPool2d((1, 1))
36.         compressed_channels = in_planes // ratio
37.         self.conv1 = nn.Conv2d(in_planes, compressed_channels, kernel_size=1, stride=1, padding=0)
38.         self.conv2 = nn.Conv2d(compressed_channels, in_planes, kernel_size=1, stride=1, padding=0)
39.         self.leaky_relu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
41.     def forward(self, inputs):
42.         avg = self.avg_pool(inputs)
43.         max = self.max_pool(inputs)
44.         avg = self.conv2(self.leaky_relu(self.conv1(avg)))
45.         max = self.conv2(self.leaky_relu(self.conv1(max)))
46.         out = avg + max
47.         out = torch.sigmoid(out)
48.         return out
51. ########################### 空间注意力机制 ###########################
52. class SpatialAttention(nn.Module):
53.     def __init__(self, kernel_size=7):
54.         super(SpatialAttention, self).__init__()
55.         self.conv1 = regularized_padded_conv(2, 1, kernel_size, stride=1)
56.         self.sigmoid = nn.Sigmoid()
57.         self.leaky_relu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
59.     def forward(self, inputs):
60.         avg_out = torch.mean(inputs, dim=1, keepdim=True)
61.         max_out, _ = torch.max(inputs, dim=1, keepdim=True)
62.         out = torch.cat([avg_out, max_out], dim=1)
63.         out = self.conv1(out)
64.         out = self.sigmoid(out)
65.         return out
68. ####################################csc layer###########################################################
69. class elasnet_prox(nn.Module):
70.     r"""Applies the elastic net proximal operator,
71.     NOTS: it will degenerate to ell1_prox if mu=0.0
73.     The elastic net proximal operator function is given as the following function
74.     \argmin_{x} \lambda ||x||_1 + \mu /2 ||x||_2^2 + 0.5 ||x - input||_2^2
76.     Args:
77.       lambd: the :math:`\lambda` value on the ell_1 penalty term. Default: 0.5
78.       mu:    the :math:`\mu` value on the ell_2 penalty term. Default: 0.0
80.     Shape:
81.       - Input: :math:`(N, *)` where `*` means, any number of additional
82.         dimensions
83.       - Output: :math:`(N, *)`, same shape as the input
85.     """
87.     def __init__(self, lambd=0.5, mu=0.0):
88.         super(elasnet_prox, self).__init__()
89.         self.lambd = lambd
90.         self.scaling_mu = 1.0 / (1.0 + mu)
92.     def forward(self, input):
93.         return F.softshrink(input * self.scaling_mu, self.lambd * self.scaling_mu)
95.     def extra_repr(self):
96.         return '{} {}'.format(self.lambd, self.scaling_mu)
99. class DictBlock(nn.Module):
100.     # c = argmin_c lmbd * ||c||_1  +  mu/2 * ||c||_2^2 + 1 / 2 * ||x - weight (@conv) c||_2^2
101.     def __init__(self, n_channel, dict_size, mu=0.0, lmbd=0.0, n_dict=1, non_negative=True,
102.                  stride=1, kernel_size=3, padding=1, share_weight=True, square_noise=True,
103.                  n_steps=10, step_size_fixed=True, step_size=0.1, w_norm=True,
104.                  padding_mode="constant"):
105.         super(DictBlock, self).__init__()
107.         self.mu = mu
108.         self.lmbd = lmbd  # LAMBDA
109.         self.n_dict = n_dict
110.         self.stride = stride
111.         self.kernel_size = (kernel_size, kernel_size)
112.         self.padding = padding
113.         self.padding_mode = padding_mode
114.         assert self.padding_mode in ['constant', 'reflect', 'replicate', 'circular']
115.         self.groups = 1
116.         self.n_steps = n_steps
117.         self.conv_transpose_output_padding = 0 if stride == 1 else 1
118.         self.w_norm = w_norm
119.         self.non_negative = non_negative
120.         self.v_max = None
121.         self.v_max_error = 0.
122.         self.xsize = None
123.         self.zsize = None
124.         self.lmbd_ = None
125.         self.square_noise = square_noise
127.         self.weight = nn.Parameter(torch.Tensor(dict_size, self.n_dict * n_channel, kernel_size, kernel_size))
129.         with torch.no_grad():
130.             init.kaiming_uniform_(self.weight)
132.         self.nonlinear = elasnet_prox(self.lmbd * step_size, self.mu * step_size)
134.         self.register_buffer('step_size', torch.tensor(step_size, dtype=torch.float))
136.     def fista_forward(self, x):
138.         for i in range(self.n_steps):
140.             weight = self.weight
141.             step_size = self.step_size
143.             if i == 0:
144.                 c_pre = 0.
146.                 c = step_size * F.conv2d(x.repeat(1, self.n_dict, 1, 1), weight, bias=None, stride=self.stride,
147.                                          padding=self.padding)
149.                 c = self.nonlinear(c)
150.             elif i == 1:
151.                 c_pre = c
152.                 xp = F.conv_transpose2d(c, weight, bias=None, stride=self.stride, padding=self.padding,
153.                                         output_padding=self.conv_transpose_output_padding)
154.                 r = x.repeat(1, self.n_dict, 1, 1) - xp
156.                 if self.square_noise:
157.                     gra = F.conv2d(r, weight, bias=None, stride=self.stride, padding=self.padding)
158.                 else:
159.                     w = r.view(r.size(0), -1)
160.                     normw = w.norm(p=2, dim=1, keepdim=True).clamp_min(1e-12).expand_as(w).detach()
161.                     w = (w / normw).view(r.size())
163.                     gra = F.conv2d(w, weight, bias=None, stride=self.stride, padding=self.padding) * 0.5
165.                 c = c + step_size * gra
166.                 c = self.nonlinear(c)
167.                 t = (math.sqrt(5.0) + 1.0) / 2.0
168.             else:
169.                 t_pre = t
170.                 t = (math.sqrt(1.0 + 4.0 * t_pre * t_pre) + 1) / 2.0
171.                 a = (t_pre + t - 1.0) / t * c + (1.0 - t_pre) / t * c_pre
172.                 c_pre = c
173.                 xp = F.conv_transpose2d(c, weight, bias=None, stride=self.stride, padding=self.padding,
174.                                         output_padding=self.conv_transpose_output_padding)
175.                 r = x.repeat(1, self.n_dict, 1, 1) - xp
177.                 if self.square_noise:
178.                     gra = F.conv2d(r, weight, bias=None, stride=self.stride, padding=self.padding)
179.                 else:
180.                     w = r.view(r.size(0), -1)
181.                     normw = w.norm(p=2, dim=1, keepdim=True).clamp_min(1e-12).expand_as(w).detach()
182.                     w = (w / normw).view(r.size())
184.                     gra = F.conv2d(w, weight, bias=None, stride=self.stride, padding=self.padding) * 0.5
186.                 c = a + step_size * gra
187.                 c = self.nonlinear(c)
189.             if self.non_negative:
190.                 c = F.leaky_relu(c, negative_slope=0.1)
192.         return c, weight
194.     def forward(self, x):
196.         if self.xsize is None:
197.             self.xsize = (x.size(-3), x.size(-2), x.size(-1))
198.             print(self.xsize)
199.         else:
200.             assert self.xsize[-3] == x.size(-3) and self.xsize[-2] == x.size(-2) and self.xsize[-1] == x.size(-1)
202.         if self.w_norm:
203.             self.normalize_weight()
205.         c, weight = self.fista_forward(x)
207.         # Compute loss
208.         xp = F.conv_transpose2d(c, weight, bias=None, stride=self.stride, padding=self.padding,
209.                                 output_padding=self.conv_transpose_output_padding)
210.         r = x.repeat(1, self.n_dict, 1, 1) - xp
211.         r_loss = torch.sum(torch.pow(r, 2)) / self.n_dict
212.         c_loss = self.lmbd * torch.sum(torch.abs(c)) + self.mu / 2. * torch.sum(torch.pow(c, 2))
214.         if self.zsize is None:
215.             self.zsize = (c.size(-3), c.size(-2), c.size(-1))
216.             print(self.zsize)
217.         else:
218.             assert self.zsize[-3] == c.size(-3) and self.zsize[-2] == c.size(-2) and self.zsize[-1] == c.size(-1)
220.         if self.lmbd_ is None and config.MODEL.ADAPTIVELAMBDA:
221.             self.lmbd_ = self.lmbd * self.xsize[-3] * self.xsize[-2] * self.xsize[-1] / (
222.                         self.zsize[-3] * self.zsize[-2] * self.zsize[-1])
223.             self.lmbd = self.lmbd_
224.             print("======")
225.             print("xsize", self.xsize)
226.             print("zsize", self.zsize)
227.             print("new lmbd: ", self.lmbd)
229.         return c, (r_loss, c_loss)
231.     def update_stepsize(self):
232.         step_size = 0.9 / self.power_iteration(self.weight)
233.         self.step_size = self.step_size * 0. + step_size
234.         self.nonlinear.lambd = self.lmbd * step_size
235.         self.nonlinear.scaling_mu = 1.0 / (1.0 + self.mu * step_size)
237.     def normalize_weight(self):
238.         with torch.no_grad():
239.             w = self.weight.view(self.weight.size(0), -1)
240.             normw = w.norm(p=2, dim=1, keepdim=True).clamp_min(1e-12).expand_as(w)
241.             w = (w / normw).view(self.weight.size())
242.             self.weight.data = w.data
244.     def power_iteration(self, weight):
246.         max_iteration = 50
247.         v_max_error = 1.0e5
248.         tol = 1.0e-5
249.         k = 0
251.         with torch.no_grad():
252.             if self.v_max is None:
253.                 c = weight.shape[0]
254.                 v = torch.randn(size=(1, c, self.zsize[-2], self.zsize[-1])).to(weight.device)
255.             else:
256.                 v = self.v_max.clone()
258.             while k < max_iteration and v_max_error > tol:
259.                 tmp = F.conv_transpose2d(
260.                     v, weight, bias=None, stride=self.stride, padding=self.padding,
261.                     output_padding=self.conv_transpose_output_padding
262.                 )
263.                 v_ = F.conv2d(tmp, weight, bias=None, stride=self.stride, padding=self.padding)
264.                 v_ = F.normalize(v_.view(-1), dim=0, p=2).view(v.size())
265.                 v_max_error = torch.sum((v_ - v) ** 2)
266.                 k += 1
267.                 v = v_
269.             v_max = v.clone()
270.             Dv_max = F.conv_transpose2d(
271.                 v_max, weight, bias=None, stride=self.stride, padding=self.padding,
272.                 output_padding=self.conv_transpose_output_padding
273.             )  # Dv
275.             lambda_max = torch.sum(Dv_max ** 2).item()  # vTDTDv / vTv, ignore the vTv since vTv = 1
277.         self.v_max = v_max
278.         return lambda_max
281. ################################# SDNet ################################################################
282. from Lib.config import config as _cfg
284. cfg = _cfg
286. class DictConv2d(nn.Module):
287.     def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=True):
288.         super(DictConv2d, self).__init__()
290.         self.dn = DictBlock(
291.             in_channels, out_channels, stride=stride, kernel_size=kernel_size, padding=padding,
292.             mu=cfg['MODEL']['MU'], lmbd=cfg['MODEL']['LAMBDA'][0], square_noise=cfg['MODEL']['SQUARE_NOISE'],
293.             n_dict=cfg['MODEL']['EXPANSION_FACTOR'], non_negative=cfg['MODEL']['NONEGATIVE'],
294.             n_steps=cfg['MODEL']['NUM_LAYERS'], w_norm=cfg['MODEL']['WNORM']
295.         )
297.         self.rc = None
298.         self.r_loss = []
300.     def get_rc(self):
301.         if self.rc is None:
302.             raise ValueError("should call forward first.")
303.         else:
304.             return self.rc
306.     def forward(self, x):
307.         out, rc = self.dn(x)
308.         self.rc = rc
310.         if self.training is False:
311.             self.r_loss.extend([self.rc[0].item() / len(x)] * len(x))
313.         return out
316. #########模型构建###############
317. class SDNet_model(nn.Module):
318.     def __init__(self, dropout1, dropout2, num_classes=2):
319.         super(SDNet_model, self).__init__()
320.         #  self.layer0 = nn.Sequential(
321.         #      DictConv2d(1, 64, kernel_size=3, stride=1, padding=1, bias=False),
322.         #      nn.BatchNorm2d(64),
323.         #      nn.ReLU(inplace=True),
324.         #  )
325.         self.conv0 = nn.Conv2d(1, 64, kernel_size=(3, 3), padding=(1, 1))
326.         self.bn0 = nn.BatchNorm2d(64)
327.         self.pool0 = nn.MaxPool2d(kernel_size=(2, 2))
328.         self.conv1 = nn.Conv2d(64, 128, kernel_size=(3, 3), padding=(1, 1))
329.         self.bn1 = nn.BatchNorm2d(128)
330.         self.pool1 = nn.MaxPool2d(kernel_size=(2, 2))
331.         self.dropout1 = nn.Dropout2d(p=dropout1)
333.         self.layer0 = nn.Sequential(
334.             DictConv2d(128, 256, kernel_size=3, stride=1, padding=1, bias=False),
335.             nn.BatchNorm2d(256),
336.             nn.LeakyReLU(inplace=True),
337.         )
338.         self.conv2 = nn.Conv2d(256, 256, kernel_size=(3, 3), padding=(1, 1))
339.         self.bn2 = nn.BatchNorm2d(256)
340.         self.ca = ChannelAttention(256)
341.         self.sa = SpatialAttention()
342.         self.conv3 = nn.Conv2d(256, 256, kernel_size=(3, 3), padding=(1, 1))
343.         self.pool2 = nn.MaxPool2d(kernel_size=(2, 2))
344.         self.dropout2 = nn.Dropout2d(p=dropout2)
345.         self.flatten = nn.Flatten()
346.         self.fc1 = nn.Linear(256 * 12 * 75, 512)
347.         self.fc2 = nn.Linear(512, 256)
348.         self.fc3 = nn.Linear(256, num_classes)
349.         self.leaky_relu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
350.         self.sigmoid = nn.Sigmoid()
352.     def update_stepsize(self):
354.         for m in self.modules():
355.             if isinstance(m, DictBlock):
356.                 m.update_stepsize()
358.     def get_rc(self):
360.         rc_list = []
361.         for m in self.modules():
362.             if isinstance(m, DictConv2d):
363.                 rc_list.append(m.get_rc())
365.         return rc_list
367.     def forward(self, x):
368.         #  x = self.layer0(x)
369.         x = self.conv0(x)
370.         x = self.bn0(x)
371.         x = self.pool0(x)
372.         x = self.conv1(x)
373.         x = self.bn1(x)
374.         x = self.pool1(x)
375.         x = self.dropout1(x)
377.         x = self.layer0(x)
379.         x = self.conv2(x)
380.         x = self.bn2(x)
381.         x = self.ca(x) * x
382.         x = self.sa(x) * x
383.         x = self.conv3(x)
384.         x = self.pool2(x)
385.         # print(x.shape)
386.         x = self.dropout2(x)
387.         x = self.flatten(x)
388.         # print(x.shape)
389.         x = self.leaky_relu(self.fc1(x))
390.         x = self.fc2(x)
391.         x = self.leaky_relu(x)
392.         x = self.fc3(x)
393.         x = self.sigmoid(x)
394.         return x
397. def SDCNN_model(num_classes, dropout1, dropout2):
398.     model = SDNet_model(num_classes=num_classes, dropout1=dropout1, dropout2=dropout2)
399.     return model
402. randomSeed = 1
403. random.seed(randomSeed)
404. torch.manual_seed(randomSeed)
405. np.random.seed(randomSeed)
408. def main():
409.     # 数据导入
410.     dataFile = r'C:\Users\sun\Desktop\SDNET\SDNet-main\data\python_energy_T.mat'
411.     data = scio.loadmat(dataFile)
412.     train_input = data['train_input']
413.     train_output = data['train_output']
414.     test_input = data['test_input']
415.     test_output = data['test_output']
416.     validate_input = data['validate_input']
417.     validate_output = data['validate_output']
419.     train_input = train_input.reshape(-1, 1, 100, 300).astype('float32')
420.     test_input = test_input.reshape(-1, 1, 100, 300).astype('float32')
421.     validate_input = validate_input.reshape(-1, 1, 100, 300).astype('float32')
423.     train_input = torch.from_numpy(train_input)
424.     train_output = torch.from_numpy(train_output)
425.     validate_input = torch.from_numpy(validate_input)
426.     validate_output = torch.from_numpy(validate_output)
427.     test_input = torch.from_numpy(test_input)
428.     test_output = torch.from_numpy(test_output)
430.     # 定义超参数搜索空间
431.     epochs = range(50, 201)
432.     batch_sizes = [64, 128, 256]
433.     dropouts1 = [0.1, 0.3, 0.5]
434.     dropouts2 = [0.1, 0.3, 0.5]
436.     # 初始化最优超参数和最高准确度
437.     best_hyperparams = {'epoch': None, 'batch_size': None, 'dropout1': None, 'dropout2': None}
438.     best_accuracy = 0.0
440.     # 定义随机搜索算法的迭代次数
441.     num_iterations = 10
443.     # 随机搜索算法
444.     for i in range(num_iterations):
445.         # 随机选择超参数组合
446.         epoch = random.choice(epochs)
447.         batch_size = random.choice(batch_sizes)
448.         dropout1 = random.choice(dropouts1)
449.         dropout2 = random.choice(dropouts2)
451.         print(f"Iteration {i+1}/{num_iterations}: epoch={epoch}, batch_size={batch_size}, dropout1={dropout1}, dropout2={dropout2}")
453.         # 实例化模型、损失函数和优化器
454.         model = SDCNN_model(num_classes=2, dropout1=dropout1, dropout2=dropout2)
455.         criterion = nn.BCELoss()
456.         optimizer = optim.Adam(model.parameters(), lr=0.001)
458.         # 将数据转换为PyTorch DataLoader
459.         train_dataset = TensorDataset(train_input, torch.tensor(train_output).float())
460.         valid_dataset = TensorDataset(validate_input, torch.tensor(validate_output).float())
461.         train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
462.         valid_loader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False)
464.         # 实例化学习率调度器 #diff 添加学习率调度器
465.         scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1)
467.         # 训练模型
468.         for e in range(epoch):
469.             model.train()
470.             for inputs, targets in train_loader:
471.                 inputs, targets = inputs, targets
472.                 optimizer.zero_grad()
473.                 outputs = model(inputs)
474.                 loss = criterion(outputs, targets)
475.                 loss.backward()
476.                 optimizer.step()
477.             scheduler.step()
479.         # 评估模型
480.         model.eval()
481.         correct = 0
482.         total = 0
483.         with torch.no_grad():
484.             for inputs, targets in valid_loader:
485.                 inputs, targets = inputs, targets
486.                 outputs = model(inputs)
487.                 predicted = torch.argmax(outputs, dim=1)
488.                 total += targets.size(0)
489.                 targets_index = torch.argmax(targets, dim=1)
490.                 correct += (predicted == targets_index).sum().item()
492.         accuracy = 100 * correct / total
494.         print(f"Iteration {i+1}: Accuracy={accuracy:.2f}%")
496.         # 更新最优超参数和最高准确度
497.         if accuracy > best_accuracy:
498.             best_hyperparams['epoch'] = epoch
499.             best_hyperparams['batch_size'] = batch_size
500.             best_hyperparams['dropout1'] = dropout1
501.             best_hyperparams['dropout2'] = dropout2
502.             best_accuracy = accuracy
504.     print(f"New best accuracy: {best_accuracy:.2f}% with hyperparameters {best_hyperparams}")
506.     # 使用找到的最佳超参数进行最终训练
507.     best_epoch = best_hyperparams['epoch']
508.     best_batch_size = best_hyperparams['batch_size']
509.     best_dropout1 = best_hyperparams['dropout1']
510.     best_dropout2 = best_hyperparams['dropout2']
512.     def weights_init(m):
513.         if isinstance(m, (nn.Conv2d, nn.Linear)):
514.             nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='leaky_relu')
515.             if m.bias is not None:
516.                 nn.init.constant_(m.bias, 0)
518.     # 重新实例化模型以确保权重是新的
519.     model = SDCNN_model(num_classes=2, dropout1=best_dropout1, dropout2=best_dropout2)
520.     model.apply(weights_init)
521.     optimizer = optim.Adam(model.parameters(), lr=0.001)
523.     # 使用最佳批量大小创建数据加载器
524.     train_loader = DataLoader(train_dataset, batch_size=best_batch_size, shuffle=True)
525.     valid_loader = DataLoader(valid_dataset, batch_size=best_batch_size, shuffle=False)
527.     # 实例化学习率调度器 #diff 添加学习率调度器
528.     scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1)
530.     # 特征可视化准备
531.     feature_maps = {}
532.     def get_activation(name):
533.         def hook(model, input, output):
534.             feature_maps[name] = output.detach()
535.         return hook
537.     # 注册钩子 #diff 注册前向钩子以提取特征图
538.     for name, layer in model.named_modules():
539.         if isinstance(layer, nn.Conv2d) or isinstance(layer, DictConv2d):
540.             layer.register_forward_hook(get_activation(name))
542.     # 训练模型
543.     for e in range(best_epoch):
544.         model.train()
545.         running_loss = 0.0
546.         for inputs, targets in train_loader:
547.             inputs, targets = inputs, targets
548.             optimizer.zero_grad()
549.             outputs = model(inputs)
550.             loss = criterion(outputs.squeeze(), targets.squeeze())
551.             loss.backward()
552.             optimizer.step()
553.             running_loss += loss.item()  # 累加损失以计算平均损失
554.         scheduler.step()
556.         print(f'Epoch {e + 1}/{best_epoch}, Loss: {running_loss / len(train_loader):.4f}')
558.         # 评估模型
559.         model.eval()  # 设置模型为评估模式
560.         validation_loss = 0.0
561.         with torch.no_grad():
562.             for inputs, targets in valid_loader:
563.                 inputs, targets = inputs, targets
564.                 outputs = model(inputs)
565.                 validation_loss += criterion(outputs.squeeze(), targets.squeeze()).item()
567.         print(f'Validation Loss: {validation_loss / len(valid_loader):.4f}')
569.     model.eval()
570.     with torch.no_grad():
571.         sample_inputs = validate_input[:1]
572.         model(sample_inputs)
574.     def visualize_features(feature_maps, layer_names, num_images=5):
575.         for layer_name in layer_names:
576.             act = feature_maps.get(layer_name)
577.             if act is None:
578.                 continue
579.             act = act.cpu().numpy()
580.             num_channels = act.shape[1]
581.             plt.figure(figsize=(20, 10))
582.             for i in range(min(num_channels, 64)):
583.                 plt.subplot(8, 8, i + 1)
584.                 plt.imshow(act[0, i, :, :], cmap='viridis')
585.                 plt.axis('off')
586.             plt.suptitle(f'Feature Maps of {layer_name}')
587.             plt.savefig(f'feature_maps_{layer_name}.png')
588.             plt.close()
590.     layers_to_visualize = ['conv0', 'conv1', 'DictConv2d', 'conv2', 'conv3']
591.     visualize_features(feature_maps, layers_to_visualize)
593.     model.eval()
594.     with torch.no_grad():
595.         predictions = model(test_input.float())
596.         probabilities = predictions
597.         predicted_labels = torch.argmax(probabilities, dim=1)
598.         predict = predicted_labels.cpu().numpy()
599.         print(predict)
601.     with open(r'C:\Users\sun\Desktop\SDNET\SDNet-main\predict_label.csv', 'w', newline='') as pr_file:
602.         writer = csv.writer(pr_file)
603.         for label in predict:
604.             writer.writerow([label])
606.     with open(r'C:\Users\sun\Desktop\SDNET\SDNet-main\pr.csv', 'w+') as pr_file:
607.         out = [f"{i[0]},{i[1]}" for i in probabilities]
608.         pr_file.write("\n".join(out))
610.     # 调用函数保存预测结果
611.     # save_predictions_to_csv(probabilities.cpu().numpy(), 'pr.csv')
613.     def save_model_complete(model, filename=r'C:\Users\sun\Desktop\SDNET\SDNet-main\sdnet_model.pth'):
614.         torch.save(model.state_dict(), filename)
615.         print(f"Complete model saved as {filename}")
617.     save_model_complete(model)
620. if __name__ == '__main__':
621.     main()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金