本文目標是如何使用Pytorch以盡可能短的方式從圖像中預測顏色、填充級別等連續屬性。我們將學習加載現有網絡，修改它以預測特定屬性，并用不到40行代碼（不包括空格）對其進行訓練。

Standart神經網絡通常專注于分類問題，比如識別貓和狗。然而，這些網絡可以很容易地進行修改，從圖像中預測連續屬性，如年齡、大小或價格。

首先，讓我們導入軟件包并定義主要的訓練參數：

import numpy as np

import torchvision．models．segmentation

import torch

import torchvision．transforms as tf

Learning＿Rate＝1e－5

width＝height＝900

batchSize＝1

學習率：是訓練過程中梯度下降的步長。

寬度和高度是用于訓練的圖像的尺寸。訓練過程中的所有圖像都將調整為該大小。

batchSize：是將用于每次訓練迭代的圖像數。

batchSize，width，height將與訓練的內存需求成比例。根據硬件的不同，可能需要使用較小的批處理大小來避免內存不足問題。

請注意，由于我們只使用單一大小的圖像進行訓練，因此訓練后的網絡可能僅限于使用這種大小的圖像。

接下來，讓我們創建訓練數據。我們想做一個簡單的演示，所以我們將創建一個用白色填充到一定高度的圖像。該網絡的目標是預測被白色覆蓋的圖像的比例。這可以很容易地用于從真實圖像預測更復雜的屬性，如其他教程所示。

例如：

在上圖中，我們希望網絡預測為0．47，因為47％的圖像填充為白色。在底圖中，我們希望網絡預測0．76，因為76％的圖像填充為白色。

在實際環境中，你可能會從文件中加載數據。在這里，我們將動態創建它：

def ReadRandomImage（）： 

  FillLevel＝np．random．random（） ＃ Set random fill level

  Img＝np．zeros（［900，900，3］，np．uint8） ＃ Create black image 

  Img［0：int（FillLevel＊900），：］＝255 ＃ Fill the image  

  transformImg＝tf．Compose（［tf．ToPILImage（），  

tf．Resize（（height，width）），tf．ToTensor（），tf．Normalize（（0．485， 0．456， 0．406）， （0．229， 0．224， 0．225））］） ＃ Set image transformation 

Img＝transformImg（Img） ＃ Transform to pytorch

return Img，FillLevel

在第一部分中，我們創建圖像：

FillLevel＝np．random．random（） ＃ Set random fill level

Img＝np．zeros（［900，900，3］，np．uint8） ＃ Create black image

Img［0：int（FillLevel＊900），：］＝255 ＃ Fill the image

第一行選擇0–1之間的隨機數作為填充級別。

Img＝np．zeros（［900，900，3］）創建一個大小為900X900的矩陣，填充零作為圖像。這相當于一個高度和寬度為900的黑色圖像。圖像有3個對應于RGB的通道。

接下來，我們用白色填充圖像的頂部，直到填充水平線。

Img［0：int（FillLevel＊900），：］＝255

現在我們創建了圖像，我們對其進行處理并將其轉換為Pytorch格式：

transformImg＝tf．Compose（［tf．ToPILImage（），  

tf．Resize（（height，width）），tf．ToTensor（），tf．Normalize（（0．485， 0．456， 0．406）， （0．229， 0．224， 0．225））］） ＃ Set image transformation

這定義了一組將應用于圖像的變換。這包括轉換為PIL格式（轉換的標準格式），以及調整大小和轉換為PyTorch格式。

對于圖像，我們還通過減去平均值并除以像素強度來標準化圖像中像素的強度。

對于我們的簡單圖像，標準化和大小調整并不是真正需要的，但這些轉換對于真實圖像很重要。

接下來，我們將變換應用于圖像：

Img＝transformImg（Img）

對于訓練，我們需要使用一批圖像。這意味著在4D矩陣中，多個圖像相互疊加。我們使用以下函數創建batch：

def LoadBatch（）： ＃ Load batch of images
          images ＝ torch．zeros（［batchSize，3，height，width］）
          FillLevel ＝ torch．zeros（［batchSize］）
          for i in range（batchSize）：
              images［i］，FillLevel［i］＝ReadRandomImage（）
          return images，FillLevel

第一行創建一個空的4d矩陣，該矩陣將存儲尺寸為［batchSize，Channel，height，width］的圖像，其中Channel是圖像的層數；這是RGB圖像的3。下一行創建一個數組，其中存儲填充級別。這將作為我們訓練的標簽。

下一部分使用前面定義的ReadRandomImage函數將圖像集和填充級別加載到空矩陣：

for i in range（batchSize）：
           images［i］，FillLevel［i］＝ReadRandomImage（）

現在我們可以加載數據了，是時候加載神經網絡了：

device ＝ torch．device（＇cuda＇） if torch．cuda．is＿available（） else torch．device（＇cpu＇）

Net ＝ torchvision．models．resnet18（pretrained＝True） ＃ Load net

Net．fc ＝ torch．nn．Linear（in＿features＝512， out＿features＝1， bias＝True）

Net ＝ Net．to（device）

optimizer ＝ torch．optim．Adam（params＝Net．parameters（），lr＝Learning＿Rate）

第一部分是確定計算機是否有GPU或CPU。如果有Cuda GPU，訓練將在GPU上進行：

device ＝ torch．device（‘cuda’） if torch．cuda．is＿available（） else torch．device（‘cpu’）

對于任何實際數據集，使用CPU進行訓練都非常緩慢。

接下來，我們加載用于圖像分類的網絡：

Net ＝ torchvision．models．resnet18（pretrained＝True）

torchvision．models包含許多有用的圖像分類模型。Reseet18是一個輕量級的分類模型，適用于低資源訓練或簡單的數據集。對于更難的問題，最好使用resenet50（請注意，數字指的是網絡中的層數）。

通過設置pretrained＝True，我們在Imagenet數據集上加載帶有預訓練權重的網絡。

在學習新問題時，最好從預訓練的模型開始，因為它允許網絡使用以前的經驗并更快地收斂。

我們可以看到我們剛剛通過print（Net）查看網絡的所有結構和所有層：

print（Net）

…

…

（avgpool）： AdaptiveAvgPool2d（output＿size＝（1， 1））

（fc）： Linear（in＿features＝512， out＿features＝1000， bias＝True）

這會按使用順序打印層。

網絡的最后一層是線性變換，輸入512層，輸出1000層。1000代表輸出類的數量（這個網絡是在圖像網絡上訓練的，圖像網絡將圖像分為1000個類中的一個）。

因為我們只想預測一個值，所以我們想用一個輸出的新線性層來代替它：

Net．fc ＝ torch．nn．Linear（in＿features＝512， out＿features＝1， bias＝True）

公平地說，這部分是可選的，因為一個有1000個輸出通道的網絡只需忽略999個通道就可以預測一個值。但這樣更優雅。

接下來，我們將網絡加載到GPU或CPU設備中：

Net＝Net．to（device）

最后，我們加載一個優化器：

optimizer＝torch．optim．Adam（params＝Net．parameters（），lr＝Learning＿Rate） ＃ Create adam optimizer

優化器將在反向傳播步驟中控制梯度速率。Adam是最快的優化器之一。

最后，我們通過加載數據開始訓練，使用網絡進行預測：

AverageLoss＝np．zeros（［50］） ＃ Save average loss for display

for itr in range（2001）： ＃ Training loop 

   images，GTFillLevel＝LoadBatch（） ＃ Load taining batch   

   images＝torch．autograd．Variable（images，requires＿grad＝False）．
   to（device）    

   GTFillLevel ＝ torch．autograd．Variable（GTFillLevel，

   requires＿grad＝False）．to（device）

   PredLevel＝Net（images） ＃ make prediction

首先，我們希望保存訓練期間的平均損失；我們創建一個數組來存儲最后50步的損失。

AverageLoss＝np．zeros（［50］）

這將使我們能夠跟蹤網絡的學習情況。

我們將訓練2000個步驟：

for itr in range（2000）：

LoadBatch在前面定義，幫助加載一批圖像及其填充級別。

torch．autograd．Variable：將數據轉換成網絡可以使用的梯度變量。我們設置Requires＿grad＝False，因為我們只將梯度應用于網絡的層。to（device） 將張量復制到對應的設備（GPU／CPU）。

最后，我們將圖像輸入網絡，得到預測結果。

PredLevel＝Net（images）

一旦我們做出預測，我們可以將其與實際填充水平進行比較，并計算損失。損失是圖像的預測和真實填充水平之間的絕對差（L1）：

Loss＝torch．abs（PredLevel－GTFillLevel）．mean（）

請注意，我們不是將損失應用于一張圖像，而是應用于批次中的多張圖像，因此我們需要將損失的平均值作為單個數字。

一旦我們計算了損失，我們就可以應用反向傳播并改變權重。

Loss．backward（） ＃ Backpropogate loss

Optimizer．step（） ＃ Apply gradient descent change to wei

在訓練期間，我們想看看我們的平均損失是否減少，看看網絡是否真的學到了什么。

因此，我們將最后50個損失值存儲在一個數組中，并顯示每個步驟的平均值：

AverageLoss［itr％50］＝Loss．data．cpu（）．numpy（） ＃ Save loss average

print（itr，＂） Loss＝＂，Loss．data．cpu（）．numpy（），
＇AverageLoss＇，AverageLoss．mean（））

這涵蓋了整個訓練階段，但我們還需要保存經過訓練的模型。否則，一旦程序停止，它就會丟失。

保存很費時，所以我們希望大約每200步只做一次：

if itr ％ 200 ＝＝ 0：
         print（“Saving Model” ＋str（itr） ＋ “．torch”）

  torch．save（Net．state＿dict（）， str（itr） ＋ “．torch”）

在運行這個腳本大約200步之后，網絡應該會給出很好的結果。

總共40行代碼，不包括空格。

訓練并保存網絡后，可以加載網絡進行預測：

https：／／github．com／sagieppel／Train－neural－net－to－predict－continuous－property－from－an－image－in－40－lines－of－code－with－PyTorch／blob／main／Infer．py

該腳本加載你之前訓練和保存的網絡，并使用它進行預測。

這里的大部分代碼與訓練腳本相同，只有幾處不同：

Net．load＿state＿dict（torch．load（modelPath）） ＃ Load trained model

從modelPath中的文件加載我們之前訓練和保存的網絡

＃Net．eval（）

將網絡從訓練模式轉換為評估模式。這主要意味著不會計算批次標準化統計數據。

雖然使用它通常是一個好主意，但在我們的例子中，它實際上會降低準確性，因此我們將在沒有它的情況下使用網絡。

with torch．no＿grad（）：

這意味著網絡運行時沒有收集梯度。梯度只與訓練相關，收集梯度需要大量資源。

感謝閱讀！

       原文標題 : 用Pytorch訓練神經網絡