Summary  
This chapter covers constructing multi-step computational graphs on tensors and using automatic differentiation to perform backpropagation via the chain rule to compute gradients, as well as disabling gradient tracking to save memory and computation.  

General domain of usage  
Deep learning model training  

Come **Tensorflow**, anche PyTorch consente di costruire grafi computazionali più complessi che coinvolgono **più tensori intermedi**.

import torch
# Create a 2D tensor with gradient tracking
x = torch.tensor([[1.0, 2.0, 3.0], [3.0, 2.0, 1.0]], requires_grad=True)
# Define intermediate layers
y = 6 * x + 3
z = 10 * y ** 2
# Compute the mean of the final output
output_mean = z.mean()
print(f"Output: {output_mean}")
# Perform backpropagation
output_mean.backward()
# Print the gradient of x
print("Gradient of x:\n", x.grad)

Il gradiente di `output_mean` rispetto a `x` viene calcolato utilizzando la **regola della catena**. Il risultato mostra quanto una piccola variazione di ciascun elemento di `x` influenzi `output_mean`.

## Disabilitazione del tracciamento dei gradienti

In alcuni casi, potrebbe essere necessario disabilitare il tracciamento dei gradienti per **risparmiare memoria e calcolo**. Poiché `requires_grad=False` è il comportamento predefinito, è possibile creare il tensore **senza specificare questo parametro**:
```python
x = torch.tensor([[1.0, 2.0, 3.0], [3.0, 2.0, 1.0]])
```

import unittest
import torch
import importlib
import io
import sys


def _dynamic(test, cond, success, fail):
    if cond:
        test._testMethodName = success
        test.assertTrue(True)
    else:
        test._testMethodName = fail
        test.fail(fail)


class TestUserCode(unittest.TestCase):

    # --------- Test W creation ---------
    def test_W_exists(self):
        import user_code
        cond = hasattr(user_code, "W")
        _dynamic(
            self,
            cond,
            "`W` is successfully defined.",
            "`W` is missing. Define the weight matrix using `torch.rand(1, 3, requires_grad=True)`."
        )

    def test_W_shape(self):
        import user_code
        W = user_code.W
        cond = isinstance(W, torch.Tensor) and W.shape == (1, 3)
        _dynamic(
            self,
            cond,
            "`W` has the correct shape (1x3).",
            "`W` must be a tensor of shape (1, 3)."
        )

    def test_W_requires_grad(self):
        import user_code
        W = user_code.W
        cond = hasattr(W, "requires_grad") and W.requires_grad is True
        _dynamic(
            self,
            cond,
            "`W` correctly tracks gradients (`requires_grad=True`).",
            "`W` must be created with `requires_grad=True` to enable gradient computation."
        )

    # --------- Test X ---------
    def test_X_correct(self):
        import user_code
        cond = hasattr(user_code, "X")
        if cond:
            expected = torch.tensor([[1.0, 2.0],
                                     [3.0, 4.0],
                                     [5.0, 6.0]])
            cond = torch.allclose(user_code.X.float(), expected)
        _dynamic(
            self,
            cond,
            "`X` is correctly defined from the given list.",
            "`X` must be created as `torch.tensor([[1.0,2.0],[3.0,4.0],[5.0,6.0]])`."
        )

    # --------- Test Y = W @ X ---------
    def test_Y_computed(self):
        import user_code
        cond = hasattr(user_code, "Y")
        _dynamic(
            self,
            cond,
            "`Y` is computed.",
            "`Y` is missing. Compute it using matrix multiplication: `W @ X`."
        )

    # --------- Test loss ---------
    def test_loss_computed(self):
        import user_code
        cond = hasattr(user_code, "loss")
        _dynamic(
            self,
            cond,
            "`loss` is successfully computed.",
            "`loss` is missing. Use mean squared error: `((Y - Y_target)**2).mean()`."
        )

    # --------- Test backward() ---------
    def test_backward_computed(self):
        import user_code
        try:
            W = user_code.W
            cond = W.grad is not None
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "Gradient for `W` is computed using backpropagation.",
            "Gradient for `W` is missing. Make sure to call `loss.backward()`."
        )

    # --------- Test printed output ---------
    def test_output_printed(self):
        import user_code
        buf = io.StringIO()
        sys.stdout = buf

        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        cond = len(buf.getvalue().strip()) > 0
        _dynamic(
            self,
            cond,
            "Gradient values are printed.",
            "No gradient output detected. Make sure to print `W.grad`."
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Passaggio dalle librerie di alto livello alla flessibilità di PyTorch. Padronanza dei componenti fondamentali del deep learning lavorando con i Tensori, la struttura dati principale di PyTorch. Esplorazione della differenziazione automatica con i gradienti, implementazione della retropropagazione e costruzione di reti neurali complete da zero. Gestione di dataset reali e dell'intero ciclo di addestramento, dall'inizializzazione dei pesi alla valutazione del modello.

Backpropagation Multi-Step

Disabilitazione del tracciamento dei gradienti

Soluzione