Tôi nên đặt các lớp bỏ học ở đâu trong mạng lưới thần kinh?

Có hướng dẫn chung nào về nơi đặt các lớp bỏ học trong mạng lưới thần kinh không?

Trong bài báo gốc đề xuất các lớp bỏ học, bởi Hinton (2012) , bỏ học (với p = 0,5) đã được sử dụng trên mỗi lớp được kết nối đầy đủ (đậm đặc) trước khi xuất ra; nó không được sử dụng trên các lớp chập. Điều này đã trở thành cấu hình được sử dụng phổ biến nhất.

Nhiều nghiên cứu gần đây đã cho thấy một số giá trị trong việc áp dụng bỏ học cũng cho các lớp chập, mặc dù ở mức thấp hơn nhiều: p = 0,1 hoặc 0,2. Bỏ học được sử dụng sau chức năng kích hoạt của từng lớp chập: CONV-> RELU-> DROP.

Trước mọi dự đoán tuyến tính. Tham khảo Srivastava et al. (2014) .

Bài báo gốc đề xuất các lớp bỏ học được sử dụng trên mỗi lớp được kết nối đầy đủ (dày đặc) trước khi xuất ra; nó không được sử dụng trên các lớp chập.

Chúng ta không được sử dụng lớp bỏ qua sau lớp chập khi trượt bộ lọc qua chiều rộng và chiều cao của hình ảnh đầu vào, chúng ta tạo ra bản đồ kích hoạt 2 chiều cung cấp phản hồi của bộ lọc đó ở mọi vị trí không gian. Vì vậy, khi lớp bỏ học trung hòa (làm cho nó bằng không) các tế bào thần kinh ngẫu nhiên, có khả năng mất đi tính năng rất quan trọng trong một hình ảnh trong quá trình đào tạo của chúng tôi.

Nếu tôi không sai, bạn có thể thêm nó sau tính phi tuyến tính của mọi ô:

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

Dòng đầu tiên là chức năng kích hoạt và cuối cùng là thêm phần bỏ vào kết quả. Vui lòng tham khảo blog này . Hi vọng điêu nay co ich.

Hoặc bạn có thể đặt nó vào phần nhúng đầu vào như trong đoạn trích này:

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

Nguồn: https://github.com/spro/prreal-pytorch/blob/master/seq2seq-translation/seq2seq-translation.ipynb

Về mặt kỹ thuật, bạn có thể thêm lớp bỏ học ở cuối khối, ví dụ sau khi tích chập hoặc sau mã hóa RNN.