Wo soll ich Dropout-Layer in einem neuronalen Netzwerk platzieren?

Gibt es allgemeine Richtlinien zum Platzieren von Dropout-Layern in einem neuronalen Netzwerk?

In der Originalarbeit, die Dropout-Schichten vorschlug, von Hinton (2012) , wurde Dropout (mit p = 0,5) für jede der vollständig verbundenen (dichten) Schichten vor der Ausgabe verwendet. es wurde nicht auf den Faltungsschichten verwendet. Dies wurde die am häufigsten verwendete Konfiguration.

Neuere Forschungen haben gezeigt, dass das Anwenden von Dropout auch auf Faltungsschichten einen gewissen Wert hat, obwohl dies bei viel niedrigeren Niveaus der Fall ist: p = 0,1 oder 0,2. Dropout wurde nach der Aktivierungsfunktion jeder Faltungsschicht verwendet: CONV-> RELU-> DROP.

Vor jeder linearen Projektion. Siehe Srivastava et al. (2014) .

Das Originalpapier schlug Dropout-Schichten vor, die auf jeder der vollständig verbundenen (dichten) Schichten vor der Ausgabe verwendet wurden. es wurde nicht auf den Faltungsschichten verwendet.

Wir dürfen keine Dropout-Schicht nach der Faltungsschicht verwenden, da wir den Filter über die Breite und Höhe des Eingabebildes schieben. Wir erstellen eine zweidimensionale Aktivierungskarte, die die Antworten dieses Filters an jeder räumlichen Position angibt. Wenn die Dropout-Schicht zufällige Neuronen neutralisiert (auf Null stellt), besteht die Möglichkeit, dass sehr wichtige Merkmale in einem Bild in unserem Trainingsprozess verloren gehen.

Wenn ich mich nicht irre, können Sie es nach der Nichtlinearität jeder Zelle hinzufügen:

layer_1 = (1/(1+np.exp(-(np.dot(X,synapse_0)))))
if(do_dropout):
    layer_1 *= np.random.binomial([np.ones((len(X),hidden_dim))],1-dropout_percent)[0] * (1.0/(1-dropout_percent))

Die erste Zeile ist die Aktivierungsfunktion, und die letzte Zeile fügt das Dropout zum Ergebnis hinzu. Bitte beziehen Sie sich auf diesen Blog . Hoffe das hilft.

Oder Sie können es in die Eingabe einbetten, wie in diesem Snippet:

class BahdanauAttnDecoderRNN(nn.Module):
    def __init__(self, hidden_size, output_size, n_layers=1, dropout_p=0.1):
        super(AttnDecoderRNN, self).__init__()

        # Define parameters
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.n_layers = n_layers
        self.dropout_p = dropout_p
        self.max_length = max_length

        # Define layers
        self.embedding = nn.Embedding(output_size, hidden_size)
        self.dropout = nn.Dropout(dropout_p)
        self.attn = GeneralAttn(hidden_size)
        self.gru = nn.GRU(hidden_size * 2, hidden_size, n_layers, dropout=dropout_p)
        self.out = nn.Linear(hidden_size, output_size)

    def forward(self, word_input, last_hidden, encoder_outputs):
        # Note that we will only be running forward for a single decoder time step, but will use all encoder outputs

        # Get the embedding of the current input word (last output word)
        word_embedded = self.embedding(word_input).view(1, 1, -1) # S=1 x B x N
        word_embedded = self.dropout(word_embedded)

        # Calculate attention weights and apply to encoder outputs
        attn_weights = self.attn(last_hidden[-1], encoder_outputs)
        context = attn_weights.bmm(encoder_outputs.transpose(0, 1)) # B x 1 x N

        # Combine embedded input word and attended context, run through RNN
        rnn_input = torch.cat((word_embedded, context), 2)
        output, hidden = self.gru(rnn_input, last_hidden)

        # Final output layer
        output = output.squeeze(0) # B x N
        output = F.log_softmax(self.out(torch.cat((output, context), 1)))

        # Return final output, hidden state, and attention weights (for visualization)
        return output, hidden, attn_weights

Quelle: https://github.com/spro/practical-pytorch/blob/master/seq2seq-translation/seq2seq-translation.ipynb

Technisch gesehen können Sie die Dropout-Ebene am Ende eines Blocks hinzufügen, beispielsweise nach der Faltung oder nach der RNN-Codierung.