Comprendre torch.nn.Parameter

Question

Comment torch.nn.Parameter() travail ?

Answer 1

Je vais le décomposer pour vous. Les tenseurs, comme vous le savez peut-être, sont des matrices multidimensionnelles. Paramètre, dans sa forme brute, est un tenseur, c'est-à-dire une matrice multidimensionnelle. Elle sous-classe la classe Variable.

La différence entre une variable et un paramètre intervient lorsqu'elle est associée à un module. Lorsqu'un paramètre est associé à un module en tant qu'attribut de modèle, il est automatiquement ajouté à la liste des paramètres et peut être consulté à l'aide de l'itérateur 'parameters'.

Initialement dans Torch, une variable (qui pourrait par exemple être un état intermédiaire) serait également ajoutée comme un paramètre du modèle lors de l'affectation. Plus tard, des cas d'utilisation ont été identifiés où il était nécessaire de mettre en cache les variables au lieu de les ajouter à la liste des paramètres.

L'un de ces cas, comme le mentionne la documentation, est celui du RNN, dans lequel il faut sauvegarder le dernier état caché pour ne pas avoir à le repasser sans cesse. La nécessité de mettre en cache une variable au lieu de l'enregistrer automatiquement comme paramètre du modèle est la raison pour laquelle nous avons un moyen explicite d'enregistrer des paramètres dans notre modèle, c'est-à-dire la classe nn.Parameter.

Par exemple, exécutez le code suivant -

import torch
import torch.nn as nn
from torch.optim import Adam

class NN_Network(nn.Module):
    def __init__(self,in_dim,hid,out_dim):
        super(NN_Network, self).__init__()
        self.linear1 = nn.Linear(in_dim,hid)
        self.linear2 = nn.Linear(hid,out_dim)
        self.linear1.weight = torch.nn.Parameter(torch.zeros(in_dim,hid))
        self.linear1.bias = torch.nn.Parameter(torch.ones(hid))
        self.linear2.weight = torch.nn.Parameter(torch.zeros(in_dim,hid))
        self.linear2.bias = torch.nn.Parameter(torch.ones(hid))

    def forward(self, input_array):
        h = self.linear1(input_array)
        y_pred = self.linear2(h)
        return y_pred

in_d = 5
hidn = 2
out_d = 3
net = NN_Network(in_d, hidn, out_d)

Maintenant, vérifiez la liste des paramètres associés à ce modèle -

for param in net.parameters():
    print(type(param.data), param.size())

""" Output
<class 'torch.FloatTensor'> torch.Size([5, 2])
<class 'torch.FloatTensor'> torch.Size([2])
<class 'torch.FloatTensor'> torch.Size([5, 2])
<class 'torch.FloatTensor'> torch.Size([2])
"""

Ou essayez,

list(net.parameters())

Ces données peuvent facilement être transmises à votre optimiseur -.

opt = Adam(net.parameters(), learning_rate=0.001)

Notez également que les Paramètres ont require_grad par défaut.

Answer 2

Les versions récentes de PyTorch n'ont que des Tenseurs, il est apparu que le concept de Variable a été déprécié.

Paramètres sont juste des tenseurs limités au module dans lequel ils sont définis (dans le constructeur de module __init__ méthode).

Ils apparaîtront à l'intérieur module.parameters() . Ceci est pratique lorsque vous construisez vos modules personnalisés qui apprennent grâce à ces paramètres la descente de gradient.

Tout ce qui est vrai pour les tenseurs de PyTorch est vrai pour les paramètres, puisqu'ils sont des tenseurs.

De plus, si un module va vers le GPU, les paramètres y vont aussi. Si un module est sauvegardé, les paramètres seront également sauvegardés.

Il existe un concept similaire aux paramètres du modèle appelé tampons .

Ils sont nommés tenseurs dans le module, mais ces tenseurs ne sont pas destinés à être appris par descente de gradient, vous pouvez plutôt les considérer comme des variables. Vous mettrez à jour vos tampons nommés dans le module forward() comme vous le souhaitez.

Pour les buffers, il est également vrai qu'ils iront vers le GPU avec le module, et qu'ils seront sauvegardés avec le module.