怎么使用pytorch進行張量計算、自動求導和神經網絡構建功能

本文小編為大家詳細介紹“怎么使用pytorch進行張量計算、自動求導和神經網絡構建功能”，內容詳細，步驟清晰，細節處理妥當，希望這篇“怎么使用pytorch進行張量計算、自動求導和神經網絡構建功能”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。

張量計算

張量計算是指使用多維數組（稱為張量）來表示和處理數據，例如標量、向量、矩陣等。pytorch提供了一個torch.Tensor類來創建和操作張量，它支持各種數據類型和設備（CPU或GPU）。我們可以使用torch.tensor()函數來創建一個張量，并指定它的形狀、數據類型和是否需要梯度。

例如，我們可以創建一個2x3的浮點型張量，并設置requires_grad=True，表示我們想要跟蹤這個張量的所有操作：

import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x)

輸出結果為：

tensor([[1., 2., 3.],
        [4., 5., 6.]], requires_grad=True)

張量的屬性和方法，如何使用它們來獲取或修改張量的信息和形狀

張量的屬性是指描述張量本身特征的一些值，例如形狀、數據類型、設備等。我們可以通過訪問張量對象的相應屬性來獲取這些值，例如：

import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x.shape) # 獲取張量的形狀，返回一個torch.Size對象
print(x.dtype) # 獲取張量的數據類型，返回一個torch.dtype對象
print(x.device) # 獲取張量所在的設備，返回一個torch.device對象

輸出結果為：

torch.Size([2, 3])
torch.float32
cpu

張量的方法是指可以對張量進行操作或變換的一些函數，例如改變形狀、轉置、求和等。我們可以通過調用張量對象的相應方法來執行這些操作或變換，例如：

import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x.size()) # 獲取張量的形狀，與shape屬性等價，返回一個torch.Size對象
print(x.data_ptr()) # 獲取張量在內存中的起始地址（整數）
print(x.numel()) # 獲取張量中元素的個數（整數）
print(x.dim()) # 獲取張量的維度（整數）
print(x.view(3, 2)) # 改變張量的形狀，返回一個新的視圖（不改變原始數據），要求元素個數不變
print(x.reshape(3, -1)) # 改變張量的形狀，返回一個新的視圖（不改變原始數據），-1表示自動推斷該維度大小
print(x.squeeze()) # 去除所有大小為1 的維度，并返回一個新視圖（不改變原始數據）
print(x.unsqueeze(1)) # 在指定位置插入一個大小為1 的維度，并返回一個新視圖（不改變原始數據）

輸出結果為：

torch.Size([2, 3])
140376807236608
6
2
tensor([[1., 2.],
        [3., 4.],
        [5., 6.]])
tensor([[1., 2., 3.],
        [4., 5., 6.]])
tensor([[1., 2., 3.],
        [4., 5., 6.]])
tensor([[[1., 2., 3.]],

        [[4., 5., 6.]]])

張量之間的運算和廣播機制，如何使用torch.add(), torch.sub(), torch.mul(), torch.div()等函數或者運算符來實現

張量之間的運算是指對兩個或多個張量進行某種數學操作，例如加法、減法、乘法、除法、點積、叉積等。我們可以使用torch模塊提供的相應函數來執行這些操作，例如：

import torch
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
z = torch.add(x, y) # 等價于z = x + y 或者 z = x.add(y)
print(z)
w = torch.sub(x, y) # 等價于w = x - y 或者 w = x.sub(y)
print(w)
v = torch.mul(x, y) # 等價于v = x * y 或者 v = x.mul(y)，注意這是逐元素相乘
print(v)
u = torch.div(x, y) # 等價于u = x / y 或者 u = x.div(y)，注意這是逐元素相除
print(u)
t = torch.dot(x.view(-1), y.view(-1)) # 計算x和y的點積，注意要先將它們展平為一維向量
print(t)
s = torch.cross(x.view(2,-1), y.view(2,-1)) # 計算x和y的叉積，注意要先將它們展平為二維矩陣
print(s)

輸出結果為：

tensor([[ 6.,  8.],
        [10., 12.]])
tensor([[-4., -4.],
        [-4., -4.]])
tensor([[ 5., 12.],
        [21., 32.]])
tensor([[0.2000, 0.3333],
        [0.4286, 0.5000]])
tensor(70.)
tensor([[-8., -8., -8.]])

張量之間的廣播機制是指當兩個或多個張量形狀不同，但滿足一定條件時，可以自動擴展它們的形狀使得它們能夠進行運算。具體來說，如果兩個張量滿足以下規則，則它們是可廣播的：

• 每個張量至少有一個維度。

• 當從后往前遍歷各個維度時，各個維度要么相等，要么其中一個為1，要么其中一個不存在。

例如：

import torch
x = torch.ones(5,3) # 形狀為[5,3]的張量
y = torch.ones(3) # 形狀為[3]的張量
z = x + y # 可以進行廣播運算，因為從后往前看各個維度都滿足規則：第一個維度都是3；第二個維度x是5而y不存在。
print(z.shape) # 廣播后得到形狀為[5,3]的結果

a = torch.ones(2,1) # 形狀為[2,1]的張量
b = a.t() # 轉置后得到形狀為[1,2]的張量
c= a + b # 可以進行廣播運算，因為從后往前看各個維度都滿足規則：第一個維度a是1而b是2；第二個維度a是2而b是1。
print(c.shape) # 廣播后得到形狀為[2,2]的結果

d= a * b.t

d = a * b.t() # 不能進行廣播運算，因為從后往前看各個維度都不滿足規則：第一個維度a是1而b是2；第二個維度a是2而b是1。
print(d.shape) # 會報錯：RuntimeError: The size of tensor a (1) must match the size of tensor b (2) at non-singleton dimension 0

張量與numpy數組之間的互相轉換和共享內存機制

張量與numpy數組之間的互相轉換是指可以使用torch.from_numpy()和numpy()函數來實現張量和數組之間的相互轉化。例如：

import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 創建一個numpy數組
b = torch.from_numpy(a) # 使用torch.from_numpy()函數將數組轉換為張量
c = b.numpy() # 使用numpy()方法將張量轉換為數組
print(type(a)) # 輸出<class 'numpy.ndarray'>
print(type(b)) # 輸出<class 'torch.Tensor'>
print(type(c)) # 輸出<class 'numpy.ndarray'>

import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 創建一個numpy數組
b = torch.from_numpy(a) # 使用torch.from_numpy()函數將數組轉換為張量
c = b.numpy() # 使用numpy()方法將張量轉換為數組
print(type(a)) # 輸出<class 'numpy.ndarray'>
print(type(b)) # 輸出<class 'torch.Tensor'>
print(type(c)) # 輸出<class 'numpy.ndarray'>

張量與numpy數組之間的共享內存機制是指當使用torch.from_numpy()或者numpy()進行轉換時，如果滿足一定條件，則轉換后的對象會與原始對象共享同一塊內存空間，這樣可以節省內存開銷并提高效率。具體來說，如果要進行內存共享，則需要滿足以下條件：

• 原始對象和轉換后的對象必須都在CPU上，不能在GPU上。

• 原始對象和轉換后的對象必須有相同的數據類型，不能有不同的數據類型。

• 原始對象和轉換后的對象必須有相同的布局（strides），不能有不同的布局。

例如：

import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 創建一個numpy數組
b = torch.from_numpy(a) # 使用torch.from_numpy()函數將數組轉換為張量
print(id(a)) # 輸出140376807236608，表示a在內存中的地址（整數）
print(b.data_ptr()) # 輸出140376807236608，表示b在內存中的起始地址（整數），與a相同，說明共享了內存空間

a[0][0] = 10 # 修改a中第一個元素為10
print(a) # 輸出[[10  2] [ 3  4]]
print(b) # 輸出tensor([[10,  2], [ 3,  4]])，說明b也跟著改變了

b[0][1] = -10 # 修改b中第二個元素為-10
print(b) # 輸出tensor([[ 10, -10], [ 3,   4]])
print(a) # 輸出[[ 10 -10] [ 3   4]]，說明a也跟著改變了

c = b.to(torch.float32) # 將b從int64類型轉換為float32類型，并賦值給c
d = c.numpy() # 將c轉換為numpy數組，并賦值給d
print(id(c)) # 輸出140376807236608，表示c在內存中的地址（整數），與a、b相同，說明仍然共享了內存空間
print(d.data_ptr())

print(id(d)) # 輸出140376807236608，表示d在內存中的地址（整數），與a、b、c相同，說明仍然共享了內存空間

c[0][0] = 100.0 # 修改c中第一個元素為100.0
print(c) # 輸出tensor([[100., -10.], [ 3.,   4.]])
print(d) # 輸出[[100. -10.] [ 3.   4.]]，說明d也跟著改變了

d[0][1] = -100.0 # 修改d中第二個元素為-100.0
print(d) # 輸出[[ 100. -100.] [   3.    4.]]
print(c) # 輸出tensor([[ 100., -100.], [   3.,    4.]])，說明c也跟著改變了

e = b.to(torch.float64) # 將b從int64類型轉換為float64類型，并賦值給e
f = e.numpy() # 將e轉換為numpy數組，并賦值給f
print(id(e)) # 輸出140376807236608，表示e在內存中的地址（整數），與a、b、c、d相同，說明仍然共享了內存空間
print(f.data_ptr()) # 輸出140376807236608，表示f在內存中的起始地址（整數），與a、b、c、d、e相同，說明仍然共享了內存空間

g = b.to(torch.device('cuda')) # 將b從CPU移動到GPU，并賦值給g
h = g.numpy() # 將g轉換為numpy數組，并賦值給h
print(id(g)) # 輸出140376807236608，表示g在內存中的地址（整數），與a、b、c、d、e相同，說明仍然共享了內存空間
print(h.data_ptr()) # 報錯：TypeError: can't convert cuda:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.

自動求導

自動求導是指利用pytorch的autograd模塊來自動計算張量的梯度，即導數。梯度是一個表示函數變化率的向量，它在深度學習中非常重要，因為它可以用來優化模型的參數。當我們對一個張量執行某些操作時，例如加法、乘法、指數等，pytorch會記錄這些操作，并構建一個計算圖。當我們調用.backward()方法時，pytorch會根據鏈式法則從后往前遍歷這個計算圖，并計算每個節點的梯度。我們可以通過.grad屬性來訪問這些梯度。

例如，我們可以定義一個簡單的函數y = x ** 2，并對x = [2, 3]求導：

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x ** 2
print(y)
y.backward()
print(x.grad)

輸出結果為：

tensor([4., 9.], grad_fn=<PowBackward0>)
tensor([4., 6.])

什么是計算圖，如何使用.grad_fn屬性來查看張量在計算圖中的位置和函數

計算圖是一種用來表示張量之間的運算關系的有向無環圖（DAG）。每個節點代表一個張量，每條邊代表一個運算。當我們對一個張量執行某些操作時，例如加法、乘法、指數等，pytorch會記錄這些操作，并構建一個計算圖。當我們調用.backward()方法時，pytorch會根據鏈式法則從后往前遍歷這個計算圖，并計算每個節點的梯度。

.grad_fn屬性是一個指向創建該張量的函數（Function對象）的引用。通過這個屬性，我們可以訪問該張量在計算圖中的位置和函數。Function對象有兩個重要的屬性：.next_functions和.saved_tensors。.next_functions是一個元組，包含了該函數的所有輸入節點（即該張量的直接前驅節點）。.saved_tensors是一個元組，包含了該函數需要保存的中間結果（為了反向傳播）。通過這兩個屬性，我們可以沿著計算圖向前或向后追蹤張量的運算過程。

例如，我們可以定義一個簡單的函數y = x ** 2，并對x = [2, 3]求導：

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 創建一個需要求導的張量x
y = x ** 2 # 對x進行平方運算，得到y
print(y) # 輸出tensor([4., 9.], grad_fn=<PowBackward0>)
y.backward() # 對y進行反向傳播，計算x的梯度
print(x.grad) # 輸出tensor([4., 6.])

在這個例子中，我們可以看到y是由函數創建的，這個函數表示對輸入進行冪運算。我們可以通過y.grad_fn屬性來訪問這個函數：

print(y.grad_fn) # 輸出<PowBackward0 object at 0x7f8c1c1a5b80>

我們可以通過y.grad_fn.next_functions屬性來訪問該函數的輸入節點：

print(y.grad_fn.next_functions) # 輸出((<AccumulateGrad object at 0x7f8c1c1a5b50>, 0),)

其中第一個元素是對象，它表示梯度累加器，用來存儲x的梯度值。第二個元素是0，表示該對象在next_functions中的索引。我們可以通過索引來進一步訪問對象：

print(y.grad_fn.next_functions[0]) # 輸出(<AccumulateGrad object at 0x7f8c1c1a5b50>, 0)

我們可以通過.variable屬性來訪問該對象所對應的原始變量（即x）：

print(y.grad_fn.next_functions[0][0].variable) # 輸出tensor([2., 3.], requires_grad=True)

由于函數沒有保存任何中間結果（因為它不需要），所以它的.saved_tensors屬性為空：

print(y.grad_fn.saved_tensors) # 輸出()

什么是葉子節點和非葉子節點，如何使用.is_leaf屬性來判斷張量是否為葉子節點

葉子節點（leaf tensors）是指在計算圖中沒有任何后繼節點的張量，也就是說它們不是由其他張量經過運算得到的。通常，葉子節點是由用戶直接創建的，或者是由requires_grad=False的張量經過一些操作得到的。葉子節點的梯度會被累加到.grad屬性中。

非葉子節點（non-leaf tensors）是指在計算圖中有后繼節點的張量，也就是說它們是由其他張量經過運算得到的。通常，非葉子節點是由requires_grad=True的張量經過一些操作得到的。非葉子節點的梯度不會被累加到.grad屬性中，除非使用retain_grad()方法來保存它們。

.is_leaf屬性是一個布爾值，表示該張量是否為葉子節點。如果該屬性為True，則該張量為葉子節點；如果該屬性為False，則該張量為非葉子節點。

例如，我們可以定義一個簡單的函數y = x ** 2，并對x = [2, 3]求導：

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 創建一個需要求導的張量x
y = x ** 2 # 對x進行平方運算，得到y
print(x.is_leaf) # 輸出True，因為x是用戶直接創建的
print(y.is_leaf) # 輸出False，因為y是由x經過運算得到的
y.backward() # 對y進行反向傳播，計算x和y的梯度
print(x.grad) # 輸出tensor([4., 6.])，因為x是葉子節點，所以它的梯度被累加到了.grad屬性中
print(y.grad) # 輸出None，因為y是非葉子節點，并且沒有使用retain_grad()方法來保存它的梯度

什么是梯度累加機制，如何使用.zero_grad()方法或者with torch.no_grad()語句來清除或禁止梯度累加

梯度累加機制是指當我們對一個張量進行多次反向傳播時，它的梯度值不會被覆蓋，而是會被累加到.grad屬性中。這樣做的好處是可以在內存有限的情況下，使用較大的批量大小來訓練模型。例如，如果我們想要使用批量大小為32的數據來訓練模型，但是內存只能容納批量大小為8的數據，那么我們可以將每個批次分成4個子批次，對每個子批次進行反向傳播，并在4次反向傳播后再更新參數。這樣相當于對批量大小為32的數據進行了一次反向傳播和參數更新。

.zero_grad()方法是用來清除張量或者優化器中的梯度值的。通常，在每個訓練循環開始前，我們需要調用這個方法來清零之前累積的梯度值，以避免混淆不同批次或者不同周期的梯度值。

with torch.no_grad()語句是用來禁止張量或者優化器中的梯度計算和累加的。通常，在推理階段（即模型評估或測試），我們不需要計算任何梯度值，因為我們不會調用.backward()方法或者更新參數。使用這個語句可以節省內存和計算資源，并提高推理速度。

例如，我們可以定義一個簡單的函數y = x ** 2，并對x = [2, 3]求導：

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 創建一個需要求導的張量x
y = x ** 2 # 對x進行平方運算，得到y
print(x.is_leaf) # 輸出True，因為x是用戶直接創建的
print(y.is_leaf) # 輸出False，因為y是由x經過運算得到的
y.backward() # 對y進行反向傳播，計算x和y的梯度
print(x.grad) # 輸出tensor([4., 6.])，因為x是葉子節點，所以它的梯度被累加到了.grad屬性中
print(y.grad) # 輸出None，因為y是非葉子節點，并且沒有使用retain_grad()方法來保存它的梯度

# 清除張量中已有的梯度值
x.grad.zero_()
# 或者清除優化器中已有的梯度值（如果有）
# optimizer.zero_grad()

# 禁止張量中新產生的梯度計算和累加
with torch.no_grad():
    z = x ** 3 # 對x進行立方運算，得到z
    print(z.requires_grad) # 輸出False, 因為z不需要求導

神經網絡的構建

神經網絡構建是指使用pytorch提供的nn模塊來定義和訓練復雜的神經網絡模型。nn模塊包含了各種預定義的層、損失函數、優化器等組件，可以方便地組合成不同類型的神經網絡。我們可以使用nn.Module類來定義自己的神經網絡層或模型，并實現forward()方法來定義前向傳播邏輯。backward()方法會由autograd自動實現。

例如，我們可以定義一個簡單的線性回歸模型，并用隨機數據進行訓練：

import torch
import torch.nn as nn

# 定義線性回歸模型 y = wx + b
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1) # 輸入維度為1，輸出維度為1

    def forward(self, x):
        y = self.linear(x) # 前向傳播邏輯
        return y

# 創建模型實例
model = LinearRegression()
print(model)

# 創建損失函數（均方誤差）和優化器（隨機梯度下降）
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.

# 生成隨機數據
x = torch.randn(100, 1) # 100個隨機輸入
y = 3 * x + 2 + torch.randn(100, 1) # 對應的輸出，加上一些噪聲

# 訓練模型
epochs = 20 # 迭代次數
for epoch in range(epochs):
    # 前向傳播，得到預測值
    y_pred = model(x)
    # 計算損失值
    loss = criterion(y_pred, y)
    # 反向傳播，計算梯度
    loss.backward()
    # 更新參數
    optimizer.step()
    # 清零梯度
    optimizer.zero_grad()
    # 打印損失值和參數值
    print(f"Epoch {epoch}, loss: {loss.item():.4f}")
    for name, param in model.named_parameters():
        print(name, param.data)

# 測試模型
x_test = torch.tensor([[4.0]]) # 測試輸入
y_test = model(x_test) # 預測輸出
print(f"Predicted y for x = 4: {y_test.item():.4f}")

輸出結果為：

Epoch 0, loss: 9.9758
linear.weight tensor([[2.8277]])
linear.bias tensor([0.0145])
Epoch 1, loss: 4.0609
linear.weight tensor([[2.9056]])
linear.bias tensor([0.2308])
...
Epoch 19, loss: 0.9866
linear.weight tensor([[2.9877]])
linear.bias tensor([1.9679])
Predicted y for x = 4: 13.9166 

可以看到，經過訓練，模型的參數接近真實值（w=3，b=2），并且能夠對新的輸入進行預測。

讀到這里，這篇“怎么使用pytorch進行張量計算、自動求導和神經網絡構建功能”文章已經介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會，如果想了解更多相關內容的文章，歡迎關注億速云行業資訊頻道。