Bırakma katmanlarını sinir ağında nereye yerleştirmeliyim?

Bir sinir ağında bırakma katmanlarının nereye yerleştirileceği hakkında genel bir kılavuz var mı?

Düşme katmanları öneren orijinal makalede, Hinton (2012) tarafından , çıktımdan önce tamamen bağlı (yoğun) katmanların her birinde bırakma (p = 0.5 ile) kullanılmıştır; evrişimli tabakalarda kullanılmamıştır. Bu en yaygın kullanılan konfigürasyon oldu.

Daha yeni araştırmalar , çok daha düşük seviyelerde olmasına rağmen, püskürtülen katmanlara da okulu bırakma uygulamasında bir değer göstermiştir: Her konvolüsyon tabakasının aktivasyon fonksiyonundan sonra bırakma kullanılmıştır: CONV-> RELU-> DROP.

Her doğrusal projeksiyonun önünde. Bakınız Srivastava ve diğ. (2014) .

Orijinal makale, çıktıdan önce tamamen birbirine bağlı (yoğun) tabakaların her birinde kullanılmış olan bırakma katmanları önermiştir; evrişimli tabakalarda kullanılmamıştır.

Konvolüsyonlu katmanın ardından bırakma katmanı kullanmamalıyız, filtreyi giriş görüntüsünün genişliği ve yüksekliği üzerine kaydırdıkça, her bir uzaysal konumda bu filtrenin yanıtlarını veren 2 boyutlu bir aktivasyon haritası üretiyoruz. Bırakma katmanı nötrleştirirken (sıfır yapar) rastgele nöronlar, eğitim sürecimizdeki bir görüntüde çok önemli bir özelliği kaybetme şansı yakalar.

Yanılmıyorsam, her hücrenin doğrusal olmayışından sonra ekleyebilirsiniz:

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

İlk satır etkinleştirme işlevidir ve sonuncusu bırakma sonucuna ekliyor. Lütfen bu bloga bakın . Bu yardımcı olur umarım.

Veya bu kod parçasında olduğu gibi giriş gömme içine yerleştirebilirsiniz:

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

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

Teknik olarak, bırakma katmanını bir bloğun sonuna, örneğin evrişimden sonra veya RNN kodlamasından sonra ekleyebilirsiniz.