NLP-DAY5-李宏毅机器学习L2_saving model with acc

今天起的很早，3:30就起了。我真的很喜欢早起的感觉。
早上第一次尝试用notability做笔记，梳理了一个slide的内容。大概是什么是机器学习，神经网络的搭建步骤（对理解神经网络很有帮助）。

后来又看了一些L2的正课，就去收拾宿舍、干活了。现在8:00，打算继续看L2！

0837听完了L2的正课，主要是在用一个实际区别的例子讲解训练集采样的问题。引出了训练集与Dall之间的概率分布问题，并说明模型复杂度和样本数据量共同决定着L（htrain,Dall)和L(hall,Dall)之间的差距。虽然减小H可以使两者close，但是也会使“理想崩塌”，也就是L（hall,Dall）减小，因为H的可选择空间变小了。

0843突然想到，其实可以在ipad上做预习，到时候复习也好check！！！下载一下slides。

0847下完资料，预习一下作业，看作业去。
0858看完资料了，在想要不要在ipad上做笔记！感觉可以试一下！
0920太香了！！！可以在ipad上预习+做笔记；然后在notability上总结问题和践行费曼学习法的时候！！！去接个水！！！开始看code！！！先跑一下

0926回来看代码
1、这里的*是干什么的呢？
因为大概知道意思，所以就查了一下“如何写多个同样的结构”

大概的意思是，*是一个可以拆分列表的运算符，具体如下：

可以看到psxx的层的东西都是一样的，层结构一样，参数也一样，那么有没有个方便的写法，简化一些。
python里面有个写法是可以这样生成一个列表的，
[a for a in list_a]
又有一个能把列表的元素拆分成单个元素的*运算符。
那么就可以改成这样：
参考链接：https://blog.csdn.net/Yonggie/article/details/115373788

2、gc.collect()作用，del作用，两者区别？
大概看了一下，就是del不一定会清空内存，但是del的本意是清空内存，为了确保真的清空了，我们就gc一下。
参考：https://www.py.cn/jishu/jichu/10819.html

清空内存，源代码如下：

3、代码主体流程
正好复习一下pytorch的使用，巩固一下。写了注释。
一、数据预处理
1、观察数据，对其进行加工
2、返回向量形式
二、定义数据集类、划分数据集、dataloader
三、定义模型
四、准备训练（确认gpu及实例化）
1、查看gpu连接
2、定义种子
3、实例化模型
4、实例化criterion,损失函数
5、实例化optimizer
五、训练
清理train_loader和val_loader所占用内存空间
六、测试
------load data
1、导入
2、实例化数据类
3、使用DataLoader获得batch集。

---

--------load model
1、实例化模型
2、把参数导入到模型中

---------预测测试集

test_acc = 0.0
test_lengths = 0
pred = np.array([], dtype=np.int32)
# 把模型调到测试模式
model.eval()
with torch.no_grad():
    for i, batch in enumerate(tqdm(test_loader)):
      # 获取每个batch中的数据
        features = batch
        # 把feature数据送给机器
        features = features.to(device)
        # 获得预测结果
        outputs = model(features)

        _, test_pred = torch.max(outputs, 1) # get the index of the class with the highest probability
        # 将不同batch的结果按照按照纵向concatenate
        pred = np.concatenate((pred, test_pred.cpu().numpy()), axis=0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

model.load_state_dict(torch.load(model_path))
1

4、pytorch相关语法
(1)torch.max的返回值
如果加了dim的话，会返回（最大值，索引）

(2)detach（）作用

因为torch中计算的数据都是带有gradient的，所以想要转化为其他类型，就要先把gradient去掉，这也就是detach的作用！

参考文献：
https://codeantenna.com/a/kYNYAYqUeu

1135啊啊啊上午没看手机，突然被同学叫去开会了。
又弄了一下快递的事情，现在打完饭，预习一下下一章节的slides，一会下去吃的时候可以看。下午1350还要去做核酸~

1139把主要代码的comment补完，梳理了一遍，自己还没能力写！有机会复现！

best_acc = 0.0
for epoch in range(num_epoch):
    # 记录每个epoch的参数
    train_acc = 0.0
    train_loss = 0.0
    val_acc = 0.0
    val_loss = 0.0
    
    # training
    # model调整至训练模式
    model.train() # set the model to training mode
    # train_loader里面是实例化的对象，里面是一个个batch元组
    for i, batch in enumerate(tqdm(train_loader)):
      # 1得到每个batch数据，每个batch是（featues,labels）
        features, labels = batch
        # 2\把数据给机器
        features = features.to(device)
        labels = labels.to(device)
        # 3\梯度回零
        optimizer.zero_grad() 
        # 4\前向传播
        outputs = model(features) 
        # 5\定义损失函数
        loss = criterion(outputs, labels)
        # 6\计算这一batch的参数的梯度
        loss.backward() 
        # 6\对参数进行优化
        optimizer.step() 
        # train_pred为1维度上最大值的索引
        _, train_pred = torch.max(outputs, 1) # get the index of the class with the highest probability
        # 先对一堆去g，然后对比，得到sum，但是仍为torch类型数据，通过Item（）转换为python类型
        train_acc += (train_pred.detach() == labels.detach()).sum().item()
        train_loss += loss.item()
    
    # validation
    if len(val_set) > 0:
      # 将模型调整至test模式
        model.eval() # set the model to evaluation mode
        # 用with语句保证不变动g
        with torch.no_grad():
            for i, batch in enumerate(tqdm(val_loader)):
              # 1\得到每个batch的数据
                features, labels = batch
              # 2、将数据分配给机器
                features = features.to(device)
                labels = labels.to(device)
              # 3、前向传播
                
                outputs = model(features)
              # 4、定义损失函数
                loss = criterion(outputs, labels) 
                # 5、检查预测结果
                _, val_pred = torch.max(outputs, 1) 
                val_acc += (val_pred.cpu() == labels.cpu()).sum().item() # get the index of the class with the highest probability
                val_loss += loss.item()

            print('[{:03d}/{:03d}] Train Acc: {:3.6f} Loss: {:3.6f} | Val Acc: {:3.6f} loss: {:3.6f}'.format(
                epoch + 1, num_epoch, train_acc/len(train_set), train_loss/len(train_loader), val_acc/len(val_set), val_loss/len(val_loader)
            ))

            # if the model improves, save a checkpoint at this epoch
            if val_acc > best_acc:
                best_acc = val_acc
                # 保存当前对于验证集，最好的结果
                torch.save(model.state_dict(), model_path)
                print('saving model with acc {:.3f}'.format(best_acc/len(val_set)))
    else:
    # 设计了仅仅训练，不去测试的情形
        print('[{:03d}/{:03d}] Train Acc: {:3.6f} Loss: {:3.6f}'.format(
            epoch + 1, num_epoch, train_acc/len(train_set), train_loss/len(train_loader)
        ))

# if not validating, save the last epoch
# 设计了仅仅训练，不去测试的情形
if len(val_set) == 0:
  # 仅训练，就保存最后一轮的参数
    torch.save(model.state_dict(), model_path)
    print('saving model at last epoch')

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

1140去预习一下slides，然后下去吃饭！！！

鹅鹅鹅刚刚睡醒了看完了cnn。
去做核酸，发现蓝桥出成绩了。从省三开始看，发现没有自己，以为gg了，没想到得了一等奖。接下来要好好准备了！！！每天写writeup~现在先去y总网站还愿。
看了一下决赛原计划的时间是5月底-6月。从今天开始，每天写两道writeup，应该没啥问题。
现在先去跑个模型。

15:00，和导师交代完了。老师说国一才值得祝贺，那就只好努努力了哈哈哈！！！
我现在要跑L2的实验了。已经忘了写到哪里了。

----1514把代码过了一遍，comment了，现在开始做一些改进！
原本的训练情况

主要看下report的任务吧
任务一：
1\对于隐藏层为6层，每层为1024的网络。
【这个更深一点】

Train Acc: 0.479256 Loss: 1.780055 | Val Acc: 0.468751 loss: 1.823825

2、改为2,1700
【这个更胖一点】
Train Acc: 0.486203 Loss: 1.750067 | Val Acc: 0.471475 loss: 1.814500
saving model with acc 0.471
对比：
1、acc、泛化能力
胖模型的acc差一点，但是loss小一点，也就是泛化能力差。
2、收敛速度
粗略比较，感觉深的收敛快一点？？？参数一样多的情况下，每个参数性价比更高导致的？

跑的好慢，而且不知道怎么看收敛速度。刚刚预习完了下面的正课，可以开始听课了
想了一下，收敛速度应该就是说loss下降到不动的速度把，应该画个图的。

---------1557看完了Validation set。主要讲的是为什么通过validation set选出来的模型在测试集也不好。我本来以为是数据分布问题。但其实，在Dval里面选一个func使得loss最小，也是一个训练过程，所以也符合我们之前讨论的，“训练集和测试集结果相似度与H和N有关”的结论，如果val里的模型尝试过多，就代表其H过大，那结果相似度就会下降。通俗理解，就是尝试的多了，就过拟合了，失去了generalization,这是我自己理解的部分。
胖模型也跑完了，正好在下一讲之前看看结果。下一讲要讨论这个事情。

任务二：设置dropout（解决过拟合吗）
1\0.25
2\0.5

3\0.75

ACC:随着dropout增大，val和train的acc减小；
收敛：dropout增大，收敛变快
泛化能力：dropout增大，泛化能力变强
我觉得用dropout还是得看模型复杂度和数据多少的，看看有没有过拟合之类的

现在1708，看完了L3的第二讲，讲的是为什么要深度学习，而不是学习。其实，深度学习参数效率会提高，能够在保证h相同的情况下，为模型提供更多可能性，使其L（hall,Dall）变得更小，而由于h没变、N没变，所以二者之间的距离没有变大，所以L（htrain，Dall）【也就是我们需要的那个值】，也随着变小。解决了上面因为改变h造成的两难问题。所以深度学习其实是一种效率很高的学习，和我们想法中的那种需要很多参数，很多数据的理念还不一样，因为人家已经是宽广学习的优化版本了，已经有用到效率很高的参数了！！

=—1712写完了！！养了几天膝盖了，现在去跑步试一试，然后回来吃饭之类的~先把ppt放在云盘，一会路上看看。

—1721找到了17年RNN的课件！！！终于可以学attention了！！！开心！现在传到云盘

-------2107出了点小问题，回来有点晚了，今天先到这里叭。明天再看，去给舍友讲点东西。