介紹
如果你是神經網路領域的初學者，那麼你可能已經使用過CPU訓練模型。好吧，即使你的模型有 100000 個引數也沒關係，訓練模型可能需要幾個小時。但是，如果你的模型有 100 億或 200 億個引數怎麼辦？像 VGG16 這樣常見的 CNN 模型有 1。38 億個引數，因此使用 CPU 訓練這樣的模型將是一個問題，因為它會佔用你很多寶貴的時間。
在本文中，我們將討論 GPU 如何為我們解決這個問題，並擁有使用 GPU 訓練簡單模型的實踐經驗。
為什麼 GPU 在某些任務中優於 CPU？
而不是我介紹它的好處，相信我這個影片會給你一個更好的想法。
現在你可能有主意了吧？是的，GPU 的這種大規模平行計算能力極大地幫助我們提高了複雜神經網路模型的效能並減少了訓練時間。GPU 包含大量內建的較小核心，有助於完成此任務。
神經網路中最基本的運算是矩陣乘法，GPU 非常擅長這個任務，它像專門研究矩陣乘法的專業數學家一樣解決這些計算。GPU 相對於 CPU 的其他一些優勢是：
它具有更大的記憶體頻寬。
較小的L1 和 L2 快取有助於更快地訪問快取記憶體。
為了高效利用 GPU 的多核，我們使用了 CUDA 程式設計模型。在 Pytorch 中，執行 CUDA 操作要容易得多。
但請切記，GPU不會在所有目的上替代CPU，因為在主程式仍在執行時，GPU會透過幫助執行給定應用程式的並行重複計算，而僅作為CPU的額外貢獻者。在 CPU 上。GPU優於CPU的其他一些應用程式是：
渲染影片
——由於高計算能力和記憶體頻寬，它可以有效地渲染影片。
加密貨幣挖掘
——最初使用 CPU 進行加密貨幣挖掘。但由於其高功耗和有限的處理能力導致結果不盡人意。目前，有可用於挖礦的專用 GPU，例如 Nvidia GeForce RTX 2080 Ti。
與其堅持理論方面，不如讓我們透過在 Google Colab notebook 上使用 GPU 訓練模型來動手實踐。
在 google Colab 中在 GPU 上訓練神經網路模型
使用google Colab環境，我們可以免費使用“NVIDIA Tesla K80”GPU。但請記住，你只能連續使用它 12 小時，之後你可能無法在特定時間內訪問它，除非你購買 Colab pro。
我們將把MNIST 手寫數字分類資料集作為我們的問題。我們的任務是訓練一個模型，該模型可以將給定的手寫數字影象正確分類為相應的標籤。因此，在 GPU 上訓練模型時，你必須強調的一些主要步驟是：
設定執行時型別。
定義一個在 GPU 和 CPU 之間切換的函式。
將資料集和模型載入到 GPU 中。
那麼讓我們開始吧！
步驟 1：設定 Google Colab 筆記本
建立新筆記本後，第一步是將執行時型別設定為 GPU。
步驟 2：載入必要的庫
import torch
import torchvision
import numpy as np
import matplotlib
import matplotlib。pyplot as plt
import torch。nn as nn
import torch。nn。functional as F
from torchvision。datasets import MNIST
from torchvision。transforms import ToTensor
from torchvision。utils import make_grid
from torch。utils。data。dataloader import DataLoader
from torch。utils。data import random_split
%matplotlib inline
# Use a white background for matplotlib figures
matplotlib。rcParams［‘figure。facecolor’］ = ‘#ffffff’
步驟 3：建立訓練和驗證資料集
dataset = MNIST（root=‘data/’，download =True，transform = ToTensor（））
#Splitting dataset to train and validaion
val_size = 10000
train_size = len（dataset） - val_size
train_set，val_set = random_split（dataset，［train_size，val_size］
步驟 4：批次載入訓練和驗證資料集
batch_size = 128
train_loader = DataLoader（train_set，batch_size=128，shuffle=True，num_workers=2，pin_memory =True）
val_loader = DataLoader（val_set，batch_size=256，shuffle=True，num_workers=2，pin_memory=True）
當你想將 CPU 上載入的資料集推送到 GPU 時，設定pin_memory = True 會導致兩者之間的資料傳輸速度更快。
步驟 5：建立類 Mnistmodel
class Mnistmodel（nn。Module）：
def __init__（self，input_size，hidden_size，out_size）：
super（）。__init__（）
##hidden layer
self。linear1 = nn。Linear（input_size，hidden_size）
## Output layer
self。linear2 = nn。Linear（hidden_size，out_size）
def forward（self，xb）：
xb = xb。view（xb。size（），-1）
# Output of hidden layer
out = self。linear1（xb）
#Applying Relu activation on output of hidden layer
rel = F。relu（out）
# Final output
out = self。linear2（rel）
return out
def training_step（self，batch）：
“”“ Returns loss for a training data”“”
images，labels = batch
out = self（images）
loss = F。cross_entropy（out，labels）
return loss
def validation_step（self，batch）：
“”“Finding loss and accuracy for a batch of validation data”“”
images，labels = batch
out = self（images）
loss = F。cross_entropy（out，labels）
acc = accuracy（out，labels）
return {‘val_loss’：loss，‘val_acc’：acc}
def validation_epoch_end（self，outputs）：
batch_losses = ［x［‘val_loss’］ for x in outputs］
epoch_loss = torch。stack（batch_losses）。mean（）
batch_accuracy = ［x［‘val_acc’］ for x in outputs］
epoch_accuracy = torch。stack（batch_accuracy）。mean（）
return {‘val_loss’：epoch_loss，‘val_acc’：epoch_accuracy}
def epoch_end（self，epoch，result）：
print（“Epoch ［{}］， val_loss： {：。4f}， val_acc： {：。4f}”。format（epoch， result［‘val_loss’］， result［‘val_acc’］））
使用該類，我們可以建立需要訓練的模型。
在將模型和資料載入到 GPU 之前，讓我們檢查一下 GPU 是否可用？
如果一切順利，你可能會得到輸出為
True。
但是 由於你沒有使用 Colab pro，如果你連續使用一段時間，有時 GPU 將無法使用。
所以在下一步中，我們正在建立一個在 GPU 和 CPU 之間切換的函式，以便在 GPU 不可用時自動切換到 CPU。
步驟 6：建立一個輔助函式，以在 CPU 和 GPU 之間切換
device = get_default_device（）
現在即使GPU不可用也不會有問題，因為你將自動切換到CPU進行訓練，但是訓練所花費的時間會很長。
步驟 7：定義將資料/模型移動到 GPU 的函式
def to_device（data， device）：
“”“Move tensor（s） to chosen device”“”
if isinstance（data， （list，tuple））：
return ［to_device（x， device） for x in data］
return data。to（device， non_blocking=True）
步驟 8：建立類 Devicedataloader
class DevicedataLoader（）：
def __init__（self，dl，device）：
self。dl = dl
self。device = device
def __iter__（self）：
for b in self。dl：
yield to_device（b， self。device）
def __len__（self）：
return len（self。dl）
train_loader = DeviceDataLoader（train_loader，device）
val_loader = DeviceDataLoader（val_loader，device）
使用類 Devicedataloader，我們將建立幫助我們將 train_loader 和 val_loader（在步驟 4 中定義）中存在的資料移動到 GPU 的物件。
步驟 9：定義用於訓練和驗證模型的函式
def fit（epochs，lr，model，train_loader，val_loader，opt_func = torch。optim。SGD）：
history = ［］
optimizer = opt_func（model。parameters（），lr）
for epoch in range（epochs）：
#training phase
for batch in train_loader：
loss = model。training_step（batch）
loss。backward（）
optimizer。step（）
optimizer。zero_grad（）
#Validation phase
result = evaluate（model，val_loader）
model。epoch_end（epoch，result）# Result after each epoch
history。append（result）
return history
def evaluate（model，val_loader）：
outputs = ［model。validation_step（batch） for batch in val_loader］
return model。validation_epoch_end（outputs）
步驟 10：建立類 MNISTmodel 的例項並將其移動到 GPU
num_classes =10
model = Mnistmodel（input_size =784 ，hidden_size=32，out_size= num_classes）
to_device（model，device）
請注意，在建立模型後，你必須將其移至GPU，否則我們已經移動的資料將在GPU中，而模型將在CPU中。
步驟 11 ：訓練和驗證模型
就是這樣了！！你已經使用 GPU 訓練了你的模型。
結論
現在我希望你可能對使用 GPU 訓練模型有了更好的想法，以及在使用 GPU 的訓練階段要記住的三個重要步驟。
為了使你瞭解更多，最近，由萊斯大學的一組計算機科學家建立了一種稱為SLIDE（亞線性深度學習引擎）的新演算法。該演算法背後的主要思想是減少在反向傳播中進行的無用計算。這種高效的演算法僅使用 CPU 來訓練深度學習模型，而不依賴於硬體加速器。
☆ END ☆
如果看到這裡，說明你喜歡這篇文章，請轉發、點贊。微信搜尋「uncle_pn」，歡迎新增小編微信「 mthler」，每日朋友圈更新一篇高質量博文。
