PyTorch的Debug指南

时间：2021-12-14 16:07:26

一、ipdb 介绍

很多初学 python 的同学会使用 print 或 log 调试程序，但是这只在小规模的程序下调试很方便，更好的调试应该是在一边运行的时候一边检查里面的变量和方法。

感兴趣的可以去了解 pycharm 的 debug 模式，功能也很强大，能够满足一般的需求，这里不多做赘述，我们这里介绍一个更适用于 pytorch 的一个灵活的 pdb 交互式调试工具。

Pdb 是一个交互式的调试工具，集成与 Python 标准库中，它能让你根据需求跳转到任意的 Python 代码断点、查看任意变量、单步执行代码，甚至还能修改变量的值，而没有必要去重启程序。

ipdb 则是一个增强版的 pdb，它提供了调试模式下的代码自动补全，还有更好的语法高亮和代码溯源，以及更好的内省功能，最重要的是它和 pdb 接口完全兼容，可以通过 pip install ipdb 安装。

二、ipdb 的使用

首先看一个例子，要使用 ipdb 的话，只需要在想要进行调试的地方插入 ipdb.set_trace()，当代码运行到这个地方时，就会自动进入交互式调试模式。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import ipdb
 
 
def sum(x):
    r = 0
    for ii in x:
        r += ii
    return r
 
 
def mul(x):
    r = 1
    for ii in x:
        r *= 11
    return r
 
 
ipdb.set_trace()
x = [1, 2, 3, 4, 5]
r = sum(x)
r = mul(x)
?
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
> /Users/mac/Desktop/jupyter/test.py(19)<module>()
     18 ipdb.set_trace()
---> 19 x = [1, 2, 3, 4, 5]
     20 r = sum(x)
 
ipdb> l 1,5  # l(ist) 1,5 的缩写，查看第 1 行到第 5 行的代码
      1 import ipdb
      2
      3
      4 def sum(x):
      5     r = 0
 
ipdb> n  # n(ext) 的缩写执行下一步
> /Users/mac/Desktop/jupyter/test.py(20)<module>()
     19 x = [1, 2, 3, 4, 5]
---> 20 r = sum(x)
     21 r = mul(x)
 
ipdb> s  # s(tep) 的缩写，进入 sum 函数内部
--Call--
> /Users/mac/Desktop/jupyter/test.py(4)sum()
      3
----> 4 def sum(x):
      5     r = 0
 
ipdb> n  # n(ext) 单步执行
> /Users/mac/Desktop/jupyter/test.py(5)sum()
      4 def sum(x):
----> 5     r = 0
      6     for ii in x:
 
ipdb> n
> /Users/mac/Desktop/jupyter/test.py(6)sum()
      5     r = 0
----> 6     for ii in x:
      7         r += ii
 
ipdb> u  # u(p) 的缩写，调回上一层的调用
> /Users/mac/Desktop/jupyter/test.py(20)<module>()
     19 x = [1, 2, 3, 4, 5]
---> 20 r = sum(x)
     21 r = mul(x)
 
ipdb> d  # d(own) 的缩写，跳到调用的下一层
> /Users/mac/Desktop/jupyter/test.py(6)sum()
      5     r = 0
----> 6     for ii in x:
      7         r += ii
 
ipdb> n
> /Users/mac/Desktop/jupyter/test.py(7)sum()
      6     for ii in x:
----> 7         r += ii
      8     return r
 
ipdb> !r  # 查看变量 r 的值，该变量名与调试命令 `r(eturn)` 冲突
0
    
ipdb> return  # 继续运行知道函数返回
--Return--
15
> /Users/mac/Desktop/jupyter/test.py(8)sum()
      7         r += ii
----> 8     return r
      9
 
ipdb> n
> /Users/mac/Desktop/jupyter/test.py(21)<module>()
     19 x = [1, 2, 3, 4, 5]
     20 r = sum(x)
---> 21 r = mul(x)
 
ipdb> x  # 查看变量 x
[1, 2, 3, 4, 5]
    
ipdb> x[0] = 10000  # 修改变量 x
    
ipdb> x
[10000, 2, 3, 4, 5]
    
ipdb> b 12  # b(reak) 的缩写，在第 10 行设置断点
Breakpoint 1 at /Users/mac/Desktop/jupyter/test.py:12
    
ipdb> c  # c(ontinue) 的缩写，继续运行，直到遇到断点
> /Users/mac/Desktop/jupyter/test.py(12)mul()
     11 def mul(x):
1--> 12     r = 1
     13     for ii in x:
 
ipdb> return  # 可以看到计算的是修改之后的 x 的乘积
--Return--
1200000
> /Users/mac/Desktop/jupyter/test.py(15)mul()
     14         r *= ii
---> 15     return r
     16
 
ipdb> q  # q(uit) 的缩写，退出 debug

上述只是给出了 ipdb 的一部分使用方法，关于 ipdb 还有一些小的使用技巧：

  • 键能够自动补齐，补齐用法和 IPython 中的类似
  • j(ump) 能够跳过中间某些行的代码的执行
  • 可以直接在 ipdb 中修改变量的值
  • help 能够查看调试命令的用法，比如 h h 可以查看 help 命令的用法，h j(ump) 能够查看 j(ump) 命令的用法

三、在 PyTorch 中 Debug

PyTorch 作为一个动态图框架，和 ipdb 结合使用能够让调试过程更加便捷，下面我们将距离说明以下三点：

  • 如何在 PyTorch 中查看神经网络各个层的输出
  • 如何在 PyTorch 中分析各个参数的梯度
  • 如何动态修改 PyTorch 的训练流程

首先，运行上一篇文章给出的“猫狗大战”程序：python main.py train --debug-file='debug/debug.txt'

程序运行一段时间后，在debug目录下创建debug.txt标识文件，当程序检测到这个文件存在时，会自动进入debug模式。

?
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
99it [00:17,  6.07it/s]loss: 0.22854854568839075
119it [00:21,  5.79it/s]loss: 0.21267264398435753
139it [00:24,  5.99it/s]loss: 0.19839374726372108
> e:/Users/mac/Desktop/jupyter/mdFile/deeplearning/main.py(80)train()
     79         loss_meter.reset()
---> 80         confusion_matrix.reset()
     81         for ii, (data, label) in tqdm(enumerate(train_dataloader)):
 
ipdb> break 88    # 在第88行设置断点，当程序运行到此处进入debug模式
Breakpoint 1 at e:/Users/mac/Desktop/jupyter/mdFile/deeplearning/main.py:88
 
ipdb> # 打印所有参数及其梯度的标准差
for (name,p) in model.named_parameters(): \
    print(name,p.data.std(),p.grad.data.std())
model.features.0.weight tensor(0.2615, device='cuda:0') tensor(0.3769, device='cuda:0')
model.features.0.bias tensor(0.4862, device='cuda:0') tensor(0.3368, device='cuda:0')
model.features.3.squeeze.weight tensor(0.2738, device='cuda:0') tensor(0.3023, device='cuda:0')
model.features.3.squeeze.bias tensor(0.5867, device='cuda:0') tensor(0.3753, device='cuda:0')
model.features.3.expand1x1.weight tensor(0.2168, device='cuda:0') tensor(0.2883, device='cuda:0')
model.features.3.expand1x1.bias tensor(0.2256, device='cuda:0') tensor(0.1147, device='cuda:0')
model.features.3.expand3x3.weight tensor(0.0935, device='cuda:0') tensor(0.1605, device='cuda:0')
model.features.3.expand3x3.bias tensor(0.1421, device='cuda:0') tensor(0.0583, device='cuda:0')
model.features.4.squeeze.weight tensor(0.1976, device='cuda:0') tensor(0.2137, device='cuda:0')
model.features.4.squeeze.bias tensor(0.4058, device='cuda:0') tensor(0.1798, device='cuda:0')
model.features.4.expand1x1.weight tensor(0.2144, device='cuda:0') tensor(0.4214, device='cuda:0')
model.features.4.expand1x1.bias tensor(0.4994, device='cuda:0') tensor(0.0958, device='cuda:0')
model.features.4.expand3x3.weight tensor(0.1063, device='cuda:0') tensor(0.2963, device='cuda:0')
model.features.4.expand3x3.bias tensor(0.0489, device='cuda:0') tensor(0.0719, device='cuda:0')
model.features.6.squeeze.weight tensor(0.1736, device='cuda:0') tensor(0.3544, device='cuda:0')
model.features.6.squeeze.bias tensor(0.2420, device='cuda:0') tensor(0.0896, device='cuda:0')
model.features.6.expand1x1.weight tensor(0.1211, device='cuda:0') tensor(0.2428, device='cuda:0')
model.features.6.expand1x1.bias tensor(0.0670, device='cuda:0') tensor(0.0162, device='cuda:0')
model.features.6.expand3x3.weight tensor(0.0593, device='cuda:0') tensor(0.1917, device='cuda:0')
model.features.6.expand3x3.bias tensor(0.0227, device='cuda:0') tensor(0.0160, device='cuda:0')
model.features.7.squeeze.weight tensor(0.1207, device='cuda:0') tensor(0.2179, device='cuda:0')
model.features.7.squeeze.bias tensor(0.1484, device='cuda:0') tensor(0.0381, device='cuda:0')
model.features.7.expand1x1.weight tensor(0.1235, device='cuda:0') tensor(0.2279, device='cuda:0')
model.features.7.expand1x1.bias tensor(0.0450, device='cuda:0') tensor(0.0100, device='cuda:0')
model.features.7.expand3x3.weight tensor(0.0609, device='cuda:0') tensor(0.1628, device='cuda:0')
model.features.7.expand3x3.bias tensor(0.0132, device='cuda:0') tensor(0.0079, device='cuda:0')
model.features.9.squeeze.weight tensor(0.1093, device='cuda:0') tensor(0.2459, device='cuda:0')
model.features.9.squeeze.bias tensor(0.0646, device='cuda:0') tensor(0.0135, device='cuda:0')
model.features.9.expand1x1.weight tensor(0.0840, device='cuda:0') tensor(0.1860, device='cuda:0')
model.features.9.expand1x1.bias tensor(0.0177, device='cuda:0') tensor(0.0033, device='cuda:0')
model.features.9.expand3x3.weight tensor(0.0476, device='cuda:0') tensor(0.1393, device='cuda:0')
model.features.9.expand3x3.bias tensor(0.0058, device='cuda:0') tensor(0.0030, device='cuda:0')
model.features.10.squeeze.weight tensor(0.0872, device='cuda:0') tensor(0.1676, device='cuda:0')
model.features.10.squeeze.bias tensor(0.0484, device='cuda:0') tensor(0.0088, device='cuda:0')
model.features.10.expand1x1.weight tensor(0.0859, device='cuda:0') tensor(0.2145, device='cuda:0')
model.features.10.expand1x1.bias tensor(0.0160, device='cuda:0') tensor(0.0025, device='cuda:0')
model.features.10.expand3x3.weight tensor(0.0456, device='cuda:0') tensor(0.1429, device='cuda:0')
model.features.10.expand3x3.bias tensor(0.0070, device='cuda:0') tensor(0.0021, device='cuda:0')
model.features.11.squeeze.weight tensor(0.0786, device='cuda:0') tensor(0.2003, device='cuda:0')
model.features.11.squeeze.bias tensor(0.0422, device='cuda:0') tensor(0.0069, device='cuda:0')
model.features.11.expand1x1.weight tensor(0.0690, device='cuda:0') tensor(0.1400, device='cuda:0')
model.features.11.expand1x1.bias tensor(0.0138, device='cuda:0') tensor(0.0022, device='cuda:0')
model.features.11.expand3x3.weight tensor(0.0366, device='cuda:0') tensor(0.1517, device='cuda:0')
model.features.11.expand3x3.bias tensor(0.0109, device='cuda:0') tensor(0.0023, device='cuda:0')
model.features.12.squeeze.weight tensor(0.0729, device='cuda:0') tensor(0.1736, device='cuda:0')
model.features.12.squeeze.bias tensor(0.0814, device='cuda:0') tensor(0.0084, device='cuda:0')
model.features.12.expand1x1.weight tensor(0.0977, device='cuda:0') tensor(0.1385, device='cuda:0')
model.features.12.expand1x1.bias tensor(0.0102, device='cuda:0') tensor(0.0032, device='cuda:0')
model.features.12.expand3x3.weight tensor(0.0365, device='cuda:0') tensor(0.1312, device='cuda:0')
model.features.12.expand3x3.bias tensor(0.0038, device='cuda:0') tensor(0.0026, device='cuda:0')
model.classifier.1.weight tensor(0.0285, device='cuda:0') tensor(0.0865, device='cuda:0')
model.classifier.1.bias tensor(0.0362, device='cuda:0') tensor(0.0192, device='cuda:0')
 
ipdb> opt.lr    # 查看学习率
0.001
 
ipdb> opt.lr = 0.002    # 更改学习率
 
ipdb> for p in optimizer.param_groups: \
    p['lr'] = opt.lr
 
ipdb> model.save()    # 保存模型
'checkpoints/squeezenet_20191004212249.pth'
 
ipdb> c    # 继续运行，直到第88行暂停
222it [16:38, 35.62s/it]> e:/Users/mac/Desktop/jupyter/mdFile/deeplearning/main.py(88)train()
     87             optimizer.zero_grad()
1--> 88             score = model(input)
     89             loss = criterion(score, target)
 
ipdb> s    # 进入model(input)内部，即model.__call__(input)
--Call--
> c:\programdata\anaconda3\lib\site-packages\torch\nn\modules\module.py(537)__call__()
    536
--> 537     def __call__(self, *input, **kwargs):
    538         for hook in self._forward_pre_hooks.values():
 
ipdb> n    # 下一步
> c:\programdata\anaconda3\lib\site-packages\torch\nn\modules\module.py(538)__call__()
    537     def __call__(self, *input, **kwargs):
--> 538         for hook in self._forward_pre_hooks.values():
    539             result = hook(self, input)
 
ipdb> n    # 下一步
> c:\programdata\anaconda3\lib\site-packages\torch\nn\modules\module.py(544)__call__()
    543                 input = result
--> 544         if torch._C._get_tracing_state():
    545             result = self._slow_forward(*input, **kwargs)
 
ipdb> n    # 下一步
> c:\programdata\anaconda3\lib\site-packages\torch\nn\modules\module.py(547)__call__()
    546         else:
--> 547             result = self.forward(*input, **kwargs)
    548         for hook in self._forward_hooks.values():
 
ipdb> s    # 进入forward函数内容
--Call--
> c:\programdata\anaconda3\lib\site-packages\torch\nn\modules\loss.py(914)forward()
    913
--> 914     def forward(self, input, target):
    915         return F.cross_entropy(input, target, weight=self.weight,
 
ipdb> input    # 查看input变量值
tensor([[4.5005, 2.0725],
        [3.5933, 7.8643],
        [2.9086, 3.4209],
        [2.7740, 4.4332],
        [6.0164, 2.3033],
        [5.2261, 3.2189],
        [2.6529, 2.0749],
        [6.3259, 2.2383],
        [3.0629, 3.4832],
        [2.7008, 8.2818],
        [5.5684, 2.1567],
        [3.0689, 6.1022],
        [3.4848, 5.3831],
        [1.7920, 5.7709],
        [6.5032, 2.8080],
        [2.3071, 5.2417],
        [3.7474, 5.0263],
        [4.3682, 3.6707],
        [2.2196, 6.9298],
        [5.2201, 2.3034],
        [6.4315, 1.4970],
        [3.4684, 4.0371],
        [3.9620, 1.7629],
        [1.7069, 7.8898],
        [3.0462, 1.6505],
        [2.4081, 6.4456],
        [2.1932, 7.4614],
        [2.3405, 2.7603],
        [1.9478, 8.4156],
        [2.7935, 7.8331],
        [1.8898, 3.8836],
        [3.3008, 1.6832]], device='cuda:0', grad_fn=<AsStridedBackward>)
 
ipdb> input.data.mean()    # 查看input的均值和标准差
tensor(3.9630, device='cuda:0')
ipdb> input.data.std()
tensor(1.9513, device='cuda:0')
 
ipdb> u    # 跳回上一层
> c:\programdata\anaconda3\lib\site-packages\torch\nn\modules\module.py(547)__call__()
    546         else:
--> 547             result = self.forward(*input, **kwargs)
    548         for hook in self._forward_hooks.values():
 
ipdb> u    # 跳回上一层
> e:/Users/mac/Desktop/jupyter/mdFile/deeplearning/main.py(88)train()
     87             optimizer.zero_grad()
1--> 88             score = model(input)
     89             loss = criterion(score, target)
 
ipdb> clear    # 清除所有断点
Clear all breaks? y
Deleted breakpoint 1 at e:/Users/mac/Desktop/jupyter/mdFile/deeplearning/main.py:88
 
ipdb> c    # 继续运行，记得先删除"debug/debug.txt"，否则很快又会进入调试模式
59it [06:21,  5.75it/s]loss: 0.24856307208538073
76it [06:24,  5.91it/s]

当我们想要进入 debug 模式，修改程序中某些参数值或者想分析程序时，就可以通过创建 debug 标识文件，此时程序会进入调试模式，调试完成之后删除这个文件并在 ipdb 调试接口输入 c 继续运行程序。如果想退出程序，也可以使用这种方式，先创建 debug 标识文件，然后输入 quit 在退出 debug 的同时退出程序。这种退出程序的方式，与使用 Ctrl + C 的方式相比更安全，因为这能保证数据加载的多进程程序也能正确地退出，并释放内存、显存等资源。

PyTorch 和 ipdb 集合能完成很多其他框架所不能完成或很难完成的功能。根据笔者日常使用的总结，主要有以下几个部分：

  1. 通过 debug 暂停程序。当程序进入 debug 模式后，将不再执行 CPU 和 GPU 运算，但是内存和显存及相应的堆栈空间不会释放。
  2. 通过 debug 分析程序，查看每个层的输出，查看网络的参数情况。通过 u(p) 、 d(own) 、 s(tep) 等命令，能够进入指定的代码，通过 n(ext) 可以单步执行，从而看到每一层的运算结果，便于分析网络的数值分布等信息。
  3. 作为动态图框架， PyTorch 拥有 Python 动态语言解释执行的优点，我们能够在运行程序时，用过 ipdb 修改某些变量的值或属性，这些修改能够立即生效。例如可以在训练开始不久根据损失函数调整学习率，不必重启程序。
  4. 如果在 IPython 中通过 %run 魔法方法运行程序，那么在程序异常退出时，可以使用 %debug 命令，直接进入 debug 模式，通过 u(p) 和 d(own) 跳到报错的地方，查看对应的变量，找出原因后修改相应的代码即可。有时我们的模式训练了好几个小时，却在将要保存模式之前，因为一个小小的拼写错误异常退出。此时，如果修改错误再重新运行程序又要花费好几个小时，太浪费时间。因此最好的方法就是看利用 %debug 进入调试模式，在调试模式中直接运行 model . save() 保存模型。在 IPython 中， %pdb 魔术方法能够使得程序出现问题后，不用手动输入 %debug 而自动进入 debug 模式，建议使用。

四、 通过PyTorch实现项目中容易遇到的问题

PyTorch 调用 CuDNN 报错时，报错信息诸如 CUDNN_STATUS_BAD_PARAM，从这些报错内容很难得到有用的帮助信息，最后先利用 PCU 运行代码，此时一般会得到相对友好的报错信息，例如在 ipdb 中执行 model.cpu() （input.cpu()）， PyTorch 底层的 TH 库会给出相对比较详细的信息。

常见的错误主要有以下几种：

  • 类型不匹配问题。例如 CrossEntropyLoss 的输入 target 应该是一个 LongTensor ，而很多人输入 FloatTensor 。
  • 部分数据忘记从 CPU 转移到 GPU 。例如，当 model 存放于 GPU 时，输入 input 也需要转移到 GPU 才能输入到 model 中。还有可能就是把多个 model 存放于一个 list 对象，而在执行 model.cuda() 时，这个 list 中的对象是不会被转移到 CUDA 上的，正确的用法是用 ModuleList 代替。
  • Tensor 形状不匹配。此类问题一般是输入数据形状不对，或是网络结构设计有问题，一般通过 u(p) 跳到指定代码，查看输入和模型参数的形状即可得知。

此外，可能还会经常遇到程序正常运行、没有报错，但是模型无法收敛的问题。例如对于二分类问题，交叉熵损失一直徘徊在 0.69 附近（ln2），或者是数值出现溢出等问题，此时可以进入 debug 模式，用单步执行查看，每一层输出的均值和方差，观察从哪一层的输出开始出现数值异常。还要查看每个参数梯度的均值和方差，查看是否出现梯度消失或者梯度爆炸等问题。一般来说，通过再激活函数之前增加 BatchNorm 层、合理的参数初始化、使用 Adam 优化器、学习率设为0.001，基本就能确保模型在一定程度收敛。

五、总结

本章带同学们从头实现了一个 Kaggle 上的经典竞赛，重点讲解了如何合理地组合安排程序，同时介绍了一些在PyTorch中调试的技巧，下章将正式的进入编程实战之旅，其中一些细节不会再讲的如此详细，做好心理准备。

以上就是PyTorch的Debug指南的详细内容，更多关于PyTorch Debug的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/nickchen121/p/14737988.html

标签：

相关文章