Où devrais-je placer des couches de décrochage dans un réseau de neurones?

Existe-t-il des directives générales sur l'emplacement des couches d'abandon dans un réseau de neurones?

Dans le document original qui proposait des couches de suppression, de Hinton (2012) , une suppression (avec p = 0,5) a été utilisée sur chacune des couches entièrement connectées (denses) avant la sortie; il n'a pas été utilisé sur les couches convolutives. Ceci est devenu la configuration la plus couramment utilisée.

Des recherches plus récentes ont montré un intérêt dans l'application du décrochage également aux couches convolutives, bien qu'à des niveaux beaucoup plus bas: p = 0,1 ou 0,2. La suppression a été utilisée après la fonction d'activation de chaque couche de convolution: CONV-> RELU-> DROP.

Devant chaque projection linéaire. Voir Srivastava et al. (2014) .

Le document original proposait des couches de suppression qui étaient utilisées sur chacune des couches entièrement connectées (denses) avant la sortie; il n'a pas été utilisé sur les couches convolutives.

Nous ne devons pas utiliser les couches de suppression après les couches de convolution lorsque nous faisons glisser le filtre sur la largeur et la hauteur de l'image d'entrée, nous produisons une carte d'activation à 2 dimensions qui donne les réponses de ce filtre à chaque position spatiale. Donc, comme la couche de suppression neutralise (le rend nul) les neurones aléatoires, il y a des chances de perdre une caractéristique très importante d'une image dans notre processus de formation.

Si je ne me trompe pas, vous pouvez l'ajouter après la non-linéarité de chaque cellule:

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 première ligne est la fonction d'activation et la dernière ajoute la suppression au résultat. S'il vous plaît se référer à ce blog . J'espère que cela t'aides.

Ou vous pouvez le placer dans l’incorporation d’entrée comme dans cet extrait:

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

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

Techniquement, vous pouvez ajouter la couche de suppression à la fin d'un bloc, par exemple après la convolution ou après le codage RNN.