基於PyTorch圖像特徵工程的深度學習圖像加強

時間 2020-08-03

標籤基於 pytorch 圖像特徵工程深度學習加強简体版

原文原文鏈接

介紹

在深度學習黑客競賽中表現出色的技巧（或者坦率地說，是任何數據科學黑客競賽）一般歸結爲特徵工程。當您得到的數據不足以創建一個成功的深度學習模型時，你能發揮多少創造力？python

我是根據本身參加屢次深度學習黑客競賽的經驗而談的，在此次深度黑客競賽中，咱們得到了包含數百張圖像的數據集——根本不足以贏得甚至完成排行榜的頂級排名。那咱們怎麼處理這個問題呢？數組

答案？好吧，那要看數據科學家的技能了！這就是咱們的好奇心和創造力脫穎而出的地方。這就是特徵工程背後的理念——在現有特徵的狀況下，咱們能多好地提出新特徵。當咱們處理圖像數據時，一樣的想法也適用。網絡

這就是圖像加強的主要做用。這一律念不只僅侷限於黑客競賽——咱們在工業和現實世界中深度學習模型項目中都使用了它！

圖像加強功能幫助我擴充現有數據集，而無需費時費力。並且我相信您會發現這項技術對您本身的項目很是有幫助。app

所以，在本文中，咱們將瞭解圖像加強的概念，爲什麼有用以及哪些不一樣的圖像加強技術。咱們還將實現這些圖像加強技術，以使用PyTorch構建圖像分類模型。dom

爲何須要圖像加強？

深度學習模型一般須要大量的數據來進行訓練。一般，數據越多，模型的性能越好。可是獲取海量數據面臨着自身的挑戰。不是每一個人都有大公司的雄厚財力。機器學習

缺乏數據使得咱們的深度學習模型可能沒法從數據中學習模式或功能，所以在未見過的數據上可能沒法提供良好的性能。ide

那麼在那種狀況下咱們該怎麼辦？咱們可使用圖像加強技術，而無需花費幾天的時間手動收集數據。函數

圖像加強是生成新圖像以訓練咱們的深度學習模型的過程。這些新圖像是使用現有的訓練圖像生成的，所以咱們沒必要手動收集它們。

有多種圖像加強技術，咱們將在下一節討論一些常見的和使用最普遍的技術。性能

不一樣的圖像加強技術

圖像旋轉

圖像旋轉是最經常使用的加強技術之一。它能夠幫助咱們的模型對對象方向的變化變得健壯。即便咱們旋轉圖像，圖像的信息也保持不變。汽車就是一輛汽車，即便咱們從不一樣的角度看它：學習

所以，咱們可使用此技術，經過從原始圖像建立旋轉圖像來增長數據量。讓咱們看看如何旋轉圖像：

# 導入全部必需的庫
import warnings
warnings.filterwarnings('ignore')
import numpy as np
import skimage.io as io
from skimage.transform import rotate, AffineTransform, warp
from skimage.util import random_noise
from skimage.filters import gaussian
import matplotlib.pyplot as plt
% matplotlib inline

我將使用此圖像演示不一樣的圖像加強技術。你也能夠根據本身的要求嘗試其餘圖片。

咱們先導入圖像並將其可視化：

# reading the image using its path
image = io.imread('emergency_vs_non-emergency_dataset/images/0.jpg')


# shape of the image
print(image.shape)


# displaying the image
io.imshow(image)

這是原始圖像。如今讓咱們看看如何旋轉它。我將使用skimage 庫的旋轉功能來旋轉圖像：

print('Rotated Image')
#rotating the image by 45 degrees
rotated = rotate(image, angle=45, mode = 'wrap')
#plot the rotated image
io.imshow(rotated)

很好！將模式設置爲「wrap」，用圖像的剩餘像素填充輸入邊界以外的點。

平移圖像

可能會出現圖像中的對象沒有徹底居中對齊的狀況。在這些狀況下，可使用圖像平移爲圖像添加平移不變性。

經過移動圖像，咱們能夠更改對象在圖像中的位置，從而使模型更具多樣性。最終將生成更通用的模型。

圖像平移是一種幾何變換，它將圖像中每一個對象的位置映射到最終輸出圖像中的新位置。

在移位操做以後，輸入圖像中的位置（x，y）處的對象被移位到新位置（X，Y）：

X = x + dx
Y = y + dy

其中，dx和dy分別是沿不一樣維度的位移。讓咱們看看如何將shift應用於圖像：

# 應用平移操做
transform = AffineTransform(translation=(25,25))
wrapShift = warp(image,transform,mode='wrap')
plt.imshow(wrapShift)
plt.title('Wrap Shift')

translation超參數定義圖像應移動的像素數。這裏，我把圖像移了（25，25）個像素。您能夠隨意設置此超參數的值。

我再次使用「wrap」模式，它用圖像的剩餘像素填充輸入邊界以外的點。在上面的輸出中，您能夠看到圖像的高度和寬度都移動了25像素。

翻轉圖像

翻轉是旋轉的延伸。它使咱們能夠在左右以及上下方向上翻轉圖像。讓咱們看看如何實現翻轉：

#flip image left-to-right
flipLR = np.fliplr(image)


plt.imshow(flipLR)
plt.title('Left to Right Flipped')

在這裏，我使用了NumPy的fliplr 函數從左向右翻轉圖像。它翻轉每一行的像素值，而且輸出確認相同。相似地，咱們能夠沿上下方向翻轉圖像：

# 上下翻轉圖像
flipUD = np.flipud(image)


plt.imshow(flipUD)
plt.title('Up Down Flipped')

這就是咱們能夠翻轉圖像並製做更通用的模型的方法，該模型將學習到原始圖像以及翻轉後的圖像。向圖像添加隨機噪聲也是圖像加強技術。讓咱們經過一個例子來理解它。

給圖像添加噪點

圖像噪聲是一個重要的加強步驟，使咱們的模型可以學習如何分離圖像中的信號和噪聲。這也使得模型對輸入的變化更加健壯。

咱們將使用「skipage」庫的「random_noise」函數爲原始圖像添加一些隨機噪聲

我將噪聲的標準差取爲0.155（您也能夠更改此值）。請記住，增長此值將爲圖像添加更多噪聲，反之亦然：

# 要添加到圖像中的噪聲的標準差
sigma=0.155
# 向圖像添加隨機噪聲
noisyRandom = random_noise(image,var=sigma**2)


plt.imshow(noisyRandom)
plt.title('Random Noise')

咱們能夠看到隨機噪聲已添加到原始圖像中。試一下不一樣的標準誤差的值，看看獲得的不一樣結果。

模糊圖像

全部攝影愛好者都會當即理解這個想法。

圖像有不一樣的來源。所以，每一個來源的圖像質量都將不一樣。有些圖像的質量可能很高，而另外一些則可能不好勁。

在這種狀況下，咱們可使圖像模糊。那將有什麼幫助？好吧，這有助於使咱們的深度學習模型更強大。

讓咱們看看咱們如何作到這一點。咱們將使用高斯濾波器來模糊圖像：

# 模糊圖像
blurred = gaussian(image,sigma=1,multichannel=True)


plt.imshow(blurred)
plt.title('Blurred Image')

Sigma是高斯濾波器的標準差。我將其視爲1。sigma值越高，模糊效果越強。 將* Multichannel *設置爲true可確保分別過濾圖像的每一個通道。

一樣，您能夠嘗試使用不一樣的sigma值來更改模糊度。

這些是一些圖像加強技術，有助於使咱們的深度學習模型健壯且可推廣。這也有助於增長訓練集的大小。

咱們即將完成本教程的實現部分。在此以前，讓咱們看看一些基本的準則，以決定正確的圖像加強技術。

選擇正確的加強技術的基本準則

我認爲在根據您試圖解決的問題來決定加強技術時，有一些準則是很重要的。如下是這些準則的簡要概述：

任何模型構建過程的第一步都是確保輸入的大小與模型所指望的大小相匹配。咱們還必須確保全部圖像的大小應該類似。爲此，咱們能夠調整咱們的圖像到適當的大小。
假設您正在處理一個分類問題，而且樣本數據量相對較少。在這種狀況下，可使用不一樣的加強技術，如圖像旋轉、圖像噪聲、翻轉、移位等。請記住，全部這些操做都適用於對圖像中對象位置可有可無的分類問題。
若是您正在處理一個對象檢測任務，其中對象的位置是咱們要檢測的，這些技術可能不合適。
圖像像素值的標準化是保證模型更好更快收斂的一個很好的策略。若是模型有特定的要求，咱們必須根據模型的要求對圖像進行預處理。

如今，不用再等了，讓咱們繼續到模型構建部分。咱們將應用本文討論的加強技術生成圖像，而後使用這些圖像來訓練模型。

咱們將研究緊急車輛與非緊急車輛的分類問題。若是你看過我之前的PyTorch文章，你應該熟悉問題的描述。

該項目的目標是將車輛圖像分爲緊急和非緊急兩類。你猜對了，這是一個圖像分類問題。您能夠從這裏下載數據集。

加載數據集

咱們開始吧！咱們先把數據裝入notebook。而後，咱們將應用圖像加強技術，最後，創建一個卷積神經網絡(CNN)模型。

讓咱們導入所需的庫：

# 導入庫
from torchsummary import summary
import pandas as pd
import numpy as np
from skimage.io import imread, imsave
from tqdm import tqdm
import matplotlib.pyplot as plt
%matplotlib inline


from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score


from skimage.transform import rotate
from skimage.util import random_noise
from skimage.filters import gaussian
from scipy import ndimage

如今，咱們將讀取包含圖像名稱及其相應標籤的CSV文件：

# 加載數據集
data = pd.read_csv('emergency_vs_non-emergency_dataset/emergency_train.csv')
data.head()

0表示該車爲非緊急車輛，1表示該車爲緊急車輛。如今讓咱們從數據集中加載全部圖像：

# 加載圖像
train_img = []
for img_name in tqdm(data['image_names']):
    image_path = 'emergency_vs_non-emergency_dataset/images/' + img_name
    img = imread(image_path)
    img = img/255
    train_img.append(img)


train_x = np.array(train_img)
train_y = data['emergency_or_not'].values
train_x.shape, train_y.shape

數據集中共有1646幅圖像。讓咱們把這些數據分紅訓練和驗證集。咱們將使用驗證集來評估模型在未見過的數據上的性能：

train_x, val_x, train_y, val_y = train_test_split(train_x, train_y, test_size = 0.1, random_state = 13, stratify=train_y)
(train_x.shape, train_y.shape), (val_x.shape, val_y.shape)

我將「test_size」保持爲0.1，所以10%的數據將隨機選擇做爲驗證集，剩下的90%將用於訓練模型。訓練集有1481個圖像，這對於訓練深度學習模型來講是至關少的。

所以，接下來，咱們將增長這些訓練圖像，以增長訓練集，並可能提升模型的性能。

加強圖像

咱們將使用前面討論過的圖像加強技術：

final_train_data = []
final_target_train = []
for i in tqdm(range(train_x.shape[0])):
    final_train_data.append(train_x[i])
    final_train_data.append(rotate(train_x[i], angle=45, mode = 'wrap'))
    final_train_data.append(np.fliplr(train_x[i]))
    final_train_data.append(np.flipud(train_x[i]))
    final_train_data.append(random_noise(train_x[i],var=0.2**2))
    for j in range(5):
        final_target_train.append(train_y[i])

咱們爲訓練集中的1481張圖像中的每一張生成了4張加強圖像。讓咱們以數組的形式轉換圖像並驗證數據集的大小：

len(final_target_train), len(final_train_data)
final_train = np.array(final_train_data)
final_target_train = np.array(final_target_train)

這證明了咱們已經加強了圖像並增長了訓練集的大小。讓咱們將這些加強圖像進行可視化：

fig,ax = plt.subplots(nrows=1,ncols=5,figsize=(20,20))
for i in range(5):
    ax[i].imshow(final_train[i+30])
    ax[i].axis('off')

這裏的第一個圖像是來自數據集的原始圖像。其他四幅圖像分別使用不一樣的圖像加強技術（旋轉、從左向右翻轉、上下翻轉和添加隨機噪聲）生成的。

咱們的數據集如今已經準備好了。是時候定義咱們的深度學習模型的結構，而後在加強過的訓練集上對其進行訓練了。咱們先從PyTorch中導入全部函數：

# PyTorch 庫和模塊
import torch
from torch.autograd import Variable
from torch.nn import Linear, ReLU, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout
from torch.optim import Adam, SGD

咱們必須將訓練集和驗證集轉換爲PyTorch格式：

# 將訓練圖像轉換爲torch格式
final_train = final_train.reshape(7405, 3, 224, 224)
final_train  = torch.from_numpy(final_train)
final_train = final_train.float()


# 將target轉換爲torch格式
final_target_train = final_target_train.astype(int)
final_target_train = torch.from_numpy(final_target_train)

一樣，咱們將轉換驗證集：

# 將驗證圖像轉換爲torch格式
val_x = val_x.reshape(165, 3, 224, 224)
val_x  = torch.from_numpy(val_x)
val_x = val_x.float()


# 將target轉換爲torch格式
val_y = val_y.astype(int)
val_y = torch.from_numpy(val_y)

模型結構

接下來，咱們將定義模型的結構。這有點複雜，由於模型結構包含4個卷積塊，而後是4個全鏈接層：

torch.manual_seed(0)


class Net(Module):   
    def __init__(self):
        super(Net, self).__init__()


        self.cnn_layers = Sequential(
            # 定義2D convolution層
            Conv2d(3, 32, kernel_size=3, stride=1, padding=1),
            ReLU(inplace=True),
            # 添加batch normalization層
            BatchNorm2d(32),
            MaxPool2d(kernel_size=2, stride=2),
            # 添加 dropout
            Dropout(p=0.25),
            # 定義另外一個2D convolution層
            Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
            ReLU(inplace=True),
            # 添加batch normalization層
            BatchNorm2d(64),
            MaxPool2d(kernel_size=2, stride=2),
            # 添加 dropout
            Dropout(p=0.25),
            # 定義另外一個2D convolution層
            Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            ReLU(inplace=True),
            # 添加batch normalization層
            BatchNorm2d(128),
            MaxPool2d(kernel_size=2, stride=2),
            # 添加 dropout
            Dropout(p=0.25),
            # 定義另外一個2D convolution層
            Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            ReLU(inplace=True),
            # 添加batch normalization層
            BatchNorm2d(128),
            MaxPool2d(kernel_size=2, stride=2),
            # 添加 dropout
            Dropout(p=0.25),
        )


        self.linear_layers = Sequential(
            Linear(128 * 14 * 14, 512),
            ReLU(inplace=True),
            Dropout(),
            Linear(512, 256),
            ReLU(inplace=True),
            Dropout(),
            Linear(256,10),
            ReLU(inplace=True),
            Dropout(),
            Linear(10,2)
        )


    # 定義前向過程    
    def forward(self, x):
        x = self.cnn_layers(x)
        x = x.view(x.size(0), -1)
        x = self.linear_layers(x)
        return x

讓咱們定義模型的其餘超參數，包括優化器、學習率和損失函數：

# defining the model
model = Net()
# defining the optimizer
optimizer = Adam(model.parameters(), lr=0.000075)
# defining the loss function
criterion = CrossEntropyLoss()
# checking if GPU is available
if torch.cuda.is_available():
    model = model.cuda()
    criterion = criterion.cuda()


print(model)

訓練模型

爲咱們的深度學習模型訓練20個epoch：

torch.manual_seed(0)


# 模型的batch size
batch_size = 64


# 訓練模型的epoch數
n_epochs = 20


for epoch in range(1, n_epochs+1):


    train_loss = 0.0
        
    permutation = torch.randperm(final_train.size()[0])


    training_loss = []
    for i in tqdm(range(0,final_train.size()[0], batch_size)):


        indices = permutation[i:i+batch_size]
        batch_x, batch_y = final_train[indices], final_target_train[indices]
        
        if torch.cuda.is_available():
            batch_x, batch_y = batch_x.cuda(), batch_y.cuda()
        
        optimizer.zero_grad()
        outputs = model(batch_x)
        loss = criterion(outputs,batch_y)


        training_loss.append(loss.item())
        loss.backward()
        optimizer.step()
        
    training_loss = np.average(training_loss)
    print('epoch: \t', epoch, '\t training loss: \t', training_loss)

這是訓練階段的summary。你會注意到，隨着epoch的增長，訓練loss會減小。讓咱們保存已訓練的模型的權重，以便未來在不從新訓練模型的狀況下使用它們：

torch.save(model, 'model.pt')

若是您不想在您的終端訓練模型，您可使用此連接下載已訓練了20個epoch的模型的權重。

接下來，讓咱們加載這個模型：

the_model = torch.load('model.pt')

測試咱們模型的性能

最後，讓咱們對訓練集和驗證集進行預測，並檢查各自的準確度：

torch.manual_seed(0)
# 預測訓練集
prediction = []
target = []
permutation = torch.randperm(final_train.size()[0])
for i in tqdm(range(0,final_train.size()[0], batch_size)):
    indices = permutation[i:i+batch_size]
    batch_x, batch_y = final_train[indices], final_target_train[indices]


    if torch.cuda.is_available():
        batch_x, batch_y = batch_x.cuda(), batch_y.cuda()


    with torch.no_grad():
        output = model(batch_x.cuda())


    softmax = torch.exp(output).cpu()
    prob = list(softmax.numpy())
    predictions = np.argmax(prob, axis=1)
    prediction.append(predictions)
    target.append(batch_y)
    
# 訓練準確度
accuracy = []
for i in range(len(prediction)):
    accuracy.append(accuracy_score(target[i].cpu(),prediction[i]))
    
print('training accuracy: \t', np.average(accuracy))

訓練集的準確率超過91%！頗有但願。可是，讓咱們拭目以待吧。咱們須要對驗證集進行相同的檢查：

# 預測驗證集
torch.manual_seed(0)
output = model(val_x.cuda())
softmax = torch.exp(output).cpu()
prob = list(softmax.detach().numpy())
predictions = np.argmax(prob, axis=1)
accuracy_score(val_y, predictions)

驗證準確性約爲78％。很好！