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

65

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

Franck Dernoncourt
la source
1
L'utilisation de la régularisation du décrochage désactive de manière aléatoire une partie des neurones d'une couche masquée. Dans la bibliothèque Keras, vous pouvez ajouter un abandon après un calque masqué et spécifier un taux d'abandon, qui détermine le pourcentage de neurones désactivés dans le calque précédent.
réparation
l'agriculture de karma est-elle autorisée ici?
réparation
4
@Redress qui a cultivé, et comment?
Franck Dernoncourt
Avez-vous résolu cette réponse?
Blaszard
Quels types de réseaux de neurones? CNN, RNN, autre?
Wayne

Réponses:

34

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.

4Oh4
la source
Devraient-ils donc être placés après toutes les couches, ou uniquement celles avec une activation non linéaire? Par exemple, en présence d'une convolution 2D avec une reluactivation suivie d'une couche de mise en pool maximale, la couche de suppression (2D) doit-elle disparaître immédiatement après la convolution, ou après la couche de mise en pool maximale, ou les deux, ou est-ce que cela n'a pas d'importance?
z0r
1
J'ai mis à jour la réponse pour préciser que, dans le travail de Park et al., Le décrochage était appliqué après le RELUsur chaque couche de CONV. Je ne crois pas qu'ils aient étudié l'effet de l'ajout d'abandons après les couches de pooling maximales.
4h 4
Il est intéressant de noter que dans le document de Hinton, à la page 10 (1938), ils écrivent que l'utilisation du décrochage sur les couches convolutives lors des tests sur l'ensemble de données de Google Street View réduit l'erreur de classification.
Miki P
9

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

jnhwkim
la source
5
Les autres réponses décrivent comment appliquer l’abandon scolaire, mais c’est la seule réponse qui répond à la question du PO, à savoir appliquer l’abandon scolaire.
Stormont
3

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.

Pooja Sonkar
la source
2

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.

Lerner Zhang
la source
Où est défini GeneralAttn?
Rafaelvalle