# torch.autograd # Automatic differentiation package - torch.autograd `torch.autograd`提供了類和函數用來對任意標量函數進行求導。要想使用自動求導，只需要對已有的代碼進行微小的改變。只需要將所有的`tensor`包含進`Variable`對象中即可。 ### torch.autograd.backward(variables, grad\_variables, retain\_variables=False) Computes the sum of gradients of given variables w.r.t. graph leaves. 給定圖的葉子節點`variables`, 計算圖中變量的梯度和。 計算圖可以通過鏈式法則求導。如果`variables`中的任何一個`variable`是 非標量(`non-scalar`)的，且`requires_grad=True`。那么此函數需要指定`grad_variables`，它的長度應該和`variables`的長度匹配，里面保存了相關`variable`的梯度(對于不需要`gradient tensor`的`variable`，`None`是可取的)。 此函數累積`leaf variables`計算的梯度。你可能需要在調用此函數之前將`leaf variable`的梯度置零。 參數說明: - variables (variable 列表) – 被求微分的葉子節點，即 `ys` 。 - grad\_variables (`Tensor` 列表) – 對應`variable`的梯度。僅當`variable`不是標量且需要求梯度的時候使用。 - retain\_variables (bool) – `True`,計算梯度時所需要的`buffer`在計算完梯度后不會被釋放。如果想對一個子圖多次求微分的話，需要設置為`True`。 ## Variable ### API 兼容性 `Variable API` 幾乎和 `Tensor API`一致 (除了一些`in-place`方法，這些`in-place`方法會修改 `required_grad=True`的 `input` 的值)。多數情況下，將`Tensor`替換為`Variable`，代碼一樣會正常的工作。由于這個原因，我們不會列出`Variable`的所有方法，你可以通過`torch.Tensor`的文檔來獲取相關知識。 ### In-place operations on Variables 在`autograd`中支持`in-place operations`是非常困難的。同時在很多情況下，我們阻止使用`in-place operations`。`Autograd`的貪婪的 釋放`buffer`和 復用使得它效率非常高。只有在非常少的情況下，使用`in-place operations`可以降低內存的使用。除非你面臨很大的內存壓力，否則不要使用`in-place operations`。 ### In-place 正確性檢查 所有的`Variable`都會記錄用在他們身上的 `in-place operations`。如果`pytorch`檢測到`variable`在一個`Function`中已經被保存用來`backward`，但是之后它又被`in-place operations`修改。當這種情況發生時，在`backward`的時候，`pytorch`就會報錯。這種機制保證了，如果你用了`in-place operations`，但是在`backward`過程中沒有報錯，那么梯度的計算就是正確的。 ### class torch.autograd.Variable \[source\] 包裝一個`Tensor`,并記錄用在它身上的`operations`。 `Variable`是`Tensor`對象的一個`thin wrapper`，它同時保存著`Variable`的梯度和創建這個`Variable`的`Function`的引用。這個引用可以用來追溯創建這個`Variable`的整條鏈。如果`Variable`是被用戶所創建的，那么它的`creator`是`None`，我們稱這種對象為 `leaf Variables`。 由于`autograd`只支持標量值的反向求導(即：`y`是標量)，梯度的大小總是和數據的大小匹配。同時，僅僅給`leaf variables`分配梯度，其他`Variable`的梯度總是為0. **`變量：`** - data – 包含的`Tensor` - grad – 保存著`Variable`的梯度。這個屬性是懶分配的，且不能被重新分配。 - requires\_grad – 布爾值，指示這個`Variable`是否是被一個包含`Variable`的子圖創建的。更多細節請看`Excluding subgraphs from backward`。只能改變`leaf variable`的這個標簽。 - volatile – 布爾值，指示這個`Variable`是否被用于推斷模式(即，不保存歷史信息)。更多細節請看`Excluding subgraphs from backward`。只能改變`leaf variable`的這個標簽。 - creator – 創建這個`Variable`的`Function`，對于`leaf variable`，這個屬性為`None`。只讀屬性。 **`屬性:`** - data (any tensor class) – 被包含的`Tensor` - requires\_grad (bool) – `requires_grad`標記. 只能通過`keyword`傳入. - volatile (bool) – `volatile`標記. 只能通過`keyword`傳入. #### backward(gradient=None, retain\_variables=False)\[source\] 當前`Variable`對`leaf variable`求偏導。 計算圖可以通過鏈式法則求導。如果`Variable`是 非標量(`non-scalar`)的，且`requires_grad=True`。那么此函數需要指定`gradient`，它的形狀應該和`Variable`的長度匹配，里面保存了`Variable`的梯度。 此函數累積`leaf variable`的梯度。你可能需要在調用此函數之前將`Variable`的梯度置零。 **`參數:`** - gradient (Tensor) – 其他函數對于此`Variable`的導數。僅當`Variable`不是標量的時候使用，類型和位形狀應該和`self.data`一致。 - retain\_variables (bool) – `True`, 計算梯度所必要的`buffer`在經歷過一次`backward`過程后不會被釋放。如果你想多次計算某個子圖的梯度的時候，設置為`True`。在某些情況下，使用`autograd.backward()`效率更高。 #### detach()\[source\] Returns a new Variable, detached from the current graph. 返回一個新的`Variable`，從當前圖中分離下來的。 返回的`Variable``requires_grad=False`，如果輸入 `volatile=True`，那么返回的`Variable``volatile=True`。 **`注意：`** 返回的`Variable`和原始的`Variable`公用同一個`data tensor`。`in-place`修改會在兩個`Variable`上同時體現(因為它們共享`data tensor`)，可能會導致錯誤。 #### detach\_()\[source\] 將一個`Variable`從創建它的圖中分離，并把它設置成`leaf variable`。 #### register\_hook(hook)\[source\] 注冊一個`backward`鉤子。 每次`gradients`被計算的時候，這個`hook`都被調用。`hook`應該擁有以下簽名： `hook(grad) -> Variable or None` `hook`不應該修改它的輸入，但是它可以選擇性的返回一個替代當前梯度的新梯度。 這個函數返回一個 句柄(`handle`)。它有一個方法 `handle.remove()`，可以用這個方法將`hook`從`module`移除。 Example ``` v = Variable(torch.Tensor([0, 0, 0]), requires_grad=True) h = v.register_hook(lambda grad: grad * 2) # double the gradient v.backward(torch.Tensor([1, 1, 1])) #先計算原始梯度，再進hook，獲得一個新梯度。 print(v.grad.data) 2 2 2 [torch.FloatTensor of size 3] >>> h.remove() # removes the hook ``` ``` def w_hook(grad): print("hello") return None w1 = Variable(torch.FloatTensor([1, 1, 1]),requires_grad=True) w1.register_hook(w_hook) # 如果hook返回的是None的話，那么梯度還是原來計算的梯度。 w1.backward(gradient=torch.FloatTensor([1, 1, 1])) print(w1.grad) ``` ``` hello Variable containing: 1 1 1 [torch.FloatTensor of size 3] ``` #### reinforce(reward)\[source\] 注冊一個獎勵，這個獎勵是由一個隨機過程得到的。 微分一個隨機節點需要提供一個獎勵值。如果你的計算圖中包含隨機 `operations`，你需要在他們的輸出上調用這個函數。否則的話，會報錯。 **`參數:`** - reward (Tensor) – 每個元素的reward。必須和`Varaible`形狀相同，并在同一個設備上。 ### class torch.autograd.Function\[source\] Records operation history and defines formulas for differentiating ops. 記錄`operation`的歷史，定義微分公式。 每個執行在`Varaibles`上的`operation`都會創建一個`Function`對象，這個`Function`對象執行計算工作，同時記錄下來。這個歷史以有向無環圖的形式保存下來，有向圖的節點為`functions`，有向圖的邊代表數據依賴關系(`input<-output`)。之后，當`backward`被調用的時候，計算圖以拓撲順序處理，通過調用每個`Function`對象的`backward()`，同時將返回的梯度傳遞給下一個`Function`。 通常情況下，用戶能和`Functions`交互的唯一方法就是創建`Function`的子類，定義新的`operation`。這是擴展`torch.autograd`的推薦方法。 由于`Function`邏輯在很多腳本上都是熱點，所有我們把幾乎所有的`Function`都使用`C`實現，通過這種策略保證框架的開銷是最小的。 每個`Function`只被使用一次(在forward過程中)。 **`變量:`** - saved\_tensors – 調用`forward()`時需要被保存的 `Tensors`的 `tuple`。 - needs\_input\_grad – 長度為 輸入數量的 布爾值組成的 `tuple`。指示給定的`input`是否需要梯度。這個被用來優化用于`backward`過程中的`buffer`，忽略`backward`中的梯度計算。 - num\_inputs – `forward` 的輸入參數數量。 - num\_outputs – `forward`返回的`Tensor`數量。 - requires\_grad – 布爾值。指示`backward`以后會不會被調用。 - previous\_functions – 長度為 `num_inputs`的 Tuple of (int, Function) pairs。`Tuple`中的每單元保存著創建 `input`的`Function`的引用，和索引。 #### backward(\* grad\_output)\[source\] 定義了`operation`的微分公式。 所有的`Function`子類都應該重寫這個方法。 所有的參數都是`Tensor`。他必須接收和`forward`的輸出 相同個數的參數。而且它需要返回和`forward`的輸入參數相同個數的`Tensor`。 即：`backward`的輸入參數是 此`operation`的輸出的值的梯度。`backward`的返回值是此`operation`輸入值的梯度。 #### forward(\* input)\[source\] 執行`operation`。 所有的`Function`子類都需要重寫這個方法。 可以接收和返回任意個數 `tensors` #### mark\_dirty(\* args)\[source\] 將輸入的 `tensors` 標記為被`in-place operation`修改過。 這個方法應當至多調用一次，僅僅用在 `forward`方法里，而且`mark_dirty`的實參只能是`forward`的實參。 每個在`forward`方法中被`in-place operations`修改的`tensor`都應該傳遞給這個方法。這樣，可以保證檢查的正確性。這個方法在`tensor`修改前后調用都可以。 #### mark\_non\_differentiable(\* args)\[source\] 將輸出標記為不可微。 這個方法至多只能被調用一次，只能在`forward`中調用，而且實參只能是`forward`的返回值。 這個方法會將輸出標記成不可微，會增加`backward`過程中的效率。在`backward`中，你依舊需要接收`forward`輸出值的梯度，但是這些梯度一直是`None`。 This is used e.g. for indices returned from a max Function. #### mark\_shared\_storage(\* pairs)\[source\] 將給定的`tensors pairs`標記為共享存儲空間。 這個方法至多只能被調用一次，只能在`forward`中調用，而且所有的實參必須是`(input, output)`對。 如果一些 `inputs` 和 `outputs` 是共享存儲空間的，所有的這樣的 `(input, output)`對都應該傳給這個函數，保證 `in-place operations` 檢查的正確性。唯一的特例就是，當 `output`和`input`是同一個`tensor`(`in-place operations`的輸入和輸出)。這種情況下，就沒必要指定它們之間的依賴關系，因為這個很容易就能推斷出來。 這個函數在很多時候都用不到。主要是用在 索引 和 轉置 這類的 `op` 中。 #### save\_for\_backward(\* tensors)\[source\] 將傳入的 `tensor` 保存起來，留著`backward`的時候用。 這個方法至多只能被調用一次，只能在`forward`中調用。 之后，被保存的`tensors`可以通過 `saved_tensors`屬性獲取。在返回這些`tensors`之前，`pytorch`做了一些檢查，保證這些`tensor`沒有被`in-place operations`修改過。 實參可以是`None`。