人是不完美的，我们经常在程序中犯错误。有时这些错误很容易发现：你的代码根本不能工作，你的应用程序崩溃等等。但是有些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）可以很快地检测到问题。同样，也可以是单元测试。