Dove devo posizionare i livelli di dropout in una rete neurale?

Esistono linee guida generali su dove posizionare i livelli di dropout in una rete neurale?

Nel documento originale che ha proposto strati di dropout, di Hinton (2012) , il dropout (con p = 0,5) è stato usato su ciascuno degli strati (densi) completamente collegati prima dell'uscita; non è stato usato sugli strati convoluzionali. Questa è diventata la configurazione più comunemente usata.

Ricerche più recenti hanno mostrato un certo valore nell'applicare il dropout anche a strati convoluzionali, sebbene a livelli molto più bassi: p = 0,1 o 0,2. Il dropout è stato utilizzato dopo la funzione di attivazione di ogni strato convoluzionale: CONV-> RELU-> DROP.

Di fronte a ogni proiezione lineare. Fare riferimento a Srivastava et al. (2014) .

Il documento originale ha proposto strati di dropout che sono stati utilizzati su ciascuno degli strati (densi) completamente collegati prima dell'output; non è stato usato sugli strati convoluzionali.

Non dobbiamo usare il livello di dropout dopo il livello convoluzionale mentre facciamo scorrere il filtro sulla larghezza e l'altezza dell'immagine di input, produciamo una mappa di attivazione bidimensionale che fornisce le risposte di quel filtro in ogni posizione spaziale. Quindi, poiché lo strato di dropout neutralizza (lo rende zero) i neuroni casuali, ci sono possibilità di perdere funzionalità molto importanti in un'immagine nel nostro processo di allenamento.

Se non sbaglio, puoi aggiungerlo dopo la non linearità di ogni cella:

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))

La prima riga è la funzione di attivazione e l'ultima è l'aggiunta del dropout al risultato. Si prega di fare riferimento a questo blog . Spero che sia di aiuto.

Oppure puoi posizionarlo nell'incorporamento dell'input come in questo frammento:

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

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

Tecnicamente puoi aggiungere il layer dropout alla fine di un blocco, ad esempio dopo la convoluzione o dopo la codifica RNN.