poster-var/features_analysis_encoder.py at main · lg2578/poster-var · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#20250202,args.batch_size只能是1
from pytorch_grad_cam import GradCAM, HiResCAM, ScoreCAM, GradCAMPlusPlus, AblationCAM, XGradCAM, EigenCAM, FullGrad
from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
from pytorch_grad_cam.utils.image import show_cam_on_image
import torch
import torchvision
import matplotlib.pyplot as plt
import numpy as np
import timm
import argparse
from utils.configs import load_yaml
from dataset_utils.builder import build_dataloader
from utils.configs import seed_everything
from utils.visualization import tensor2img
import os
seed_everything(0)
parser = argparse.ArgumentParser("Fine-Grained Visual Classification")
parser.add_argument("--c", default="", type=str, help="config file path")
args = parser.parse_args()
assert args.c != "", "Please provide config file (.yaml)"
cfg_file = args.c.split(',')[0]
cfg_path=os.path.join('./configs/',cfg_file)
load_yaml(args, cfg_path)
args.batch_size=1
args.train_shuffle=False
# args.pretrained_local=f'./logs/{args.dataset_name}/{args.model_name}/2025-01-28-14-19/best.pt'
checkpoint = torch.load(args.pretrained_local, map_location=torch.device('cpu'),
                        weights_only=True)
model=timm.create_model(f'hf_hub:{args.model_name}',pretrained=False,num_classes=args.num_classes)
model.load_state_dict(checkpoint['model'])
device=torch.device('cuda')
model=model.to(device)
model.eval()
# _,val_loader=build_dataloader(args)
#在训练集上看看效果
_,val_loader=build_dataloader(args)
val_loader.num_workers=0
err_count=0
sample_count=0
# print(model)
if 'convnextv2' in args.model_name:
    target_layers = [model.stages[-1]]
elif 'resnet' in args.model_name:
    target_layers = [model.layer4[-1]]
# mapper=CIFAR10ClassMapper()
for idx,(idxs,datas,labels) in enumerate(val_loader.dataset):
    labels=torch.tensor([labels])
    datas=datas.unsqueeze(0)
    sample_count+=len(labels)
    datas=datas.to(device)
    labels=labels.to(device)
    with torch.no_grad():
        outs=model(datas)
        outs2=torch.softmax(outs,1)
        outs=torch.argmax(outs,1)
    #!=改成==，可以显示正确分类的图像热图信息
    err_idxs=outs!=labels
    # if idx in [7000,10994,35310,40144]:
    #     err_idxs=[True]
    err_outs=outs[err_idxs]
    plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows 系统
    if len(err_outs>0):
        err_count+=len(err_outs)
        err_datas=datas[err_idxs]

        print(f'{idxs}:{labels[err_idxs].cpu().numpy()}->{err_outs.cpu().numpy()}')
        input_tensor =err_datas[0] # Create an input tensor image for your model.
        img_input = tensor2img(input_tensor)
        input_tensor=input_tensor.unsqueeze(0)
        # Note: input_tensor can be a batch tensor with several images!
        # We have to specify the target we want to generate the CAM for.
        err_targets = [ClassifierOutputTarget(err_outs[0].cpu().numpy())]
        # img_input2=np.zeros_like(img_input)

        # Construct the CAM object once, and then re-use it on many images.
        with GradCAM(model=model, target_layers=target_layers) as cam:
            # You can also pass aug_smooth=True and eigen_smooth=True, to apply smoothing.
            grayscale_cam = cam(input_tensor=input_tensor, targets=err_targets)
            # In this example grayscale_cam has only one image in the batch:
            grayscale_cam = grayscale_cam[0, :]
            cam_err = show_cam_on_image(img_input, grayscale_cam, use_rgb=True)
            # You can also get the model outputs without having to redo inference
            # model_outputs = cam.outputs

        lbl_targets = [ClassifierOutputTarget(labels[0].cpu().numpy())]

        with GradCAM(model=model, target_layers=target_layers) as cam:
            grayscale_cam = cam(input_tensor=input_tensor, targets=lbl_targets)
            grayscale_cam = grayscale_cam[0, :]
            cam_lbl = show_cam_on_image(img_input, grayscale_cam, use_rgb=True)

        transforms=val_loader.dataset.transform
        val_loader.dataset.transform=torchvision.transforms.ToTensor()
        img_ori=val_loader.dataset[idx][1]
        val_loader.dataset.transform=transforms
        img_ori =tensor2img(img_ori)

        imgs_info=[('类激活图-标定类',cam_lbl),('类激活图-预测类',cam_err),
                   ('数据增强',img_input),('原始图',img_ori)]

        fig, axes = plt.subplots(1, 4, figsize=(10, 5))
        for i,(k,v) in enumerate(imgs_info):
            axes[i].imshow(v)
            axes[i].set_title(k)
            axes[i].axis('off')

        plt.show()
        plt.close()
        # break
print(err_count,sample_count)