Wie initialisieren Sie die GEWICHTE in PyTorch?

Wie Sie initialisiert die GEWICHTE und biases (zum Beispiel, mit dem Er oder Xavier-Initialisierung) in einem Netzwerk in PyTorch?

InformationsquelleAutor Fábio Perez | 2018-03-22

  1. 54

    Single-layer

    Zur Initialisierung der GEWICHTE einer einzigen Schicht, verwenden Sie eine Funktion aus Fackel.nn.init. Zum Beispiel:

    conv1 = torch.nn.Conv2d(...)
torch.nn.init.xavier_uniform(conv1.weight)

    Alternativ können Sie die Parameter ändern, indem Sie sich schriftlich an conv1.weight.data (das ist ein Fackel.Tensor). Beispiel:

    conv1.weight.data.fill_(0.01)

    Das gleiche gilt für Vorurteile: 

    conv1.bias.data.fill_(0.01)

    nn.Sequential oder benutzerdefinierte nn.Module

    Pass eine Funktion zur Initialisierung, zu Fackel.nn.- Modul.apply. Es initialisiert die GEWICHTE in der gesamten nn.Module rekursiv.

    gelten(fn): Gilt fn rekursiv zu jedem Submodul (zurückgegeben durch .children()) so gut wie von selbst. Die typische Nutzung umfasst das initialisieren der Parameter eines Modells (siehe auch Fackel-nn-init).

    Beispiel:

    def init_weights(m):
    if type(m) == nn.Linear:
        torch.nn.init.xavier_uniform(m.weight)
        m.bias.data.fill_(0.01)

net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
net.apply(init_weights)
    Ich fand eine reset_parameters Methode in den source-code von vielen Bausteinen. Soll ich überschreiben Sie die Methode für Gewicht-Initialisierung?
    was wenn ich eine Normale Verteilung mit einigen Mittelwert und std?
    Was ist die Standard-Initialisierung, wenn ich die nicht angeben?

    InformationsquelleAutor Fábio Perez

  2. 5

    Wir vergleichen verschiedene Modus-Gewicht-Initialisierung mit der gleichen neuronalen Netzwerk(NN -) Architektur.

    Alle Nullen oder Einsen

    Wenn Sie Folgen dem Prinzip des Occam ' s razor, könnte man denken das einstellen der GEWICHTE auf 0 oder 1 wäre die beste Lösung. Dies ist nicht der Fall.

    Mit jedem Gewicht die gleiche, alle Neuronen in jeder Schicht produzieren die gleiche Ausgabe. Dies macht es schwer zu entscheiden, welche GEWICHTE zu justieren.

        # initialize two NN's with 0 and 1 constant weights
    model_0 = Net(constant_weight=0)
    model_1 = Net(constant_weight=1)
    • Nach 2 Epochen:

    Wie initialisieren Sie die GEWICHTE in PyTorch?

    Validation Accuracy
9.625% -- All Zeros
10.050% -- All Ones
Training Loss
2.304  -- All Zeros
1552.281  -- All Ones

    Einheitliche Initialisierung

    Einen gleichmäßige Verteilung hat die gleiche Wahrscheinlichkeit, Kommissionierung jede Zahl aus einem Satz von zahlen.

    Lassen Sie uns sehen, wie gut das neuronale Netz die Züge mit einem einheitlichen Gewicht Initialisierung, wo low=0.0 und high=1.0.

    Unten werden wir sehen, einen anderen Weg (außer in der Netto-Klasse code), um die Initialisierung der GEWICHTE eines Netzes. Zu definieren, die GEWICHTE außerhalb des Modells-definition, können wir:

    1. Eine Funktion definieren, weist GEWICHTE von der Art der Netzwerk-Schicht, dann
    2. Gelten diejenigen, die GEWICHTE auf ein initialisiertes Modell mit model.apply(fn), welches eine Funktion auf jedes Modell-Ebene.
        # takes in a module and applies the specified weight initialization
    def weights_init_uniform(m):
        classname = m.__class__.__name__
        # for every Linear layer in a model..
        if classname.find('Linear') != -1:
            # apply a uniform distribution to the weights and a bias=0
            m.weight.data.uniform_(0.0, 1.0)
            m.bias.data.fill_(0)

    model_uniform = Net()
    model_uniform.apply(weights_init_uniform)
    • Nach 2 Epochen:

    Wie initialisieren Sie die GEWICHTE in PyTorch?

    Validation Accuracy
36.667% -- Uniform Weights
Training Loss
3.208  -- Uniform Weights

    Allgemeine Regel für die Einstellung der GEWICHTE

    Die Allgemeine Regel für die Einstellung der GEWICHTE in einem neuronalen Netzwerk ist, um Sie von den nahe bei null, ohne dabei zu klein.

    Gute Praxis ist, um starten Sie Ihre GEWICHTE im Bereich von [-y, y], wo y=1/sqrt(n)

    (n ist die Anzahl der Eingänge zu einem bestimmten neuron).

        # takes in a module and applies the specified weight initialization
    def weights_init_uniform_rule(m):
        classname = m.__class__.__name__
        # for every Linear layer in a model..
        if classname.find('Linear') != -1:
            # get the number of the inputs
            n = m.in_features
            y = 1.0/np.sqrt(n)
            m.weight.data.uniform_(-y, y)
            m.bias.data.fill_(0)

    # create a new model with these weights
    model_rule = Net()
    model_rule.apply(weights_init_uniform_rule)

    unten vergleichen wir die Leistung des NN, GEWICHTE Initialisierung mit Gleichverteilung [-0.5,0.5) im Vergleich zu dessen Gewicht wird initialisiert Regel

    • Nach 2 Epochen:

    Wie initialisieren Sie die GEWICHTE in PyTorch?

    Validation Accuracy
75.817% -- Centered Weights [-0.5, 0.5)
85.208% -- General Rule [-y, y)
Training Loss
0.705  -- Centered Weights [-0.5, 0.5)
0.469  -- General Rule [-y, y)

    Normalverteilung, die zum initialisieren der GEWICHTE

    Die Normalverteilung soll einen Mittelwert von 0 und eine Standardabweichung von y=1/sqrt(n), wobei n die Anzahl der Eingänge auf NN

        ## takes in a module and applies the specified weight initialization
    def weights_init_normal(m):
        '''Takes in a module and initializes all linear layers with weight
           values taken from a normal distribution.'''

        classname = m.__class__.__name__
        # for every Linear layer in a model
        if classname.find('Linear') != -1:
            y = m.in_features
        # m.weight.data shoud be taken from a normal distribution
            m.weight.data.normal_(0.0,1/np.sqrt(y))
        # m.bias.data should be 0
            m.bias.data.fill_(0)

    unten zeigen wir die performance der beiden NN man initialisiert uniform-Verteilung und die andere über normal-Verteilung

    • Nach 2 Epochen:

    Wie initialisieren Sie die GEWICHTE in PyTorch? 

    Validation Accuracy
85.775% -- Uniform Rule [-y, y)
84.717% -- Normal Distribution
Training Loss
0.329  -- Uniform Rule [-y, y)
0.443  -- Normal Distribution

    InformationsquelleAutor ashunigion

  3. 3
        import torch.nn as nn        

    # a simple network
    rand_net = nn.Sequential(nn.Linear(in_features, h_size),
                             nn.BatchNorm1d(h_size),
                             nn.ReLU(),
                             nn.Linear(h_size, h_size),
                             nn.BatchNorm1d(h_size),
                             nn.ReLU(),
                             nn.Linear(h_size, 1),
                             nn.ReLU())

    # initialization function, first checks the module type,
    # then applies the desired changes to the weights
    def init_normal(m):
        if type(m) == nn.Linear:
            nn.init.uniform_(m.weight)

    # use the modules apply function to recursively apply the initialization
    rand_net.apply(init_normal)

    InformationsquelleAutor Duane

  4. 2

    Sorry für so spät, ich hoffe, meine Antwort hilft.

    Initialisieren Sie die GEWICHTE mit einem normal distribution verwenden:

    torch.nn.init.normal_(tensor, mean=0, std=1)

    Oder ein constant distribution schreiben:

    torch.nn.init.constant_(tensor, value)

    Oder für die Verwendung eines uniform distribution:

    torch.nn.init.uniform_(tensor, a=0, b=1) # a: lower_bound, b: upper_bound

    Können Sie prüfen, andere Methoden zu initialisieren Tensoren hier

    InformationsquelleAutor Luca Di Liello

Schreibe einen Kommentar