[已解决]基于VGGNet网络的多标签分类任务

黎明丿晓小

在基于原项目代码的基础上，根据以下要求做出修改使其满足多标签分类任务，并高亮对应文件的相关代码段注明修改原因：

1.修改softmax激活函数为sigmoid激活函数使其在输出层输出多个标签类别。

2.修改loss函数CrossEntropyLoss为BCELoss。

3.增添评价指标Hamming Loss，Accuracyexam，Precisionexam，Recallexam，Fβexam，并输出这些评价结果。

4.可视化训练时的loss损失，横坐标为epochs，epochs为训练轮数，纵坐标分别为train_loss和val_loss，train_loss为训练过程中的损失，val_loss为验证过程中的损失。

5.可视化预测结果，展示的图片中有输出的多标签类别。

6.当涉及到变量及函数定义时，请使用项目文件中的相关变量及函数定义，并与上下代码段保证顺畅。新定义的变量及函数除外。

将修改好的项目代码文件逐个展示自己的完整内容，并说明每个文件的具体用法。

主要项目代码如下：
model.py：定义了VGG模型的架构，并提供了辅助函数和配置信息。

1. import torch.nn as nn
   
2. import torch
   
3. 
   
4. # official pretrain weights
   
5. model_urls = {
   
6.     'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
   
7.     'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
   
8.     'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
   
9.     'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth'
   
10. }
    
11. 
    
12. 
    
13. class VGG(nn.Module):
    
14.     def __init__(self, features, num_classes=1000, init_weights=False):
    
15.         super(VGG, self).__init__()
    
16.         self.features = features
    
17.         self.classifier = nn.Sequential(
    
18.             nn.Linear(512*7*7, 4096),
    
19.             nn.ReLU(True),
    
20.             nn.Dropout(p=0.5),
    
21.             nn.Linear(4096, 4096),
    
22.             nn.ReLU(True),
    
23.             nn.Dropout(p=0.5),
    
24.             nn.Linear(4096, num_classes)
    
25.         )
    
26.         if init_weights:
    
27.             self._initialize_weights()
    
28. 
    
29.     def forward(self, x):
    
30.         # N x 3 x 224 x 224
    
31.         x = self.features(x)
    
32.         # N x 512 x 7 x 7
    
33.         x = torch.flatten(x, start_dim=1)
    
34.         # N x 512*7*7
    
35.         x = self.classifier(x)
    
36.         return x
    
37. 
    
38.     def _initialize_weights(self):
    
39.         for m in self.modules():
    
40.             if isinstance(m, nn.Conv2d):
    
41.                 # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
    
42.                 nn.init.xavier_uniform_(m.weight)
    
43.                 if m.bias is not None:
    
44.                     nn.init.constant_(m.bias, 0)
    
45.             elif isinstance(m, nn.Linear):
    
46.                 nn.init.xavier_uniform_(m.weight)
    
47.                 # nn.init.normal_(m.weight, 0, 0.01)
    
48.                 nn.init.constant_(m.bias, 0)
    
49. 
    
50. 
    
51. def make_features(cfg: list):
    
52.     layers = []
    
53.     in_channels = 3
    
54.     for v in cfg:
    
55.         if v == "M":
    
56.             layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
    
57.         else:
    
58.             conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
    
59.             layers += [conv2d, nn.ReLU(True)]
    
60.             in_channels = v
    
61.     return nn.Sequential(*layers)
    
62. 
    
63. 
    
64. cfgs = {
    
65.     'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    
66.     'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    
67.     'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
    
68.     'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
    
69. }
    
70. 
    
71. 
    
72. def vgg(model_name="vgg16", **kwargs):
    
73.     assert model_name in cfgs, "Warning: model number {} not in cfgs dict!".format(model_name)
    
74.     cfg = cfgs[model_name]
    
75. 
    
76.     model = VGG(make_features(cfg), **kwargs)
    
77.     return model
    

复制代码

predict.py：基于训练好的VGG模型，对输入的图像进行分类预测，并输出预测结果。

1. import os
   
2. import json
   
3. 
   
4. import torch
   
5. from PIL import Image
   
6. from torchvision import transforms
   
7. import matplotlib.pyplot as plt
   
8. 
   
9. from model import vgg
   
10. 
    
11. 
    
12. def main():
    
13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
14. 
    
15.     data_transform = transforms.Compose(
    
16.         [transforms.Resize((224, 224)),
    
17.          transforms.ToTensor(),
    
18.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
19. 
    
20.     # load image
    
21.     img_path = "../tulip.jpg"
    
22.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    
23.     img = Image.open(img_path)
    
24.     plt.imshow(img)
    
25.     # [N, C, H, W]
    
26.     img = data_transform(img)
    
27.     # expand batch dimension
    
28.     img = torch.unsqueeze(img, dim=0)
    
29. 
    
30.     # read class_indict
    
31.     json_path = './class_indices.json'
    
32.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
    
33. 
    
34.     with open(json_path, "r") as f:
    
35.         class_indict = json.load(f)
    
36.    
    
37.     # create model
    
38.     model = vgg(model_name="vgg16", num_classes=5).to(device)
    
39.     # load model weights
    
40.     weights_path = "./vgg16Net.pth"
    
41.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    
42.     model.load_state_dict(torch.load(weights_path, map_location=device))
    
43. 
    
44.     model.eval()
    
45.     with torch.no_grad():
    
46.         # predict class
    
47.         output = torch.squeeze(model(img.to(device))).cpu()
    
48.         predict = torch.softmax(output, dim=0)
    
49.         predict_cla = torch.argmax(predict).numpy()
    
50. 
    
51.     print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
    
52.                                                  predict[predict_cla].numpy())
    
53.     plt.title(print_res)
    
54.     for i in range(len(predict)):
    
55.         print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
    
56.                                                   predict[i].numpy()))
    
57.     plt.show()
    
58. 
    
59. 
    
60. if __name__ == '__main__':
    
61.     main()
    

复制代码

train.py:基于给定的数据集，训练VGG模型，最终得到可用于图像分类的模型文件。

1. import os
   
2. import sys
   
3. import json
   
4. 
   
5. import torch
   
6. import torch.nn as nn
   
7. from torchvision import transforms, datasets
   
8. import torch.optim as optim
   
9. from tqdm import tqdm
   
10. 
    
11. from model import vgg
    
12. 
    
13. 
    
14. def main():
    
15.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
16.     print("using {} device.".format(device))
    
17. 
    
18.     data_transform = {
    
19.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    
20.                                      transforms.RandomHorizontalFlip(),
    
21.                                      transforms.ToTensor(),
    
22.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    
23.         "val": transforms.Compose([transforms.Resize((224, 224)),
    
24.                                    transforms.ToTensor(),
    
25.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    
26. 
    
27.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../"))  # get data root path
    
28.     image_path = os.path.join(data_root, "data_set", "PlantVillage")  # flower data set path
    
29.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    
30.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
    
31.                                          transform=data_transform["train"])
    
32.     train_num = len(train_dataset)
    
33. 
    
34.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    
35.     flower_list = train_dataset.class_to_idx
    
36.     cla_dict = dict((val, key) for key, val in flower_list.items())
    
37.     # write dict into json file
    
38.     json_str = json.dumps(cla_dict, indent=4)
    
39.     with open('class_indices.json', 'w') as json_file:
    
40.         json_file.write(json_str)
    
41. 
    
42.     batch_size = 32
    
43.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    
44.     print('Using {} dataloader workers every process'.format(nw))
    
45. 
    
46.     train_loader = torch.utils.data.DataLoader(train_dataset,
    
47.                                                batch_size=batch_size, shuffle=True,
    
48.                                                num_workers=nw)
    
49. 
    
50.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
    
51.                                             transform=data_transform["val"])
    
52.     val_num = len(validate_dataset)
    
53.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
    
54.                                                   batch_size=batch_size, shuffle=False,
    
55.                                                   num_workers=nw)
    
56.     print("using {} images for training, {} images for validation.".format(train_num,
    
57.                                                                            val_num))
    
58. 
    
59.     # test_data_iter = iter(validate_loader)
    
60.     # test_image, test_label = test_data_iter.next()
    
61. 
    
62.     model_name = "vgg16"
    
63.     net = vgg(model_name=model_name, num_classes=4, init_weights=True)
    
64.     net.to(device)
    
65.     loss_function = nn.CrossEntropyLoss()
    
66.     optimizer = optim.Adam(net.parameters(), lr=0.0001)
    
67. 
    
68.     epochs = 30
    
69.     best_acc = 0.0
    
70.     save_path = './{}Net.pth'.format(model_name)
    
71.     train_steps = len(train_loader)
    
72.     for epoch in range(epochs):
    
73.         # train
    
74.         net.train()
    
75.         running_loss = 0.0
    
76.         train_bar = tqdm(train_loader, file=sys.stdout)
    
77.         for step, data in enumerate(train_bar):
    
78.             images, labels = data
    
79.             optimizer.zero_grad()
    
80.             outputs = net(images.to(device))
    
81.             loss = loss_function(outputs, labels.to(device))
    
82.             loss.backward()
    
83.             optimizer.step()
    
84. 
    
85.             # print statistics
    
86.             running_loss += loss.item()
    
87. 
    
88.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
    
89.                                                                      epochs,
    
90.                                                                      loss)
    
91. 
    
92.         # validate
    
93.         net.eval()
    
94.         acc = 0.0  # accumulate accurate number / epoch
    
95.         with torch.no_grad():
    
96.             val_bar = tqdm(validate_loader, file=sys.stdout)
    
97.             for val_data in val_bar:
    
98.                 val_images, val_labels = val_data
    
99.                 outputs = net(val_images.to(device))
    
100.                 predict_y = torch.max(outputs, dim=1)[1]
     
101.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
     
102. 
     
103.         val_accurate = acc / val_num
     
104.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
     
105.               (epoch + 1, running_loss / train_steps, val_accurate))
     
106. 
     
107.         if val_accurate > best_acc:
     
108.             best_acc = val_accurate
     
109.             torch.save(net.state_dict(), save_path)
     
110. 
     
111.     print('Finished Training')
     
112. 
     
113. 
     
114. if __name__ == '__main__':
     
115.     main()
     

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-4-22 10:33:52

黎明丿晓小 发表于 2023-4-22 16:42
在运行以下代码时，报错“RuntimeError: Error(s) in loading state_dict for VGG:
        size mismatch for  ...

这个错误是因为您试图将预训练模型的权重（输出层有4个神经元）加载到具有不同输出层结构的模型中（输出层有5个神经元）。这会导致权重和模型的形状不匹配，因此无法加载权重。

要解决这个问题，您需要确保模型的类别数量与预训练模型权重的类别数量一致。在这个例子中，您应该将模型的类别数量改为4：

1. model = vgg(model_name="vgg16", num_classes=4).to(device)
   

复制代码

然后，您需要更新`class_indices.json`文件，确保它包含正确的类别数量和类别名称。您可以手动编辑文件或在训练模型时自动生成该文件。

请注意，如果您需要处理5个类别，您需要重新训练模型，以适应5个类别的任务。在这种情况下，您需要使用适当数量的类别重新训练模型，并确保`class_indices.json`文件包含正确的类别信息。

跳转到最佳答案楼层

isdkz

黎明丿晓小 发表于 2023-4-22 16:42
在运行以下代码时，报错“RuntimeError: Error(s) in loading state_dict for VGG:
        size mismatch for  ...

这个错误是因为您试图将预训练模型的权重（输出层有4个神经元）加载到具有不同输出层结构的模型中（输出层有5个神经元）。这会导致权重和模型的形状不匹配，因此无法加载权重。

要解决这个问题，您需要确保模型的类别数量与预训练模型权重的类别数量一致。在这个例子中，您应该将模型的类别数量改为4：

1. model = vgg(model_name="vgg16", num_classes=4).to(device)
   

复制代码

然后，您需要更新`class_indices.json`文件，确保它包含正确的类别数量和类别名称。您可以手动编辑文件或在训练模型时自动生成该文件。

请注意，如果您需要处理5个类别，您需要重新训练模型，以适应5个类别的任务。在这种情况下，您需要使用适当数量的类别重新训练模型，并确保`class_indices.json`文件包含正确的类别信息。

isdkz

[b]在基于原项目代码的基础上，根据要求做出修改以满足多标签分类任务。以下是修改后的代码文件及修改原因：

1. 修改 model.py 文件
在 model.py 文件中，为了实现多标签分类任务，我们需要修改分类器部分的最后一个线性层输出数量以及激活函数。将 softmax 激活函数改为 sigmoid 激活函数。

1. class VGG(nn.Module):
   
2.     def __init__(self, features, num_classes=1000, init_weights=False):
   
3.         super(VGG, self).__init__()
   
4.         self.features = features
   
5.         self.classifier = nn.Sequential(
   
6.             nn.Linear(512*7*7, 4096),
   
7.             nn.ReLU(True),
   
8.             nn.Dropout(p=0.5),
   
9.             nn.Linear(4096, 4096),
   
10.             nn.ReLU(True),
    
11.             nn.Dropout(p=0.5),
    
12.             nn.Linear(4096, num_classes),
    
13.             nn.Sigmoid()  # Add Sigmoid activation function
    
14.         )
    
15.         if init_weights:
    
16.             self._initialize_weights()
    

复制代码

2. 修改 train.py 文件
在 train.py 文件中，我们需要修改损失函数为 BCELoss 以满足多标签分类任务。同时，我们还需要修改评价指标。在此，我们添加了 Hamming Loss，Accuracyexam，Precisionexam，Recallexam，Fβexam 作为评价指标。

首先，我们需要安装 scikit-learn 库以使用 hamming_loss 函数：

1. pip install scikit-learn
   

复制代码

然后，修改 train.py 文件：

1. import os
   
2. import sys
   
3. import json
   
4. 
   
5. import torch
   
6. import torch.nn as nn
   
7. from torchvision import transforms, datasets
   
8. import torch.optim as optim
   
9. from tqdm import tqdm
   
10. from sklearn.metrics import hamming_loss, accuracy_score, precision_score, recall_score, fbeta_score
    
11. 
    
12. from model import vgg
    
13. 
    
14. # Define the evaluation function
    
15. def evaluate(y_true, y_pred):
    
16.     hamming = hamming_loss(y_true, y_pred)
    
17.     accuracy = accuracy_score(y_true, y_pred)
    
18.     precision = precision_score(y_true, y_pred, average='micro')
    
19.     recall = recall_score(y_true, y_pred, average='micro')
    
20.     fbeta = fbeta_score(y_true, y_pred, beta=1, average='micro')
    
21. 
    
22.     return hamming, accuracy, precision, recall, fbeta
    
23. 
    
24. # ... (same as before)
    
25. 
    
26. # Change the loss function to BCELoss
    
27. loss_function = nn.BCELoss()
    
28. # ... (same as before)
    
29. 
    
30. # Modify the training and validation loop to calculate evaluation metrics
    
31. # ... (same as before)
    
32. 
    
33. # Modify the validation part
    
34. net.eval()
    
35. acc = 0.0
    
36. val_true_labels = []
    
37. val_pred_labels = []
    
38. with torch.no_grad():
    
39.     val_bar = tqdm(validate_loader, file=sys.stdout)
    
40.     for val_data in val_bar:
    
41.         val_images, val_labels = val_data
    
42.         outputs = net(val_images.to(device))
    
43.         val_true_labels.append(val_labels.cpu().numpy())
    
44.         val_pred_labels.append((outputs > 0.5).float().cpu().numpy())
    
45. 
    
46. val_true_labels = np.vstack(val_true_labels)
    
47. val_pred_labels = np.vstack(val_pred_labels)
    
48. hamming, accuracy, precision, recall, fbeta = evaluate(val_true_labels, val_pred_labels)
    
49. print('[epoch %d] train_loss: %.3f val_hamming: %.3f val_accuracy: %.3f val_precision: %.3f val_recall: %.3f')
    

复制代码

[b]接下来，我们根据要求对代码进行修改。

首先，我们需要修改VGG模型的输出层激活函数为sigmoid激活函数。这一步我们在`model.py`文件中修改VGG模型的架构。将原本的`nn.Linear(4096, num_classes)`修改为：

1. nn.Sequential(
   
2.     nn.Linear(4096, num_classes),
   
3.     nn.Sigmoid()
   
4. )
   

复制代码

接下来，我们需要在`train.py`中修改损失函数为BCELoss。首先，在文件开头导入所需的模块：

1. from torch.nn import BCELoss, BCEWithLogitsLoss
   

复制代码

然后，修改损失函数定义：

1. loss_function = BCEWithLogitsLoss()
   

复制代码

注意：我们使用`BCEWithLogitsLoss`损失函数，因为它结合了`Sigmoid`激活函数和`BCELoss`损失函数的计算，具有更好的数值稳定性。

接下来，我们需要在`train.py`中增添评价指标，并输出这些评价结果。首先，在文件开头导入所需的模块：

1. from sklearn.metrics import hamming_loss, accuracy_score, precision_score, recall_score, f1_score
   

复制代码

然后，在训练和验证循环的适当位置计算并输出评价指标。为了计算这些指标，我们需要将模型输出转换为二进制格式。这可以通过使用阈值（如0.5）来实现：

1. threshold = 0.5
   
2. binary_outputs = (outputs.sigmoid() > threshold).float()
   

复制代码

现在，我们可以使用这些二进制输出计算各种评价指标：

1. hamming = hamming_loss(labels.cpu().numpy(), binary_outputs.cpu().numpy())
   
2. accuracy = accuracy_score(labels.cpu().numpy(), binary_outputs.cpu().numpy())
   
3. precision = precision_score(labels.cpu().numpy(), binary_outputs.cpu().numpy(), average='samples')
   
4. recall = recall_score(labels.cpu().numpy(), binary_outputs.cpu().numpy(), average='samples')
   
5. f1 = f1_score(labels.cpu().numpy(), binary_outputs.cpu().numpy(), average='samples')
   

复制代码

随后，在训练循环的输出部分，添加这些评价指标的结果：

1. print('hamming_loss: {:.3f}, accuracy: {:.3f}, precision: {:.3f}, recall: {:.3f}, f1_score: {:.3f}'.format(hamming, accuracy, precision, recall, f1))
   

复制代码

对于可视化训练时的loss损失，可以使用Matplotlib库来绘制损失图。首先，在`train.py`的开头导入必要的库：

1. import matplotlib.pyplot as plt
   

复制代码

接下来，在训练循环之前，创建两个空列表以存储训练损失和验证损失：

1. train_losses = []
   
2. val_losses = []
   

复制代码

在训练循环中，将损失值添加到相应的列表中：

1. train_losses.append(running_loss / train_steps)
   
2. val_losses.append(val_loss / val_steps)  # 需要在验证循环中计算val_loss

复制代码

最后，在训练循环结束后，使用Matplotlib绘制损失曲线：

1. plt.figure(figsize=(10, 5))
   
2. plt.plot(train_losses, label='Training Loss')
   
3. plt.plot(val_losses, label='Validation Loss')
   
4. plt.xlabel('Epochs')
   
5. plt.ylabel('Loss')
   
6. plt.legend()
   
7. plt.show()
   

复制代码

这将显示一个图形，展示了训练损失和验证损失随着训练周期的变化情况。通常，随着训练的进行，损失值应该逐渐减小。如果验证损失在某个时刻停止下降并开始上升，这可能意味着模型过拟合。在这种情况下，可以考虑使用早停法等策略来优化模型。

在对模型进行了上述修改后，可以重新运行`train.py`来训练模型。在训练结束时，可以观察到损失曲线，了解模型在训练过程中的表现。此外，还可以观察各种评价指标，包括Hamming损失、准确率、精确度、召回率和F1分数，以评估模型在多标签分类任务上的性能。

总结一下，我们对代码进行了如下修改：

1. 修改VGG模型输出层的激活函数为sigmoid激活函数。
2. 将损失函数更改为BCEWithLogitsLoss。
3. 计算并输出各种评价指标。
4. 使用Matplotlib绘制损失曲线。

这些更改有助于将现有的单标签分类模型适应多标签分类任务，并提供了关于模型性能的直观信息。
[/b]
[/b]

黎明丿晓小

isdkz 发表于 2023-4-22 10:39
在基于原项目代码的基础上，根据要求做出修改以满足多标签分类任务。以下是修改后的代码文件及修改原因：
...

我有以下问题需要你来回答：
1.np.vstack中的np是numpy吗？
2.val_loss是如何定义的？
3.请在基于predict.py代码的基础上，修改部分代码使其满足以下图片要求：
   
   其中，red和dress为多标签预测，后面对应的数字为置信度，也就是概率，可以设置一个阈值threshold=0.5，当预测一个图片的输出结果时，某一个标签的置信度大于阈值即可显示在输出结果图片上面。
   

isdkz

黎明丿晓小 发表于 2023-4-22 11:35
我有以下问题需要你来回答：
1.np.vstack中的np是numpy吗？
2.val_loss是如何定义的？

1. 是的，`np`通常是`numpy`库的缩写。在Python程序中，您经常会看到这样的导入语句：`import numpy as np`。这意味着`numpy`库被导入并使用别名`np`，以便在后续代码中更方便地引用。

2. `val_loss`是验证损失（Validation Loss）的缩写，它表示在验证集上计算得到的损失值。验证集是从训练集中划分出来的一个数据子集，用于在训练过程中评估模型的泛化性能。在训练过程中，您需要监视验证损失，以了解模型是否过拟合或者是否需要调整超参数。

3. 假设您有一个名为`predict.py`的脚本，用于进行多标签预测。您可以使用以下代码来实现输出图片的要求：

1. import numpy as np
   
2. import cv2
   
3. from model import MyModel
   
4. import torch
   
5. import torchvision.transforms as transforms
   
6. 
   
7. def predict(image_path, model, threshold=0.5):
   
8.     # Load image and perform preprocessing
   
9.     img = cv2.imread(image_path)
   
10.     img = cv2.resize(img, (224, 224))
    
11.     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
12. 
    
13.     # Convert image to PyTorch tensor and normalize
    
14.     transform = transforms.Compose([
    
15.         transforms.ToTensor(),
    
16.         transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    
17.     ])
    
18.     img_tensor = transform(img)
    
19.     img_tensor = img_tensor.unsqueeze(0)
    
20. 
    
21.     # Get predictions
    
22.     model.eval()
    
23.     with torch.no_grad():
    
24.         output = model(img_tensor)
    
25.         prob = torch.sigmoid(output).numpy().flatten()
    
26.         pred_labels = np.where(prob > threshold)[0]
    
27. 
    
28.     return pred_labels, prob
    
29. 
    
30. def draw_labels(image_path, pred_labels, prob, labels):
    
31.     img = cv2.imread(image_path)
    
32.     img = cv2.resize(img, (224, 224))
    
33. 
    
34.     for idx in pred_labels:
    
35.         label = labels[idx]
    
36.         confidence = prob[idx]
    
37.         cv2.putText(img, f'{label}: {confidence:.2f}', (5, 15 * (idx + 1)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
    
38. 
    
39.     cv2.imshow('Output Image', img)
    
40.     cv2.waitKey(0)
    
41.     cv2.destroyAllWindows()
    
42. 
    
43. if __name__ == '__main__':
    
44.     image_path = 'path/to/image'
    
45.     model_path = 'path/to/model.pth'
    
46. 
    
47.     # Load the model
    
48.     model = MyModel()
    
49.     model.load_state_dict(torch.load(model_path))
    
50. 
    
51.     # Assume a list of labels in the same order as the output of the model
    
52.     labels = ['label_0', 'label_1', 'label_2', 'label_3', 'label_4', 'red', 'dress']
    
53. 
    
54.     pred_labels, prob = predict(image_path, model, threshold=0.5)
    
55.     draw_labels(image_path, pred_labels, prob, labels)
    

复制代码

这段代码定义了一个`predict`函数，用于从图像文件路径加载图像并使用模型进行预测。然后，它计算预测标签的

黎明丿晓小

isdkz 发表于 2023-4-22 11:38
1. 是的，`np`通常是`numpy`库的缩写。在Python程序中，您经常会看到这样的导入语句：`import numpy as n ...

我的意思是val_loss在以下代码是如何定义的：

1. import os
   
2. import sys
   
3. import json
   
4. 
   
5. import torch
   
6. import torch.nn as nn
   
7. from torchvision import transforms, datasets
   
8. import torch.optim as optim
   
9. from tqdm import tqdm
   
10. from sklearn.metrics import hamming_loss,accuracy_score,precision_score,recall_score,fbeta_score
    
11. import numpy as np
    
12. import matplotlib.pyplot as plt
    
13. 
    
14. from model import vgg
    
15. 
    
16. # Define the evaluation function
    
17. def evaluate(y_true, y_pred):
    
18.     hamming = hamming_loss(y_true, y_pred)
    
19.     accuracy = accuracy_score(y_true, y_pred)
    
20.     precision = precision_score(y_true, y_pred, average='micro')
    
21.     recall = recall_score(y_true, y_pred, average='micro')
    
22.     fbeta = fbeta_score(y_true, y_pred, beta=1, average='micro')
    
23. 
    
24.     return hamming, accuracy, precision, recall, fbeta
    
25. 
    
26. def main():
    
27.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
28.     print("using {} device.".format(device))
    
29. 
    
30.     data_transform = {
    
31.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    
32.                                      transforms.RandomHorizontalFlip(),
    
33.                                      transforms.ToTensor(),
    
34.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    
35.         "val": transforms.Compose([transforms.Resize((224, 224)),
    
36.                                    transforms.ToTensor(),
    
37.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    
38. 
    
39.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../"))  # get data root path
    
40.     image_path = os.path.join(data_root, "data_set", "PlantVillage")  # flower data set path
    
41.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    
42.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
    
43.                                          transform=data_transform["train"])
    
44.     train_num = len(train_dataset)
    
45. 
    
46.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    
47.     flower_list = train_dataset.class_to_idx
    
48.     cla_dict = dict((val, key) for key, val in flower_list.items())
    
49.     # write dict into json file
    
50.     json_str = json.dumps(cla_dict, indent=4)
    
51.     with open('class_indices.json', 'w') as json_file:
    
52.         json_file.write(json_str)
    
53. 
    
54.     batch_size = 32
    
55.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    
56.     print('Using {} dataloader workers every process'.format(nw))
    
57. 
    
58.     train_loader = torch.utils.data.DataLoader(train_dataset,
    
59.                                                batch_size=batch_size, shuffle=True,
    
60.                                                num_workers=nw)
    
61. 
    
62.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
    
63.                                             transform=data_transform["val"])
    
64.     val_num = len(validate_dataset)
    
65.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
    
66.                                                   batch_size=batch_size, shuffle=False,
    
67.                                                   num_workers=nw)
    
68.     print("using {} images for training, {} images for validation.".format(train_num,
    
69.                                                                            val_num))
    
70. 
    
71.     # test_data_iter = iter(validate_loader)
    
72.     # test_image, test_label = test_data_iter.next()
    
73. 
    
74.     model_name = "vgg16"
    
75.     net = vgg(model_name=model_name, num_classes=4, init_weights=True)
    
76.     net.to(device)
    
77.     # Change the loss function to BCELoss
    
78.     loss_function = nn.BCEWithLogitsLoss()
    
79.     optimizer = optim.Adam(net.parameters(), lr=0.0001)
    
80. 
    
81.     train_losses = []
    
82.     val_losses = []
    
83. 
    
84.     # Modify the training and validation loop to calculate evaluation metrics
    
85.     epochs = 30
    
86.     best_acc = 0.0
    
87.     save_path = './{}Net.pth'.format(model_name)
    
88.     train_steps = len(train_loader)
    
89.     for epoch in range(epochs):
    
90.         # train
    
91.         net.train()
    
92.         running_loss = 0.0
    
93.         train_bar = tqdm(train_loader, file=sys.stdout)
    
94.         for step, data in enumerate(train_bar):
    
95.             images, labels = data
    
96.             optimizer.zero_grad()
    
97.             outputs = net(images.to(device))
    
98.             loss = loss_function(outputs, labels.to(device))
    
99.             loss.backward()
    
100.             optimizer.step()
     
101. 
     
102.             # print statistics
     
103.             running_loss += loss.item()
     
104. 
     
105.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
     
106.                                                                      epochs,
     
107.                                                                      loss)
     
108.             train_losses.append(running_loss / train_steps)
     
109. 
     
110.         # validate, Modify the validation part
     
111.         net.eval()
     
112.         acc = 0.0  # accumulate accurate number / epoch
     
113.         val_steps = len(validate_loader)
     
114.         val_true_labels = []
     
115.         val_pred_labels = []
     
116.         with torch.no_grad():
     
117.             val_bar = tqdm(validate_loader, file=sys.stdout)
     
118.             for val_data in val_bar:
     
119.                 val_images, val_labels = val_data
     
120.                 outputs = net(val_images.to(device))
     
121.                 val_true_labels.append(val_labels.cpu().numpy())
     
122.                 val_pred_labels.append((outputs > 0.5).float().cpu().numpy())
     
123.                 val_losses.append(val_loss / val_steps)
     
124.                 # predict_y = torch.max(outputs, dim=1)[1]
     
125.                 # acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
     
126.         val_true_labels = np.vstack(val_true_labels)
     
127.         val_pred_labels = np.vstack(val_pred_labels)
     
128.         hamming, accuracy, precision, recall, fbeta = evaluate(val_true_labels, val_pred_labels)
     
129.         print('[epoch %d] train_loss: %.3f val_hamming: %.3f val_accuracy: %.3f val_precision: %.3f val_recall: %.3f')
     
130. 
     
131.         # val_accurate = acc / val_num
     
132.         # print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
     
133.         #       (epoch + 1, running_loss / train_steps, val_accurate))
     
134.         #
     
135.         # if val_accurate > best_acc:
     
136.         #     best_acc = val_accurate
     
137.         #     torch.save(net.state_dict(), save_path)
     
138.     plt.figure(figsize=(10, 5))
     
139.     plt.plot(train_losses, label='Training Loss')
     
140.     plt.plot(val_losses, label='Validation Loss')
     
141.     plt.xlabel('Epochs')
     
142.     plt.ylabel('Loss')
     
143.     plt.legend()
     
144.     plt.show()
     
145. 
     
146.     print('Finished Training')
     
147. 
     
148. 
     
149. if __name__ == '__main__':
     
150.     main()
     

复制代码

另外，请在基于以下代码的基础上，修改部分代码使其满足以下图片要求：
其中，red和dress为多标签预测，后面对应的数字为置信度，也就是概率，可以设置一个阈值threshold=0.5，当预测一个图片的输出结果时，某一个标签的置信度大于阈值即可显示在输出结果图片上面。
  

1. import os
   
2. import json
   
3. 
   
4. import torch
   
5. from PIL import Image
   
6. from torchvision import transforms
   
7. import matplotlib.pyplot as plt
   
8. 
   
9. from model import vgg
   
10. 
    
11. 
    
12. def main():
    
13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
14. 
    
15.     data_transform = transforms.Compose(
    
16.         [transforms.Resize((224, 224)),
    
17.          transforms.ToTensor(),
    
18.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
19. 
    
20.     # load image
    
21.     img_path = "./test.jpg"
    
22.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    
23.     img = Image.open(img_path)
    
24.     plt.imshow(img)
    
25.     # [N, C, H, W]
    
26.     img = data_transform(img)
    
27.     # expand batch dimension
    
28.     img = torch.unsqueeze(img, dim=0)
    
29. 
    
30.     # read class_indict
    
31.     json_path = './class_indices.json'
    
32.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
    
33. 
    
34.     with open(json_path, "r") as f:
    
35.         class_indict = json.load(f)
    
36.    
    
37.     # create model
    
38.     model = vgg(model_name="vgg16", num_classes=5).to(device)
    
39.     # load model weights
    
40.     weights_path = "./vgg16Net.pth"
    
41.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    
42.     model.load_state_dict(torch.load(weights_path, map_location=device))
    
43. 
    
44.     model.eval()
    
45.     with torch.no_grad():
    
46.         # predict class
    
47.         output = torch.squeeze(model(img.to(device))).cpu()
    
48.         predict = torch.softmax(output, dim=0)
    
49.         predict_cla = torch.argmax(predict).numpy()
    
50. 
    
51.     print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
    
52.                                                  predict[predict_cla].numpy())
    
53.     plt.title(print_res)
    
54.     for i in range(len(predict)):
    
55.         print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
    
56.                                                   predict[i].numpy()))
    
57.     plt.show()
    
58. 
    
59. 
    
60. if __name__ == '__main__':
    
61.     main()
    

复制代码

isdkz

黎明丿晓小 发表于 2023-4-22 11:46
我的意思是val_loss在以下代码是如何定义的：

另外，请在基于以下代码的基础上，修改部分代码使其满足 ...

首先，针对您提供的第一个代码片段，关于`val_loss`的定义问题。实际上，在这段代码中，并没有显式地定义`val_loss`变量。代码中的`running_loss`是累加每个批次的训练损失，然后将累加结果除以`train_steps`来得到每个`epoch`的平均训练损失。对于验证损失，您可以类似地计算，但在此代码中，它并未明确计算。要计算验证损失，您可以在验证阶段的循环中累加损失，然后除以`val_steps`得到每个`epoch`的平均验证损失。

对于您的第二个问题，根据您的要求，我对代码进行了修改，以满足阈值和输出的需求。请查看以下修改后的代码：

1. import os
   
2. import json
   
3. 
   
4. import torch
   
5. from PIL import Image
   
6. from torchvision import transforms
   
7. import matplotlib.pyplot as plt
   
8. 
   
9. from model import vgg
   
10. 
    
11. 
    
12. def main():
    
13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
14. 
    
15.     data_transform = transforms.Compose(
    
16.         [transforms.Resize((224, 224)),
    
17.          transforms.ToTensor(),
    
18.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
19. 
    
20.     # load image
    
21.     img_path = "./test.jpg"
    
22.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    
23.     img = Image.open(img_path)
    
24.     plt.imshow(img)
    
25.     # [N, C, H, W]
    
26.     img = data_transform(img)
    
27.     # expand batch dimension
    
28.     img = torch.unsqueeze(img, dim=0)
    
29. 
    
30.     # read class_indict
    
31.     json_path = './class_indices.json'
    
32.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
    
33. 
    
34.     with open(json_path, "r") as f:
    
35.         class_indict = json.load(f)
    
36. 
    
37.     # create model
    
38.     model = vgg(model_name="vgg16", num_classes=5).to(device)
    
39.     # load model weights
    
40.     weights_path = "./vgg16Net.pth"
    
41.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    
42.     model.load_state_dict(torch.load(weights_path, map_location=device))
    
43. 
    
44.     model.eval()
    
45.     threshold = 0.5
    
46.     with torch.no_grad():
    
47.         # predict class
    
48.         output = torch.squeeze(model(img.to(device))).cpu()
    
49.         probabilities = torch.sigmoid(output)
    
50.         predicted_labels = (probabilities > threshold).float().numpy()
    
51.         label_confidences = {class_indict[str(i)]: prob.item() for i, prob in enumerate(probabilities) if predicted_labels[i] == 1}
    
52. 
    
53.     for label, confidence in label_confidences.items():
    
54.         print("Label: {}    Confidence: {:.3f}".format(label, confidence))
    
55. 
    
56.     plt.title("\n".join("{}: {:.3f}".format(label, confidence) for label, confidence in label_confidences.items()))
    
57.     plt.show()
    
58. 
    
59. 
    
60. if __name__ == '__main__':
    
61.     main()
    

复制代码

这段代码首先计算概率（置信度），然后根据阈值过滤预测标签。最后，它将满足阈值条件的标签及其置信度显示在图像上方。在这个示例中，我将概率更改为使用`sigmoid`函数而不是`softmax`，因为对于多标签分类问题，使用`sigmoid`通常更合适。`softmax`主要用于单一标签分类问题，因为它会使得概率之和为1。而在多标签分类问题中，多个类别的存在可能是独立的，因此使用`sigmoid`可以单独计算每个类别的概率。

以下是修改后的代码：

1. import os
   
2. import json
   
3. 
   
4. import torch
   
5. from PIL import Image
   
6. from torchvision import transforms
   
7. import matplotlib.pyplot as plt
   
8. 
   
9. from model import vgg
   
10. 
    
11. 
    
12. def main():
    
13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
14. 
    
15.     data_transform = transforms.Compose(
    
16.         [transforms.Resize((224, 224)),
    
17.          transforms.ToTensor(),
    
18.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
19. 
    
20.     # load image
    
21.     img_path = "./test.jpg"
    
22.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    
23.     img = Image.open(img_path)
    
24.     plt.imshow(img)
    
25.     # [N, C, H, W]
    
26.     img = data_transform(img)
    
27.     # expand batch dimension
    
28.     img = torch.unsqueeze(img, dim=0)
    
29. 
    
30.     # read class_indict
    
31.     json_path = './class_indices.json'
    
32.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
    
33. 
    
34.     with open(json_path, "r") as f:
    
35.         class_indict = json.load(f)
    
36. 
    
37.     # create model
    
38.     model = vgg(model_name="vgg16", num_classes=5).to(device)
    
39.     # load model weights
    
40.     weights_path = "./vgg16Net.pth"
    
41.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    
42.     model.load_state_dict(torch.load(weights_path, map_location=device))
    
43. 
    
44.     model.eval()
    
45.     threshold = 0.5
    
46.     with torch.no_grad():
    
47.         # predict class
    
48.         output = torch.squeeze(model(img.to(device))).cpu()
    
49.         probabilities = torch.sigmoid(output)
    
50.         predicted_labels = (probabilities > threshold).float().numpy()
    
51.         label_confidences = {class_indict[str(i)]: prob.item() for i, prob in enumerate(probabilities) if predicted_labels[i] == 1}
    
52. 
    
53.     for label, confidence in label_confidences.items():
    
54.         print("Label: {}    Confidence: {:.3f}".format(label, confidence))
    
55. 
    
56.     plt.title("\n".join("{}: {:.3f}".format(label, confidence) for label, confidence in label_confidences.items()))
    
57.     plt.show()
    
58. 
    
59. 
    
60. if __name__ == '__main__':
    
61.     main()
    

复制代码

这段代码应该满足您的要求，当一个图片的输出结果中，某个标签的置信度大于阈值时，会显示在输出结果图片上面。

黎明丿晓小

isdkz 发表于 2023-4-22 11:50
首先，针对您提供的第一个代码片段，关于`val_loss`的定义问题。实际上，在这段代码中，并没有显式地定义 ...

在训练以下代码时报错ValueError：Target size (torch.Size([32])) must be the same as input size (torch.Size([32,4]))

1. import os
   
2. import sys
   
3. import json
   
4. 
   
5. import torch
   
6. import torch.nn as nn
   
7. from torchvision import transforms, datasets
   
8. import torch.optim as optim
   
9. from tqdm import tqdm
   
10. from sklearn.metrics import hamming_loss,accuracy_score,precision_score,recall_score,fbeta_score
    
11. import numpy as np
    
12. import matplotlib.pyplot as plt
    
13. 
    
14. from model import vgg
    
15. 
    
16. # Define the evaluation function
    
17. def evaluate(y_true, y_pred):
    
18.     hamming = hamming_loss(y_true, y_pred)
    
19.     accuracy = accuracy_score(y_true, y_pred)
    
20.     precision = precision_score(y_true, y_pred, average='micro')
    
21.     recall = recall_score(y_true, y_pred, average='micro')
    
22.     fbeta = fbeta_score(y_true, y_pred, beta=1, average='micro')
    
23. 
    
24.     return hamming, accuracy, precision, recall, fbeta
    
25. 
    
26. def main():
    
27.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
28.     print("using {} device.".format(device))
    
29. 
    
30.     data_transform = {
    
31.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    
32.                                      transforms.RandomHorizontalFlip(),
    
33.                                      transforms.ToTensor(),
    
34.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    
35.         "val": transforms.Compose([transforms.Resize((224, 224)),
    
36.                                    transforms.ToTensor(),
    
37.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    
38. 
    
39.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../"))  # get data root path
    
40.     image_path = os.path.join(data_root, "data_set", "PlantVillage")  # flower data set path
    
41.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    
42.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
    
43.                                          transform=data_transform["train"])
    
44.     train_num = len(train_dataset)
    
45. 
    
46.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    
47.     flower_list = train_dataset.class_to_idx
    
48.     cla_dict = dict((val, key) for key, val in flower_list.items())
    
49.     # write dict into json file
    
50.     json_str = json.dumps(cla_dict, indent=4)
    
51.     with open('class_indices.json', 'w') as json_file:
    
52.         json_file.write(json_str)
    
53. 
    
54.     batch_size = 32
    
55.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    
56.     print('Using {} dataloader workers every process'.format(nw))
    
57. 
    
58.     train_loader = torch.utils.data.DataLoader(train_dataset,
    
59.                                                batch_size=batch_size, shuffle=True,
    
60.                                                num_workers=nw)
    
61. 
    
62.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
    
63.                                             transform=data_transform["val"])
    
64.     val_num = len(validate_dataset)
    
65.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
    
66.                                                   batch_size=batch_size, shuffle=False,
    
67.                                                   num_workers=nw)
    
68.     print("using {} images for training, {} images for validation.".format(train_num,
    
69.                                                                            val_num))
    
70. 
    
71.     # test_data_iter = iter(validate_loader)
    
72.     # test_image, test_label = test_data_iter.next()
    
73. 
    
74.     model_name = "vgg16"
    
75.     net = vgg(model_name=model_name, num_classes=4, init_weights=True)
    
76.     net.to(device)
    
77.     # Change the loss function to BCELoss
    
78.     loss_function = nn.BCEWithLogitsLoss()
    
79.     optimizer = optim.Adam(net.parameters(), lr=0.0001)
    
80. 
    
81.     train_losses = []
    
82.     val_losses = []
    
83. 
    
84.     # Modify the training and validation loop to calculate evaluation metrics
    
85.     epochs = 30
    
86.     best_acc = 0.0
    
87.     save_path = './{}Net.pth'.format(model_name)
    
88.     train_steps = len(train_loader)
    
89.     for epoch in range(epochs):
    
90.         # train
    
91.         net.train()
    
92.         running_loss = 0.0
    
93.         train_bar = tqdm(train_loader, file=sys.stdout)
    
94.         for step, data in enumerate(train_bar):
    
95.             images, labels = data
    
96.             optimizer.zero_grad()
    
97.             outputs = net(images.to(device))
    
98.             loss = loss_function(outputs, labels.to(device))
    
99.             loss.backward()
    
100.             optimizer.step()
     
101. 
     
102.             # print statistics
     
103.             running_loss += loss.item()
     
104. 
     
105.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
     
106.                                                                      epochs,
     
107.                                                                      loss)
     
108.             train_losses.append(running_loss / train_steps)
     
109. 
     
110.         # validate, Modify the validation part
     
111.         net.eval()
     
112.         validate_loss = 0.0
     
113.         acc = 0.0  # accumulate accurate number / epoch
     
114.         val_steps = len(validate_loader)
     
115.         val_true_labels = []
     
116.         val_pred_labels = []
     
117.         with torch.no_grad():
     
118.             val_bar = tqdm(validate_loader, file=sys.stdout)
     
119.             for val_data in val_bar:
     
120.                 val_images, val_labels = val_data
     
121.                 outputs = net(val_images.to(device))
     
122.                 val_loss = loss_function(outputs,val_labels.to(device))
     
123.                 val_loss.backward()
     
124.                 optimizer.step()
     
125.                 validate_loss += val_loss.item()
     
126.                 val_bar.desc = "val epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
     
127.                                                                      epochs,
     
128.                                                                      val_loss)
     
129.                 val_losses.append(validate_loss / val_steps)
     
130.                 val_true_labels.append(val_labels.cpu().numpy())
     
131.                 val_pred_labels.append((outputs > 0.5).float().cpu().numpy())
     
132. 
     
133.                 # predict_y = torch.max(outputs, dim=1)[1]
     
134.                 # acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
     
135.         val_true_labels = np.vstack(val_true_labels)
     
136.         val_pred_labels = np.vstack(val_pred_labels)
     
137.         hamming, accuracy, precision, recall, fbeta = evaluate(val_true_labels, val_pred_labels)
     
138.         print('[epoch %d] train_loss: %.3f val_hamming: %.3f val_accuracy: %.3f val_precision: %.3f val_recall: %.3f')
     
139. 
     
140.         # val_accurate = acc / val_num
     
141.         # print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
     
142.         #       (epoch + 1, running_loss / train_steps, val_accurate))
     
143.         #
     
144.         # if val_accurate > best_acc:
     
145.         #     best_acc = val_accurate
     
146.         #     torch.save(net.state_dict(), save_path)
     
147.     plt.figure(figsize=(10, 5))
     
148.     plt.plot(train_losses, label='Training Loss')
     
149.     plt.plot(val_losses, label='Validation Loss')
     
150.     plt.xlabel('Epochs')
     
151.     plt.ylabel('Loss')
     
152.     plt.legend()
     
153.     plt.show()
     
154. 
     
155.     print('Finished Training')
     
156. 
     
157. 
     
158. if __name__ == '__main__':
     
159.     main()
     

复制代码

请指出错误原因并更改相应代码段

isdkz

黎明丿晓小 发表于 2023-4-22 12:24
在训练以下代码时报错ValueError：Target size (torch.Size([32])) must be the same as input size (tor ...

根据您提供的代码，错误出现在处理多标签分类问题时的损失函数计算部分。`nn.BCEWithLogitsLoss`需要将标签的尺寸更改为与模型输出相同的尺寸。因为您的模型的输出是大小为 `[32, 4]` 的张量，因此标签的大小也应为 `[32, 4]`。为了解决这个问题，请在数据加载器（DataLoader）部分添加一个函数，将分类标签转换为独热编码。以下是相关代码的修改：

1. 定义一个函数将标签转换为独热编码：

1. def label_to_onehot(labels, num_classes):
   
2.     batch_size = len(labels)
   
3.     one_hot = torch.zeros(batch_size, num_classes)
   
4.     one_hot[torch.arange(batch_size), labels] = 1
   
5.     return one_hot
   

复制代码

2. 在训练和验证循环中使用该函数转换标签：
将以下代码：

1. images, labels = data
   

复制代码

更改为：

1. images, labels = data
   
2. labels = label_to_onehot(labels, num_classes=4).to(device)
   

复制代码

同时，将验证部分的这段代码：

1. val_images, val_labels = val_data
   

复制代码

更改为：

1. val_images, val_labels = val_data
   
2. val_labels = label_to_onehot(val_labels, num_classes=4).to(device)
   

复制代码

这些更改应解决您遇到的问题。现在，标签的大小与模型输出的大小相同，因此可以正确计算损失函数。

黎明丿晓小

isdkz 发表于 2023-4-22 12:25
根据您提供的代码，错误出现在处理多标签分类问题时的损失函数计算部分。`nn.BCEWithLogitsLoss`需要将标 ...

应该是“将标签的尺寸更改为与模型输入相同的尺寸”吧，另外，这样改会失去多标签分类任务的功能吗？

isdkz

黎明丿晓小 发表于 2023-4-22 12:31
应该是“将标签的尺寸更改为与模型输入相同的尺寸”吧，另外，这样改会失去多标签分类任务的功能吗？

抱歉，我在描述中的确有误，应该是“将标签的尺寸更改为与模型输出相同的尺寸”。

另外，不用担心，这样的更改不会失去多标签分类任务的功能。实际上，通过将标签转换为独热编码，我们确保了多标签分类任务的正确处理。多标签分类意味着每个样本可以属于多个类别。在这种情况下，通过使用独热编码，我们可以表示每个样本属于多个类别的情况。`nn.BCEWithLogitsLoss()`损失函数适用于多标签分类任务，因为它在每个类别之间独立计算二元交叉熵损失。这意味着对于每个类别，模型都将学习一个独立的二元分类器。因此，通过执行上述更改，您的模型仍然可以处理多标签分类任务。

黎明丿晓小

isdkz 发表于 2023-4-22 12:43
抱歉，我在描述中的确有误，应该是“将标签的尺寸更改为与模型输出相同的尺寸”。

另外，不用担心，这 ...

运行以下代码时，在训练过程中报出警告“UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use zero_division parameter to control this behavior._warn_prf(average, modifier, msg_start, len(result))”，请解释报出警告的原因，并给出解决办法：

1. import os
   
2. import sys
   
3. import json
   
4. 
   
5. import torch
   
6. import torch.nn as nn
   
7. from torchvision import transforms, datasets
   
8. import torch.optim as optim
   
9. from tqdm import tqdm
   
10. from sklearn.metrics import hamming_loss,accuracy_score,precision_score,recall_score,fbeta_score
    
11. import numpy as np
    
12. import matplotlib.pyplot as plt
    
13. import warnings
    
14. 
    
15. from model import vgg
    
16. 
    
17. # Define the evaluation function
    
18. def evaluate(y_true, y_pred):
    
19.     hamming = hamming_loss(y_true, y_pred)
    
20.     accuracy = accuracy_score(y_true, y_pred)
    
21.     precision = precision_score(y_true, y_pred, average='micro')
    
22.     recall = recall_score(y_true, y_pred, average='micro')
    
23.     fbeta = fbeta_score(y_true, y_pred, beta=1, average='micro')
    
24. 
    
25.     return hamming, accuracy, precision, recall, fbeta
    
26. 
    
27. def main():
    
28.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
29.     print("using {} device.".format(device))
    
30. 
    
31.     data_transform = {
    
32.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    
33.                                      transforms.RandomHorizontalFlip(),
    
34.                                      transforms.ToTensor(),
    
35.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    
36.         "val": transforms.Compose([transforms.Resize((224, 224)),
    
37.                                    transforms.ToTensor(),
    
38.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    
39. 
    
40.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
    
41.     image_path = os.path.join(data_root, "data_set", "plantvillage_demo1")  # flower data set path
    
42.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    
43.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
    
44.                                          transform=data_transform["train"])
    
45.     train_num = len(train_dataset)
    
46. 
    
47.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    
48.     flower_list = train_dataset.class_to_idx
    
49.     cla_dict = dict((val, key) for key, val in flower_list.items())
    
50.     # write dict into json file
    
51.     json_str = json.dumps(cla_dict, indent=4)
    
52.     with open('class_indices.json', 'w') as json_file:
    
53.         json_file.write(json_str)
    
54. 
    
55.     batch_size = 32
    
56.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    
57.     print('Using {} dataloader workers every process'.format(nw))
    
58. 
    
59.     def label_to_onehot(labels, num_classes):
    
60.         batch_size = len(labels)
    
61.         one_hot = torch.zeros(batch_size, num_classes)
    
62.         one_hot[torch.arange(batch_size), labels] = 1
    
63.         return one_hot
    
64. 
    
65.     train_loader = torch.utils.data.DataLoader(train_dataset,
    
66.                                                batch_size=batch_size, shuffle=True,
    
67.                                                num_workers=nw)
    
68. 
    
69.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
    
70.                                             transform=data_transform["val"])
    
71.     val_num = len(validate_dataset)
    
72.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
    
73.                                                   batch_size=batch_size, shuffle=False,
    
74.                                                   num_workers=nw)
    
75.     print("using {} images for training, {} images for validation.".format(train_num,
    
76.                                                                            val_num))
    
77. 
    
78.     # test_data_iter = iter(validate_loader)
    
79.     # test_image, test_label = test_data_iter.next()
    
80. 
    
81.     model_name = "vgg16"
    
82.     net = vgg(model_name=model_name, num_classes=4, init_weights=True)
    
83.     net.to(device)
    
84.     # Change the loss function to BCELoss
    
85.     loss_function = nn.BCEWithLogitsLoss()
    
86.     optimizer = optim.Adam(net.parameters(), lr=0.0001)
    
87. 
    
88.     train_losses = []
    
89.     #val_losses = []
    
90. 
    
91.     # Modify the training and validation loop to calculate evaluation metrics
    
92.     #warnings.filterwarnings("ignore")
    
93.     epochs = 30
    
94.     best_acc = 0.0
    
95.     save_path = './{}Net.pth'.format(model_name)
    
96.     train_steps = len(train_loader)
    
97.     for epoch in range(epochs):
    
98.         # train
    
99.         net.train()
    
100.         running_loss = 0.0
     
101.         train_bar = tqdm(train_loader, file=sys.stdout)
     
102.         for step, data in enumerate(train_bar):
     
103.             images, labels = data
     
104.             labels = label_to_onehot(labels, num_classes=4).to(device)
     
105.             optimizer.zero_grad()
     
106.             outputs = net(images.to(device))
     
107.             loss = loss_function(outputs, labels.to(device))
     
108.             loss.backward()
     
109.             optimizer.step()
     
110. 
     
111.             # print statistics
     
112.             running_loss += loss.item()
     
113. 
     
114.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
     
115.                                                                      epochs,
     
116.                                                                      loss)
     
117.             train_losses.append(running_loss / train_steps)
     
118. 
     
119.         # validate, Modify the validation part
     
120.         net.eval()
     
121.         acc = 0.0  # accumulate accurate number / epoch
     
122.         val_true_labels = []
     
123.         val_pred_labels = []
     
124.         with torch.no_grad():
     
125.             val_bar = tqdm(validate_loader, file=sys.stdout)
     
126.             for val_data in val_bar:
     
127.                 val_images, val_labels = val_data
     
128.                 #val_labels = label_to_onehot(val_labels, num_classes=4).to(device)
     
129.                 outputs = net(val_images.to(device))
     
130.                 val_true_labels.append(label_to_onehot(val_labels,num_classes=4).cpu().numpy())
     
131.                 val_pred_labels.append((outputs > 0.5).float().cpu().numpy())
     
132. 
     
133.                 predict_y = torch.max(outputs, dim=1)[1]
     
134.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
     
135.         val_true_labels = np.vstack(val_true_labels)
     
136.         val_pred_labels = np.vstack(val_pred_labels)
     
137.         hamming, accuracy, precision, recall, fbeta = evaluate(val_true_labels, val_pred_labels)
     
138.         val_accurate = acc / val_num
     
139.         print('[epoch %d] train_loss: %.3f val_hamming: %.3f val_accuracy: %.3f val_precision: %.3f val_recall: %.3f fbeta: %.3f' %
     
140.               (epoch + 1, running_loss / train_steps, hamming, val_accurate, precision, recall, fbeta))
     
141. 
     
142. 
     
143.         # print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
     
144.         #       (epoch + 1, running_loss / train_steps, val_accurate))
     
145. 
     
146.         if val_accurate > best_acc:
     
147.             best_acc = val_accurate
     
148.             torch.save(net.state_dict(), save_path)
     
149.     plt.figure(figsize=(10, 5))
     
150.     plt.plot(train_losses, label='Training Loss')
     
151.     plt.plot(val_accurate, label='Validation Accuracy')
     
152.     plt.xlabel('Epochs')
     
153.     plt.ylabel('Loss/Accuracy')
     
154.     plt.legend()
     
155.     plt.show()
     
156. 
     
157.     print('Finished Training')
     
158. 
     
159. 
     
160. if __name__ == '__main__':
     
161.     main()
     

复制代码

isdkz

黎明丿晓小 发表于 2023-4-22 16:16
运行以下代码时，在训练过程中报出警告“UndefinedMetricWarning: Precision is ill-defined and being ...

这个警告出现的原因是，在计算precision（精确度）时，有些标签在预测结果中没有出现，导致在计算这些标签的精确度时产生除以0的情况。在这种情况下，`sklearn`将精确度设置为0.0，并发出“UndefinedMetricWarning”警告。为了解决这个问题，您可以使用`zero_division`参数来控制这种行为。例如，您可以将`zero_division`设置为1，这样当分母为0时，精确度将被设置为1。

您可以将`precision_score`函数更改为：

1. precision = precision_score(y_true, y_pred, average='micro', zero_division=1)
   

复制代码

这将消除警告，并在计算精确度时处理除以0的情况。但请注意，这种方法可能会导致某些标签的精确度被高估。另一种方法是在计算评估指标之前，检查是否存在这种情况，例如，您可以检查预测结果中是否包含所有标签。如果所有标签都在预测结果中，那么计算精确度时就不会出现除以0的问题。

需要注意的是，`UndefinedMetricWarning`警告不会影响其他评估指标的计算。所以，如果您觉得精确度对您的任务来说并不是关键指标，您可以选择忽略这个警告。

黎明丿晓小

isdkz 发表于 2023-4-22 16:21
这个警告出现的原因是，在计算precision（精确度）时，有些标签在预测结果中没有出现，导致在计算这些标 ...

在运行以下代码时，报错“RuntimeError: Error(s) in loading state_dict for VGG:
        size mismatch for classifier.6.weight: copying a param with shape torch.Size([4, 4096]) from checkpoint, the shape in current model is torch.Size([5, 4096]).
        size mismatch for classifier.6.bias: copying a param with shape torch.Size([4]) from checkpoint, the shape in current model is torch.Size([5]).”
请给出错误原因以及修改意见

1. import os
   
2. import json
   
3. 
   
4. import torch
   
5. from PIL import Image
   
6. from torchvision import transforms
   
7. import matplotlib.pyplot as plt
   
8. 
   
9. from model import vgg
   
10. 
    
11. 
    
12. def main():
    
13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
14. 
    
15.     data_transform = transforms.Compose(
    
16.         [transforms.Resize((224, 224)),
    
17.          transforms.ToTensor(),
    
18.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
19. 
    
20.     # load image
    
21.     img_path = "./test.jpg"
    
22.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    
23.     img = Image.open(img_path)
    
24.     plt.imshow(img)
    
25.     # [N, C, H, W]
    
26.     img = data_transform(img)
    
27.     # expand batch dimension
    
28.     img = torch.unsqueeze(img, dim=0)
    
29. 
    
30.     # read class_indict
    
31.     json_path = './class_indices.json'
    
32.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
    
33. 
    
34.     with open(json_path, "r") as f:
    
35.         class_indict = json.load(f)
    
36.    
    
37.     # create model
    
38.     model = vgg(model_name="vgg16", num_classes=5).to(device)
    
39.     # load model weights
    
40.     weights_path = "./vgg16Net.pth"
    
41.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    
42.     model.load_state_dict(torch.load(weights_path, map_location=device))
    
43. 
    
44.     model.eval()
    
45.     threshold = 0.5
    
46.     with torch.no_grad():
    
47.         # predict class
    
48.         output = torch.squeeze(model(img.to(device))).cpu()
    
49.         probabilities = torch.sigmoid(output)
    
50.         predicted_labels = (probabilities > threshold).float().numpy()
    
51.         label_confidences = {class_indict[str(i)]: prob.item() for i, prob in enumerate(probabilities) if
    
52.                              predicted_labels[i] == 1}
    
53. 
    
54.     for label, confidence in label_confidences.items():
    
55.         print("Label: {}    Confidence: {:.3f}".format(label, confidence))
    
56. 
    
57.     plt.title("\n".join("{}: {:.3f}".format(label, confidence) for label, confidence in label_confidences.items()))
    
58.     plt.show()
    
59.     #     output = torch.squeeze(model(img.to(device))).cpu()
    
60.     #     predict = torch.softmax(output, dim=0)
    
61.     #     predict_cla = torch.argmax(predict).numpy()
    
62.     #
    
63.     # print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
    
64.     #                                              predict[predict_cla].numpy())
    
65.     # plt.title(print_res)
    
66.     # for i in range(len(predict)):
    
67.     #     print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
    
68.     #                                               predict[i].numpy()))
    
69.     # plt.show()
    
70. 
    
71. 
    
72. if __name__ == '__main__':
    
73.     main()
    

复制代码

黎明丿晓小

黎明丿晓小 发表于 2023-4-22 16:16
运行以下代码时，在训练过程中报出警告“UndefinedMetricWarning: Precision is ill-defined and being ...

在运行此代码的过程中，hamming,  precision, recall, fbeta的输出分别一直为0.250,0.000,0.000,0.000。请说明原因并给出解决方法

黎明丿晓小

isdkz 发表于 2023-4-22 16:45
这个错误是因为您试图将预训练模型的权重（输出层有4个神经元）加载到具有不同输出层结构的模型中（输出 ...

请修改以下代码的数据读取方式以满足多标签分类任务的数据读取方式：

1. import os
   
2. import sys
   
3. import json
   
4. 
   
5. import torch
   
6. import torch.nn as nn
   
7. from torchvision import transforms, datasets
   
8. import torch.optim as optim
   
9. from tqdm import tqdm
   
10. from sklearn.metrics import hamming_loss,accuracy_score,precision_score,recall_score,fbeta_score
    
11. import numpy as np
    
12. import matplotlib.pyplot as plt
    
13. import warnings
    
14. 
    
15. from model import vgg
    
16. 
    
17. # Define the evaluation function
    
18. def evaluate(y_true, y_pred):
    
19.     hamming = hamming_loss(y_true, y_pred)
    
20.     accuracy = accuracy_score(y_true, y_pred)
    
21.     precision = precision_score(y_true, y_pred, average='micro')
    
22.     recall = recall_score(y_true, y_pred, average='micro')
    
23.     fbeta = fbeta_score(y_true, y_pred, beta=1, average='micro')
    
24. 
    
25.     return hamming, accuracy, precision, recall, fbeta
    
26. 
    
27. def main():
    
28.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
29.     print("using {} device.".format(device))
    
30. 
    
31.     data_transform = {
    
32.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    
33.                                      transforms.RandomHorizontalFlip(),
    
34.                                      transforms.ToTensor(),
    
35.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    
36.         "val": transforms.Compose([transforms.Resize((224, 224)),
    
37.                                    transforms.ToTensor(),
    
38.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    
39. 
    
40.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
    
41.     image_path = os.path.join(data_root, "data_set", "plantvillage_demo1")  # flower data set path
    
42.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    
43.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
    
44.                                          transform=data_transform["train"])
    
45.     train_num = len(train_dataset)
    
46. 
    
47.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    
48.     flower_list = train_dataset.class_to_idx
    
49.     cla_dict = dict((val, key) for key, val in flower_list.items())
    
50.     # write dict into json file
    
51.     json_str = json.dumps(cla_dict, indent=4)
    
52.     with open('class_indices.json', 'w') as json_file:
    
53.         json_file.write(json_str)
    
54. 
    
55.     batch_size = 32
    
56.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    
57.     print('Using {} dataloader workers every process'.format(nw))
    
58. 
    
59.     def label_to_onehot(labels, num_classes):
    
60.         batch_size = len(labels)
    
61.         one_hot = torch.zeros(batch_size, num_classes)
    
62.         one_hot[torch.arange(batch_size), labels] = 1
    
63.         return one_hot
    
64. 
    
65.     train_loader = torch.utils.data.DataLoader(train_dataset,
    
66.                                                batch_size=batch_size, shuffle=True,
    
67.                                                num_workers=nw)
    
68. 
    
69.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
    
70.                                             transform=data_transform["val"])
    
71.     val_num = len(validate_dataset)
    
72.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
    
73.                                                   batch_size=batch_size, shuffle=False,
    
74.                                                   num_workers=nw)
    
75.     print("using {} images for training, {} images for validation.".format(train_num,
    
76.                                                                            val_num))
    
77. 
    
78.     # test_data_iter = iter(validate_loader)
    
79.     # test_image, test_label = test_data_iter.next()
    
80. 
    
81.     model_name = "vgg16"
    
82.     net = vgg(model_name=model_name, num_classes=4, init_weights=True)
    
83.     net.to(device)
    
84.     # Change the loss function to BCELoss
    
85.     loss_function = nn.BCEWithLogitsLoss()
    
86.     optimizer = optim.Adam(net.parameters(), lr=0.0001)
    
87. 
    
88.     train_losses = []
    
89.     #val_losses = []
    
90. 
    
91.     # Modify the training and validation loop to calculate evaluation metrics
    
92.     warnings.filterwarnings("ignore")
    
93.     epochs = 30
    
94.     best_acc = 0.0
    
95.     save_path = './{}Net.pth'.format(model_name)
    
96.     train_steps = len(train_loader)
    
97.     for epoch in range(epochs):
    
98.         # train
    
99.         net.train()
    
100.         running_loss = 0.0
     
101.         train_bar = tqdm(train_loader, file=sys.stdout)
     
102.         for step, data in enumerate(train_bar):
     
103.             images, labels = data
     
104.             labels = label_to_onehot(labels, num_classes=4).to(device)
     
105.             optimizer.zero_grad()
     
106.             outputs = net(images.to(device))
     
107.             loss = loss_function(outputs, labels.to(device))
     
108.             loss.backward()
     
109.             optimizer.step()
     
110. 
     
111.             # print statistics
     
112.             running_loss += loss.item()
     
113. 
     
114.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
     
115.                                                                      epochs,
     
116.                                                                      loss)
     
117.             train_losses.append(running_loss / train_steps)
     
118. 
     
119.         # validate, Modify the validation part
     
120.         net.eval()
     
121.         acc = 0.0  # accumulate accurate number / epoch
     
122.         val_true_labels = []
     
123.         val_pred_labels = []
     
124.         with torch.no_grad():
     
125.             val_bar = tqdm(validate_loader, file=sys.stdout)
     
126.             for val_data in val_bar:
     
127.                 val_images, val_labels = val_data
     
128.                 #val_labels = label_to_onehot(val_labels, num_classes=4).to(device)
     
129.                 outputs = net(val_images.to(device))
     
130.                 val_true_labels.append(label_to_onehot(val_labels,num_classes=4).cpu().numpy())
     
131.                 val_pred_labels.append((outputs > 0.5).float().cpu().numpy())
     
132. 
     
133.                 predict_y = torch.max(outputs, dim=1)[1]
     
134.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
     
135.         val_true_labels = np.vstack(val_true_labels)
     
136.         val_pred_labels = np.vstack(val_pred_labels)
     
137.         hamming, accuracy, precision, recall, fbeta = evaluate(val_true_labels, val_pred_labels)
     
138.         val_accurate = acc / val_num
     
139.         print('[epoch %d] train_loss: %.3f val_hamming: %.3f val_accuracy: %.3f val_precision: %.3f val_recall: %.3f fbeta: %.3f' %
     
140.               (epoch + 1, running_loss / train_steps, hamming, val_accurate, precision, recall, fbeta))
     
141. 
     
142. 
     
143.         # print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
     
144.         #       (epoch + 1, running_loss / train_steps, val_accurate))
     
145. 
     
146.         if val_accurate > best_acc:
     
147.             best_acc = val_accurate
     
148.             torch.save(net.state_dict(), save_path)
     
149.     plt.figure(figsize=(10, 5))
     
150.     plt.plot(train_losses, label='Training Loss')
     
151.     plt.plot(val_accurate, label='Validation Accuracy')
     
152.     plt.xlabel('Epochs')
     
153.     plt.ylabel('Loss/Accuracy')
     
154.     plt.legend()
     
155.     plt.show()
     
156. 
     
157.     print('Finished Training')
     
158. 
     
159. 
     
160. if __name__ == '__main__':
     
161.     main()
     

复制代码