PyTorch 学习笔记

2019-12-25

1：准确度的计算

1.1 topk()相关

1	torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

沿给定dim维度返回输入张量input中 k 个最大值。
如果不指定dim，则默认为input的最后一维。
如果为largest为 False ，则返回最小的 k 个值。
返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标。
如果设定布尔值sorted 为_True_，将会确保返回的 k 个值被排序。
1
参数:
input (Tensor) – 输入张量
dim (int, optional) – 排序的维
largest (bool, optional) – 布尔值，控制返回最大或最小值
sorted (bool, optional) – 布尔值，控制返回值是否排序
out (tuple, optional) – 可选输出张量 (Tensor, LongTensor) output buffer

示例:

import torch
output = torch.tensor([[-5.4783, 0.2298],
                           [-4.2573, -0.4794],
                           [-0.1070, -5.1511],
                           [-0.1785, -4.3339]])
maxk = max((1,))  # 取top1准确率，若取top1和top5准确率改为max((1,5))
_, pred = output.topk(maxk, 1, True, True)

输出结果如下:

_
tensor([[ 0.2298],
        [-0.4794],
        [-0.1070],
        [-0.1785]])

pred
tensor([[1],
        [1],
        [0],
        [0]])

topk参数中，maxk取得是top1准确率，dim=1是按行取值， largest=1是取最大值

1.2 计算准确率

def accuracy(output, target, topk=(1,5)):
    """Computes the precision@k for the specified values of k
    prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
    """
    maxk = max(topk)
    # print(maxk)
    # size函数：总元素的个数
    batch_size = target.size(0)
    # topk函数选取output前k大个数,这里的_是值,pred是索引.
    _, pred = output.topk(maxk, 1, True, True)

    pred = pred.t()
    correct = pred.eq(target.view(1, -1).expand_as(pred))   
    res = []
    for k in topk:
        correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
        res.append(correct_k.mul_(100.0 / batch_size))
    return res

以top5，batch_size = 64为例：

1.topk()的使用：获取output中最大的5个数，如对第一张图片的output为[0.03,0.05,0.04,0.1…….(共1000个)]，经过topk()后得到的_是[0.2,0.19,0.18,0.17,0.16]，pred分别是其索引,共64张图片，可理解为一个645 的矩阵(其实是Tensor),然后在pred.t()求转置,变成564的矩阵,每一列的数即为该张图片的索引。(_是top1的值，pred是最大值的索引（size=4*1），一般会进行转置处理同真实值对比)

2.target为64个值，代表每张图片所属的类别，经过target.view()后变成[1,2,3,4,5,6,7…..]，再经过expand_as(pred)，该函数代表将target.view()扩展到跟pred相同的维度，可理解为5 X 64的矩阵，每一列的值都相同。

3.经过torch.eq()后，correct为一个5X64的矩阵，每一列仅有一个值为1，如第一列[0,0,1,0,0]，代表top1错误，top3正确，每一行代表top-k的值，在for循环中，可自由选择k的值，当K的值为4时，取correct前4行，通过.float().sum()操作，计算top4中1的总个数，除以batch_size，则能得到top4的准确率。

2. args.resume参数

args.resume这个参数主要是用来设置是否从断点处继续训练，比如原来训练模型训到一半停止了，希望继续从保存的最新epoch开始训练，因此args.resume要么是默认的None，要么就是你保存的模型文件（.pth）的路径。其中checkpoint = torch.load(args.resume)是用来导入已训练好的模型。model.load_state_dict(checkpoint[‘state_dict’])是完成导入模型的参数初始化model这个网络的过程，load_state_dict是torch.nn.Module类中重要的方法之一.

3. 按照迭代的次数n输出前n次的top1与top5平均值

top1.update(prec1[0], input.size(0))   #更新 input.size(0)=batch_size
top5.update(prec5[0], input.size(0))   #更新prec1[0]和prec5[0]是res返回的acc

class AverageMeter(object):
    # Computes and stores the average and current value
    """
       batch_time = AverageMeter()
       即 self = batch_time
       则 batch_time 具有__init__，reset，update三个属性，
       直接使用batch_time.update()调用
       功能为：batch_time.update(time.time() - end)
               仅一个参数，则直接保存参数值
        对应定义：def update(self, val, n=1)
        losses.update(loss.data[0], input.size(0))
        top1.update(prec1[0], input.size(0))
        top5.update(prec5[0], input.size(0))
        这些有两个参数则求参数val的均值，保存在avg中
    """
    def __init__(self):
        self.reset()       # __init__():reset parameters

    def reset(self):
        self.val = 0
        self.avg = 0
        self.sum = 0
        self.count = 0

    def update(self, val, n=1):
        self.val = val
        self.sum += val * n
        self.count += n
        self.avg = self.sum / self.count

reset()代表初始化，在训练过程中，每次iterion都会进行top1与top5的更新，每次iterion将会加载batch_size个数据，通过pre1.update()计算每次的平均值，val代表本次iterion的预测值，self.sum代表总的概率(25630%+25640%+50*70%)，self.count代表加载过的数据量（每次叠加），self.avg代表平均值（通过总概率除总数据量求得）。每个epoch单独计算平均概率。

4 随便迭代次数的增加,降低学习率.每30步，lr = lr /10;

def adjust_learning_rate(optimizer, epoch):
    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
    lr = args.lr * (0.1 ** (epoch // 30))            # args.lr = 0.1 , 即每30步，lr = lr /10
    for param_group in optimizer.param_groups:       # 将更新的lr 送入优化器 optimizer 中，进行下一次优化
        param_group['lr'] = lr

5.打印日志到pickle,序列化

class Logger(object):
  """ Class to update every epoch to keep trace of the results
    Methods:
        - log() log and save
    """

    def __init__(Self,path):
      self.path = path
      self.data = []

    def log(self,train_point):
      self.data.append(train_point)
      with open(os.path.join(self.path),"wb") as fb:
        pickle.dump(self.data,fp,-1)

# 创建loss_log,prec1,prec5三个文件,且loss_log,prec1_log,prec5_log
# 具有init,log的属性,能够将loss,prec1,prec5的信息写入到文件中
loss_log = Logger(os.path.join(exp_log, 'loss_log'))
# prec1 top1的准确率
prec1_log = Logger(os.path.join(exp_log, 'prec1'))
prec5_log = Logger(os.path.join(exp_log, 'prec5'))

loss_log.log(loss)
prec1_log.log(prec1)
prec5_log.log(prec5)

读取pickle(序列化)文件(此处应该注意你的pickle文件是在python2生成的还是python3生成的.应为Python3和Python2的字符串兼容问题，数据文件假如是在Python2下序列化的，在使用Python3读取时，需要将‘str’转化为’bytes’。或者python2序列化的就直接在python2环境下读取pickle文件):

import pickle
with open("C:/Users/Administrator/Desktop/prec11", "rb") as f:
    b = pickle.load(f)
    print(b)

6 设定随机种子

#设置random的随机种子,一般是np.random.seed(args.seed),不知道random.seed(args.seed)的作用
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)