ConvMAE实战：使用ConvMAE实现对植物幼苗的分类（非官方）（二）

2024-03-22 16:10
文章标签 实战 实现 使用 分类 植物 非官方 幼苗 convmae

本文主要是介绍ConvMAE实战：使用ConvMAE实现对植物幼苗的分类（非官方）（二），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

训练

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

导入项目使用的库

import json
import os
import shutil
import matplotlib.pyplot as plt
import torch
import torch.nn.parallel
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
from sklearn.metrics import classification_report
from timm.data.mixup import Mixup
from timm.loss import SoftTargetCrossEntropy
from timm.utils import accuracy, AverageMeter
from torchtoolbox.transform import Cutout
from torchvision import datasets
from models.models_convvit import convvit_base_patch16
torch.backends.cudnn.benchmark = False
os.environ['CUDA_VISIBLE_DEVICES'] = "0,1"

设置全局参数

设置学习率、BatchSize、epoch等参数，判断环境中是否存在GPU，如果没有则使用CPU。建议使用GPU，CPU太慢了。

if __name__ == '__main__':# 创建保存模型的文件夹file_dir = 'checkpoints/convmea'if os.path.exists(file_dir):print('true')# os.rmdir(file_dir)shutil.rmtree(file_dir)  # 删除再建立os.makedirs(file_dir)else:os.makedirs(file_dir)# 设置全局参数model_lr = 1e-4BATCH_SIZE = 2EPOCHS = 1000DEVICE = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')use_amp =True  # 是否使用混合精度use_dp = True  # 是否开启dp方式的多卡训练classes = 12resume = FalseCLIP_GRAD = 5.0model_path = 'best.pth'Best_ACC = 0  # 记录最高得分

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

接下来，查看全局参数：

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

BATCH_SIZE：batchsize，根据显卡的大小设置。

EPOCHS：epoch的个数，一般300够用。

use_amp：是否使用混合精度。

classes：类别个数。

resume：是否接着上次模型继续训练。

model_path：模型的路径。如果resume设置为True时，就采用model_path定义的模型继续训练。

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

Best_ACC：记录最高ACC得分。

图像预处理与增强

数据处理比较简单，加入了Cutout、做了Resize和归一化，定义Mixup函数。

这里注意下Resize的大小，由于RepLKNet的输入是224×224的大小，所以要Resize为224×224。

# 数据预处理7
transform = transforms.Compose([transforms.Resize((224, 224)),Cutout(),transforms.ToTensor(),transforms.Normalize(mean=[0.51819474, 0.5250407, 0.4945761], std=[0.24228974, 0.24347611, 0.2530049])
])
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])
])
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)

读取数据

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

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

# 读取数据
dataset_train = datasets.ImageFolder('data/train', transform=transform)
dataset_test = datasets.ImageFolder("data/val", transform=transform_test)
# 导入数据
train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=False)
print(dataset_train.class_to_idx)
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))

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函数，train的loss为：SoftTargetCrossEntropy，val的loss：nn.CrossEntropyLoss()。
  • 设置模型为convvit_base_patch16()，然后加载预训练模型，strict设置为False，是因为这个预训练和模型对不上，只获取能对上的权重。
  • num_classes设置为12。
  • 如果resume为True，则加载模型接着上次训练。
  • 优化器设置为adamW。
  • 学习率调整策略选择为余弦退火。
  • 开启混合精度训练，声明pytorch自带的混合精度 torch.cuda.amp.GradScaler()。
  • 检测可用显卡的数量，如果大于1，并且开启多卡训练的情况下，则要用torch.nn.DataParallel加载模型，开启多卡训练。
	# 实例化模型并且移动到GPUcriterion_train = SoftTargetCrossEntropy()criterion_val = torch.nn.CrossEntropyLoss()# 设置模型model_ft = convvit_base_patch16()model_ft.load_state_dict(torch.load('checkpoint.pth'), strict=False)numftr = model_ft.head.in_featuresmodel_ft.head = torch.nn.Linear(numftr, classes)# nn.init.trunc_normal_(model_ft.head.weight, std=2e-5)  # 将参数初始化为整态分布if resume:model_ft = torch.load(model_path)model_ft.to(DEVICE)print(model_ft)# 选择简单暴力的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)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)

注：torch.nn.DataParallel方式，默认不能开启混合精度训练的，如果想要开启混合精度训练，则需要在模型的forward前面加上@autocast()函数。

在这里插入图片描述

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

定义训练和验证函数

训练函数

训练的主要步骤：

1、使用AverageMeter保存自定义变量，包括loss，ACC1，ACC5。

2、判断迭代的数据是否是奇数，由于mixup_fn只能接受偶数，所以如果不是偶数则要减去一位，让其变成偶数。但是有可能最后一次迭代只有一条数据，减去后就变成了0，所以还要判断不能小于2，如果小于2则直接中断本次循环。

3、将数据输入mixup_fn生成mixup数据，然后输入model计算loss。

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

5、如果使用混合精度，则

  • with torch.cuda.amp.autocast(),开启混合精度。
  • 计算loss。
  • 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_函数执行梯度裁剪，防止梯度爆炸。

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

7、接下来，更新loss，ACC1，ACC5的值。

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

# 定义训练过程
def train(model, device, train_loader, optimizer, epoch):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):if len(data) % 2 != 0:if len(data) < 2:continuedata = data[0:len(data) - 1]target = target[0:len(target) - 1]print(len(data))data, target = data.to(device, non_blocking=True), 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 = 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 iterationscaler.update()else:loss = criterion_train(output, targets)loss.backward()torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD)optimizer.step()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.avgacc = acc1_meter.avgprint('epoch:{}\tloss:{:.2f}\tacc:{:.2f}'.format(epoch, ave_loss, acc))return ave_loss, acc

验证函数

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

1、定义参数，test_loss测试的loss，total_num总的验证集的数量，val_list验证集的label，pred_list预测的label。

2、在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求导。

3、使用验证集的loss函数求出验证集的loss。

4、调用accuracy函数计算ACC1和ACC5

5、更新loss_meter、acc1_meter、acc5_meter的参数。

本次epoch循环完成后，求得本次epoch的acc、loss。

如果acc比Best_ACC大，则保存模型。

# 验证过程
@torch.no_grad()
def val(model, device, test_loader):global Best_ACCmodel.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.avgprint('\nVal set: Average loss: {:.4f}\tAcc1:{:.0f}%\tAcc5:{:.0f}%\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 + "/" + 'model_' + str(epoch) + '_' + str(round(acc, 3)) + '.pth')torch.save(model.module, file_dir + '/' + 'best.pth')else:torch.save(model, file_dir + "/" + 'model_' + str(epoch) + '_' + str(round(acc, 3)) + '.pth')torch.save(model, file_dir + '/' + 'best.pth')Best_ACC = accreturn val_list, pred_list, loss_meter.avg, acc

调用训练和验证方法

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

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的值。

循环epoch

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

2、调用验证函数，得到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曲线。

 	# 训练与验证is_set_lr = Falselog_dir = {}train_loss_list, val_loss_list, train_acc_list, val_acc_list, epoch_list = [], [], [], [], []for epoch in range(1, EPOCHS + 1):epoch_list.append(epoch)train_loss, train_acc = train(model_ft, DEVICE, train_loader, optimizer, epoch)train_loss_list.append(train_loss)train_acc_list.append(train_acc)log_dir['train_acc'] = train_acc_listlog_dir['train_loss'] = train_loss_listval_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_listlog_dir['val_loss'] = val_loss_listlog_dir['best_acc'] = Best_ACCwith 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-6is_set_lr = Truefig = 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)

运行以及结果查看

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

在这里插入图片描述

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

在这里插入图片描述

绘制acc曲线
在这里插入图片描述

绘制loss曲线
训练了1000个epoch，最好的成绩能达到93.X%

测试

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

测试集存放的目录如下图：
在这里插入图片描述

import torch.utils.data.distributed
import torchvision.transforms as transforms
from PIL import Image
from torch.autograd import Variable
import osclasses = ('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((256, 256)),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/convmea/best.pth")
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、定义transforms，transforms和验证集的transforms一样即可，别做数据增强。

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

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

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

运行结果：

image-20220427112634211

完整的代码

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

这篇关于ConvMAE实战：使用ConvMAE实现对植物幼苗的分类（非官方）（二）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/835643。

相关文章

SpringBoot集成redisson实现延时队列教程

SpringBoot集成redisson实现延时队列教程

《SpringBoot集成redisson实现延时队列教程》文章介绍了使用Redisson实现延迟队列的完整步骤,包括依赖导入、Redis配置、工具类封装、业务枚举定义、执行器实现、Bean创建、消费... 目录1、先给项目导入Redisson依赖2、配置redis3、创建 RedissonConfig 配
阅读更多...
Python的Darts库实现时间序列预测

Python的Darts库实现时间序列预测

《Python的Darts库实现时间序列预测》Darts一个集统计、机器学习与深度学习模型于一体的Python时间序列预测库,本文主要介绍了Python的Darts库实现时间序列预测,感兴趣的可以了解... 目录目录一、什么是 Darts？二、安装与基本配置安装 Darts导入基础模块三、时间序列数据结构与
阅读更多...
Python使用FastAPI实现大文件分片上传与断点续传功能

Python使用FastAPI实现大文件分片上传与断点续传功能

《Python使用FastAPI实现大文件分片上传与断点续传功能》大文件直传常遇到超时、网络抖动失败、失败后只能重传的问题,分片上传+断点续传可以把大文件拆成若干小块逐个上传,并在中断后从已完成分片继... 目录一、接口设计二、服务端实现（FastAPI）2.1 运行环境2.2 目录结构建议2.3 serv
阅读更多...
C#实现千万数据秒级导入的代码

C#实现千万数据秒级导入的代码

《C#实现千万数据秒级导入的代码》在实际开发中excel导入很常见,现代社会中很容易遇到大数据处理业务,所以本文我就给大家分享一下千万数据秒级导入怎么实现,文中有详细的代码示例供大家参考,需要的朋友可... 目录前言一、数据存储二、处理逻辑优化前代码处理逻辑优化后的代码总结前言在实际开发中excel导入很
阅读更多...
MyBatis分页查询实战案例完整流程

MyBatis分页查询实战案例完整流程

《MyBatis分页查询实战案例完整流程》MyBatis是一个强大的Java持久层框架,支持自定义SQL和高级映射,本案例以员工工资信息管理为例,详细讲解如何在IDEA中使用MyBatis结合Page... 目录1. MyBATis框架简介2. 分页查询原理与应用场景2.1 分页查询的基本原理2.1.1 分
阅读更多...
Spring Security简介、使用与最佳实践

Spring Security简介、使用与最佳实践

《SpringSecurity简介、使用与最佳实践》SpringSecurity是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架,本文给大家介绍SpringSec... 目录一、如何理解 Spring Security？—— 核心思想二、如何在 Java 项目中使用？——
阅读更多...
SpringBoot+RustFS 实现文件切片极速上传的实例代码

SpringBoot+RustFS 实现文件切片极速上传的实例代码

《SpringBoot+RustFS实现文件切片极速上传的实例代码》本文介绍利用SpringBoot和RustFS构建高性能文件切片上传系统,实现大文件秒传、断点续传和分片上传等功能,具有一定的参考... 目录一、为什么选择 RustFS + SpringBoot？二、环境准备与部署2.1 安装 RustF
阅读更多...
Nginx部署HTTP/3的实现步骤

Nginx部署HTTP/3的实现步骤

《Nginx部署HTTP/3的实现步骤》本文介绍了在Nginx中部署HTTP/3的详细步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学... 目录前提条件第一步：安装必要的依赖库第二步：获取并构建 BoringSSL第三步：获取 Nginx
阅读更多...
springboot中使用okhttp3的小结

springboot中使用okhttp3的小结

《springboot中使用okhttp3的小结》OkHttp3是一个JavaHTTP客户端,可以处理各种请求类型,比如GET、POST、PUT等,并且支持高效的HTTP连接池、请求和响应缓存、以及异... 在 Spring Boot 项目中使用 OkHttp3 进行 HTTP 请求是一个高效且流行的方式。
阅读更多...
MyBatis Plus实现时间字段自动填充的完整方案

MyBatis Plus实现时间字段自动填充的完整方案

《MyBatisPlus实现时间字段自动填充的完整方案》在日常开发中,我们经常需要记录数据的创建时间和更新时间,传统的做法是在每次插入或更新操作时手动设置这些时间字段,这种方式不仅繁琐,还容易遗漏,... 目录前言解决目标技术栈实现步骤1. 实体类注解配置2. 创建元数据处理器3. 服务层代码优化填充机制详
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2