Comment pytorch calcule-t-il les gradients pour un modèle de régression linéaire simple?

Question

J'utilise pytorch et j'essaie de comprendre comment un modèle de régression linéaire simple fonctionne.

J'utilise une simple classe LinearRegressionModel:

class LinearRegressionModel(nn.Module): 
    def __init__(self, input_dim, output_dim): 
     super(LinearRegressionModel, self).__init__() 
     self.linear = nn.Linear(input_dim, output_dim) 

    def forward(self, x): 
     out = self.linear(x) 
     return out 

model = LinearRegressionModel(1, 1) 

Ensuite, j'instancier un critère de perte et un optimiseur

criterion = nn.MSELoss() 

optimizer = torch.optim.SGD(model.parameters(), lr=0.01) 

Enfin, pour former le modèle que j'utilise le code suivant:

for epoch in range(epochs): 
    if torch.cuda.is_available(): 
     inputs = Variable(torch.from_numpy(x_train).cuda()) 

    if torch.cuda.is_available(): 
     labels = Variable(torch.from_numpy(y_train).cuda()) 

    # Clear gradients w.r.t. parameters 
    optimizer.zero_grad() 

    # Forward to get output 
    outputs = model(inputs) 

    # Calculate Loss 
    loss = criterion(outputs, labels) 

    # Getting gradients w.r.t. parameters 
    loss.backward() 

    # Updating parameters 
    optimizer.step() 

Ma question est de savoir comment l'optimiseur obtient le gradient de perte, calculé par loss.backward(), pour mettre à jour les paramètres en utilisant la méthode step()? Comment le modèle, le critère de perte et l'optimiseur sont-ils liés?

Answer 1

PyTorch a ce concept de tenseurs et les variables. Lorsque vous utilisez nn.Linear, la fonction crée 2 variables à savoir W et b.In pytorch une variable est un wrapper qui encapsule un tenseur, son dégradé et des informations sur sa fonction create. vous pouvez accéder directement aux dégradés par

w.grad 

Lorsque vous l'essayez avant d'appeler loss.backward(), vous obtenez None. Une fois que vous appelez le loss.backward(), il contiendra des dégradés. Maintenant, vous pouvez mettre à jour ces dégradés manuellement avec les étapes simples ci-dessous.

w.data -= learning_rate * w.grad.data 

Lorsque vous avez un réseau complexe, l'étape simple ci-dessus peut devenir complexe. Alors les optimiseurs comme SGD, Adam s'en charge. Lorsque vous créez l'objet pour ces optimiseurs, nous transmettons les paramètres de notre modèle. nn.Module contient cette fonction parameters() qui retournera tous les paramètres apprenables à l'optimiseur. Ce qui peut être fait en utilisant l'étape ci-dessous.

Answer 2

loss.backward() 

calcule les gradients et les stocke dans les paramètres. Et vous passez dans les paremeters qui sont nécessaires pour être à l'écoute ici:

optimizer = torch.optim.SGD(model.parameters(), lr=0.01)