深度學習框架的自動微分功能極大簡化了神經網路模型的訓練過程。透過動態計算圖追蹤張量運算，並根據鏈式法則自動計算梯度，開發者只需關注模型的前向傳播邏輯，而無需手動推導和實作反向傳播。本文以 RNN 應用於莎士比亞語言建模為例，闡述瞭如何利用自動微分系統構建和訓練深度學習模型。首先，我們定義了 RNNCell 的基本結構，包含輸入層、隱藏層和輸出層之間的線性轉換，並使用 Tanh 作為啟用函式。接著，我們將莎士比亞文字轉換為字元級索引序列，作為模型的輸入。模型訓練過程中，嵌入層將字元索引對映到高維向量空間，RNNCell 根據之前的隱藏狀態和當前輸入預測下一個字元。我們使用交叉熵損失函式評估模型效能，並採用隨機梯度下降最佳化器更新模型引數。自動梯度計算系統自動計算損失函式對模型引數的梯度，簡化了訓練流程。
迴圈神經網路如何預測任意長度序列？
迴圈神經網路（RNN）的核心能力在於預測任意長度的序列。本章中，我們學習瞭如何為任意長度的序列建立向量表示。最後的練習訓練了一個線性迴圈神經網路，根據之前的短語來預測下一個詞。為此，它需要學習如何建立嵌入，將不同長度的詞串準確地表示為固定大小的向量。
最後一句話應該會引出一個問題：神經網路如何將可變數量的資訊放入固定大小的向量中？事實上，句子向量並不會編碼句子中的所有資訊。迴圈神經網路的關鍵不僅在於這些向量記住了什麼，還在於它們忘記了什麼。在預測下一個詞的情況下，大多數 RNN 學習到只有最後幾個詞是真正必要的，並且它們學會忘記（或者說，不在向量中為其建立唯一模式）更早出現的詞。
但請注意，在生成這些表示時沒有非線性因素。你認為這會造成什麼樣的限制？在下一章中，我們將使用非線性和門控機制來形成一種稱為長短期記憶網路（LSTM）的神經網路，從而探索這個問題以及更多其他問題。但在繼續之前，請確保您可以坐下來（憑記憶）編寫一個可以收斂的線性 RNN 的工作程式碼。這些網路的動態和控制流程可能有點令人生畏，而與複雜性也將會大幅提升。在繼續之前，請先熟悉本章所學的內容。
有了這些基礎，讓我們深入研究 LSTM 吧！
深度學習框架：自動最佳化的利器
好的工具可以減少錯誤、加快開發速度並提高執行時效能。如果您已經閱讀了很長時間的深度學習相關資料，您可能已經遇到過一些主要的框架，例如 PyTorch、TensorFlow、Theano（最近已棄用）、Keras、Lasagne 或 DyNet。在過去的幾年中，框架的發展非常迅速，儘管所有框架都是免費的開源軟體，但每個框架周圍都存在著一種輕鬆的競爭和友愛精神。
到目前為止，我們一直避免討論框架這個話題，因為首先，透過自己實作演算法（從 NumPy 中從頭開始），瞭解這些框架的底層工作原理非常重要。但現在我們將過渡到使用框架，因為您接下來要訓練的網路——長短期記憶網路（LSTM）——非常複雜，描述其實作的 NumPy 程式碼難以閱讀、使用或除錯（梯度到處都是）。
深度學習框架正是為瞭解決這種程式碼複雜性而建立的。特別是如果您希望在 GPU 上訓練神經網路（訓練速度提高 10-100 倍），深度學習框架可以顯著降低程式碼複雜性（減少錯誤並提高開發速度），同時提高執行時效能。由於這些原因，它們在研究界幾乎被普遍使用，深入瞭解深度學習框架對於您成為深度學習使用者或研究人員的旅程至關重要。
但是，我們不會直接跳到您聽說過的任何深度學習框架，因為這會妨礙您瞭解複雜模型（例如 LSTM）的底層工作原理。相反，您將根據框架開發的最新趨勢構建一個輕量級的深度學習框架。這樣，在將框架用於複雜架構時，您將毫無疑問地瞭解框架的作用。此外，自己構建一個小型框架應該可以順利過渡到使用實際的深度學習框架，因為您已經熟悉 API 及其底層功能。我發現這個練習對我自己很有幫助，在構建自己的框架時學到的經驗教訓在嘗試除錯有問題的模型時尤其有用。
框架如何簡化您的程式碼？從抽象的角度來看，它消除了編寫您會多次重複的程式碼的需要。具體來說，深度學習框架最有益的部分是它對自動反向傳播和自動最佳化的支援。這些功能使您只需指定模型的前向傳播程式碼，框架就會自動處理反向傳播和權重更新。大多數框架甚至透過提供常用層和損失函式的高階介面，使前向傳播程式碼更容易編寫。
張量：深度學習的根本
張量是向量和矩陣的抽象形式。到目前為止，我們一直專門使用向量和矩陣作為深度學習的基本資料結構。回想一下，矩陣是向量的列表，向量是標量的列表（單個數字）。張量是這種巢狀數字列表形式的抽象版本。向量是一維張量。矩陣是二維張量，更高維度稱為 n 維張量。因此，新深度學習框架的起點是構建這個基本型別，我們將其稱為 Tensor：
import numpy as np
class Tensor(object):
def __init__(self, data, creators=None, creation_op=None):
self.data = np.array(data)
self.creation_op = creation_op
self.creators = creators
self.grad = None
def backward(self, grad):
self.grad = grad
if self.creation_op == "add":
self.creators[0].backward(grad)
self.creators[1].backward(grad)
def __add__(self, other):
return Tensor(self.data + other.data,
creators=[self, other],
creation_op="add")
def __repr__(self):
return str(self.data.__repr__())
def __str__(self):
return str(self.data.__str__())
x = Tensor([1, 2, 3, 4, 5])
print(x) # Output: [1 2 3 4 5]
y = Tensor([2, 2, 2, 2, 2])
z = x + y
z.backward(Tensor(np.array([1, 1, 1, 1, 1])))
print(x.grad) # Output: [1 1 1 1 1]
print(y.grad) # Output: [1 1 1 1 1]
內容解密：
這段程式碼定義了一個名為 Tensor 的類別，它是我們深度學習框架的基本構建塊。它使用 NumPy 陣列儲存資料，並實作了加法運算和反向傳播功能。backward 方法根據建立操作（creation_op）將梯度傳播到建立該張量的張量。在這個例子中，加法運算的反向傳播只是將梯度傳遞給兩個加數。
這段程式碼展示瞭如何建立 Tensor 物件並執行加法運算。z.backward() 函式觸發反向傳播，計算 x 和 y 的梯度。
這個 Tensor 類別是我們框架的基礎，我們將在其上構建更複雜的層和運算。
在深度學習的領域中，自動梯度計算（Autograd）是現代深度學習框架的核心功能，它讓開發者能更輕鬆地訓練複雜的神經網路模型。本文將探討 Autograd 的運作機制，並以實務角度解析其在深度學習框架中的應用。
Autograd 與動態計算圖
Autograd 的核心概念是動態計算圖。在進行運算時，系統會自動構建一個計算圖，記錄每個張量的運算過程和依賴關係。每個張量都包含 creators 和 creation_op 屬性，分別記錄建立該張量的父張量和運算操作。
以下程式碼片段展示了動態計算圖的構建過程：
import numpy as np
class Tensor(object):
def __init__(self, data, autograd=False, creators=None, creation_op=None, id=None):
# ... (其他初始化程式碼)
if creators is not None:
for c in creators:
if self.id not in c.children:
c.children[self.id] = 1
else:
c.children[self.id] += 1
x = Tensor(np.array([1, 2, 3, 4, 5]), autograd=True)
y = Tensor(np.array([2, 2, 2, 2, 2]), autograd=True)
z = x + y
print(z.creators) # 輸出: [<__main__.Tensor object at 0x7f8b9c0f3a90>, <__main__.Tensor object at 0x7f8b9c0f3b00>]
print(z.creation_op) # 輸出: add
內容解密：
這段程式碼定義了一個 Tensor 類別，用於表示計算圖中的節點。當執行 z = x + y 時，系統會自動將 x 和 y 設定為 z 的 creators，並將 creation_op 設定為 add，從而建立了計算圖的邊。
反向傳播與梯度計算
計算圖建立後，就可以透過反向傳播計算梯度。呼叫 z.backward() 時，系統會根據計算圖的結構和 creation_op，自動計算 x 和 y 的梯度。
z.backward(Tensor(np.array([1, 1, 1, 1, 1])))
print(x.grad) # 輸出: [1. 1. 1. 1. 1.]
print(y.grad) # 輸出: [1. 1. 1. 1. 1.]
內容解密：
z.backward() 方法接收一個梯度向量作為引數，表示相對於 z 的梯度。系統會根據加法運算，將 z 的梯度傳遞給 x 和 y。
多重使用張量的處理
當一個張量被多次使用時，需要累積來自不同子節點的梯度。以下程式碼展示瞭如何處理這種情況：
# ... (Tensor類別定義)
def backward(self, grad=None, grad_origin=None):
if self.autograd:
# ... (其他程式碼)
if self.grad is None:
self.grad = grad
else:
self.grad += grad
# ... (其他程式碼)
a = Tensor([1, 2, 3, 4, 5], autograd=True)
b = Tensor([2, 2, 2, 2, 2], autograd=True)
c = Tensor([5, 4, 3, 2, 1], autograd=True)
d = a + b
e = b + c
f = d + e
f.backward(Tensor(np.array([1, 1, 1, 1, 1])))
print(b.grad.data == np.array([2, 2, 2, 2, 2])) # 輸出: [ True True True True True]
內容解密：
在 backward 方法中，使用累積指定(self.grad += grad)確保正確計算重複使用張量的梯度。這種機制確保了像 b 這樣的張量能夠正確累積來自多個後代節點(d 和 e)的梯度。
透過動態計算圖和反向傳播，Autograd 能夠自動計算梯度，簡化深度學習模型的訓練過程。理解 Autograd 的運作原理對於深度學習框架的應用和除錯至關重要。
此圖示說明瞭 Autograd 如何構建動態計算圖並執行反向傳播：
圖表說明：
此 Plantuml 圖展示了 Autograd 的核心運作機制。首先，在前向傳播階段，輸入張量 x 和 y 經過加法運算建立輸出張量 z。在反向傳播階段，z 的梯度被傳遞回 x 和 y，從而實作自動梯度計算。這種動態計算圖機制使得 Autograd 能夠靈活地處理各種複雜的神經網路結構，同時準確地計算所需的梯度資訊。
總而言之，本篇技術文章探討了深度學習中的關鍵概念，包括迴圈神經網路、深度學習框架、張量運算以及自動梯度計算等。透過詳細的程式碼示例和技術解析，我們展示瞭如何構建一個簡單的深度學習框架，並實作了自動微分功能。這些基礎知識對於理解和實作更複雜的深度學習模型至關重要。透過結合理論講解和實際程式碼演示，本篇文章為讀者提供了一個全面而深入的深度學習入門，為進一步探索這一領域奠定了堅實的基礎。
流程解密：
此圖示展示了張量 f 的計算圖，清楚地說明瞭各個張量之間的運算關係以及梯度反向傳播的路徑。圖中節點代表不同的張量運算步驟，而箭頭則表示資料流動的方向。從圖中可見，d 和 e 是透過基本的加法運算得出的中間結果，最終這兩個中間結果被用來計算輸出張量 f。
具體來說，d = a + b 和 e = b + c 是兩個獨立的加法運算，它們的結果被用於計算 f = d + e。這種結構不僅闡明瞭前向計算的流程，也為理解反向傳播過程中梯度的流動提供了直觀的視覺化基礎。
在反向傳播過程中，梯度從輸出節點 f 開始逐步回溯至輸入節點 a、b 和 c。每個節點根據鏈式法則計算相應的梯度，並將其傳遞給前驅節點。這種機制使得系統能夠有效地計算複雜運算的梯度，為深度學習模型的訓練提供了基礎。
import numpy as np
class Tensor (object):
def __init__(self,data,
autograd=False,
creators=None,
creation_op=None,
id=None):
self.data = np.array(data)
self.autograd = autograd
self.grad = None
if(id is None):
self.id = np.random.randint(0,100000)
else:
self.id = id
self.creators = creators
self.creation_op = creation_op
self.children = {}
if(creators is not None):
for c in creators:
if(self.id not in c.children):
c.children[self.id] = 1
else:
c.children[self.id] += 1
def all_children_grads_accounted_for(self):
for id,cnt in self.children.items():
if(cnt != 0):
return False
return True
def backward(self,grad=None, grad_origin=None):
if(self.autograd):
if(grad is None):
grad = Tensor(np.ones_like(self.data))
if(grad_origin is not None):
if(self.children[grad_origin.id] == 0):
raise Exception("cannot backprop more than once")
else:
self.children[grad_origin.id] -= 1
if(self.grad is None):
self.grad = grad
else:
self.grad += grad
if(self.creators is not None and
(self.all_children_grads_accounted_for() or
grad_origin is None)):
if(self.creation_op == "add"):
self.creators[0].backward(self.grad, self)
self.creators[1].backward(self.grad, self)
if(self.creation_op == "sub"):
self.creators[0].backward(self.grad, self)
self.creators[1].backward(self.grad.__neg__(), self)
if(self.creation_op == "mul"):
new = self.grad * self.creators[1]
self.creators[0].backward(new , self)
new = self.grad * self.creators[0]
self.creators[1].backward(new, self)
if(self.creation_op == "mm"):
act = self.creators[0]
weights = self.creators[1]
new = self.grad.mm(weights.transpose())
act.backward(new)
new = self.grad.transpose().mm(act).transpose()
weights.backward(new)
if(self.creation_op == "transpose"):
self.creators[0].backward(self.grad.transpose())
if("sum" in self.creation_op):
dim = int(self.creation_op.split("_")[1])
self.creators[0].backward(self.grad.expand(dim,
self.creators[0].data.shape[dim]))
if("expand" in self.creation_op):
dim = int(self.creation_op.split("_")[1])
self.creators[0].backward(self.grad.sum(dim))
if(self.creation_op == "neg"):
self.creators[0].backward(self.grad.__neg__())
def __add__(self, other):
if(self.autograd and other.autograd):
return Tensor(self.data + other.data,
autograd=True,
creators=[self,other],
creation_op="add")
return Tensor(self.data + other.data)
def __neg__(self):
if(self.autograd):
return Tensor(self.data * -1,
autograd=True,
creators=[self],
creation_op="neg")
return Tensor(self.data * -1)
def __sub__(self, other):
if(self.autograd and other.autograd):
return Tensor(self.data - other.data,
autograd=True,
creators=[self,other],
creation_op="sub")
return Tensor(self.data - other.data)
def __mul__(self, other):
if(self.autograd and other.autograd):
return Tensor(self.data * other.data,
autograd=True,
creators=[self,other],
creation_op="mul")
return Tensor(self.data * other.data)
def sum(self, dim):
if(self.autograd):
return Tensor(self.data.sum(dim),
autograd=True,
creators=[self],
creation_op="sum_"+str(dim))
return Tensor(self.data.sum(dim))
def expand(self, dim,copies):
trans_cmd = list(range(0,len(self.data.shape)))
trans_cmd.insert(dim,len(self.data.shape))
new_data = self.data.repeat(copies).reshape(list(self.data.shape) + [copies]).transpose(trans_cmd)
內容解密：
這段程式碼實作了一個名為 Tensor 的類別，用於支援自動梯度計算（autograd）。該類別模擬了深度學習框架中的張量運算，並提供了反向傳播所需的梯度計算功能。
首先，Tensor 類別的建構函式初始化了一個張量物件，包含資料、是否啟用自動梯度計算、建立該張量的父張量、建立操作型別等屬性。其中，autograd 引數控制是否啟用自動梯度計算，而 creators 和 creation_op 則記錄了該張量的來源和建立方式。
在反向傳播過程中，backward 方法根據鏈式法則計算梯度並將其回傳給父張量。該方法首先檢查是否需要啟用自動梯度計算，然後根據不同的建立操作型別（如加法、乘法、矩陣乘法等）進行相應的梯度計算。
例如，在加法運算中，梯度會被直接回傳給兩個父張量；而在乘法運算中，梯度則會根據鏈式法則進行計算並分配給兩個父張量。這種機制使得系統能夠自動計算複雜運算的梯度，為深度學習模型的訓練提供了基礎。
此外，該類別還實作了各種張量運算，如加法、減法、乘法、矩陣乘法、轉置、求和等，並在啟用自動梯度計算時記錄相應的操作型別和父張量，以便在反向傳播過程中正確計算梯度。
總體而言，這個 Tensor 類別提供了一個基礎的自動梯度計算系統，能夠支援簡單的深度學習模型訓練和梯度計算需求。透過這個實作，開發者可以更深入地理解深度學習框架中的自動微分機制，並在此基礎上建立更複雜的模型和應用。
自動最佳化：簡化神經網路訓練
在深度學習領域中，反向傳播的自動化是實作高效模型訓練的關鍵。本文將探討自動最佳化的內部機制，並透過具體例項展示如何利用自動梯度計算來最佳化神經網路的訓練流程。
反向傳播機制的技術解析
反向傳播過程從網路輸出端開始，透過一系列與正向傳播對應的操作，將誤差訊號逐層回傳。在這個過程中，不同的操作型別對應不同的梯度計算邏輯。以下程式碼片段展示了反向傳播的核心實作：
if(self.creation_op == "sub"):
new = Tensor(self.grad.data)
self.creators[0].backward(new, self)
new = Tensor(self.grad.__neg__().data)
self.creators[1].backward(new, self)
if(self.creation_op == "mul"):
new = self.grad * self.creators[1]
self.creators[0].backward(new, self)
new = self.grad * self.creators[0]
self.creators[1].backward(new, self)
if(self.creation_op == "mm"):
act = self.creators[0]
weights = self.creators[1]
new = self.grad.mm(weights.transpose())
act.backward(new)
new = self.grad.transpose().mm(act).transpose()
weights.backward(new)
內容解密：
這段程式碼定義了不同操作的反向傳播邏輯：
- 對於減法操作 (
"sub")，梯度被分別傳遞給兩個運算元，第一個運算元接收原始梯度，第二個運算元接收梯度的負值 - 對於乘法操作 (
"mul")，梯度根據鏈式法則進行計算並傳遞 - 對於矩陣乘法 (
"mm")，梯度計算涉及轉置操作，以正確分配誤差訊號
自動梯度計算的最佳實踐
自動梯度計算系統消除了手動實作反向傳播的需求，大大簡化了神經網路的訓練過程。以下比較了手動實作和自動梯度計算的實作方式：
手動反向傳播實作：
# 前向傳播
layer_1 = x.dot(weights_0_1)
layer_1[layer_1<0] = 0
layer_2 = layer_1.dot(weights_1_2)
# 計算誤差
diff = layer_2 - target
layer_2_delta = diff
layer_1_delta = layer_2_delta.dot(weights_1_2.transpose())
layer_1_delta[layer_1<=0] = 0
# 權重更新
weights_1_2 -= layer_1.transpose().dot(layer_2_delta) * alpha
weights_0_1 -= x.transpose().dot(layer_1_delta) * alpha
自動梯度計算實作：
# 前向傳播
pred = x.mm(w1).clamp(0, float('inf')).mm(w2)
# 計算損失
loss = ((pred - target)*(pred - target)).sum(0)
# 自動反向傳播
loss.backward(Tensor(np.ones_like(loss.data)))
# 權重更新
w1.data -= w1.grad.data * alpha
w2.data -= w2.grad.data * alpha
內容解密：
在自動梯度計算版本中：
- 只需定義前向傳播過程和損失函式
- 透過呼叫
loss.backward()自動完成反向傳播 - 直接使用計算得到的梯度進行權重更新
隨機梯度下降最佳化器的實作
根據自動梯度計算，可以輕鬆實作隨機梯度下降（SGD）最佳化器：
class SGD(object):
def __init__(self, parameters, alpha=0.1):
self.parameters = parameters
self.alpha = alpha
def zero(self):
for p in self.parameters:
p.grad.data *= 0
def step(self):
for p in self.parameters:
p.data -= p.grad.data * self.alpha
流程解密：
此圖展示了SGD最佳化器的運作流程： 這種自動化的訓練流程不僅提高了開發效率，還減少了手動實作反向傳播可能引入的錯誤。透過結合自動梯度計算和SGD最佳化器，可以實作高效、穩定的神經網路訓練過程。
自動微分與深度學習框架實作
深度學習框架透過自動微分技術簡化了複雜神經網路的訓練過程。以下程式碼展示了自動微分系統的核心實作，包括張量運算與反向傳播機制。
張量自動微分實作
class Tensor:
def __init__(self, data, autograd=False, creators=None, creation_op=None):
self.data = np.array(data)
self.autograd = autograd
self.grad = None
if creators is not None:
self.creators = creators
else:
self.creators = None
self.creation_op = creation_op
self.children = {}
內容解密： Tensor 類別封裝了數值資料並支援自動微分功能。當 autograd=True 時，張量會記錄其建立過程以便進行反向傳播計算。
反向傳播機制
反向傳播是神經網路訓練的核心。以下程式碼展示了不同運算操作的梯度計算：
def backward(self, grad=None, grad_origin=None):
if self.autograd:
# 梯度累積
if self.grad is None:
self.grad = grad
else:
self.grad += grad
# 根據運算型別進行反向傳播
if self.creators is not None:
if self.creation_op == "add":
self.creators[0].backward(self.grad, self)
self.creators[1].backward(self.grad, self)
# 其他運算的梯度計算...
內容解密： backward() 方法實作了反向傳播邏輯，根據不同的張量運算（如加法、乘法等）計算梯度並將其回傳給前面的張量。
層級抽象與前向傳播
深度學習框架透過層級抽象簡化了模型建立過程。以下是一個線性層的實作範例：
class Linear(Layer):
def __init__(self, n_inputs, n_outputs):
# 初始化權重和偏差...
def forward(self, input):
return input.mm(self.weight) + self.bias.expand(0, len(input.data))
內容解密： Linear 類別定義了一個線性層，包含權重和偏差，並透過 forward() 方法執行前向傳播計算。
最佳化器實作
最佳化器負責更新模型引數。以下是一個簡單的 SGD 最佳化器實作：
def step(self, zero=True):
for p in self.parameters:
p.data -= p.grad.data * self.alpha
if zero:
p.grad.data *= 0
內容解密： SGD 類別實作了隨機梯度下降最佳化演算法，透過 step() 方法更新模型引數，並可選擇是否在更新後將梯度歸零。
計算流程視覺化
以下 Plantuml 圖表展示了線性層的前向傳播過程：
流程解密： 此圖展示了資料流經線性層的過程，輸入經過線性變換後產生輸出。
序列圖進一步說明瞭線性層的內部計算步驟：
流程解密： 此序列圖詳細展示了線性層的運算順序，包括加權求和與偏差新增的步驟。
這些實作細節和視覺化說明共同構成了深度學習框架的核心功能，為建立和訓練複雜的神經網路模型提供了堅實的基礎。整個系統透過自動微分技術和層級抽象，大幅簡化了深度學習模型的開發流程。
深度學習模型的自動最佳化：索引、嵌入層與交叉熵損失函式實作
本篇技術文章探討深度學習框架中的關鍵元件，包括索引操作、嵌入層的實作細節，以及交叉熵損失函式的應用。這些技術是現代自然語言處理和推薦系統的核心基礎。
索引操作的技術實作
在深度學習框架中，索引操作是實作嵌入層和其他離散表示轉換的基礎。index_select 方法允許從高維張量中根據指定的索引提取特定的資料切片。
程式碼實作與解析
def index_select(self, index):
if self.autograd:
new_tensor = Tensor(self.data[index.data],
autograd=True,
creators=[self],
creation_op="index_select")
new_tensor.index = index
return new_tensor
return Tensor(self.data[index.data])
內容解密：
此方法實作了根據索引的資料選擇操作。當啟用自動微分功能時，它會建立一個新的 Tensor 物件並追蹤其建立過程，記錄原始張量和索引資訊以便於後續的梯度計算。
嵌入層的設計與實作
嵌入層（Embedding Layer）是將離散變數（如單詞索引或使用者ID）對映到連續向量空間的關鍵元件。它在自然語言處理和推薦系統中有著廣泛的應用。
嵌入層的核心功能
- 詞彙表初始化：使用隨機初始化的權重矩陣來表示詞彙表中的每個索引。
- 向量表示：根據輸入的索引傳回對應的向量表示。
- 梯度更新：在訓練過程中，嵌入向量會根據損失函式的梯度進行更新。
程式碼實作
class Embedding(Layer):
def __init__(self, vocab_size, dim):
super().__init__()
self.vocab_size = vocab_size
self.dim = dim
self.weight = Tensor((np.random.rand(vocab_size, dim) - 0.5) / dim, autograd=True)
self.parameters.append(self.weight)
def forward(self, input):
return self.weight.index_select(input)
交叉熵損失函式的應用
交叉熵損失函式是分類別問題中常用的損失函式，特別是在多分類別任務中。它衡量了模型預測的機率分佈與真實標籤之間的差異。
實作細節
class CrossEntropyLoss(Layer):
def __init__(self):
super().__init__()
def forward(self, pred, target):
pred = pred.softmax()
return (-target * pred.log()).sum(1).mean()
內容解密：
- Softmax 操作：將模型的原始輸出轉換為機率分佈。
- 對數似然計算：計算真實標籤對應的預測機率的對數值。
- 損失計算：對所有樣本的對數似然取負值並求平均，得到最終的損失值。
技術整合與最佳化實踐
在實際應用中，這些元件通常會被整合到一個完整的深度學習模型中。例如，在一個文字分類別任務中，我們可能會使用嵌入層來表示單詞，然後透過多層神經網路進行特徵提取，最後使用交叉熵損失函式進行模型訓練。
最佳化策略
- 隨機梯度下降（SGD）：使用小批次資料來估計梯度並更新模型引數。
- 動量法：引入動量項來加速收斂並減少震蕩。
- 學習率排程：動態調整學習率以適應訓練過程的不同階段。
# 前瞻性思考
隨著深度學習技術的不斷發展，我們可以預期在嵌入表示學習、損失函式設計和最佳化演算法等方面會有更多的創新。這些進展將進一步推動自然語言處理、電腦視覺和其他領域的發展。
玄貓指引
建議讀者在理解本文內容的基礎上，嘗試實作一個簡單的文字分類別模型，使用嵌入層和交叉熵損失函式，並觀察不同最佳化策略對模型效能的影響。
內容解密：
本段內容探討了深度學習中的自動最佳化技術，重點介紹了索引操作在自動梯度計算中的應用、嵌入層的設計以及交叉熵損失函式的整合。首先，文章解釋瞭如何在自動梯度計算系統中支援索引操作，以實作嵌入策略。接著，展示瞭如何利用新的 .index_select() 方法完成嵌入層的正向傳播，並透過實際範例演示了其工作原理。
此外，文章還介紹了交叉熵損失層的實作，將 softmax 和損失計算結合在損失類別中，以提高效能。最後，簡要提及了迴圈神經網路（RNN）層的構建，透過組合多個層來實作時間序列學習。
關鍵技術解析：
索引操作與自動梯度計算：
- 為了支援嵌入策略，需要在自動梯度計算系統中實作索引操作。
- 在反向傳播過程中，梯度需放置在與正向傳播索引相同的行中。
- 透過保留傳入的索引，在反向傳播期間使用
for迴圈將每個梯度放置在適當的位置。
嵌入層的設計與實作：
- 使用新的
.index_select()方法完成正向傳播。 - 嵌入層的權重矩陣透過隨機初始化，並在訓練過程中進行更新。
- 展示瞭如何將輸入索引與預測值相關聯，並進行模型訓練。
- 使用新的
交叉熵損失函式的整合：
- 將 softmax 和負對數似然計算結合在交叉熵損失類別中，以提高效能。
- 這種組合減少了單獨計算 softmax 和損失的計算開銷。
迴圈神經網路（RNN）層的構建：
- RNN 層透過組合多個線性層和非線性啟用函式來實作。
.forward()方法同時接收來自先前隱藏狀態的輸出和當前訓練資料的輸入，以實作時間序列學習。
流程解密：
此圖示展示了嵌入層和交叉熵損失函式的工作流程，以及它們如何與自動梯度計算系統協同工作。
@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle
title RNN 莎士比亞語言建模實作
package "機器學習流程" {
package "資料處理" {
component [資料收集] as collect
component [資料清洗] as clean
component [特徵工程] as feature
}
package "模型訓練" {
component [模型選擇] as select
component [超參數調優] as tune
component [交叉驗證] as cv
}
package "評估部署" {
component [模型評估] as eval
component [模型部署] as deploy
component [監控維護] as monitor
}
}
collect --> clean : 原始資料
clean --> feature : 乾淨資料
feature --> select : 特徵向量
select --> tune : 基礎模型
tune --> cv : 最佳參數
cv --> eval : 訓練模型
eval --> deploy : 驗證模型
deploy --> monitor : 生產模型
note right of feature
特徵工程包含：
- 特徵選擇
- 特徵轉換
- 降維處理
end note
note right of eval
評估指標：
- 準確率/召回率
- F1 Score
- AUC-ROC
end note
@enduml
技術深度探討：
本文透過詳細的程式碼範例和技術解析，探討了深度學習中的關鍵技術。首先，自動梯度計算中的索引操作確保了嵌入層在反向傳播過程中的正確梯度更新。其次，嵌入層的設計展示瞭如何將輸入索引對映到密集向量空間，並透過訓練進行最佳化。此外，交叉熵損失函式的整合提高了模型訓練的效能和穩定性。最後，RNN 層的構建為處理時間序列資料提供了有效的解決方案。
這些技術的結合使得深度學習模型能夠更有效地處理複雜任務，如自然語言處理和序列預測。透過深入理解這些核心元件，開發者可以構建更強大和高效的神經網路模型。
技術內容生成：RNN 與莎士比亞語言建模實作
本章節探討迴圈神經網路（RNN）的基本架構及其在莎士比亞語言建模中的應用，展現了深度學習在自然語言處理領域的強大能力。以下內容將詳細解析 RNN 的內部機制和相關實作細節。
RNNCell 架構實作
RNNCell 是實作 RNN 的核心元件，其內部結構包含多個關鍵的線性層轉換：
class RNNCell:
def __init__(self, n_inputs, n_hidden, n_output):
self.activation = Tanh()
self.w_ih = Linear(n_inputs, n_hidden)
self.w_hh = Linear(n_hidden, n_hidden)
self.w_ho = Linear(n_hidden, n_output)
# 引數整合
self.parameters += self.w_ih.get_parameters()
self.parameters += self.w_hh.get_parameters()
self.parameters += self.w_ho.get_parameters()
def forward(self, input, hidden):
from_prev_hidden = self.w_hh.forward(hidden)
combined = self.w_ih.forward(input) + from_prev_hidden
new_hidden = self.activation.forward(combined)
output = self.w_ho.forward(new_hidden)
return output, new_hidden
def init_hidden(self, batch_size=1):
return Tensor(np.zeros((batch_size, self.n_hidden)), autograd=True)
內容解密：
此實作展示了 RNNCell 的基本組成：
- 三個線性層（
w_ih、w_hh、w_ho）分別負責輸入到隱藏層、隱藏層狀態更新和隱藏層到輸出層的轉換 - 使用
Tanh作為隱藏層的啟用函式，有助於捕捉序列資料中的非線性關係 forward方法實作了 RNN 的核心遞迴計算邏輯- 隱藏狀態的初始化由
init_hidden方法負責，確保初始狀態為零向量
莎士比亞語言建模實作
在莎士比亞文字的語言建模任務中，我們首先需要對原始文字進行預處理：
f = open('shakespear.txt','r')
raw = f.read()
f.close()
# 建立字元級詞彙表
vocab = list(set(raw))
word2index = {word: i for i, word in enumerate(vocab)}
indices = np.array([word2index[x] for x in raw])
內容解密：
- 讀取莎士比亞文字並建立字元級詞彙表，不同於傳統的單詞級處理
word2index字典實作了字元到索引的對映，便於後續的數值化處理- 將整個文字轉換為索引序列儲存在
indices陣列中，為模型的輸入做好準備
模型組態與訓練設定
模型的實作採用了嵌入層與 RNNCell 的組合，並組態了適當的損失函式和最佳化器：
embed = Embedding(vocab_size=len(vocab), dim=512)
model = RNNCell(n_inputs=512, n_hidden=512, n_output=len(vocab))
criterion = CrossEntropyLoss()
optim = SGD(parameters=model.get_parameters() + embed.get_parameters(), alpha=0.05)
內容解密：
- 嵌入層將字元索引對映到高維向量空間（維度為512），捕捉字元間的語義關係
- RNNCell 組態了與嵌入層相同維度的輸入和隱藏狀態，確保資訊的有效傳遞
- 採用交叉熵損失函式評估模型的預測效能
- 使用隨機梯度下降（SGD）作為最佳化器，並設定適當的學習率（0.05）進行模型引數更新
技術深度解析
RNN 的工作原理：RNN 透過隱藏狀態在時間步之間的傳遞來捕捉序列資料中的時間依賴關係。在莎士比亞語言建模任務中，RNN 能夠根據前面的字元預測下一個字元，從而學習到語言的統計規律。
嵌入層的作用：嵌入層將離散的字元索引轉換為連續的向量表示，使得模型能夠更好地捕捉字元之間的語義關係。這種表示方法為後續的 RNN 處理提供了豐富的輸入特徵。
訓練挑戰：在訓練 RNN 時，可能會遇到梯度消失或梯度爆炸的問題。未來的改進可以考慮使用更高階的 RNN 架構，如 LSTM 或 GRU，以更好地處理長序列依賴關係。