深度学习中的函数（一）

1.zip文件解压到任意路径下（python）

#解压自己上传的程序压缩包，解压到work文件夹下，然后自己根据需要重命名
import zipfile
f = zipfile.ZipFile("mobilenet-v4-torch-AI.zip",'r') 
for file in f.namelist():   
    f.extract(file,"work/")#将文件解压到当前文件夹下            
f.close()
1
2
3
4
5
6

2.遍历文件夹下的内容，根据后缀名进行筛选，只保存除后缀名外的名字（python）

import os
path = r"G:\pycharm"
name=[]
for i in os.listdir(path):
    if i.endswith(".png"):
    	#file_name: cat      extension: .png
        (file_name, extension) = os.path.splitext(i)
        name.append(file_name)
print(name)
1
2
3
4
5
6
7
8
9

3.设置使用断点续训（python）

import argparse

#       1.首先设置容器  
parser = argparse.ArgumentParser(description=__doc__)
# 若需要接着上次训练，则指定上次训练保存权重文件地址
parser.add_argument('--resume', default='', type=str, help='resume from checkpoint')

#       2.训练阶段保存模型参数（设置在循环训练模型的代码中）
save_files = {
	'model': model.state_dict(),
	'optimizer': optimizer.state_dict(),
	'lr_scheduler': lr_scheduler.state_dict(),
	'epoch': epoch}
torch.save(save_files, "./save_weights/model_{}.pth".format(epoch))

#       3.使用断点续训
# 如果传入resume参数，即上次训练的权重地址，则接着上次的参数训练
if args.resume:
	checkpoint = torch.load(args.resume, map_location='cpu')  # 读取之前保存的权重文件(包括优化器以及学习率策略)
	model.load_state_dict(checkpoint['model'])
	optimizer.load_state_dict(checkpoint['optimizer'])
	lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
	args.start_epoch = checkpoint['epoch'] + 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.优化器设置及学习率衰减策略（python）

#        1.将args容器定义在主函数内
if__name__=='__main__':
	import argparse
	parser = argparse.ArgumentParser(description=__doc__)
	# SGD的momentum参数
	parser.add_argument('--momentum', default=0.9, type=float, metavar='M',help='momentum')
	# SGD的weight_decay参数
	parser.add_argument('--wd', '--weight-decay', default=1e-4, type=float,metavar='W', help='weight decay (default: 1e-4)',
		dest='weight_decay')
	# 针对torch.optim.lr_scheduler.MultiStepLR的参数[16,22]
	parser.add_argument('--lr-steps', default=[5, 8], nargs='+', type=int,help='decrease lr every step-size epochs')
	# 针对torch.optim.lr_scheduler.MultiStepLR的参数
	parser.add_argument('--lr-gamma', default=0.1, type=float, help='decrease lr by a factor of lr-gamma')
	args = parser.parse_args()

#       2.模型训练阶段调用优化器策略和学习率衰减策略
model = xxxx()
model.to(device)
# 将可训练参数保存在params列表内
params = [p for p in model.parameters() if p.requires_grad]
# 设置SGD优化器
optimizer = torch.optim.SGD(params, lr=args.lr,
                                momentum=args.momentum,
                                weight_decay=args.weight_decay)
# 学习率衰减策略
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma)
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

5.Tensorboard可视化代码（python）

from torch.utils.tensorboard import SummaryWriter  # 导包
writer = SummaryWriter()               # 生成默认的存储文件
writer = SummaryWriter("tensorboard")  # 指定存储路径为tensorboard文件夹 （writer要为全局变量）
writer.add_scalar('y=2x', i * 2, i)    #第一个元素是可视化图的标题，第二个标题是可视化的数据（标量），第三个元素是x轴坐标
1
2
3
4

6.模型训练及测试及Tensorboard可视化的主要步骤（python）

from torch.utils.tensorboard import SummaryWriter  # 导包
writer = SummaryWriter()               # 生成默认的存储文件
writer = SummaryWriter("tensorboard")  # 指定存储路径为tensorboard文件夹 （writer要为全局变量）

#        1.将args容器定义在主函数内
if__name__=='__main__':
	import argparse
	parser = argparse.ArgumentParser(description=__doc__)
	# 指定接着从哪个epoch数开始训练
    parser.add_argument('--start_epoch', default=0, type=int, help='start epoch')
    # 训练的总epoch数
    parser.add_argument('--epochs', default=10, type=int, metavar='N',help='number of total epochs to run')
    args = parser.parse_args()
    
#        2.模型训练的主要步骤
for epoch in range(args.start_epoch, args.epochs):
	# 训练阶段
	model.train()
    train_loss = 0.0  #  训练损失初始化为0
    train_bar = tqdm(train_loader, file=sys.stdout)  #  类似于处理数据的进度条
    for step, data in enumerate(train_bar):  
		images, labels = data
        optimizer.zero_grad()  #  梯度清零，因为optimizer里面保存着可训练参数params
        logits = model(images.to(device))  #  图片读入网络，产生预测值
        loss = loss_function(logits, labels.to(device))  #  预测值和真实值计算损失
        loss.backward()   #   误差反向传播
        optimizer.step()  #   参数迭代更新
        train_loss += loss.item()   #   训练阶段的损失值
		train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1, epochs, loss)
		
	#  测试阶段
	model.eval()
        acc = 0.0  # 精度初始化
        with torch.no_grad():
            val_bar = tqdm(validate_loader, file=sys.stdout)
            for val_data in val_bar:
                val_images, val_labels = val_data      # 测试集图片和标签
                outputs = model(val_images.to(device))
                predict_y = torch.max(outputs, dim=1)[1]   # outputs输出的是tensor变量，每行最大值
                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()   # 判断两个数组的元素是否相等torch.eq(a,b) 返回的是数组维度的True 或者 False 值
                val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1, epochs)
        val_accurate = acc / val_num    #  测试集精度
        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %(epoch + 1, train_loss / train_steps, val_accurate))
        writer.add_scalar('train loss', train_loss/ train_steps, epoch)    # 第一个元素是可视化图的标题，第二个标题是可视化的数据（变量），第三个元素是x轴坐标---》将train_loss的值写入tensorboard
        writer.add_scalar('val accurate', val_accurate, epoch)    # 第一个元素是可视化图的标题，第二个标题是可视化的数据（变量），第三个元素是x轴坐标---》将测试集精度的值写入tensorboard
        
        # 做一个判断  保存最佳精度  其中best_acc为全局变量
        if val_accurate > best_acc:
            best_acc = val_accurate
            torch.save(model.state_dict(), save_path)   # 保存模型的参数 
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