PyTorch 作為主流深度學習框架，提供豐富的工具和功能，方便開發者建構和訓練各種深度學習模型。本文從 PyTorch 安裝與版本驗證開始，逐步深入講解張量操作、自動微分機制、計算圖的應用，最後示範如何建構一個多層神經網路，並探討訓練流程與技巧。為確保開發環境順利運作，文章也涵蓋 CUDA 和 GPU 的組態說明，以及在不同硬體平臺（如 Apple Silicon）上的 PyTorch 使用方法。透過循序漸進的實作範例和圖表解析，讀者能快速掌握 PyTorch 的核心概念，並應用於實際的深度學習專案開發。

人工智慧預測模型的建立在人工智慧領域中，預測模型是一種重要的工具，能夠幫助我們根據既有的資料預測新的、未知的資料標籤。這個過程被稱為監督式學習（Supervised Learning），它涉及到訓練一個模型，使其能夠根據給定的輸入預測相應的輸出。

監督式學習工作流程監督式學習的工作流程包括兩個主要階段：訓練階段和預測階段。在訓練階段中，我們使用一個包含標籤的資料集來訓練模型，使其能夠學習到資料之間的關係。在預測階段中，我們使用已經訓練好的模型來預測新的、未知的資料標籤。

訓練階段在訓練階段中，我們首先需要準備一個包含標籤的資料集。這個資料集被稱為訓練資料集（Training Dataset）。然後，我們使用這個資料集來訓練模型，使其能夠學習到資料之間的關係。

預測階段在預測階段中，我們使用已經訓練好的模型來預測新的、未知的資料標籤。這個過程被稱為預測（Prediction）。

PyTorch簡介PyTorch是一種流行的深度學習框架，能夠幫助我們建立和訓練深度學習模型。PyTorch有兩個版本：一個是隻支援CPU計算的精簡版，另一個是支援CPU和GPU計算的完整版。如果你的電腦上有支援CUDA的GPU（例如NVIDIA T4、RTX 2080 Ti或更新的型號），我建議你安裝GPU版本。

安裝PyTorch要安裝PyTorch，你可以使用以下命令：

pip install torch

如果你的電腦支援CUDA相容的GPU，則會自動安裝支援GPU加速的PyTorch版本。

指定CUDA版本如果你想明確指定CUDA版本，你可以使用以下命令：

pip install torch==2.4.0

這個命令會安裝PyTorch 2.4.0版本，並且保證與本章中的範例相容。

驗證PyTorch版本要驗證PyTorch版本，你可以使用以下程式碼：

import torch

print(torch.__version__)

這會輸出PyTorch版本號碼。

驗證GPU是否可用要驗證GPU是否可用，你可以使用以下程式碼：

import torch

print(torch.cuda.is_available())

如果輸出為True,則表示GPU可用。如果輸出為False,則表示GPU不可用或PyTorch未能識別GPU。

圖表翻譯： graph LR

A[開始] --> B[訓練階段]

B --> C[預測階段]

C --> D[輸出預測結果]

此圖表展示了監督式學習的工作流程，包括訓練階段和預測階段。

內容解密：在上述程式碼中，我們使用torch模組來安裝和驗證PyTorch版本。然後，我們使用torch.cuda.is_available()函式來驗證GPU是否可用。如果GPU可用，則會輸出True，否則會輸出False。這些程式碼片段展示瞭如何使用PyTorch建立和驗證深度學習模型。

什麼是 PyTorch？PyTorch 是一個根據 Python 的開源機器學習函式庫，主要用於深度學習和神經網路的開發。它的名字來自於 Torch，這是一個最初使用 Lua 程式語言開發的科學計算框架。PyTorch 繼承了 Torch 的優點，並將其適應於 Python，用於支援廣泛的機器學習演算法。

在雲端運算平臺上使用 PyTorch如果您沒有 GPU 的話，可以使用雲端運算平臺，如 Google Colab，來執行 PyTorch 程式。Google Colab 提供了免費的 GPU 計算資源，雖然有時間限制，但對於初學者和小型專案來說已經足夠。您可以透過 Runtime 選單選擇 GPU 作為執行環境，如圖 A.5 所示。

在 Apple Silicon 上使用 PyTorch如果您擁有一臺搭載 Apple Silicon 晶片（如 M1、M2、M3 或更新款）的 Mac，則可以利用這些晶片加速 PyTorch 程式碼的執行。首先，您需要正常安裝 PyTorch。然後，透過執行一段簡單的 Python 程式碼來檢查您的 Mac 是否支援使用 Apple Silicon 晶片加速 PyTorch：

print(torch.backends.mps.is_available())

如果傳回 True，則表示您的 Mac 可以使用 Apple Silicon 晶片加速 PyTorch 程式碼。

練習在您的電腦上安裝和設定 PyTorch。確保環境設定正確。選擇 GPU 而非 TPU 或 CPU如果沒有 A100 GPU 可用，也可以選擇其他 GPU。您可以透過「Runtime」選單下的「Change Runtime Type」選項來進行選擇，如圖 A.5 所示。

瞭解張量張量是一個數學概念，將向量和矩陣推廣到更高維度。從計算的角度來看，張量作為資料容器，能夠高效地建立、操作和計算多維資料。PyTorch 中的張量與 NumPy 陣列相似，但具有更多適合深度學習的功能，例如自動微分引擎和對 GPU 計算的支援。

樣本、向量、矩陣和張量PyTorch 中的張量是陣列結構的資料容器。一個標量（零維張量）只是一個數字，一個向量是一個一維張量，一個矩陣是一個二維張量。對於更高維度的張量，我們通常直接稱之為「3D 張量」等。可以使用 torch.tensor 函式建立 PyTorch 張量物件。

PyTorch 的 NumPy 風格 APIPyTorch 大多數採用了 NumPy 陣列 API 和語法，用於其張量操作。如果您不熟悉 NumPy，可以透過相關文章或教程進行簡要瞭解。

內容解密：import torch

# 建立一個標量（零維張量）

scalar = torch.tensor(5)

# 建立一個向量（一維張量）

vector = torch.tensor([1, 2, 3])

# 建立一個矩陣（二維張量）

matrix = torch.tensor([[1, 2], [3, 4]])

print(scalar)

print(vector)

print(matrix)

這段程式碼示範瞭如何在 PyTorch 中建立不同維度的張量，並列印預出結果。

圖表翻譯： graph LR

A[標量] -->|建立|> B[torch.tensor(5)]

C[向量] -->|建立|> D[torch.tensor([1, 2, 3])]

E[矩陣] -->|建立|> F[torch.tensor([[1, 2], [3, 4]])]

這個 Mermaid 圖表展示了建立不同型別張量的過程，並對應到 PyTorch 中的 torch.tensor 函式。

瞭解張量的基礎在深度學習中，張量（Tensor）是一個基本的資料結構。簡單來說，張量就是一個多維陣列，可以用來表示各種不同維度的資料。

單一數值：0維張量一個單一的數值可以被視為一個0維張量。例如，數值1就是一個0維張量。

向量：1維張量一個向量是一個一維陣列，可以用來表示一系列的數值。例如，[1, 2, 3]是一個1維張量。

矩陣：2維張量一個矩陣是一個二維陣列，可以用來表示一系列的向量。例如，[[1, 2], [3, 4]]是一個2維張量。

高維張量高維張量是指維度大於2的張量。例如，[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]是一個3維張量。

使用PyTorch建立張量PyTorch是一個流行的深度學習框架，提供了建立和操作張量的功能。以下是建立不同維度張量的例子：

import torch

# 建立0維張量

tensor0d = torch.tensor(1)

# 建立1維張量

tensor1d = torch.tensor([1, 2, 3])

# 建立2維張量

tensor2d = torch.tensor([[1, 2], [3, 4]])

# 建立3維張量

tensor3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

張量的資料型別PyTorch預設使用64位整數作為資料型別。可以透過.dtype屬性存取張量的資料型別：

tensor1d = torch.tensor([1, 2, 3])

print(tensor1d.dtype) # 輸出：torch.int64

如果建立張量時使用Python浮點數，PyTorch將建立一個32位精確度的張量：

floatvec = torch.tensor([1.0, 2.0, 3.0])

瞭解PyTorch張量的基礎在深度學習中，張量（Tensor）是一種基本的資料結構，用於表示多維資料。PyTorch是一個流行的深度學習框架，它提供了強大的張量操作功能。在本文中，我們將介紹PyTorch張量的基礎知識。

張量的資料型別當建立一個PyTorch張量時，系統會自動選擇一個合適的資料型別。例如，當我們建立一個包含浮點數的張量時，PyTorch會選擇torch.float32作為資料型別。這是因為32位浮點數在精確度和計算效率之間取得了良好的平衡。

import torch

floatvec = torch.tensor([1.0, 2.0, 3.0])

print(floatvec.dtype)

輸出結果：

torch.float32

更改張量的資料型別如果需要，更改張量的資料型別可以使用.to()方法。以下程式碼示範如何將一個張量的資料型別更改為torch.float32：

floatvec = torch.tensor([1.0, 2.0, 3.0]).to(torch.float32)

print(floatvec.dtype)

輸出結果：

torch.float32

建立PyTorch張量PyTorch提供了多種方法來建立張量，包括從Python資料結構（如列表和整數）建立張量。以下程式碼示範如何建立不同維度的張量：

# 建立零維張量（標量）

scalar = torch.tensor(1)

print(scalar)

# 建立一維張量（向量）

vector = torch.tensor([1, 2, 3])

print(vector)

# 建立二維張量

matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])

print(matrix)

# 建立三維張量

tensor3d = torch.tensor([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

print(tensor3d)

常見PyTorch張量操作PyTorch提供了許多常見的張量操作，包括基本的算術運算、索引和切片等。在本章中，我們將在需要時介紹相關的操作。

# 建立二維張量

tensor2d = torch.tensor([[1, 2, 3], [4, 5, 6]])

print(tensor2d)

輸出結果：

tensor([[1, 2, 3],

[4, 5, 6]])

圖表翻譯： graph LR

A[建立張量] --> B[指定資料型別]

B --> C[進行運算]

C --> D[索引和切片]

D --> E[顯示結果]

在這個圖表中，我們展示了建立PyTorch張量的基本流程，包括指定資料型別、進行運算、索引和切片，以及顯示結果。這些操作是PyTorch中非常重要的基礎知識。

瞭解 PyTorch 中的張量操作在 PyTorch 中，張量（tensor）是一種多維資料結構，類別似於 NumPy 中的陣列。下面，我們將探討如何操作張量，包括取得其形狀、重塑、轉置和矩陣乘法。

取得張量形狀要取得一個張量的形狀，可以使用 .shape 屬性。例如，給定一個 2x3 的張量 tensor2d：

import torch

tensor2d = torch.tensor([[1, 2, 3], [4, 5, 6]])

print(tensor2d.shape)

輸出將是 torch.Size([2, 3])，表示張量有 2 行和 3 列。

重塑張量重塑張量可以使用 .reshape() 或 .view() 方法。這兩個方法都可以將張量改變為新的形狀，但它們在記憶體佈局上的處理方式有所不同。.view() 需要原始資料是連續的，如果不是，它會失敗；而 .reshape() 則會在必要時複製資料以確保新的形狀。

# 使用.reshape()

print(tensor2d.reshape(3, 2))

# 使用.view()

print(tensor2d.view(3, 2))

兩者都會輸出 tensor([[1, 2], [3, 4], [5, 6]])，但如前所述，它們在記憶體佈局上的處理有差異。

轉置張量轉置是一種特殊的重塑操作，透過 .T 屬性可以實作。它會將張量沿著其對角線翻轉。

print(tensor2d.T)

輸出將是 tensor([[1, 4], [2, 5], [3, 6]])。

矩陣乘法最後，PyTorch 提供了 .matmul() 方法來進行矩陣乘法。

# 假設我們有兩個矩陣

matrix1 = torch.tensor([[1, 2], [3, 4]])

matrix2 = torch.tensor([[5, 6], [7, 8]])

# 進行矩陣乘法

result = matrix1.matmul(matrix2)

print(result)

這將輸出矩陣乘法的結果。

使用PyTorch進行張量運算和自動微分在PyTorch中，張量運算是一個基本的概念。以下是使用PyTorch進行張量運算的例子：

import torch

# 建立兩個2D張量

tensor2d = torch.tensor([[1, 2], [3, 4]])

tensor2d_T = tensor2d.T # 取得張量的轉置

# 使用matmul方法進行矩陣乘法

result = tensor2d.matmul(tensor2d_T)

print(result)

# 使用@運運算元進行矩陣乘法

result = tensor2d @ tensor2d_T

print(result)

輸出結果為：

tensor([[14, 32],

[32, 77]])

自動微分和計算圖PyTorch的自動微分引擎（autograd）可以自動計算梯度。計算圖是一個有向圖，用於表示數學表示式。在深度學習中，計算圖用於表示神經網路的計算過程。

import torch

import torch.nn.functional as F

# 建立張量

y = torch.tensor([1.0])

x1 = torch.tensor([1.1])

w1 = torch.tensor([2.2])

b = torch.tensor([0.0])

# 定義計算圖

z = x1 * w1 + b

a = torch.sigmoid(z)

loss = F.binary_cross_entropy(a, y)

在這個例子中，計算圖用於表示一個簡單的邏輯迴歸分類別器的計算過程。PyTorch可以自動建立計算圖，並使用它來計算梯度。

計算圖和梯度計算PyTorch可以自動計算梯度，用於訓練神經網路。以下是使用PyTorch計算梯度的例子：

import torch

import torch.nn.functional as F

# 建立張量

y = torch.tensor([1.0])

x1 = torch.tensor([1.1])

w1 = torch.tensor([2.2])

b = torch.tensor([0.0])

# 定義計算圖

z = x1 * w1 + b

a = torch.sigmoid(z)

loss = F.binary_cross_entropy(a, y)

# 計算梯度

loss.backward()

print(w1.grad) # 輸出梯度值

在這個例子中，PyTorch自動建立計算圖，並使用它來計算梯度。梯度值可以用於訓練神經網路。

圖表翻譯： graph LR

A[輸入] -->|x1|> B[權重]

B -->|w1|> C[偏置]

C -->|b|> D[啟用函式]

D -->|sigmoid|> E[輸出]

E -->|loss|> F[梯度計算]

F -->|backward|> G[梯度值]

這個圖表表示了計算圖的過程，從輸入到梯度計算。

自動微分的簡化在 PyTorch 中，當我們進行計算時，它會在內部建立一個計算圖。這對於計算梯度非常有用，梯度是訓練神經網路透過流行的反向傳播演算法所需的，而反向傳播演算法可以被視為神經網路中的一種鏈式法則實作，詳見圖 A.8。

偏導數和梯度圖 A.8 顯示了偏導數，它們衡量函式相對於其中一個變數的變化率。梯度是一個包含多變數函式（即輸入多個變數的函式）所有偏導數的向量。如果您不熟悉或不記得微積分中的偏導數、梯度或鏈式法則，不要擔心。從高層面來看，您只需要知道鏈式法則是一種計算損失函式給定模型引數在計算圖中梯度的方法。這提供了更新每個引數以最小化損失函式所需的資訊，而損失函式作為衡量模型效能的代理。

圖表翻譯： graph LR

A[計算圖] --> B[鏈式法則]

B --> C[梯度計算]

C --> D[引數更新]

D --> E[損失函式最小化]

這個圖表展示了計算圖、鏈式法則、梯度計算、引數更新和損失函式最小化之間的關係。透過這個過程，模型可以不斷學習和改進，以達到最佳的效能。

自動微分的應用PyTorch 的自動微分功能使得計算梯度和更新模型引數變得非常簡單和高效。這對於深度學習模型的訓練尤其重要，因為它們通常涉及大量的引數和複雜的計算。

內容解密：import torch

# 定義模型引數

x = torch.tensor(1.0, requires_grad=True)

y = torch.tensor(2.0, requires_grad=True)

# 定義計算圖

z = x * y

# 計算梯度

z.backward()

# 更新引數

x.grad # 輸出：tensor(2.)

y.grad # 輸出：tensor(1.)

在這個例子中，我們定義了兩個模型引數 x 和 y，然後建立了一個計算圖 z = x * y。接著，我們計算了梯度 z.backward()，最後更新了引數 x.grad 和 y.grad。這個過程展示了 PyTorch 中自動微分的簡單和強大。

梯度計算與自動微分在神經網路訓練中，梯度計算是一個至關重要的步驟。梯度代表了損失函式對於模型引數的偏導數，指出了模型引數需要如何調整以最小化損失。自動微分（autograd）是計算梯度的一種方法，它可以自動地計算出損失函式對於模型引數的偏導數。

自動微分的工作原理自動微分的工作原理是透過構建一個計算圖（computation graph），然後從右到左地應用鏈式法則（chain rule）來計算梯度。計算圖是一個有向無環圖（DAG），它描述了模型的計算過程。每個節點代表了一個中間結果，每個邊代表了一個計算操作。

PyTorch 的自動微分引擎PyTorch 的自動微分引擎（autograd engine）是一個強大的工具，可以自動地計算出損失函式對於模型引數的偏導數。它透過構建一個計算圖，在背景中默默地工作。當我們呼叫 grad 函式時，autograd 引擎就會計算出梯度。

範例：使用 PyTorch 的 autograd 引擎計算梯度import torch.nn.functional as F

from torch.autograd import grad

# 定義輸入和輸出

y = torch.tensor([1.0])

x1 = torch.tensor([1.1])

# 定義模型引數

w1 = torch.tensor([2.2], requires_grad=True)

b = torch.tensor([0.0], requires_grad=True)

# 計算中間結果

z = x1 * w1 + b

a = torch.sigmoid(z)

# 計算損失

loss = F.binary_cross_entropy(a, y)

# 計算梯度

loss.backward()

# 取出梯度

print(w1.grad)

在這個範例中，我們定義了一個簡單的神經網路，包含一個輸入層、一個隱藏層和一個輸出層。然後，我們計算了損失，並使用 backward 方法計算了梯度。最後，我們取出了梯度並印出了它。

使用PyTorch自動計算梯度在之前的例子中，我們手動使用grad函式計算損失函式對模型引數的梯度。但是在實際應用中，PyTorch提供了更高階的工具來自動化這個過程。例如，我們可以在損失函式上呼叫.backward()方法，PyTorch就會計算圖中所有葉節點（leaf nodes）的梯度，並將其儲存在張量的.grad屬性中。

# 手動計算梯度

grad_L_w1 = grad(loss, w1, retain_graph=True)

grad_L_b = grad(loss, b, retain_graph=True)

print(grad_L_w1)

print(grad_L_b)

輸出結果為：

(tensor([-0.0898]),)

(tensor([-0.0817]),)

現在，讓我們使用PyTorch的自動梯度計算功能：

# 自動計算梯度

loss.backward()

print(w1.grad)

print(b.grad)

輸出結果為：

(tensor([-0.0898]),)

(tensor([-0.0817]),)

如您所見，兩種方法計算出的梯度值相同。需要注意的是，PyTorch在計算梯度後會銷毀計算圖以釋放記憶體。但是，由於我們使用了retain_graph=True，計算圖仍然被保留。

自動梯度計算的優勢使用PyTorch的自動梯度計算功能可以大大簡化我們的工作。首先，我們不需要手動計算每個引數的梯度；其次，PyTorch會自動管理計算圖，減少記憶體佔用。

實際應用在實際應用中，我們通常會使用PyTorch的自動梯度計算功能來訓練神經網路。以下是簡單的示例：

# 定義模型、損失函式和最佳化器

model =...

criterion =...

optimizer =...

# 訓練迴圈

for epoch in range(num_epochs):

# 前向傳播

outputs = model(inputs)

loss = criterion(outputs, labels)

# 反向傳播

optimizer.zero_grad()

loss.backward()

optimizer.step()

在這個例子中，我們定義了模型、損失函式和最佳化器。然後，在訓練迴圈中，我們進行前向傳播、計算損失、反向傳播和最佳化器更新。PyTorch的自動梯度計算功能使得我們可以專注於模型設計和訓練，而不需要手動計算梯度。

圖表翻譯： graph LR

A[模型] -->|前向傳播|> B[損失函式]

B -->|反向傳播|> C[最佳化器]

C -->|更新引數|> A

這個圖表展示了模型訓練的過程。首先，模型進行前向傳播，輸出結果傳遞給損失函式。然後，損失函式計算損失，並進行反向傳播，計算梯度。最後，最佳化器更新模型引數，以最小化損失。

多層神經網路的實作在深度學習中，多層神經網路是一種常見的神經網路結構。下面，我們將實作一個具有兩個隱藏層的多層感知器（Multilayer Perceptron, MLP），以展示 PyTorch 中如何定義自訂的神經網路架構。

定義神經網路架構要在 PyTorch 中實作一個神經網路，我們可以繼承 torch.nn.Module 類別，並定義自己的網路層和前向傳播方法。這個基礎類別提供了許多功能，使得建立和訓練模型變得更加容易。例如，它允許我們封裝層和操作，並追蹤模型的引數。

在定義神經網路的類別中，我們在 __init__ 方法中定義網路層，並在 forward 方法中指定如何將輸入資料傳遞透過網路，形成計算圖。相反，backward 方法通常不需要自己實作，因為 PyTorch 在訓練過程中會自動計算損失函式對模型引數的梯度。

實作多層感知器以下是實作一個具有兩個隱藏層的多層感知器的程式碼：

import torch

import torch.nn as nn

class NeuralNetwork(nn.Module):

def __init__(self):

super(NeuralNetwork, self).__init__()

self.fc1 = nn.Linear(10, 6) # 輸入層（10個單元）到第一隱藏層（6個單元）

self.fc2 = nn.Linear(6, 4) # 第一隱藏層（6個單元）到第二隱藏層（4個單元）

self.fc3 = nn.Linear(4, 3) # 第二隱藏層（4個單元）到輸出層（3個單元）

def forward(self, x):

x = torch.relu(self.fc1(x)) # 啟用第一隱藏層

x = torch.relu(self.fc2(x)) # 啟用第二隱藏層

x = self.fc3(x) # 輸出層

return x

# 初始化神經網路

model = NeuralNetwork()

# 測試輸入

input_data = torch.randn(1, 10)

# 前向傳播

output = model(input_data)

print(output)

這段程式碼定義了一個具有兩個隱藏層的多層感知器，每個隱藏層分別有 6 和 4 個單元，輸入層有 10 個單元，輸出層有 3 個單元。啟用函式使用 ReLU（Rectified Linear Unit），它是一種常見的隱藏層啟用函式。

訓練神經網路要訓練這個神經網路，我們需要定義損失函式和最佳化器，然後使用 backward 方法計算梯度，並使用最佳化器更新模型引數。這個過程通常在一個迴圈中重複多次，直到模型收斂或達到預設的停止條件。

內容解密：神經網路模型的實作import torch

import torch.nn as nn

class NeuralNetwork(nn.Module):

def __init__(self, num_inputs, num_outputs):

super().__init__()

self.layers = nn.Sequential(

# 第一隱藏層

nn.Linear(num_inputs, 30),

nn.ReLU(),

# 第二隱藏層

nn.Linear(30, 20),

nn.ReLU(),

# 輸出層

nn.Linear(20, num_outputs)

)

def forward(self, x):

logits = self.layers(x)

return logits

# 建立一個新的神經網路模型

model = NeuralNetwork(50, 3)

# 列印模型的結構

print(model)

圖表翻譯： graph LR

A[輸入層] --> B[第一隱藏層]

B --> C[ReLU啟用函式]

C --> D[第二隱藏層]

D --> E[ReLU啟用函式]

E --> F[輸出層]

在這個例子中，我們定義了一個具有兩個隱藏層的神經網路模型。每個隱藏層都使用了ReLU啟用函式，以增加模型的非線性表達能力。輸出層則直接輸出最終的結果。透過使用torch.nn.Sequential類別，我們可以輕鬆地定義模型的結構，並且不需要手動實作前向傳播的過程。

多層神經網路的實作在實作多層神經網路時，將輸入和輸出的數量編碼為變數可以讓我們重用相同的程式碼來處理具有不同特徵數量和類別數量的資料集。線性層（Linear layer）需要輸入和輸出的節點數量作為引數。

非線性啟用函式（Nonlinear activation functions）通常放在隱藏層（hidden layers）之間。每個隱藏層的輸出節點數量必須與下一個層的輸入節點數量相匹配。最後一層的輸出被稱為邏輯值（logits）。

從技術架構視角來看，本文深入淺出地介紹了使用 PyTorch 建立人工智慧預測模型的基礎知識，涵蓋了監督式學習流程、PyTorch 安裝與驗證、張量操作、自動微分以及多層神經網路的構建。透過詳盡的程式碼範例和圖表，清晰地闡述了從張量操作到模型構建的核心概念，尤其對於理解自動微分引擎和計算圖的工作原理至關重要。然而，文章並未深入探討不同模型的選擇策略、超引數調整技巧以及模型評估指標等進階議題，這對於構建高效能預測模型同樣關鍵。對於初學者，建議進一步學習如何選擇合適的模型架構、損失函式和最佳化器，並掌握模型調優和評估的最佳實務。展望未來，隨著 PyTorch 生態系統的持續發展，更多便捷的工具和技術將會出現，進一步降低深度學習模型的開發門檻，加速人工智慧技術在各個領域的應用落地。對於有意深耕人工智慧領域的開發者而言，持續關注 PyTorch 的最新發展，並積極探索新的模型架構和訓練策略，將是保持競爭力的關鍵。