Onde devo colocar as camadas de dropout em uma rede neural?

Existe alguma orientação geral sobre onde colocar camadas de dropout em uma rede neural?

No artigo original que propôs camadas de abandono, por Hinton (2012) , o abandono (com p = 0,5) foi usado em cada uma das camadas (densas) totalmente conectadas antes da saída; não foi usado nas camadas convolucionais. Essa se tornou a configuração mais usada.

Pesquisas mais recentes mostraram algum valor na aplicação do abandono também em camadas convolucionais, embora em níveis muito mais baixos: p = 0,1 ou 0,2. O abandono foi utilizado após a função de ativação de cada camada convolucional: CONV-> RELU-> DROP.

Na frente de todas as projeções lineares. Consulte Srivastava et al. (2014) .

O documento original propunha camadas de abandono que eram usadas em cada uma das camadas (densas) totalmente conectadas antes da saída; não foi usado nas camadas convolucionais.

Não devemos usar a camada de eliminação após a camada convolucional. Ao deslizar o filtro sobre a largura e a altura da imagem de entrada, produzimos um mapa de ativação bidimensional que fornece as respostas desse filtro em todas as posições espaciais. Assim, à medida que a camada de abandono neutraliza (torna zero) os neurônios aleatórios, há chances de perder recursos muito importantes em uma imagem em nosso processo de treinamento.

Se não estou errado, você pode adicioná-lo após a não linearidade de cada célula:

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

A primeira linha é a função de ativação e a última é a adição do dropout ao resultado. Por favor, consulte este blog . Espero que isto ajude.

Ou você pode colocá-lo na incorporação de entrada como neste trecho:

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, você pode adicionar a camada de eliminação no final de um bloco, por exemplo, após a convolução ou após a codificação RNN.