在上一篇文章中完成了前期的准备工作见链接
ConvNeXt V2实战使用ConvNeXt V2实现图像分类任务一
这篇主要是讲解如何训练和测试

训练部分

完成上面的步骤后就开始train脚本的编写新建train.py

导入项目使用的库

在train.py导入

import json
import os
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
from timm.utils import accuracy, AverageMeter, ModelEma
from sklearn.metrics import classification_report
from timm.data.mixup import Mixup
from timm.loss import SoftTargetCrossEntropy
from models.convnextv2 import convnextv2_base
from torch.autograd import Variable
from torchvision import datasets
torch.backends.cudnn.benchmark = False
import warnings
warnings.filterwarnings("ignore")
os.environ['CUDA_VISIBLE_DEVICES']="0,1"

os.environ[‘CUDA_VISIBLE_DEVICES’]=“0,1” 选择显卡index从0开始比如一台机器上有8块显卡我们打算使用前两块显卡训练设置为“0,1”,同理如果打算使用第三块和第六块显卡训练则设置为“2,5”。

设置随机因子

def seed_everything(seed=42):
    os.environ['PYHTONHASHSEED'] = str(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.backends.cudnn.deterministic = True

设置了固定的随机因子再次训练的时候就可以保证图片的加载顺序不会发生变化。

设置全局参数

if __name__ == '__main__':
    #创建保存模型的文件夹
    file_dir = 'checkpoints/ConvNext/'
    if os.path.exists(file_dir):
        print('true')
        os.makedirs(file_dir,exist_ok=True)
    else:
        os.makedirs(file_dir)

    # 设置全局参数
    model_lr = 1e-4
    BATCH_SIZE = 16
    EPOCHS = 1000
    DEVICE = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    use_amp = True  # 是否使用混合精度
    use_dp = True #是否开启dp方式的多卡训练
    classes = 12
    resume =None #"checkpoints/ConvNext/model_5_93.776.pth"
    CLIP_GRAD = 5.0
    Best_ACC = 0 #记录最高得分
    use_ema=False
    model_ema_decay=0.9998
    start_epoch=1
    seed=1
    seed_everything(seed)

设置存放权重文件的文件夹如果文件夹存在删除再建立。

接下来设置全局参数比如学习率、BatchSize、epoch等参数判断环境中是否存在GPU如果没有则使用CPU。
注建议使用GPUCPU太慢了。

参数的详细解释

model_lr学习率根据实际情况做调整。

BATCH_SIZEbatchsize根据显卡的大小设置。

EPOCHSepoch的个数一般300够用。

use_amp是否使用混合精度。

use_dp 是否开启dp方式的多卡训练

classes类别个数。

resume再次训练的模型路径如果不为None,则表示加载resume指向的模型继续训练。

CLIP_GRAD梯度的最大范数在梯度裁剪里设置。

Best_ACC记录最高ACC得分。

use_ema是否使用ema

start_epoch开始的epoch默认是1如果重新训练时需要给start_epoch重新赋值。

SEED:随机因子数值可以随意设定但是设置后不要随意更改更改后图片加载的顺序会改变影响测试结果。

 file_dir = 'checkpoints/ConvNext'

这是存放ConvNext模型的路径。

图像预处理与增强

   # 数据预处理7
    transform = transforms.Compose([
        transforms.RandomRotation(10),
        transforms.GaussianBlur(kernel_size=(5,5),sigma=(0.1, 3.0)),
        transforms.ColorJitter(brightness=0.5, contrast=0.5, saturation=0.5),
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.44127703, 0.4712498, 0.43714803], std= [0.18507297, 0.18050247, 0.16784933])

    ])
    transform_test = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.44127703, 0.4712498, 0.43714803], std= [0.18507297, 0.18050247, 0.16784933])
    ])
    mixup_fn = Mixup(
        mixup_alpha=0.8, cutmix_alpha=1.0, cutmix_minmax=None,
        prob=0.1, switch_prob=0.5, mode='batch',
        label_smoothing=0.1, num_classes=classes)

数据处理和增强比较简单加入了随机10度的旋转、高斯模糊、色彩饱和度明亮度的变化、Mixup等比较常用的增强手段做了Resize和归一化。

这里注意下Resize的大小由于选用的PoolFormer模型输入是224×224的大小所以要Resize为224×224。

读取数据

   # 读取数据
    dataset_train = datasets.ImageFolder('data/train', transform=transform)
    dataset_test = datasets.ImageFolder("data/val", transform=transform_test)
    with open('class.txt', 'w') as file:
        file.write(str(dataset_train.class_to_idx))
    with open('class.json', 'w', encoding='utf-8') as file:
        file.write(json.dumps(dataset_train.class_to_idx))
    # 导入数据
    train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, pin_memory=True,shuffle=True,drop_last=True)
    test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=BATCH_SIZE, pin_memory=True,shuffle=False)

• 使用pytorch默认读取数据的方式然后将dataset_train.class_to_idx打印出来预测的时候要用到。

• 对于train_loader drop_last设置为True因为使用了Mixup数据增强必须保证每个batch里面的图片个数为偶数不能为零如果最后一个batch里面的图片为奇数则会报错所以舍弃最后batch的迭代。pin_memory设置为True可以加快运行速度。

• 将dataset_train.class_to_idx保存到txt文件或者json文件中。

class_to_idx的结果

{'Black-grass': 0, 'Charlock': 1, 'Cleavers': 2, 'Common Chickweed': 3, 'Common wheat': 4, 'Fat Hen': 5, 'Loose Silky-bent': 6, 'Maize': 7, 'Scentless Mayweed': 8, 'Shepherds Purse': 9, 'Small-flowered Cranesbill': 10, 'Sugar beet': 11}

设置Loss

  # 实例化模型并且移动到GPU
    criterion_train = SoftTargetCrossEntropy()
    criterion_val = torch.nn.CrossEntropyLoss()

设置loss函数训练的loss为SoftTargetCrossEntropy验证的lossnn.CrossEntropyLoss()。

设置模型

   #设置模型
    model_ft = convnextv2_base(pretrained=True)
    num_fr=model_ft.head.in_features
    model_ft.head=nn.Linear(num_fr,classes)
    if resume:
        model=torch.load(resume)
        print(model['state_dict'].keys())
        model_ft.load_state_dict(model['state_dict'])
        Best_ACC=model['Best_ACC']
        start_epoch=model['epoch']+1
    model_ft.to(DEVICE)

• 设置模型为convnextv2_basepretrained设置为true,表示加载预训练模型修改head层将将输出classes设置为12。
• 如果resume为True则加载模型接着resume指向的模型接着训练使用模型里的Best_ACC初始化Best_ACC使用epoch参数初始化start_epoch

设置优化器和学习率调整算法

   # 选择简单暴力的Adam优化器学习率调低
   optimizer = optim.AdamW(model_ft.parameters(),lr=model_lr)
   cosine_schedule = optim.lr_scheduler.CosineAnnealingLR(optimizer=optimizer, T_max=20, eta_min=1e-6)

• 优化器设置为adamW。
• 学习率调整策略选择为余弦退火。

设置混合精度DP多卡EMA

    if use_amp:
        scaler = torch.cuda.amp.GradScaler()
    if torch.cuda.device_count() > 1 and use_dp:
        print("Let's use", torch.cuda.device_count(), "GPUs!")
        model_ft = torch.nn.DataParallel(model_ft)
    if use_ema:
        model_ema = ModelEma(
            model_ft,
            decay=model_ema_decay,
            device=DEVICE,
            resume=resume)
    else:
        model_ema=None

• use_amp为True则开启混合精度训练,声明pytorch自带的混合精度 torch.cuda.amp.GradScaler()。
• 检测可用显卡的数量如果大于1并且开启多卡训练的情况下则要用torch.nn.DataParallel加载模型开启多卡训练。
• 如果使用ema则注册ema
  注torch.nn.DataParallel方式默认不能开启混合精度训练的如果想要开启混合精度训练则需要在模型的forward前面加上@autocast()函数。
  

如果不开启混合精度则要将@autocast()去掉否则loss一直试nan。

定义训练和验证函数

训练函数

# 定义训练过程
def train(model, device, train_loader, optimizer, epoch,model_ema):
    model.train()
    loss_meter = AverageMeter()
    acc1_meter = AverageMeter()
    acc5_meter = AverageMeter()
    total_num = len(train_loader.dataset)
    print(total_num, len(train_loader))
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device, non_blocking=True), Variable(target).to(device,                                                                                 non_blocking=True)
        samples, targets = mixup_fn(data, target)
        output = model(samples)
        optimizer.zero_grad()
        if use_amp:
            with torch.cuda.amp.autocast():
                loss = torch.nan_to_num(criterion_train(output, targets))
            scaler.scale(loss).backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD)
            # Unscales gradients and calls
            # or skips optimizer.step()
            scaler.step(optimizer)
            # Updates the scale for next iteration
            scaler.update()
        else:
            loss = criterion_train(output, targets)
            loss.backward()
            # torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD)
            optimizer.step()

        if model_ema is not None:
            model_ema.update(model)
        torch.cuda.synchronize()
        lr = optimizer.state_dict()['param_groups'][0]['lr']
        loss_meter.update(loss.item(), target.size(0))
        acc1, acc5 = accuracy(output, target, topk=(1, 5))
        loss_meter.update(loss.item(), target.size(0))
        acc1_meter.update(acc1.item(), target.size(0))
        acc5_meter.update(acc5.item(), target.size(0))
        if (batch_idx + 1) % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tLR:{:.9f}'.format(
                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
                       100. * (batch_idx + 1) / len(train_loader), loss.item(), lr))
    ave_loss =loss_meter.avg
    acc = acc1_meter.avg
    print('epoch:{}\tloss:{:.2f}\tacc:{:.2f}'.format(epoch, ave_loss, acc))
    return ave_loss, acc

训练的主要步骤

1、使用AverageMeter保存自定义变量包括lossACC1ACC5。

2、进入循环将data和target放入device上non_blocking设置为True。如果pin_memory=True的话将数据放入GPU的时候也应该把non_blocking打开这样就只把数据放入GPU而不取出访问时间会大大减少。
如果pin_memory=False时则将non_blocking设置为False。

3、将数据输入mixup_fn生成mixup数据。

4、将第三部生成的mixup数据输入model输出预测结果然后再计算loss。

5、 optimizer.zero_grad() 梯度清零把loss关于weight的导数变成0。

6、如果使用混合精度则

• with torch.cuda.amp.autocast(),开启混合精度。
• 计算loss。torch.nan_to_num将输入中的NaN、正无穷大和负无穷大替换为NaN、posinf和neginf。默认情况下nan会被替换为零正无穷大会被替换为输入的dtype所能表示的最大有限值负无穷大会被替换为输入的dtype所能表示的最小有限值。
  
• scaler.scale(loss).backward()梯度放大。
• torch.nn.utils.clip_grad_norm_梯度裁剪放置梯度爆炸。
• scaler.step(optimizer) 首先把梯度值unscale回来如果梯度值不是inf或NaN,则调用optimizer.step()来更新权重否则忽略step调用从而保证权重不更新。
• 更新下一次迭代的scaler。

否则直接反向传播求梯度。torch.nn.utils.clip_grad_norm_函数执行梯度裁剪防止梯度爆炸。

7、如果use_ema为True则执行model_ema的updata函数更新模型。

8、 torch.cuda.synchronize()等待上面所有的操作执行完成。

9、接下来更新lossACC1ACC5的值。

等待一个epoch训练完成后计算平均loss和平均acc

验证函数

# 验证过程
@torch.no_grad()
def val(model, device, test_loader):
    global Best_ACC
    model.eval()
    loss_meter = AverageMeter()
    acc1_meter = AverageMeter()
    acc5_meter = AverageMeter()
    total_num = len(test_loader.dataset)
    print(total_num, len(test_loader))
    val_list = []
    pred_list = []
    for data, target in test_loader:
        for t in target:
            val_list.append(t.data.item())
        data, target = data.to(device,non_blocking=True), target.to(device,non_blocking=True)
        output = model(data)
        loss = criterion_val(output, target)
        _, pred = torch.max(output.data, 1)
        for p in pred:
            pred_list.append(p.data.item())
        acc1, acc5 = accuracy(output, target, topk=(1, 5))
        loss_meter.update(loss.item(), target.size(0))
        acc1_meter.update(acc1.item(), target.size(0))
        acc5_meter.update(acc5.item(), target.size(0))
    acc = acc1_meter.avg
    print('\nVal set: Average loss: {:.4f}\tAcc1:{:.3f}%\tAcc5:{:.3f}%\n'.format(
        loss_meter.avg,  acc,  acc5_meter.avg))
    if acc > Best_ACC:
        if isinstance(model, torch.nn.DataParallel):
            torch.save(model.module, file_dir + '/' + 'best.pth')
        else:
            torch.save(model, file_dir + '/' + 'best.pth')
        Best_ACC = acc
    if isinstance(model, torch.nn.DataParallel):
        state = {
            'epoch': epoch,
            'state_dict': model.module.state_dict(),
            'Best_ACC':Best_ACC
        }
        if use_ema:
            state['state_dict_ema']=model.module.state_dict()
        torch.save(state, file_dir + "/" + 'model_' + str(epoch) + '_' + str(round(acc, 3)) + '.pth')
    else:
        state = {
            'epoch': epoch,
            'state_dict': model.state_dict(),
            'Best_ACC': Best_ACC
        }
        if use_ema:
            state['state_dict_ema']=model.state_dict()
        torch.save(state, file_dir + "/" + 'model_' + str(epoch) + '_' + str(round(acc, 3)) + '.pth')
    return val_list, pred_list, loss_meter.avg, acc

验证集和训练集大致相似主要步骤

1、在val的函数上面添加@torch.no_grad()作用所有计算得出的tensor的requires_grad都自动设置为False。即使一个tensor命名为x的requires_grad = True在with torch.no_grad计算由x得到的新tensor命名为w-标量requires_grad也为False且grad_fn也为None,即不会对w求导。

2、定义参数:
loss_meter: 测试的loss
acc1_meter:top1的ACC。
acc5_metertop5的ACC。
total_num总的验证集的数量。
val_list验证集的label。
pred_list预测的label。

3、进入循环迭代test_loader

将label保存到val_list。

将data和target放入device上non_blocking设置为True。

将data输入到model中求出预测值然后输入到loss函数中求出loss。

调用torch.max函数将预测值转为对应的label。

将输出的预测值的label存入pred_list。

调用accuracy函数计算ACC1和ACC5

更新loss_meter、acc1_meter、acc5_meter的参数。

4、本次epoch循环完成后求得本次epoch的acc、loss。
5、接下来是保存模型的逻辑
如果ACC比Best_ACC高则保存best模型
判断模型是否为DP方式训练的模型。

如果是DP方式训练的模型模型参数放在model.module则需要保存model.module。
否则直接保存model。
注保存best模型我们采用保存整个模型的方式这样保存的模型包含网络结构在预测的时候就不用再重新定义网络了。

6、接下来保存每个epoch的模型。
判断模型是否为DP方式训练的模型。

如果是DP方式训练的模型模型参数放在model.module则需要保存model.module.state_dict()。

新建个字典放置Best_ACC、epoch和 model.module.state_dict()等参数。然后将这个字典保存。判断是否是使用EMA如果使用则还需要保存一份ema的权重。
否则新建个字典放置Best_ACC、epoch和 model.state_dict()等参数。然后将这个字典保存。判断是否是使用EMA如果使用则还需要保存一份ema的权重。

注意对于每个epoch的模型只保存了state_dict参数没有保存整个模型文件。

调用训练和验证方法

    # 训练与验证
    is_set_lr = False
    log_dir = {}
    train_loss_list, val_loss_list, train_acc_list, val_acc_list, epoch_list = [], [], [], [], []
    if resume and os.path.isfile(file_dir+"result.json"):
        with open(file_dir+'result.json', 'r', encoding='utf-8') as file:
            logs = json.load(file)
            train_acc_list = logs['train_acc']
            train_loss_list = logs['train_loss']
            val_acc_list = logs['val_acc']
            val_loss_list = logs['val_loss']
            epoch_list = logs['epoch_list']
    for epoch in range(start_epoch, EPOCHS + 1):
        epoch_list.append(epoch)
        log_dir['epoch_list'] = epoch_list
        train_loss, train_acc = train(model_ft, DEVICE, train_loader, optimizer, epoch,model_ema)
        train_loss_list.append(train_loss)
        train_acc_list.append(train_acc)
        log_dir['train_acc'] = train_acc_list
        log_dir['train_loss'] = train_loss_list
        if use_ema:
            val_list, pred_list, val_loss, val_acc = val(model_ema.ema, DEVICE, test_loader)
        else:
            val_list, pred_list, val_loss, val_acc = val(model_ft, DEVICE, test_loader)
        val_loss_list.append(val_loss)
        val_acc_list.append(val_acc)
        log_dir['val_acc'] = val_acc_list
        log_dir['val_loss'] = val_loss_list
        log_dir['best_acc'] = Best_ACC
        with open(file_dir + '/result.json', 'w', encoding='utf-8') as file:
            file.write(json.dumps(log_dir))
        print(classification_report(val_list, pred_list, target_names=dataset_train.class_to_idx))
        if epoch < 600:
            cosine_schedule.step()
        else:
            if not is_set_lr:
                for param_group in optimizer.param_groups:
                    param_group["lr"] = 1e-6
                    is_set_lr = True
        fig = plt.figure(1)
        plt.plot(epoch_list, train_loss_list, 'r-', label=u'Train Loss')
        # 显示图例
        plt.plot(epoch_list, val_loss_list, 'b-', label=u'Val Loss')
        plt.legend(["Train Loss", "Val Loss"], loc="upper right")
        plt.xlabel(u'epoch')
        plt.ylabel(u'loss')
        plt.title('Model Loss ')
        plt.savefig(file_dir + "/loss.png")
        plt.close(1)
        fig2 = plt.figure(2)
        plt.plot(epoch_list, train_acc_list, 'r-', label=u'Train Acc')
        plt.plot(epoch_list, val_acc_list, 'b-', label=u'Val Acc')
        plt.legend(["Train Acc", "Val Acc"], loc="lower right")
        plt.title("Model Acc")
        plt.ylabel("acc")
        plt.xlabel("epoch")
        plt.savefig(file_dir + "/acc.png")
        plt.close(2)

调用训练函数和验证函数的主要步骤

1、定义参数

• is_set_lr是否已经设置了学习率当epoch大于一定的次数后会将学习率设置到一定的值并将其置为True。
• log_dir记录log用的将有用的信息保存到字典中然后转为json保存起来。
• train_loss_list保存每个epoch的训练loss。
• val_loss_list保存每个epoch的验证loss。
• train_acc_list保存每个epoch的训练acc。
• val_acc_list保存么每个epoch的验证acc。
• epoch_list存放每个epoch的值。

如果是接着上次的断点继续训练则读取log文件然后把log取出来赋值到对应的list上。
循环epoch

1、调用train函数得到 train_loss, train_acc并将分别放入train_loss_listtrain_acc_list然后存入到logdir字典中。

2、调用验证函数判断是否使用EMA
如果使用EMA则传入model_ema.ema否则传入model_ft。得到val_list, pred_list, val_loss, val_acc。将val_loss, val_acc分别放入val_loss_list和val_acc_list中然后存入到logdir字典中。

3、保存log。

4、打印本次的测试报告。

5、如果epoch大于600将学习率设置为固定的1e-6。

6、绘制loss曲线和acc曲线。

运行以及结果查看

完成上面的所有代码就可以开始运行了。点击右键然后选择“run train.py”即可运行结果如下

在每个epoch测试完成之后打印验证集的acc、recall等指标。

ConvNeXt V2测试结果

测试

测试我们采用一种通用的方式。

测试集存放的目录如下图

PoolFormer_demo
├─test
│  ├─1.jpg
│  ├─2.jpg
│  ├─3.jpg
│  ├ ......
└─test.py

import torch.utils.data.distributed
import torchvision.transforms as transforms
from PIL import Image
from torch.autograd import Variable
import os

classes = ('Black-grass', 'Charlock', 'Cleavers', 'Common Chickweed',
           'Common wheat', 'Fat Hen', 'Loose Silky-bent',
           'Maize', 'Scentless Mayweed', 'Shepherds Purse', 'Small-flowered Cranesbill', 'Sugar beet')
transform_test = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.51819474, 0.5250407, 0.4945761], std=[0.24228974, 0.24347611, 0.2530049])
])

DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model=torch.load('checkpoints/PoolFormer/best.pth',map_location='cpu')
model.eval()
model.to(DEVICE)

path = 'test/'
testList = os.listdir(path)
for file in testList:
    img = Image.open(path + file)
    img = transform_test(img)
    img.unsqueeze_(0)
    img = Variable(img).to(DEVICE)
    out = model(img)
    # Predict
    _, pred = torch.max(out.data, 1)
    print('Image Name:{},predict:{}'.format(file, classes[pred.data.item()]))

测试的主要逻辑

1、定义类别这个类别的顺序和训练时的类别顺序对应一定不要改变顺序

2、定义transformstransforms和验证集的transforms一样即可别做数据增强。

3、 加载model并将模型放在DEVICE里

4、循环 读取图片并预测图片的类别在这里注意读取图片用PIL库的Image。不要用cv2transforms不支持。循环里面的主要逻辑

• 使用Image.open读取图片
• 使用transform_test对图片做归一化和标椎化。
• img.unsqueeze_(0) 增加一个维度由3224224变为13224224
• Variable(img).to(DEVICE)将数据放入DEVICE中。
• model(img)执行预测。
• _, pred = torch.max(out.data, 1):获取预测值的最大下角标。

运行结果

热力图可视化展示

新建脚本cam_image.py,插入如下代码

import argparse
import os
import cv2
import numpy as np
import torch
from pytorch_grad_cam import GradCAM, \
    ScoreCAM, \
    GradCAMPlusPlus, \
    AblationCAM, \
    XGradCAM, \
    EigenCAM, \
    EigenGradCAM, \
    LayerCAM, \
    FullGrad
from pytorch_grad_cam import GuidedBackpropReLUModel
from pytorch_grad_cam.utils.image import show_cam_on_image, \
    deprocess_image, \
    preprocess_image
from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget

import timm
from torch.autograd import Variable


def reshape_transform_resmlp(tensor, height=14, width=14):
    result = tensor.reshape(tensor.size(0),
                            height, width, tensor.size(2))

    result = result.transpose(2, 3).transpose(1, 2)
    return result


def reshape_transform_swin(tensor, height=7, width=7):
    result = tensor.reshape(tensor.size(0),
                            height, width, tensor.size(2))

    # Bring the channels to the first dimension,
    # like in CNNs.
    result = result.transpose(2, 3).transpose(1, 2)
    return result


def reshape_transform_vit(tensor, height=14, width=14):
    result = tensor[:, 1:, :].reshape(tensor.size(0),
                                      height, width, tensor.size(2))

    # Bring the channels to the first dimension,
    # like in CNNs.
    result = result.transpose(2, 3).transpose(1, 2)
    return result


def get_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--use-cuda', action='store_true', default=False,
                        help='Use NVIDIA GPU acceleration')
    parser.add_argument(
        '--image-path',
        type=str,
        default="./test/0bf7bfb05.png",
        help='Input image path')
    parser.add_argument(
        '--output-image-path',
        type=str,
        default=None,
        help='Output image path')
    parser.add_argument(
        '--model',
        type=str,
        default='convnext',
        help='model name')
    parser.add_argument('--aug_smooth', action='store_true',
                        help='Apply test time augmentation to smooth the CAM')
    parser.add_argument(
        '--eigen_smooth',
        action='store_true',
        help='Reduce noise by taking the first principle componenet'
             'of cam_weights*activations')
    parser.add_argument('--method', type=str, default='gradcam++',
                        choices=['gradcam', 'gradcam++',
                                 'scorecam', 'xgradcam',
                                 'ablationcam', 'eigencam',
                                 'eigengradcam', 'layercam', 'fullgrad'],
                        help='Can be gradcam/gradcam++/scorecam/xgradcam'
                             '/ablationcam/eigencam/eigengradcam/layercam')

    args = parser.parse_args()
    args.use_cuda = args.use_cuda and torch.cuda.is_available()
    if args.use_cuda:
        print('Using GPU for acceleration')
    else:
        print('Using CPU for computation')

    return args


if __name__ == '__main__':
    args = get_args()
    methods = \
        {"gradcam": GradCAM,
         "scorecam": ScoreCAM,
         "gradcam++": GradCAMPlusPlus,
         "ablationcam": AblationCAM,
         "xgradcam": XGradCAM,
         "eigencam": EigenCAM,
         "eigengradcam": EigenGradCAM,
         "layercam": LayerCAM,
         "fullgrad": FullGrad}

    DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model = torch.load('checkpoints/ConvNext/best.pth', map_location='cpu')
    reshape_transform = None
    if 'poolformer' in args.model:
        target_layers = [model.network[-1]]  # [model.network[-1][-2]]
        print(target_layers)
    elif 'resnet' in args.model:
        target_layers = [model.layer4[-1]]
    elif 'convnext' in args.model:
        target_layers = [model.stages[-1]]
    elif 'resmlp' in args.model:
        target_layers = [model.blocks[-1]]
        reshape_transform = reshape_transform_resmlp
    elif 'deit' in args.model:
        target_layers = [model.blocks[-1].norm1]
        reshape_transform = reshape_transform_vit
    elif 'swin' in args.model:
        target_layers = [model.layers[-1].blocks[-1]]
        reshape_transform = reshape_transform_swin
    print(target_layers)
    model.eval()
    model.to(DEVICE)
    img_path = args.image_path
    if args.image_path:
        img_path = args.image_path
    else:
        import requests

        image_url = 'http://146.48.86.29/edge-mac/imgs/n02123045/ILSVRC2012_val_00023779.JPEG'
        img_path = image_url.split('/')[-1]
        if os.path.exists(img_path):
            img_data = requests.get(image_url).content
            with open(img_path, 'wb') as handler:
                handler.write(img_data)

    if args.output_image_path:
        save_name = args.output_image_path
    else:
        img_type = img_path.split('.')[-1]
        it_len = len(img_type)
        save_name = img_path.split('/')[-1][:-(it_len + 1)]
        save_name = save_name + '_' + args.model + '.' + img_type

    img = cv2.imread(img_path, 1)
    img = cv2.resize(img, (224, 224), interpolation=cv2.INTER_AREA)
    if args.model == 'resize':
        cv2.imwrite(save_name, img)
    else:
        rgb_img = img[:, :, ::-1]
        rgb_img = np.float32(rgb_img) / 255
        input_tensor = Variable(preprocess_image(rgb_img,
                                                 mean=[0.485, 0.456, 0.406],
                                                 std=[0.229, 0.224, 0.225]), requires_grad=True).to(DEVICE)
        targets = None
        cam_algorithm = methods[args.method]
        with cam_algorithm(model=model,
                           target_layers=target_layers,
                           use_cuda=args.use_cuda,
                           reshape_transform=reshape_transform,
                           ) as cam:

            cam.batch_size = 1
            grayscale_cam = cam(input_tensor=input_tensor,
                                targets=targets,
                                aug_smooth=args.aug_smooth,
                                eigen_smooth=args.eigen_smooth)

            grayscale_cam = grayscale_cam[0, :]
            cam_image = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)
            cam_image = cv2.cvtColor(cam_image, cv2.COLOR_RGB2BGR)

        cv2.imwrite(save_name, cam_image)

对get_args函数的参数进行设置

• use-cuda:是否使用cuda如果在没有GPU的电脑上调试时将其设置为False。
• image-path待测图片的路径这个是必填项。
• model必填项默认值convnext。

效果如下图所示

完整的代码

完整的代码

https://download.csdn.net/download/hhhhhhhhhhwwwwwwwwww/87523225