8個計算機視覺深度學習中常見的Bug

做者 | Arseny Kravchenko
編譯 | ronghuaiyang

人是不完美的，咱們常常在軟件中犯錯誤。有時這些錯誤很容易發現：你的代碼根本不能工做，你的應用程序崩潰等等。可是有些bug是隱藏的，這使得它們更加危險。

在解決深度學習問題時，因爲一些不肯定性，很容易出現這種類型的bug：很容易看到web應用程序路由請求是否正確，而不容易檢查你的梯度降低步驟是否正確。然而，有不少錯誤是能夠避免的。

我想分享一些個人經驗，關於我在過去兩年的計算機視覺工做中看到或製造的錯誤。我以前有談到過這個話題，不少人告訴我：「是的，我也有不少這樣的bug。」我但願個人文章能夠幫助你至少避免其中的一些問題。

1. 翻轉圖片以及關鍵點

假設在關鍵點檢測的問題上。數據看起來像一對圖像和一系列的關鍵點元組。其中每一個關鍵點是一對x和y座標。

讓咱們對這個數據進行基礎的加強：

1. def flip_img_and_keypoints(img: np.ndarray, kpts:`Sequence[Sequence[int]]):`
2. img = np.fliplr(img)
3. h, w,`*_ = img.shape`
4. kpts =`[(y, w - x)`for y, x in kpts]
5. return img, kpts

看起來是正確的，嗯？咱們把它可視化。

1. image = np.ones((10,`10), dtype=np.float32)`
2. kpts =`[(0,1),(2,`2)]
3. image_flipped, kpts_flipped = flip_img_and_keypoints(image, kpts)
4. img1 = image.copy()
5. for y, x in kpts:
6. img1[y, x]`=`0
7. img2 = image_flipped.copy()
8. for y, x in kpts_flipped:
9. img2[y, x]`=`0
10. _ = plt.imshow(np.hstack((img1, img2)))

不對稱，看起來很奇怪！若是咱們檢查極值呢？

1. image = np.ones((10,`10), dtype=np.float32)`
2. kpts =`[(0,0),(1,`1)]
3. image_flipped, kpts_flipped = flip_img_and_keypoints(image, kpts)
4. img1 = image.copy()
5. for y, x in kpts:
6. img1[y, x]`=`0
7. img2 = image_flipped.copy()
8. for y, x in kpts_flipped:
9. img2[y, x]`=`0
10. ---------------------------------------------------------------------------
11. IndexError`Traceback`(most recent call last)
12. <ipython-input-5-997162463eae>`in`<module>
13. 8 img2 = image_flipped.copy()
14. 9`for y, x in kpts_flipped:`
15. --->`10 img2[y, x]=0`
16. IndexError: index 10`is out of bounds for axis 1`with size 10

很差！這是一個典型的off-by-one錯誤。正確的代碼是這樣的:

1. def flip_img_and_keypoints(img: np.ndarray, kpts:`Sequence[Sequence[int]]):`
2. img = np.fliplr(img)
3. h, w,`*_ = img.shape`
4. kpts =`[(y, w - x -1)for y, x in kpts]`
5. return img, kpts

咱們經過可視化發現了這個問題，可是，使用「x = 0」點進行單元測試也會有所幫助。一個有趣的事實是：有一個團隊中有三我的(包括我本身)獨立地犯了幾乎相同的錯誤。

2. 繼續是關鍵點相關的問題

即便在上面的函數被修復以後，仍然存在危險。如今更多的是語義，而不只僅是一段代碼。

假設須要用兩隻手掌來加強圖像。看起來很安全：手是左，右翻轉。

可是等等！咱們對關鍵點的語義並不很瞭解。若是這個關鍵點的意思是這樣的：

1. kpts =`[`
2. (20,`20),`# left pinky
3. (20,`200),`# right pinky
4. ...
5. ]

這意味着加強實際上改變了語義：左變成右，右變成左，但咱們不交換數組中的關鍵點索引。它會給訓練帶來大量的噪音和更糟糕的度量。

咱們應該吸收一個教訓：

• 在應用加強或其餘花哨的功能以前，瞭解並考慮數據結構和語義
• 保持你的實驗原子性：添加一個小的變化(例如一個新的變換)，檢查它如何進行，若是分數提升才加進去。

3. 編寫本身的損失函數

熟悉語義分割問題的人可能知道IoU指標。不幸的是，咱們不能直接用SGD來優化它，因此經常使用的方法是用可微損失函數來近似它。

1. def iou_continuous_loss(y_pred, y_true):
2. eps =`1e-6`
3. def _sum(x):
4. return x.sum(-1).sum(-1)
5. numerator =`(_sum(y_true * y_pred)`+ eps)
6. denominator =`(_sum(y_true 2)+ _sum(y_pred `2)
7. - _sum(y_true * y_pred)`+ eps)`
8. return`(numerator / denominator).mean()`

看起來不錯，咱們先作個小的檢查：

1. In`[3]: ones = np.ones((1,3,10,`10))
2. ...: x1 = iou_continuous_loss(ones *`0.01, ones)`
3. ...: x2 = iou_continuous_loss(ones *`0.99, ones)`
4. In`[4]: x1, x2`
5. Out[4]:`(0.010099999897990103,`0.9998990001020204)

在 x1中，咱們計算了一些與ground truth徹底不一樣的東西的損失，而 x2則是很是接近ground truth的東西的結果。咱們預計 x1會很大，由於預測是錯誤的， x2應該接近於零。怎麼了?

上面的函數是對metric的一個很好的近似。metric不是一種損失：它一般(包括這種狀況)越高越好。當咱們使用SGD來最小化損失時，咱們應該使用一些相反的東西：

1. def iou_continuous(y_pred, y_true):
2. eps =`1e-6`
3. def _sum(x):
4. return x.sum(-1).sum(-1)
5. numerator =`(_sum(y_true * y_pred)`+ eps)
6. denominator =`(_sum(y_true 2)+ _sum(y_pred `2)
7. - _sum(y_true * y_pred)`+ eps)`
8. return`(numerator / denominator).mean()`
9. def iou_continuous_loss(y_pred, y_true):
10. return`1`- iou_continuous(y_pred, y_true)

這些問題能夠從兩個方面來肯定：

• 編寫一個單元測試，檢查損失的方向：形式化的指望，更接近ground truth應該輸出更低的損失。
• 運行一個健全的檢查，讓你的模型在單個batch中過擬合。

4. 當咱們使用Pytorch的時候

假設有一個預先訓練好的模型，開始作infer。

1. from ceevee.base import`AbstractPredictor`
2. class`MySuperPredictor(AbstractPredictor):`
3. def __init__(self,
4. weights_path: str,
5. ):
6. super().__init__()
7. self.model = self._load_model(weights_path=weights_path)
8. def process(self, x,`*kw):`
9. with torch.no_grad():
10. res = self.model(x)
11. return res
12. @staticmethod
13. def _load_model(weights_path):
14. model =`ModelClass()`
15. weights = torch.load(weights_path, map_location='cpu')
16. model.load_state_dict(weights)
17. return model

這個代碼正確嗎？也許！這確實適用於某些模型。例如，當模型沒有dropout或norm層，如 torch.nn.BatchNorm2d。或者當模型須要爲每一個圖像使用實際的norm統計量時(例如，許多基於pix2pix的架構須要它)。

可是對於大多數計算機視覺應用程序來講，代碼忽略了一些重要的東西:切換到評估模式。

若是試圖將動態PyTorch圖轉換爲靜態PyTorch圖，這個問題很容易識別。 torch.jit用於這種轉換。

1. In`[3]: model = nn.Sequential(`
2. ...: nn.Linear(10,`10),`
3. ...: nn.Dropout(.5)
4. ...:`)`
5. ...:
6. ...: traced_model = torch.jit.trace(model, torch.rand(10))
7. /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:
8. %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`
9. This may cause errors in trace checking.`To disable trace checking,`pass check_trace=False to torch.jit.trace()
10. check_tolerance, _force_outplace,`True, _module_class)`
11. /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:`
12. Not within tolerance rtol=1e-05 atol=1e-05 at input[5]`(0.0 vs.0.5454154014587402)and`5 other locations (60.00%)
13. check_tolerance, _force_outplace,`True, _module_class)`

簡單的修復一下：

1. In`[4]: model = nn.Sequential(`
2. ...: nn.Linear(10,`10),`
3. ...: nn.Dropout(.5)
4. ...:`)`
5. ...:
6. ...: traced_model = torch.jit.trace(model.eval(), torch.rand(10))
7. # No more warnings!

在這種狀況下， torch.jit.trace將模型運行幾回並比較結果。這裏的差異是可疑的。

然而 torch.jit.trace在這裏不是萬能藥。這是一種應該知道和記住的細微差異。

5. 複製粘貼的問題

不少東西都是成對存在的：訓練和驗證、寬度和高度、緯度和經度……

1. def make_dataloaders(train_cfg, val_cfg, batch_size):
2. train =`Dataset.from_config(train_cfg)`
3. val =`Dataset.from_config(val_cfg)`
4. shared_params =`{'batch_size': batch_size,'shuffle':True,`'num_workers': cpu_count()}
5. train =`DataLoader(train,`**shared_params)
6. val =`DataLoader(train,`**shared_params)
7. return train, val

不只僅是我犯了愚蠢的錯誤。例如，在很是流行的albumentations庫也有一個相似的版本。

1. # https://github.com/albu/albumentations/blob/0.3.0/albumentations/augmentations/transforms.py
2. def apply_to_keypoint(self, keypoint, crop_height=0, crop_width=0, h_start=0, w_start=0, rows=0, cols=0,`**params):`
3. keypoint = F.keypoint_random_crop(keypoint, crop_height, crop_width, h_start, w_start, rows, cols)
4. scale_x = self.width / crop_height
5. scale_y = self.height / crop_height
6. keypoint = F.keypoint_scale(keypoint, scale_x, scale_y)
7. return keypoint

別擔憂，已經修改好了。

如何避免？不要複製和粘貼代碼，儘可能以不須要複製和粘貼的方式編寫代碼。

【NO】

1. datasets =`[]`
2. data_a = get_dataset(MyDataset(config['dataset_a']), config['shared_param'], param_a)
3. datasets.append(data_a)
4. data_b = get_dataset(MyDataset(config['dataset_b']), config['shared_param'], param_b)
5. datasets.append(data_b)

【YES】

1. datasets =`[]`
2. for name, param in zip(('dataset_a',`'dataset_b'),`
3. (param_a, param_b),
4. ):
5. datasets.append(get_dataset(MyDataset(config[name]), config['shared_param'], param))

6. 合適的數據類型

讓咱們編寫一個新的加強

1. def add_noise(img: np.ndarray)`-> np.ndarray:`
2. mask = np.random.rand(*img.shape)`+`.5
3. img = img.astype('float32')`* mask`
4. return img.astype('uint8')

圖像已被更改。這是咱們所指望的嗎?嗯，也許它改變得太多了。

這裏有一個危險的操做：將 float32 轉換爲 uint8。它可能會致使溢出：

1. def add_noise(img: np.ndarray)`-> np.ndarray:`
2. mask = np.random.rand(*img.shape)`+`.5
3. img = img.astype('float32')`* mask`
4. return np.clip(img,`0,`255).astype('uint8')
5. img = add_noise(cv2.imread('two_hands.jpg')[:,`:,`::-1])
6. _ = plt.imshow(img)

看起來好多了，是吧？

順便說一句，還有一種方法能夠避免這個問題：不要從新發明輪子，不要從頭開始編寫加強代碼並使用現有的擴展： albumentations.augmentations.transforms.GaussNoise。

我曾經作過另外一個一樣起源的bug。

1. raw_mask = cv2.imread('mask_small.png')
2. mask = raw_mask.astype('float32')`/`255
3. mask = cv2.resize(mask,`(64,`64), interpolation=cv2.INTER_LINEAR)
4. mask = cv2.resize(mask,`(128,`128), interpolation=cv2.INTER_CUBIC)
5. mask =`(mask *`255).astype('uint8')
6. _ = plt.imshow(np.hstack((raw_mask, mask)))

這裏出了什麼問題？首先，用三次插值調整掩模的大小是一個壞主意。一樣的問題 float32到 uint8：三次插值能夠輸出值大於輸入，這會致使溢出。

我在作可視化的時候發現了這個問題。在你的訓練循環中處處放置斷言也是一個好主意。

7. 拼寫錯誤

假設須要對全卷積網絡(如語義分割問題)和一個巨大的圖像進行推理。該圖像是如此巨大，沒有機會把它放在你的GPU中，它能夠是一個醫療或衛星圖像。

在這種狀況下，能夠將圖像分割成網格，獨立地對每一塊進行推理，最後合併。此外，一些預測交叉可能有助於平滑邊界附近的artifacts。

1. from tqdm import tqdm
2. class`GridPredictor:`
3. """
4. This class can be used to predict a segmentation mask for the big image
5. when you have GPU memory limitation
6. """
7. def __init__(self, predictor:`AbstractPredictor, size: int, stride:Optional[int]=`None):
8. self.predictor = predictor
9. self.size = size
10. self.stride = stride if stride is`notNoneelse size //`2
11. def __call__(self, x: np.ndarray):
12. h, w, _ = x.shape
13. mask = np.zeros((h, w,`1), dtype='float32')`
14. weights = mask.copy()
15. for i in tqdm(range(0, h -`1, self.stride)):`
16. for j in range(0, w -`1, self.stride):`
17. a, b, c, d = i, min(h, i + self.size), j, min(w, j + self.size)
18. patch = x[a:b, c:d,`:]`
19. mask[a:b, c:d,`:]+= np.expand_dims(self.predictor(patch),-1)`
20. weights[a:b, c:d,`:]=1`
21. return mask / weights

有一個符號輸入錯誤，代碼段足夠大，能夠很容易地找到它。我懷疑僅僅經過代碼就能快速識別它。可是很容易檢查代碼是否正確：

1. class`Model(nn.Module):`
2. def forward(self, x):
3. return x.mean(axis=-1)
4. model =`Model()`
5. grid_predictor =`GridPredictor(model, size=128, stride=64)`
6. simple_pred = np.expand_dims(model(img),`-1)`
7. grid_pred = grid_predictor(img)
8. np.testing.assert_allclose(simple_pred, grid_pred, atol=.001)
9. ---------------------------------------------------------------------------
10. AssertionError`Traceback`(most recent call last)
11. <ipython-input-24-a72034c717e9>`in`<module>
12. 9 grid_pred = grid_predictor(img)
13. 10
14. --->`11 np.testing.assert_allclose(simple_pred, grid_pred, atol=.001)`
15. ~/.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)
16. 1513 header =`'Not equal to tolerance rtol=%g, atol=%g'%(rtol, atol)`
17. 1514 assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
18. ->`1515 verbose=verbose, header=header, equal_nan=equal_nan)`
19. 1516
20. 1517
21. ~/.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)
22. 839 verbose=verbose, header=header,
23. 840 names=('x',`'y'), precision=precision)`
24. -->`841raiseAssertionError(msg)`
25. 842`except`ValueError:
26. 843`import traceback`
27. AssertionError:
28. Not equal to tolerance rtol=1e-07, atol=0.001
29. Mismatch:`99.6%`
30. Max absolute difference:`765.`
31. Max relative difference:`0.75000001`
32. x: array([[[215.333333],
33. [192.666667],
34. [250.`],...`
35. y: array([[[`215.33333],`
36. [`192.66667],`
37. [`250.`],...

下面是 __call__方法的正確版本:

1. def __call__(self, x: np.ndarray):
2. h, w, _ = x.shape
3. mask = np.zeros((h, w,`1), dtype='float32')`
4. weights = mask.copy()
5. for i in tqdm(range(0, h -`1, self.stride)):`
6. for j in range(0, w -`1, self.stride):`
7. a, b, c, d = i, min(h, i + self.size), j, min(w, j + self.size)
8. patch = x[a:b, c:d,`:]`
9. mask[a:b, c:d,`:]+= np.expand_dims(self.predictor(patch),-1)`
10. weights[a:b, c:d,`:]+=1`
11. return mask / weights

若是你仍然不知道問題出在哪裏，請注意 weights[a:b,c:d,:]+=1這一行。

8. Imagenet歸一化

當一我的須要進行轉移學習時，用訓練Imagenet時的方法將圖像歸一化一般是一個好主意。

讓咱們使用咱們已經熟悉的albumentations庫。

1. from albumentations import`Normalize`
2. norm =`Normalize()`
3. img = cv2.imread('img_small.jpg')
4. mask = cv2.imread('mask_small.png', cv2.IMREAD_GRAYSCALE)
5. mask = np.expand_dims(mask,`-1)`# shape (64, 64) -> shape (64, 64, 1)
6. normed = norm(image=img, mask=mask)
7. img, mask =`[normed[x]for x in['image',`'mask']]
8. def img_to_batch(x):
9. x = np.transpose(x,`(2,0,1)).astype('float32')`
10. return torch.from_numpy(np.expand_dims(x,`0))`
11. img, mask = map(img_to_batch,`(img, mask))`
12. criterion = F.binary_cross_entropy

如今是時候訓練一個網絡並對單個圖像進行過分擬合了——正如我所提到的，這是一種很好的調試技術：

1. model_a =`UNet(3,`1)
2. optimizer = torch.optim.Adam(model_a.parameters(), lr=1e-3)
3. losses =`[]`
4. for t in tqdm(range(20)):
5. loss = criterion(model_a(img), mask)
6. losses.append(loss.item())
7. optimizer.zero_grad()
8. loss.backward()
9. optimizer.step()
10. _ = plt.plot(losses)

曲率看起來很好，可是交叉熵的損失值-300是不可預料的。是什麼問題？

歸一化處理圖像效果很好，可是mask沒有：須要手動縮放到 [0,1]。

1. model_b =`UNet(3,`1)
2. optimizer = torch.optim.Adam(model_b.parameters(), lr=1e-3)
3. losses =`[]`
4. for t in tqdm(range(20)):
5. loss = criterion(model_b(img), mask /`255.)`
6. losses.append(loss.item())
7. optimizer.zero_grad()
8. loss.backward()
9. optimizer.step()
10. _ = plt.plot(losses)

訓練循環的簡單運行時斷言(例如 assertmask.max()<=1會很快檢測到問題。一樣，也能夠是單元測試。

總結

• 測試頗有必要
• 運行時斷言能夠用於訓練的pipeline;
• 可視化是一種幸福
• 複製粘貼是一種詛咒
• 沒有什麼是靈丹妙藥，一個機器學習工程師必須老是當心(或只是受苦)。