人是不完美的，我们经常在程序中犯错误。有时这些错误很容易发现：你的代码根本不能工作，你的应用程序崩溃等等。但是有些bug是隐藏的，这使得它们更加危险。
在解决深度学习问题时，由于一些不确定性，很容易出现这种类型的bug：很容易看到web应用端点路由请求是否正确，而不容易检查你的梯度下降步骤是否正确。然而，在DL从业者生涯中有很多错误是可以避免的。
我想分享一些我的经验，关于我在过去两年的计算机视觉工作中看到或制造的错误。我在会议上谈到过这个话题，很多人在会后告诉我：“是的，伙计，我也有很多这样的错误。”我希望我的文章可以帮助你至少避免其中的一些问题。
1．翻转图像和关键点
假设一个关键点检测问题的工作。它们的数据看起来像图像和一系列关键点元组，例如［（0，1），（2，2）］，其中每个关键点是一对x和y坐标。
让我们对这个数据实现一个基本的数据增强：
def flip＿img＿and＿keypoints（img： np．ndarray， kpts： Sequence［Sequence［int］］）：
img ＝ np．fliplr（img）
h， w， ＊＿ ＝ img．shape
kpts ＝ ［（y， w － x） for y， x in kpts］
return img， kpts
看起来好像是正确的，嗯，让我们把结果可视化一下：
mage ＝ np．ones（（10， 10）， dtype＝np．float32）
kpts ＝ ［（0， 1）， （2， 2）］
image＿flipped， kpts＿flipped ＝ flip＿img＿and＿keypoints（image， kpts）
img1 ＝ image．copy（）
for y， x in kpts：
img1［y， x］ ＝ 0
img2 ＝ image＿flipped．copy（）
for y， x in kpts＿flipped：
img2［y， x］ ＝ 0
＿ ＝ plt．imshow（np．hstack（（img1， img2）））
不对称看起来很奇怪！如果我们检查极值的情况呢？
image ＝ np．ones（（10， 10）， dtype＝np．float32）
kpts ＝ ［（0， 0）， （1， 1）］
image＿flipped， kpts＿flipped ＝ flip＿img＿and＿keypoints（image， kpts）
img1 ＝ image．copy（）
for y， x in kpts：
img1［y， x］ ＝ 0
img2 ＝ image＿flipped．copy（）
for y， x in kpts＿flipped：
img2［y， x］ ＝ 0
out：
IndexError
Traceback （most recent call last）
＜ipython－input－5－997162463eae＞ in ＜module＞
8 img2 ＝ image＿flipped．copy（）
9 for y， x in kpts＿flipped：
－－－＞ 10 img2［y， x］ ＝ 0
IndexError： index 10 is out of bounds for axis 1 with size 10
程序报错了！这是一个典型的差一误差。正确的代码是这样的：
def flip＿img＿and＿keypoints（img： np．ndarray， kpts： Sequence［Sequence［int］］）：
img ＝ np．fliplr（img）
h， w， ＊＿ ＝ img．shape
kpts ＝ ［（y， w － x － 1） for y， x in kpts］
return img， kpts
我们可以通过可视化来检测这个问题，而在x ＝ 0点的单元测试也会有帮助。
2．还是关键点问题
即使在上述错误被修复之后，仍然存在问题。现在更多的是语义上的问题，而不仅仅是代码上的问题。
假设需要增强具有两只手掌的图像。看起来好像没问题－左右翻转后手还是手。
但是等等！我们对我们拥有的关键点语义一无所知。如果这个关键点的意思是这样的：
kpts ＝ ［
（20， 20）， ＃ 左小指
（20， 200）， ＃ 右小指
．．．
］
这意味着增强实际上改变了语义：左变成右，右变成左，但我们不交换数组中的关键点索引。它会给训练带来大量的噪音和更糟糕的度量。
我们应该吸取教训：
在应用增强或其他特性之前，要了解和考虑数据结构和语义；
保持你的实验原子性：添加一个小的变化（例如一个新的变换），如果分数已经提高，检查它如何进行和合并。
3．编码自定义损失函数
熟悉语义分割问题的人可能知道IoU度量。不幸的是，我们不能直接用SGD来优化它，所以常用的方法是用可微损失函数来近似它。让我们编码实现一个！
def iou＿continuous＿loss（y＿pred， y＿true）：
eps ＝ 1e－6
def ＿sum（x）：
return x．sum（－1）．sum（－1）
numerator ＝ （＿sum（y＿true ＊ y＿pred） ＋ eps）
denominator ＝ （＿sum（y＿true ＊＊ 2） ＋ ＿sum（y＿pred ＊＊ 2）
－ ＿sum（y＿true ＊ y＿pred） ＋ eps）
return （numerator ／ denominator）．mean（）
看起来不错，让我们测试一下：
In ［3］： ones ＝ np．ones（（1， 3， 10， 10））
．．．： x1 ＝ iou＿continuous＿loss（ones ＊ 0．01， ones）
．．．： x2 ＝ iou＿continuous＿loss（ones ＊ 0．99， ones）
In ［4］： x1， x2
Out［4］： （0．010099999897990103， 0．9998990001020204）
在x1中，我们计算了与正确数据完全不同的数据的损失，而x2则是非常接近正确数据的数据损失结果。我们期望x1很大因为预测很糟糕，x2应该接近0。但是结果与我期望的有差别，哪里出现错误了呢？
上面的函数是度量的一个很好的近似。度量不是一种损失：它通常（包括这种情况）越高越好。当我们使用SGD最小化损失时，我们应该做一些改变：
def iou＿continuous（y＿pred， y＿true）：
eps ＝ 1e－6
def ＿sum（x）：
return x．sum（－1）．sum（－1）
numerator ＝ （＿sum（y＿true ＊ y＿pred） ＋ eps）
denominator ＝ （＿sum（y＿true ＊＊ 2） ＋ ＿sum（y＿pred ＊＊ 2）
－ ＿sum（y＿true ＊ y＿pred） ＋ eps）
return （numerator ／ denominator）．mean（）
def iou＿continuous＿loss（y＿pred， y＿true）：
return 1 － iou＿continuous（y＿pred， y＿true）
这些问题可以从两个方面来确定：
编写一个单元测试来检查损失的方向
运行健全性检查
4．当我们遇到Pytorch的时候
假设有一个预先训练好的模型。编写基于ceevee API的Predictor 类。
from ceevee．base import AbstractPredictor
class MySuperPredictor（AbstractPredictor）：
def ＿＿init＿＿（self，
weights＿path： str，
）：
super（）．＿＿init＿＿（）
self．model ＝ self．＿load＿model（weights＿path＝weights＿path）
def process（self， x， ＊kw）：
with torch．no＿grad（）：
res ＝ self．model（x）
return res
＠staticmethod
def ＿load＿model（weights＿path）：
model ＝ ModelClass（）
weights ＝ torch．load（weights＿path， map＿location＝＇cpu＇）
model．load＿state＿dict（weights）
return model
这个代码正确吗？也许！对于某些模型来说确实是正确的。例如，当模型没有dropout或norm 层，如torch．nn．BatchNorm2d。
但是对于大多数计算机视觉应用来说，代码忽略了一些重要的东西：转换到评估模式。
如果试图将动态PyTorch图转换为静态PyTorch图，这个问题很容易意识到。torch．jit模块用于这种转换。
In ［3］： model ＝ nn．Sequential（
．．．： nn．Linear（10， 10），
．．．： nn．Dropout（．5）
．．．： ）
．．．：
．．．： traced＿model ＝ torch．jit．trace（model， torch．rand（10））
／Users／Arseny／．pyenv／versions／3．6．6／lib／python3．6／site－packages／torch／jit／＿＿init＿＿．py：914： TracerWarning： Trace had nondeterministic nodes． Did you forget call ．eval（） on your model？ Nodes：
％12 ： Float（10） ＝ aten：：dropout（％input， ％10， ％11）， scope： Sequential／Dropout［1］ ＃ ／Users／Arseny／．pyenv／versions／3．6．6／lib／python3．6／site－packages／torch／nn／functional．py：806：0
This may cause errors in trace checking． To disable trace checking， pass check＿trace＝False to torch．jit．trace（）
check＿tolerance， ＿force＿outplace， True， ＿module＿class）
／Users／Arseny／．pyenv／versions／3．6．6／lib／python3．6／site－packages／torch／jit／＿＿init＿＿．py：914： TracerWarning： Output nr 1． of the traced function does not match the corresponding output of the Python function． Detailed error：
Not within tolerance rtol＝1e－05 atol＝1e－05 at input［5］ （0．0 vs． 0．5454154014587402） and 5 other locations （60．00％）
check＿tolerance， ＿force＿outplace， True， ＿module＿class）
一个简单的解决办法：
In ［4］： model ＝ nn．Sequential（
．．．： nn．Linear（10， 10），
．．．： nn．Dropout（．5）
．．．： ）
．．．：
．．．： traced＿model ＝ torch．jit．trace（model．eval（）， torch．rand（10））
＃ 没有警告！
torch．jit．trace运行模型几次并比较结果。
然而torch．jit．trace并不是万能的，你应该了解并记住。
5．复制粘贴问题
很多东西都是成对存在的：训练和验证、宽度和高度、纬度和经度……如果你仔细阅读，你会很容易发现一个bug是由某一个成员中复制粘贴到另外一个成员中引起的：
def make＿dataloaders（train＿cfg， val＿cfg， batch＿size）：
train ＝ Dataset．from＿config（train＿cfg）
val ＝ Dataset．from＿config（val＿cfg）
shared＿params ＝ ｛＇batch＿size＇： batch＿size， ＇shuffle＇： True， ＇num＿workers＇： cpu＿count（）｝
train ＝ DataLoader（train， ＊＊shared＿params）
val ＝ DataLoader（train， ＊＊shared＿params）
return train， val
不仅仅是我犯了愚蠢的错误，例如。流行的albumentations库中也有类似的问题。
＃ https：／／github．com／albu／albumentations／blob／0．3．0／albumentations／augmentations／transforms．py
def apply＿to＿keypoint（self， keypoint， crop＿height＝0， crop＿width＝0， h＿start＝0， w＿start＝0， rows＝0， cols＝0， ＊＊params）：
keypoint ＝ F．keypoint＿random＿crop（keypoint， crop＿height， crop＿width， h＿start， w＿start， rows， cols）
scale＿x ＝ self．width ／ crop＿height
scale＿y ＝ self．height ／ crop＿height
keypoint ＝ F．keypoint＿scale（keypoint， scale＿x， scale＿y）
return keypoint
不过别担心，现在已经修复好了。
如何避免？尽量以不需要复制和粘贴的方式编写代码。
下面这种编程方式不是一个好的方式：
datasets ＝ ［］
data＿a ＝ get＿dataset（MyDataset（config［＇dataset＿a＇］）， config［＇shared＿param＇］， param＿a）
datasets．append（data＿a）
data＿b ＝ get＿dataset（MyDataset（config［＇dataset＿b＇］）， config［＇shared＿param＇］， param＿b）
datasets．append（data＿b）
而下面的方式看起来好多了：
datasets ＝ ［］
for name， param in zip（（＇dataset＿a＇， ＇dataset＿b＇），
（param＿a， param＿b），
）：
datasets．append（get＿dataset（MyDataset（config［name］）， config［＇shared＿param＇］， param））
6．正确的数据类型让我们编写一个新的增强：def add＿noise（img： np．ndarray） －＞ np．ndarray：
mask ＝ np．random．rand（＊img．shape） ＋ ．5
img ＝ img．astype（＇float32＇） ＊ mask
return img．astype（＇uint8＇）
图像已被更改。这是我们所期望的吗？嗯，可能修改得有点过了。
这里有一个危险的操作：将float32转换为uint8。它可能会导致溢出：
def add＿noise（img： np．ndarray） －＞ np．ndarray：
mask ＝ np．random．rand（＊img．shape） ＋ ．5
img ＝ img．astype（＇float32＇） ＊ mask
return np．clip（img， 0， 255）．astype（＇uint8＇）
img ＝ add＿noise（cv2．imread（＇two＿hands．jpg＇）［：， ：， ：：－1］）
＿ ＝ plt．imshow（img）
看起来好多了，是吧？
顺便说一句，还有一种方法可以避免这个问题：不要重造轮子，不要从头开始编写增强代码，而是使用现有的增强，比如：albumentations．augmentations．transforms．GaussNoise。
我曾经犯过另一个同样的错误。
raw＿mask ＝ cv2．imread（＇mask＿small．png＇）
mask ＝ raw＿mask．astype（＇float32＇） ／ 255
mask ＝ cv2．resize（mask， （64， 64）， interpolation＝cv2．INTER＿LINEAR）
mask ＝ cv2．resize（mask， （128， 128）， interpolation＝cv2．INTER＿CUBIC）
mask ＝ （mask ＊ 255）．astype（＇uint8＇）
＿ ＝ plt．imshow（np．hstack（（raw＿mask， mask）））
这里出了什么问题？首先，用三次样条插值调整mask的大小是一个坏主意。与转换float32到uint8的问题是一样的：三次样条插值的输出值会大于输入值，会导致溢出。
我在做可视化的时候发现了这个问题。在你的训练循环中到处使用断言也是一个好主意。
7． 拼写错误发生
假设需要对全卷积网络（如语义分割问题）和一个巨大的图像进行推理。该图像是如此巨大，没有机会把它放在你的GPU上 －例如，它可以是一个医疗或卫星图像。
在这种情况下，可以将图像分割成网格，独立地对每一块进行推理，最后合并。此外，一些预测交叉可能有助于平滑边缘的伪影
让我们编码实现吧！
from tqdm import tqdm
class GridPredictor：
＂＂＂
你有GPU内存限制时，此类可用于预测大图像的分割掩码
＂＂＂
def ＿＿init＿＿（self， predictor： AbstractPredictor， size： int， stride： Optional［int］ ＝ None）：
self．predictor ＝ predictor
self．size ＝ size
self．stride ＝ stride if stride is not None else size ／／ 2
def ＿＿call＿＿（self， x： np．ndarray）：
h， w， ＿ ＝ x．shape
mask ＝ np．zeros（（h， w， 1）， dtype＝＇float32＇）
weights ＝ mask．copy（）
for i in tqdm（range（0， h － 1， self．stride））：
for j in range（0， w － 1， self．stride）：
a， b， c， d ＝ i， min（h， i ＋ self．size）， j， min（w， j ＋ self．size）
patch ＝ x［a：b， c：d， ：］
mask［a：b， c：d， ：］ ＋＝ np．expand＿dims（self．predictor（patch）， －1）
weights［a：b， c：d， ：］ ＝ 1
return mask ／ weights
有一个符号输入错误，可以很容易地找到它，检查代码是否正确：
class Model（nn．Module）：
def forward（self， x）：
return x．mean（axis＝－1）
model ＝ Model（）
grid＿predictor ＝ GridPredictor（model， size＝128， stride＝64）
simple＿pred ＝ np．expand＿dims（model（img）， －1）
grid＿pred ＝ grid＿predictor（img）
np．testing．assert＿allclose（simple＿pred， grid＿pred， atol＝．001）
AssertionError Traceback （most recent call last）
＜ipython－input－24－a72034c717e9＞ in ＜module＞
9 grid＿pred ＝ grid＿predictor（img）
10
－－－＞ 11 np．testing．assert＿allclose（simple＿pred， grid＿pred， atol＝．001）
～／．pyenv／versions／3．6．6／lib／python3．6／site－packages／numpy／testing／＿private／utils．py in assert＿allclose（actual， desired， rtol， atol， equal＿nan， err＿msg， verbose）
1513 header ＝ ＇Not equal to tolerance rtol＝％g， atol＝％g＇ ％ （rtol， atol）
1514 assert＿array＿compare（compare， actual， desired， err＿msg＝str（err＿msg），
－＞ 1515 verbose＝verbose， header＝header， equal＿nan＝equal＿nan）
1516
1517
～／．pyenv／versions／3．6．6／lib／python3．6／site－packages／numpy／testing／＿private／utils．py in assert＿array＿compare（comparison， x， y， err＿msg， verbose， header， precision， equal＿nan， equal＿inf）
839 verbose＝verbose， header＝header，
840 names＝（＇x＇， ＇y＇）， precision＝precision）
－－＞ 841 raise AssertionError（msg）
842 except ValueError：
843 import traceback
AssertionError：
Not equal to tolerance rtol＝1e－07， atol＝0．001
Mismatch： 99．6％
Max absolute difference： 765．
Max relative difference： 0．75000001
x： array（［［［215．333333］，
［192．666667］，
［250． ］，．．．
y： array（［［［ 215．33333］，
［ 192．66667］，
［ 250． ］，．．．
call方法的正确版本如下：
def ＿＿call＿＿（self， x： np．ndarray）：
h， w， ＿ ＝ x．shape
mask ＝ np．zeros（（h， w， 1）， dtype＝＇float32＇）
weights ＝ mask．copy（）
for i in tqdm（range（0， h － 1， self．stride））：
for j in range（0， w － 1， self．stride）：
a， b， c， d ＝ i， min（h， i ＋ self．size）， j， min（w， j ＋ self．size）
patch ＝ x［a：b， c：d， ：］
mask［a：b， c：d， ：］ ＋＝ np．expand＿dims（self．predictor（patch）， －1）
weights［a：b， c：d， ：］ ＋＝ 1
return mask ／ weights
如果你仍然不知道问题是什么，注意行weights［a：b， c：d， ：］ ＋＝ 1。
8．Imagenet归一化
当一个人需要做迁移学习时，用训练Imagenet时的方法将图像归一化通常是一个好主意。
让我们使用熟悉的albumentations来实现：
from albumentations import Normalize
norm ＝ Normalize（）
img ＝ cv2．imread（＇img＿small．jpg＇）
mask ＝ cv2．imread（＇mask＿small．png＇， cv2．IMREAD＿GRAYSCALE）
mask ＝ np．expand＿dims（mask， －1） ＃ shape （64， 64） －＞ shape （64， 64， 1）
normed ＝ norm（image＝img， mask＝mask）
img， mask ＝ ［normed［x］ for x in ［＇image＇， ＇mask＇］］
def img＿to＿batch（x）：
x ＝ np．transpose（x， （2， 0， 1））．astype（＇float32＇）
return torch．from＿numpy（np．expand＿dims（x， 0））
img， mask ＝ map（img＿to＿batch， （img， mask））
criterion ＝ F．binary＿cross＿entropy
现在是时候训练一个网络并对单个图像进行拟合——正如我所提到的，这是一种很好的调试技术：
model＿a ＝ UNet（3， 1）
optimizer ＝ torch．optim．Adam（model＿a．parameters（）， lr＝1e－3）
losses ＝ ［］
for t in tqdm（range（20））：
loss ＝ criterion（model＿a（img）， mask）
losses．append（loss．item（））
optimizer．zero＿grad（）
loss．backward（）
optimizer．step（）
＿ ＝ plt．plot（losses）
曲率看起来很好，但是－300不是我们期望的交叉熵的损失值。是什么问题？
归一化处理图像效果很好，但掩码需要缩放到［0，1］之间。
model＿b ＝ UNet（3， 1）
optimizer ＝ torch．optim．Adam（model＿b．parameters（）， lr＝1e－3）
losses ＝ ［］
for t in tqdm（range（20））：
loss ＝ criterion（model＿b（img）， mask ／ 255．）
losses．append（loss．item（））
optimizer．zero＿grad（）
loss．backward（）
optimizer．step（）
＿ ＝ plt．plot（losses）
在训练循环时一个简单运行断言（例如assert mask．max（） ＜＝ 1）可以很快地检测到问题。同样，也可以是单元测试。
