從實例逐步了解基本 PyTorch 如何運作
介紹
PyTorch 是近年來發展非常快速的深度學習框架之一。看名字可以猜到他很 pythonic，所以若是已經對 Python 很熟悉的人用起來應該會覺得很親切，所以文章也假設看的人對 Python 有基礎的了解，不會多花篇幅講解 Python 的語法。
寫這篇文章的原因是 PyTorch 的教學通常是給已經有一點基礎的人看的（也有可能只是我沒認真找），所以教學通常都很跳躍，會忽略很多細節，但這些細節對於了解整個框架的運作還蠻重要的，故整理一些英文資源，從基礎面了解 PyTorch 是如何運作的，像是 autograd, dynamic computation （動態計算圖） 等等。
簡單線性迴歸 (Simple Linear Regression, SLR)
很多教學都會從 CV 領域開始，丟給我們很多圖片，最常看到的大概是貓狗還有手寫辨識。當然這樣蠻酷的，可以馬上透過圖像看到 PyTorch 如何處理他們。不過看完常常還是有疑問，就是 PyTorch 到底是怎麼運作的？
這篇教學會從最基本面講起。這段落大概有高中數學的程度就能知道這邊在做什麼了（線性代數）。這邊有一個能夠快速了解線性迴歸如何運作的文章，若是不知道線性迴歸是什麼的話可以閱讀一下，內容非常親民，已經了解的則可以直接往下。
生成資料
首先我們先依照簡單線性迴歸的模型來生成 100 筆資料：
由上面的模型生成標記（label）Y，特徵 X ，a, b 分別是 a = 2, b = 5，最後再加上一點高斯分布的 noise：
import numpy as np
from matplotlib import pyplot as pltnp.random.seed(7) # 用來確保每次生成的隨機資料是一樣的，否則訓練結果無法比較
x = np.random.rand(100, 1)
y = 2 + 5 * x + .2 * np.random.randn(100, 1) # randn 的 n 為 normal distribution
生成 100 個索引（index）並打散：
idx = np.arange(100)
np.random.shuffle(idx) # 打散索引切分訓練用資料和驗證用資料，一個用來訓練模型，一個用來驗證我們模型訓練的如何，切分開來是因為訓練和驗證若是為同一份資料的話，那就有點像是我們考期末考前，先知道考試的題目了，這樣我們就沒有辦法知道模型真實的表現如何：
train_idx = idx[:80] # 取前 80 筆為訓練資料
val_idx = idx[80:] #取後 20 筆為驗證資料接著利用 index 來建立我們的 x, y 資料集：
x_train, y_train = x[train_idx], y[train_idx]
x_val, y_val = x[val_idx], y[val_idx]簡單看一下我們的資料分布：
plt.scatter(x_train, y_train)
plt.show()
梯度下降 (Gradient Descent)
接下來我們要簡單介紹一下梯度下降。在訓練模型的時候，其實我們就是在讓模型找參數，機器學習和深度學習所說的學習，就是這個找參數的過程，梯度下降法則是一種透過不斷更新參數，來找到最佳解的方法。當然還有許多基於梯度下降的優化算法，核心概念都是利用梯度下降法下去改良，但不是本篇文章的重點，故不多做敘述。以下我們將梯度下降分為三個步驟，對此熟悉的人可以放心跳過。
步驟一：計算 loss
以我們在處理的迴歸問題為例，我們要用 Mean Square Error, MSE 作為 loss function 來計算我們的 loss，也就是計算所有預測 a + bx 與標記 y 之間，差的平方和取平均。
當我們透過 loss function 來計算資料集中每一筆資料的 loss 並加總，他們的平均就叫做 cost function C。
步驟二：計算梯度
我們這邊所說的梯度就是在求偏導數，在這個例子中，我們需要計算兩個參數 a, b 的偏導數。導數反映的是函數在某一點處沿 x 軸正方向的變化率，更簡單的來說，就是當我們改變一個量時，我們原本給定的量會如何變化。從 loss function 來說，即當我們變動兩個參數 a, b 時，MSE loss 會如何變化。
在下列式子中，我們先分別對 a, b 求導，接著利用鏈鎖率（Chain Rule)，來代入對應元素，最後得到一般我們在做簡單迴歸時會看到的梯度回歸計算式。
步驟三：更新參數
接著我們要利用梯度來更新參數，因為我們現在要求的是最小值，而梯度的方向是面向極大值的，故我們需要減去梯度，在這裡我們用 n 來代表學習率 learning rate，即每次移動的步伐大小，來乘以梯度，以下為計算方式。
最後，我們再用更新後的參數回到步驟一計算梯度，直到我們找到最佳解。
一些關於梯度下降比較詳細的數學，還有學習率對梯度下降的影響可以參考這裡。
用 Numpy 建立線性迴歸
接下來我們試著先用 Numpy 來建立一個線性回歸模型，一是為了理解線性迴歸的架構，二是之後可以比較一下使用 numpy 和使用 PyTorch 之間的差別。
首先我們先隨便選參數 a, b 的初始值和設定基本的超參數 (hyper-parameter)，像是學習率，epoch 數等等：
# 隨機給定數值，初始化 a, b 的值
np.random.seed(7)
a = np.random.randn(1)
b = np.random.randn(1)# 設定學習率
lr = 1e-1
# 設定 epochs
epochs = 500
在每個 epoch 中，我們需要做四件事情：
- 計算模型的預測，也是所謂的正向傳遞
- 用預測和標記來計算 loss
- 計算兩個參數的梯度
- 更新參數
for epoch in range(n_epochs):
# 計算模型的預測
yhat = a + b * x_train # 用預測和標記來計算 error
error = (y_train - yhat)
# 用 error 來計算 loss
loss = (error ** 2).mean()
# 計算兩個參數的梯度
a_grad = -2 * error.mean()
b_grad = -2 * (x_train * error).mean()
# 用梯度和學習率來更新參數
a = a - lr * a_grad
b = b - lr * b_grad
print(a, b)
為了確認我們沒有算錯，我們用 scikit-learn (機器學習庫) 的 linear regression 驗證看看
from sklearn.linear_model import LinearRegression
LR = LinearRegression()
LR.fit(x_train, y_train)
print(LR.intercept_, LR.coef_[0])結果：
# 我們的
[1.95761357] [5.08223998]
# SKlearn
[1.94426643] [5.10697899]看起來是差不多的，若是把 epoch 的次數再調高一些到 1000，結果可能會更相近。
PyTorch
接下來終於要進入 PyTorch 了！不過在用 PyTorch 建立模型前，我們要先有一些 PyTorch 中的基本概念。像是 tensor 是什麼，如何建立參數和該存放在哪裡等。
Tensor
在機器學習領域中，我們可以把張量 (Tensor) 想像成一種有多個維度的數據容器，在物理和數學中，tensor 的定義又更嚴謹些。首先我們先看這個表：
從表中可以看到，rank0 的 tensor 是純量 (scalar)，1 是 vector，2 是 matrix，包含 3 以上則是 tensor，像是圖像、時間、影像都是要用 ≥ 3 維的方式，也就是 rank 3 的 tensor 來儲存。
透過實際的例子我們比較好了解究竟是怎麼回事：
讀取資料和裝置
PyTorch 有一個很方便的功能就是，能夠直接將 numpy array 轉為 PyTorch tensor。不過呢，轉換過來的 tensor 會存放在 cpu 上面，但是我們都知道嘛，用 gpu 訓練模型比用 cpu 快得多，所以我們就要把 tensor 轉到 gpu 上面。
接下來就用實例看看如何做到上述的操作，首先看看我們的電腦能不能使用CUDA (Nvidia牌的)
import torch
device = 'cuda' if torch.cuda.is_available() else 'cpu'將我們先前用 numpy 建立了資料轉成 tensor
x_train_tensor = torch.from_numpy(x_train).to(device)
y_train_tensor = torch.from_numpy(y_train).to(device)看一下各自的型別
print(type(x_train), type(x_train_tensor), x_train_tensor.type())檢查 tensor 存放在哪
x_train_tensor.type()會得到 torch.cuda.DoubleTensor, 沒 gpu 則是 torch.DoubleTensor。
當然我們也可以把 tensor 轉回去 numpy array，不過假如我們的 tensor 是在 gpu 上，我們需要先把他轉存到 cpu。
x_train_tensor.cpu().numpy()建立參數
剛剛我們只是單純建立一個資料，那要怎麼樣讓這個資料可以用來訓練呢？還記得我們在前面提到的梯度吧？沒錯！在 tensor 我們同樣要計算他的梯度，好消息是我們可以叫 PyTorch 幫我們做！只要在建立資料時，用 requires_grad=True 就可以了。
a = torch.randn(1, requires_grad=True)
b = torch.randn(1, requires_grad=True)若是要在 gpu 做運算的話，則需要先傳到 gpu 上後在使用 requires_grad
a = torch.randn(1).to(device)
b = torch.randn(1).to(device)
a.requires_grad_()
b.requires_grad_()注意 requires_grad 後面的底線「 _ 」，在 PyTorch 中，用「 _ 」結尾的方法都會改變變數本身。
最後我們也可以直接在建立參數時，直接指定 device argument。
torch.manual_seed(7)
a = torch.randn(1, requires_grad=True, device=device)
b = torch.randn(1, requires_grad=True, device=device)Autograd
Autograd 是 PyTorch 的自動微分 package，有了它我們就不用在那邊手算那些導數拉！我們直接呼叫 backward() 就能幫我們計算所有的梯度了。
那究竟 backward() 要在哪呼叫的，就在我們一開始所提到的 loss，像這樣 loss.backward()。
在 PyTorch 中，梯度會不斷往上加而不是替換掉，但是累加梯度的話會讓我們每次的梯度有偏差而影響方向，所以每次我們要用梯度去更新參數之後，需要用 zero_() 將梯度清零，那你一定會好奇為何不直接替代就好，因為在訓練 RNN 模型時，累積梯度就很方便。反正只多一個程序而已嘛～
接下來我們來試試看如何改寫前面的迴歸模型
lr = 1e-1
epochs = 500torch.manual_seed(42)
a = torch.randn(1, requires_grad=True, device=device)
b = torch.randn(1, requires_grad=True, device=device)for epoch in range(epochs):
yhat = a + b * x_train_tensor
error = y_train_tensor - yhat
loss = (error ** 2).mean() # 不用再自己計算梯度了
# a_grad = -2 * error.mean()
# b_grad = -2 * (x_tensor * error).mean()
# 從 loss 做 backward 來幫我們取得梯度
loss.backward()
with torch.no_grad():
a -= lr * a.grad
b -= lr * b.grad
# 清除梯度
a.grad.zero_()
b.grad.zero_()
print(a, b)
這邊要注意，當我們要更新參數時，必須用 with torch.no_gra() 來告訴 pytorch 我們不會動到梯度的計算，若是少了這行，就會影響到參數梯度的計算。例如我們直接用 a = a- lr * a.grad，我們的梯度就會消失， .grad 就會變成 NoneType 導致後面沒辦法清零。這跟 PyTorch 的動態計算圖有關，後面會提到。
動態計算圖（Dynamic Computation Graph）
動態計算圖光用文字很想像和說明他到底在做什麼，這邊我們運用 PyTorchViz 來把動態計算圖視覺話，讓大家能夠比較好理解。
首先先來看看預測
torch.manual_seed(7)
a = torch.randn(1, requires_grad=True, device=device)
b = torch.randn(1, requires_grad=True, device=device)yhat = a + b * x_train_tensor
error = y_train_tensor - yhat
loss = (error ** 2).mean()
make_dot(yhat)
用 yhat 來計算 error make_dot(error)
用 error 計算 MSE make_dot(loss)
接下來看看他們各自代表什麼
- 藍色方格：他們代表我們用來作為參數的 tensor，也就是我們要 PyTorch 拿來計算梯度那些，以第一個圖為例，可以看到有 a, b 兩個藍色方格，接著下面的灰色方格為 b * x。你可能會有疑問，為何 x 也是資料也用 tensor 表示，但是他沒有用藍格表示？那是因為我們不需要計算他的梯度，在動態計算圖中，只會列出需要計算其梯度的 tensor。所以只要我們把 a 的
requires_grad設成 False，他就不會出現在計算圖中了。 - 灰色方格：是跟計算梯度有關的 Python 操作。
- 綠色方格：跟灰色一樣，只是它是計算梯度的起始點（假設
backward()是在這個點呼叫 ），在計算圖中，計算方式是由底至上（bottom-up）。可以由此看到，上面三個圖之間因為變數都是拿來做下一個操作，所以他們和前者相較起來，不同的只有中間灰格的數量。
優化器（Optimizer）
目前為止我們都是利用梯度，手動地來更新參數。更新兩個可能不是什麼大問題，但是在實務上我們可能會有幾萬甚至幾億個參數需要更新，這時候我們就需要優化器了（Optimizer），像是什麼 SGD, Adam, Adagrad 之類的。
PyTorch 的 optimizer 會透過 step() 方法，依據我們設定的學習率還有其他超參數等，來更新我們的參數。另外有了優化器，我們也不用再對每一個參數做清零 zero_grad() 了，只需要透過優化器來做就好。
接著我們就用 SGD 優化器來示範一下：
from torch import optim
torch.manual_seed(7)
a = torch.randn(1, requires_grad=True)
b = torch.randn(1, requires_grad=True)
print(a, b)lr = 1e-1
epochs = 500# 指定我們的優化器為 SGD
optimizer = optim.SGD([a, b], lr=lr)for epoch in range(epochs):
yhat = a + b * x_train_tensor
error = y_train_tensor - yhat
loss = (error ** 2).mean() loss.backward()
# 不用手動更新梯度
# a -= lr * a.grad
# b -= lr * b.grad
optimizer.step()
# 不用自己將梯度清零
# a.grad.zero_()
# b.grad.zero_()
optimizer.zero_grad()
print(a, b)
Loss
有沒有人想到我們目前還是自己算 loss 呢？答對了！PyTorch 也可以幫我們算！我們一開始提到的 MSE 只是其中一種 loss function，像在分類問題，cross entropy 就是比較常見的 loss function。接下來示範如何在 PyTorch 中選擇 loss function。
from torch import nn
torch.manual_seed(7)
a = torch.randn(1, requires_grad=True)
b = torch.randn(1, requires_grad=True)
print(a, b)lr = 1e-1
epochs = 500# 指定一個 loss function
MSELoss = nn.MSELoss(reduction='mean')optimizer = optim.SGD([a, b], lr=lr)for epoch in range(epochs):
yhat = a + b * x_train_tensor
# 不用再自己算 loss 了
# error = y_tensor - yhat
# loss = (error ** 2).mean()
loss = MSELoss(y_train_tensor, yhat) loss.backward()
optimizer.step()
optimizer.zero_grad()
print(a, b)
模型（Model）
在 PyTorch 中的 model 是用從 PyTorch Module 繼承來的 Python class 表示的。
一些基礎的 methods 有這些：
__init__(self)：定義了模型的組成。在我們的例子中，是參數a, b。當然我們也能定義一些參數之外的東西，像是層數之類的。forward(self, x)：執行計算，就是讓資料通過參數來得到現在的預測，不過使用的時候不是呼叫forward()，而是呼叫 model 本身，他就會輸出預測了。
接下來建立一個簡單的模型吧！
class PyTorchLinearRegression(nn.Module):
def __init__(self):
super().__init__()
# 使用 nn.Parameter 來表示 a, b 為參數
self.a = nn.Parameter(torch.randn(1, requires_grad=True))
self.b = nn.Parameter(torch.randn(1, requires_grad=True))
def forward(self, x):
# 計算我們的輸出，也就是預測
return self.a + self.b * x在 __init__ 中，我們用 Parameter() class 定義了變數 a, b，來告訴 PyTorch 要把這兩個 tensors 作為模型的參數。此外我們還能透過 state_dict() 來看一下我們現在所有的參數。
接下來來看看如何把前面定義的模型用來訓練
torch.manual_seed(7)model = PyTorchLinearRegression()#.to(device)
print(model.state_dict())lr = 1e-1
epochs = 500MSELoss = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=lr)for epoch in range(epochs):
model.train() # 不用再手動做 output 了
# yhat = a + b * x_tensor
yhat = model(x_train_tensor)
loss = MSELoss(y_train_tensor, yhat)
loss.backward()
optimizer.step()
optimizer.zero_grad()
print(model.state_dict())
這邊要注意的是，假如資料在 GPU 上，參數也必須在 GPU 上，這時就要用 to_device() 來把參數 tensor 也傳到 GPU 上。
model = PyTorchLinearRegression().to(device)另外這裡我們也看到一段 model.train() 的程式碼，這段程式碼能夠讓我們將模型轉換到訓練模式，但並不會幫我們開始訓練模型，我們後面還是得定義訓練模型的步驟，後面會再解釋為何需要將模型轉為訓練模式。
巢狀模型
現在的線性模型是我們自己手刻出來的，PyTorch 同樣也有提供線性模型。
在下面的程式碼中，我們來把它包到我們自己的 model class 中讓他變成一個 attribute，這樣我們就有一個巢狀模型了。另外在 forward() 中，我們直接呼叫巢狀模型來進行預測的輸出，而不是呼叫 self.linear.forward(x)。
class LinearRegressionLayer(nn.Module):
def __init__(self):
super().__init__()
# 我們用一個有著 1 個輸入和輸出的線性模型層來取代原本的 2 個自訂參數
self.linear = nn.Linear(1, 1)
def forward(self, x):
# 現在只要呼叫 linear() 就可以得到預測
return self.linear(x)在建立好我們的巢狀模型後，可以透過 [*LinearRegressionLayer().parameters()] 來查看我們的參數。
順序模型（Sequential Model）
我們的模型已經夠簡單了，不過你可能會想，還敢不敢再更簡單一點？沒問題！
像我們這種很簡單的只是將資料向前傳遞，輸出用參數處理過後的值，之後再作為下一個層的輸入繼續計算下去的過程，就可以使用順序模型。
在我們的例子中，我們要建一個有一個引數（Argument），也就是我們用來做線性迴歸的 linear 層：
model = nn.Sequential(nn.Linear(1, 1))訓練過程
目前為止我們定義了一個優化器、一個損失函數（loss function）和一個模型，加上我們的資料（feature, data）和標記（label）。在訓練的過程中，我們可能需要嘗試不同的優化器、損失函數或是模型，基於這點，我們可以把函數設計的更泛用一些。
我們首先定義一個函數，引數為 optimizer, loss function 和 model，並在這個函數中，定義我們的訓練過程，引數為 data 和 label，在這個訓練過程中則執行每個訓練步驟並回傳 loss：
# 建立一個有完整訓練過程的函數
def build_train_step(model, loss_fn, optimizer):
def train_step(x, y):
# 訓練模式
model.train()
# 預測
yhat = model(x)
# 計算 loss
loss = loss_fn(y, yhat)
# 計算梯度
loss.backward()
# 更新參數並清零梯度
optimizer.step()
optimizer.zero_grad()
# 回傳 loss
return loss.item()
# 回傳會在函數內被呼叫的訓練過程
return train_step# 以我們定義好的 model, lossfunction 和 optimizer 來建立 train_step
train_step = build_train_step(model, MSELoss, optimizer)for epoch in range(epochs):
# 執行一次訓練並回傳 loss
loss = train_step(x_train_tensor, y_train_tensor)
# 確認參數
print(model.state_dict())
資料集（Dataset）
前面我們大多在講優化器、模型和損失函數，現在我們要來看一下資料的部分。我們先前的資料都是用 Numpy 和 PyTorch tensor 來表示，不過我們有更好的選擇，PyTorch 中的 dataset 也是用 Python class 來表示，其繼承了 PyTorch Dataset class。我們可以把他想成由 tuple 組成的 list，每一個 tuple 代表一個資料和標籤（x, y）。
在 dataset 中有幾個比較常用的方法：
__init__ (self)：任何可以拿來建立 tuple 列表的引數都可以在這裡定義，像是我們前面用的最基本的 tensor, 或是一個 CSV 的檔名，在之後可以用來讀取資料。
我們不用一次就讀取全部的資料集，當資料集很大的時候會浪費很多記憶空間，比較好的方式是透過
__get_item__在需要時來讀取資料，這也是為何我們前面設定的是 CSV 檔名，我們可以在這裡來透過檔名來讀取資料。
__get_item__(self, index)：為資料集建立索引，好讓我們可以像用 list[i] 這樣的互動方式來操作資料和其標籤。__len__(self)：回傳 dataset 的大小，有時會需要用到 dataset 的長度資訊。
接下來我們來建立一個有兩個 tensor 的 dataset，一個資料 x，一個標籤 y。
from torch.utils.data import Datasetclass SLRDataset(Dataset):
def __init__(self, x_tensor, y_tensor):
self.x = x_tensor
self.y = y_tensor
def __getitem__(self, index):
return (self.x[index], self.y[index]) def __len__(self):
return len(self.x)# 不用傳到 GPU 上
x_train_tensor = torch.from_numpy(x_train)
y_train_tensor = torch.from_numpy(y_train)training_data = SLRDataset(x_train_tensor, y_train_tensor)
print(training_data[0])
你可能會覺得我們不過就是用兩個 tensor 嘛，搞那麼麻煩幹嘛？如果我們只有幾個 tensor 的話，也可以用 TensorDataset 來做就好。
大家可以看到我們的 training tensors 沒有丟到 GPU 上，那是因為我們不希望在這個階段就把資料讀到 GPU 中，必須保留空間拿來訓練模型。
接下來我們要來看看為何需要這樣整理 data。
Dataloader
目前為止我們做的都是 batch grdient descent，也就是一次把所有的 data 拿來做梯度下降。這在我們這個小到不行的 data 當然沒有問題，但是資料一大可就不能這樣做事情了。
當資料量相當大時，我們要做 mini-batch gradient descent ，也就是一次讀只拿一部分資料來做 gradient descent，因此需要把資料切片，當然我們不會想自己手切嘛，這就是 dataloader 的作用了！
Dataloader 就像一個迭代器（iterator），會 loop 過資料並逐次取出不同份的 mini-batch。
from torch.utils.data import DataLoadertrain_loader = DataLoader(dataset=train_data, batch_size=16, shuffle=True)
跟 keras 的很像，我們可以透過 next() 來讓 dataloader 逐次吐出 data。
next(iter(train_loader))將 dataloader 用到我們的模型中
losses = []
train_step = build_train_step(model, MSELoss, optimizer)for epoch in range(epochs):
for x_batch, y_batch in train_loader:
# 現在 dataset 存放在 CPU 上，訓練的時候我們要把它轉移到 GPU 上
x_batch = x_batch.to(device)
y_batch = y_batch.to(device)
loss = train_step(x_batch, y_batch)
losses.append(loss)
print(model.state_dict())
print(losses[-1])
我們用了一個內迴圈來利用 dataloader 逐次讀取 mini-batch 的資料，同時也只將一份 mini-batch 傳到 GPU 上。雖然我們的資料小到不需要特定這樣做，不過在處理大的資料集時，都是先利用 dataset 的 __get_item__ 來先將資料存在 CPU，接著再將同屬一個 mini-batch 的資料傳到 GPU 做訓練，讓 GPU 的記憶空間能夠有效使用。
Random Split
目前我們都還在使用 training data，接下來我們同樣透過 dataset 和 dataloader 來處理我們的 validation data。除了我們在最一開始用的，將兩者取前 80, 後 20 的方式外，還可以使用 random_split() 。
接下來實例介紹一下如何使用 random_split() method，不過要注意我們是要用在整個 dataset 上，不是用在 training data 上，不然就會變成 training data 又再下去分，這樣就會有三份資料。
from torch.utils.data.dataset import random_split
from torch.utils.data import TensorDatasetx_tensor = torch.from_numpy(x)
y_tensor = torch.from_numpy(y)dataset = TensorDataset(x_tensor, y_tensor)train_dataset, val_dataset = random_split(dataset, [80, 20])train_loader = DataLoader(dataset=train_dataset, batch_size=16)
val_loader = DataLoader(dataset=val_dataset, batch_size=20)
評估（Evaluation）
最後我們要來把 evaluation 加到我們的模型中，讓模型能夠計算 validation loss，絕大多數的過程都樣，用 dataloader 讀 mini-batch 進來，預測後計算 loss。
除了兩點需要做一些改變：
- torch.no_grad()：在 evaluation 階段，我們不需要去計算梯度，只有在訓練時才要。評估時我們只是將訓練好的參數，拿來用在 validation set 上看看表現如何而已。
- eval()：跟做
train()對應，把我們的模型轉到 evalutaion 模式。
losses = []
val_losses = []
train_step = build_train_step(model, MSELoss, optimizer)for epoch in range(epochs):
for x, y in train_loader:
x = x.to(device)
y = y.to(device)loss = train_step(x, y)
losses.append(loss)
with torch.no_grad():
for x, y in val_loader:
x = x.to(device)
y = y.to(device)
model.eval()yhat = model(x)
val_loss = MSELoss(y, yhat)
val_losses.append(val_loss.item())print(model.state_dict())
print(losses[-1], val_losses[-1])
結語
以上就是基本的 PyTorch 範例，雖然實際在處理深度學習問題時比文章中的例子還要複雜得多，但是希望透過這篇文章能夠讓初入 PyTorch 的人，能夠透過逐步拆解、漸進式的方式，理解如何在 PyTorch 中部署我們的熟悉的 Model。接下來在看其他進階 PyTorch 教學時，應該能夠更理解它是如何運作的了。
