Di mana saya harus meletakkan layer dropout di jaringan saraf?

Apakah ada pedoman umum tentang di mana menempatkan lapisan dropout di jaringan saraf?

Dalam makalah asli yang mengusulkan lapisan dropout, oleh Hinton (2012) , dropout (dengan p = 0,5) digunakan pada masing-masing lapisan (padat) yang terhubung sepenuhnya sebelum output; itu tidak digunakan pada lapisan konvolusional. Ini menjadi konfigurasi yang paling umum digunakan.

Penelitian yang lebih baru telah menunjukkan beberapa nilai dalam menerapkan dropout juga ke lapisan konvolusional, meskipun pada tingkat yang jauh lebih rendah: p = 0,1 atau 0,2. Dropout digunakan setelah fungsi aktivasi setiap lapisan konvolusional: CONV-> RELU-> DROP.

Di depan setiap proyeksi linier. Lihat Srivastava et al. (2014) .

Makalah asli mengusulkan lapisan putus sekolah yang digunakan pada masing-masing lapisan (padat) yang terhubung sepenuhnya sebelum output; itu tidak digunakan pada lapisan konvolusional.

Kita tidak boleh menggunakan lapisan putus sekolah setelah lapisan konvolusional karena kita menggeser filter di atas lebar dan tinggi gambar input, kita menghasilkan peta aktivasi 2 dimensi yang memberikan respons dari filter itu di setiap posisi spasial. Jadi ketika lapisan dropout menetralkan (menjadikannya nol) neuron acak ada kemungkinan kehilangan fitur yang sangat penting dalam gambar dalam proses pelatihan kami.

Jika saya tidak salah, Anda dapat menambahkannya setelah non-linearitas setiap sel:

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

Baris pertama adalah fungsi aktivasi, dan yang terakhir adalah menambahkan dropout ke hasilnya. Silakan merujuk ke blog ini . Semoga ini membantu.

Atau Anda dapat menempatkannya di penyisipan input seperti dalam cuplikan ini:

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

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

Secara teknis Anda dapat menambahkan lapisan putus sekolah di akhir blok, misalnya setelah konvolusi atau setelah pengkodean RNN.