淺談 PyTorch 中的 tensor 及使用

轉自：淺談 PyTorch 中的 tensor 及使用

這篇文章主要是圍繞 PyTorch 中的 tensor 展開的，討論了張量的求導機制，在不同設備之間的轉換，神經網絡中權重的更新等內容。面向的讀者是使用過 PyTorch 一段時間的用戶。本文中的代碼例子基于 Python 3 和 PyTorch 1.1，如果文章中有錯誤或者沒有說明白的地方，歡迎在評論區指正和討論。

文章具體內容分為以下6個部分：

1. tensor.requires_grad
2. torch.no_grad()
3. 反向傳播及網絡的更新
4. tensor.detach()
5. CPU and GPU
6. tensor.item()

因為本文大部分內容是聽著冷鳥的歌完成的，故用此標題封面。

1. requires_grad

當我們創建一個張量 (tensor) 的時候，如果沒有特殊指定的話，那么這個張量是默認是不需要求導的。我們可以通過 tensor.requires_grad 來檢查一個張量是否需要求導。

在張量間的計算過程中，如果在所有輸入中，有一個輸入需要求導，那么輸出一定會需要求導；相反，只有當所有輸入都不需要求導的時候，輸出才會不需要 [1]。

舉一個比較簡單的例子，比如我們在訓練一個網絡的時候，我們從 DataLoader 中讀取出來的一個 mini-batch 的數據，這些輸入默認是不需要求導的，其次，網絡的輸出我們沒有特意指明需要求導吧，Ground Truth 我們也沒有特意設置需要求導吧。這么一想，哇，那我之前的那些 loss 咋還能自動求導呢？其實原因就是上邊那條規則，雖然輸入的訓練數據是默認不求導的，但是，我們的 model 中的所有參數，它默認是求導的，這么一來，其中只要有一個需要求導，那么輸出的網絡結果必定也會需要求的。來看個實例：

input = torch.randn(8, 3, 50, 100)
print(input.requires_grad)
# Falsenet = nn.Sequential(nn.Conv2d(3, 16, 3, 1),nn.Conv2d(16, 32, 3, 1))
for param in net.named_parameters():print(param[0], param[1].requires_grad)
# 0.weight True
# 0.bias True
# 1.weight True
# 1.bias Trueoutput = net(input)
print(output.requires_grad)
# True

誠不欺我！但是，大家請注意前邊只是舉個例子來說明。在寫代碼的過程中，不要把網絡的輸入和 Ground Truth 的 requires_grad 設置為 True。雖然這樣設置不會影響反向傳播，但是需要額外計算網絡的輸入和 Ground Truth 的導數，增大了計算量和內存占用不說，這些計算出來的導數結果也沒啥用。因為我們只需要神經網絡中的參數的導數，用來更新網絡，其余的導數都不需要。

好了，有個這個例子做鋪墊，那么我們來得寸進尺一下。我們試試把網絡參數的 requires_grad 設置為 False 會怎么樣，同樣的網絡：

input = torch.randn(8, 3, 50, 100)
print(input.requires_grad)
# Falsenet = nn.Sequential(nn.Conv2d(3, 16, 3, 1),nn.Conv2d(16, 32, 3, 1))
for param in net.named_parameters():param[1].requires_grad = Falseprint(param[0], param[1].requires_grad)
# 0.weight False
# 0.bias False
# 1.weight False
# 1.bias Falseoutput = net(input)
print(output.requires_grad)
# False

這樣有什么用處？用處大了。我們可以通過這種方法，在訓練的過程中凍結部分網絡，讓這些層的參數不再更新，這在遷移學習中很有用處。我們來看一個 官方 Tutorial: FINETUNING TORCHVISION MODELS 給的例子：

model = torchvision.models.resnet18(pretrained=True)
for param in model.parameters():param.requires_grad = False# 用一個新的 fc 層來取代之前的全連接層
# 因為新構建的 fc 層的參數默認 requires_grad=True
model.fc = nn.Linear(512, 100)# 只更新 fc 層的參數
optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)# 通過這樣，我們就凍結了 resnet 前邊的所有層，
# 在訓練過程中只更新最后的 fc 層中的參數。

2. torch.no_grad()

當我們在做 evaluating 的時候（不需要計算導數），我們可以將推斷（inference）的代碼包裹在 with torch.no_grad(): 之中，以達到 暫時 不追蹤網絡參數中的導數的目的，總之是為了減少可能存在的計算和內存消耗。看 官方 Tutorial 給出的例子：

x = torch.randn(3, requires_grad = True)
print(x.requires_grad)
# True
print((x ** 2).requires_grad)
# Truewith torch.no_grad():print((x ** 2).requires_grad)# Falseprint((x ** 2).requires_grad)
# True

3. 反向傳播及網絡的更新

這部分我們比較簡單地講一講，有了網絡輸出之后，我們怎么根據這個結果來更新我們的網絡參數呢。我們以一個非常簡單的自定義網絡來講解這個問題，這個網絡包含2個卷積層，1個全連接層，輸出的結果是20維的，類似分類問題中我們一共有20個類別，網絡如下：

class Simple(nn.Module):def __init__(self):super().__init__()self.conv1 = nn.Conv2d(3, 16, 3, 1, padding=1, bias=False)self.conv2 = nn.Conv2d(16, 32, 3, 1, padding=1, bias=False)self.linear = nn.Linear(32*10*10, 20, bias=False)def forward(self, x):x = self.conv1(x)x = self.conv2(x)x = self.linear(x.view(x.size(0), -1))return x

接下來我們用這個網絡，來研究一下整個網絡更新的流程：

# 創建一個很簡單的網絡：兩個卷積層，一個全連接層
model = Simple()
# 為了方便觀察數據變化，把所有網絡參數都初始化為 0.1
for m in model.parameters():m.data.fill_(0.1)criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1.0)model.train()
# 模擬輸入8個 sample，每個的大小是 10x10，
# 值都初始化為1，讓每次輸出結果都固定，方便觀察
images = torch.ones(8, 3, 10, 10)
targets = torch.ones(8, dtype=torch.long)output = model(images)
print(output.shape)
# torch.Size([8, 20])loss = criterion(output, targets)print(model.conv1.weight.grad)
# None
loss.backward()
print(model.conv1.weight.grad[0][0][0])
# tensor([-0.0782, -0.0842, -0.0782])
# 通過一次反向傳播，計算出網絡參數的導數，
# 因為篇幅原因，我們只觀察一小部分結果print(model.conv1.weight[0][0][0])
# tensor([0.1000, 0.1000, 0.1000], grad_fn=<SelectBackward>)
# 我們知道網絡參數的值一開始都初始化為 0.1 的optimizer.step()
print(model.conv1.weight[0][0][0])
# tensor([0.1782, 0.1842, 0.1782], grad_fn=<SelectBackward>)
# 回想剛才我們設置 learning rate 為 1，這樣，
# 更新后的結果，正好是 (原始權重 - 求導結果) ！optimizer.zero_grad()
print(model.conv1.weight.grad[0][0][0])
# tensor([0., 0., 0.])
# 每次更新完權重之后，我們記得要把導數清零啊，
# 不然下次會得到一個和上次計算一起累加的結果。
# 當然，zero_grad() 的位置，可以放到前邊去，
# 只要保證在計算導數前，參數的導數是清零的就好。

這里，我們多提一句，我們把整個網絡參數的值都傳到 optimizer 里面了，這種情況下我們調用 model.zero_grad()，效果是和 optimizer.zero_grad() 一樣的。這個知道就好，建議大家堅持用 optimizer.zero_grad()。我們現在來看一下如果沒有調用 zero_grad()，會怎么樣吧：

# ...
# 代碼和之前一樣
model.train()# 第一輪
images = torch.ones(8, 3, 10, 10)
targets = torch.ones(8, dtype=torch.long)output = model(images)
loss = criterion(output, targets)
loss.backward()
print(model.conv1.weight.grad[0][0][0])
# tensor([-0.0782, -0.0842, -0.0782])# 第二輪
output = model(images)
loss = criterion(output, targets)
loss.backward()
print(model.conv1.weight.grad[0][0][0])
# tensor([-0.1564, -0.1684, -0.1564])

我們可以看到，第二次的結果正好是第一次的2倍。第一次結束之后，因為我們沒有更新網絡權重，所以第二次反向傳播的求導結果和第一次結果一樣，加上上次我們沒有將 loss 清零，所以結果正好是2倍。另外大家可以看一下這個博客 （torch 代碼解析 為什么要使用 optimizer.zero_grad() ），我覺得講得很好。

4. tensor.detach()

接下來我們來探討兩個 0.4.0 版本更新產生的遺留問題。第一個，tensor.data 和 tensor.detach()。

在 0.4.0 版本以前，.data 是用來取 Variable 中的 tensor 的，但是之后 Variable 被取消，.data 卻留了下來。現在我們調用 tensor.data，可以得到 tensor的數據 + requires_grad=False 的版本，而且二者共享儲存空間，也就是如果修改其中一個，另一個也會變。因為 PyTorch 的自動求導系統不會追蹤 tensor.data 的變化，所以使用它的話可能會導致求導結果出錯。官方建議使用 tensor.detach() 來替代它，二者作用相似，但是 detach 會被自動求導系統追蹤，使用起來很安全[2]。多說無益，我們來看個例子吧：

a = torch.tensor([7., 0, 0], requires_grad=True)
b = a + 2
print(b)
# tensor([9., 2., 2.], grad_fn=<AddBackward0>)loss = torch.mean(b * b)b_ = b.detach()
b_.zero_()
print(b)
# tensor([0., 0., 0.], grad_fn=<AddBackward0>)
# 儲存空間共享，修改 b_ , b 的值也變了loss.backward()
# RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation

這個例子中，b 是用來計算 loss 的一個變量，我們在計算完 loss 之后，進行反向傳播之前，修改 b 的值。這么做會導致相關的導數的計算結果錯誤，因為我們在計算導數的過程中還會用到 b 的值，但是它已經變了（和正向傳播過程中的值不一樣了）。在這種情況下，PyTorch 選擇報錯來提醒我們。但是，如果我們使用 tensor.data 的時候，結果是這樣的：

a = torch.tensor([7., 0, 0], requires_grad=True)
b = a + 2
print(b)
# tensor([9., 2., 2.], grad_fn=<AddBackward0>)loss = torch.mean(b * b)b_ = b.data
b_.zero_()
print(b)
# tensor([0., 0., 0.], grad_fn=<AddBackward0>)loss.backward()print(a.grad)
# tensor([0., 0., 0.])# 其實正確的結果應該是：
# tensor([6.0000, 1.3333, 1.3333])

這個導數計算的結果明顯是錯的，但沒有任何提醒，之后再 Debug 會非常痛苦。所以，建議大家都用 tensor.detach() 啊。上邊這個代碼例子是受 這里 啟發。

5. CPU and GPU

接下來我們來說另一個問題，是關于 tensor.cuda() 和 tensor.to(device) 的。后者是 0.4.0 版本之后后添加的，當 device 是 GPU 的時候，這兩者并沒有區別。那為什么要在新版本增加后者這個表達呢，是因為有了它，我們直接在代碼最上邊加一句話指定 device ，后面的代碼直接用to(device) 就可以了：

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")a = torch.rand([3,3]).to(device)
# 干其他的活
b = torch.rand([3,3]).to(device)
# 干其他的活
c = torch.rand([3,3]).to(device)

而之前版本的話，當我們每次在不同設備之間切換的時候，每次都要用 if cuda.is_available() 判斷能否使用 GPU，很麻煩。這個精彩的解釋來自于 這里 。

if torch.cuda.is_available():a = torch.rand([3,3]).cuda()
# 干其他的活
if  torch.cuda.is_available():b = torch.rand([3,3]).cuda()
# 干其他的活
if  torch.cuda.is_available():c = torch.rand([3,3]).cuda()

關于使用 GPU 還有一個點，在我們想把 GPU tensor 轉換成 Numpy 變量的時候，需要先將 tensor 轉換到 CPU 中去，因為 Numpy 是 CPU-only 的。其次，如果 tensor 需要求導的話，還需要加一步 detach，再轉成 Numpy 。例子如下：

x  = torch.rand([3,3], device='cuda')
x_ = x.cpu().numpy()y  = torch.rand([3,3], requires_grad=True, device='cuda').
y_ = y.cpu().detach().numpy()
# y_ = y.detach().cpu().numpy() 也可以
# 二者好像差別不大？我們來比比時間：
start_t = time.time()
for i in range(10000):y_ = y.cpu().detach().numpy()
print(time.time() - start_t)
# 1.1049120426177979start_t = time.time()
for i in range(10000):y_ = y.detach().cpu().numpy()
print(time.time() - start_t)
# 1.115112543106079
# 時間差別不是很大，當然，這個速度差別可能和電腦配置
# （比如 GPU 很貴，CPU 卻很爛）有關。

6. tensor.item()

我們在提取 loss 的純數值的時候，常常會用到 loss.item()，其返回值是一個 Python 數值 (python number)。不像從 tensor 轉到 numpy (需要考慮 tensor 是在 cpu，還是 gpu，需不需要求導)，無論什么情況，都直接使用 item() 就完事了。如果需要從 gpu 轉到 cpu 的話，PyTorch 會自動幫你處理。

但注意 item() 只適用于 tensor 只包含一個元素的時候。因為大多數情況下我們的 loss 就只有一個元素，所以就經常會用到 loss.item()。如果想把含多個元素的 tensor 轉換成 Python list 的話，要使用 tensor.tolist()。

x  = torch.randn(1, requires_grad=True, device='cuda')
print(x)
# tensor([-0.4717], device='cuda:0', requires_grad=True)y = x.item()
print(y, type(y))
# -0.4717346727848053 <class 'float'>x = torch.randn([2, 2])
y = x.tolist()
print(y)
# [[-1.3069953918457031, -0.2710231840610504], [-1.26217520236969, 0.5559719800949097]]

結語

以上內容就是我平時在寫代碼的時候，覺得需要注意的地方。文章中用了一些簡單的代碼作為例子，旨在幫助大家理解。文章內容不少，看到這里的大家都辛苦了, 感謝閱讀。

最后還是那句話，希望本文能對大家學習和理解 PyTorch 有所幫助。

參考

1. PyTorch Docs: AUTOGRAD MECHANICS https://pytorch.org/docs/stable/notes/autograd.html
2. PyTorch 0.4.0 release notes https://github.com/pytorch/pytorch/releases/tag/v0.4.0