ฉันจะวางเลเยอร์ dropout ในเครือข่ายประสาทได้ที่ไหน


65

มีแนวทางทั่วไปหรือไม่ว่าจะวางเลเยอร์ dropout ในเครือข่ายประสาท


1
การใช้การออกกลางคันแบบสุ่มปิดการใช้งานบางส่วนของเซลล์ประสาทในชั้นที่ซ่อนอยู่ ในไลบรารี Keras คุณสามารถเพิ่มการออกกลางคันหลังจากเลเยอร์ที่ซ่อนอยู่และคุณสามารถระบุอัตราการออกกลางคันซึ่งกำหนดเปอร์เซ็นต์ของเซลล์ประสาทที่ถูกปิดใช้งานในชั้นก่อนหน้า
แก้ไข

กรรมกรรมได้รับอนุญาตที่นี่หรือไม่
แก้ไข

4
@ ท่านผู้เป็นผู้เพาะปลูกและเป็นอย่างไร
Franck Dernoncourt

คุณแก้ไขคำตอบนี้หรือไม่?
Blaszard

เครือข่ายประสาทประเภทใด ซีเอ็นเอ็น, RNN, อื่น ๆ ?
Wayne

คำตอบ:


34

ในกระดาษต้นฉบับที่เสนอเลเยอร์การออกกลางคันโดยHinton (2012)มีการใช้การออกกลางคัน (ด้วย p = 0.5) ในแต่ละเลเยอร์ (หนาแน่น) ที่เชื่อมต่อกันอย่างสมบูรณ์ก่อนที่จะส่งออก มันไม่ได้ใช้กับชั้น convolutional นี่เป็นรูปแบบที่ใช้กันมากที่สุด

การวิจัยเมื่อเร็ว ๆ นี้แสดงให้เห็นถึงคุณค่าบางอย่างในการใช้ดรอปเอาท์กับเลเยอร์ convolutional แม้ว่าในระดับที่ต่ำกว่ามาก: p = 0.1 หรือ 0.2 การออกกลางคันถูกใช้หลังจากฟังก์ชั่นการเปิดใช้งานของแต่ละชั้น convolutional: CONV-> RELU-> DROP


ดังนั้นควรวางหลังจากเลเยอร์ทั้งหมดหรือเฉพาะกับการเปิดใช้งานที่ไม่ใช่เชิงเส้น? เช่นได้รับการสนทนาแบบ 2 มิติพร้อมการreluเปิดใช้งานตามด้วยเลเยอร์รวมกำไรสูงสุดเลเยอร์การออกกลางคัน (2D) ควรไปทันทีหลังจากการสนทนาหรือหลังเลเยอร์รวมกำไรสูงสุดหรือทั้งสองอย่างหรือไม่เป็นไร?
z0r

1
ฉันได้อัปเดตคำตอบเพื่อชี้แจงว่าในงานของ Park et al. การออกกลางคันถูกนำไปใช้หลังจากRELUแต่ละ CONV เลเยอร์ ฉันไม่เชื่อว่าพวกเขาตรวจสอบผลกระทบของการเพิ่มการออกกลางคันหลังจากเลเยอร์รวมกำไรสูงสุด
4Oh4

เป็นที่น่าสังเกตว่าในบทความ Hinton หน้า 10 (1938) พวกเขาเขียนว่าใช้การออกกลางคันบนเลเยอร์ convolutional เมื่อทดสอบกับชุดข้อมูล Google Street View ลดข้อผิดพลาดการจัดหมวดหมู่
มิกิพี

9

ด้านหน้าของทุกเส้นฉาย อ้างถึงSrivastava และคณะ (2014)


4
คำตอบอื่น ๆ อธิบายถึงวิธีการใช้การออกกลางคัน แต่นี่เป็นคำตอบเดียวที่ตอบคำถาม OP ของสถานที่ที่จะใช้การออกกลางคัน
stormont

3

กระดาษต้นฉบับเสนอเลเยอร์ dropout ที่ใช้กับแต่ละเลเยอร์ (หนาแน่น) ที่เชื่อมต่อกันอย่างสมบูรณ์ก่อนที่จะส่งออก มันไม่ได้ใช้กับชั้น convolutional

เราต้องไม่ใช้เลเยอร์ดรอปเอาต์หลังจากเลเยอร์ convolutional เนื่องจากเราเลื่อนฟิลเตอร์เหนือความกว้างและความสูงของภาพอินพุตเราสร้างแผนที่การเปิดใช้งานแบบ 2 มิติที่ให้การตอบสนองของตัวกรองนั้นในทุกตำแหน่งอวกาศ ดังนั้นเมื่อเลเยอร์การออกกลางคันทำให้เซลล์ประสาทสุ่ม (ทำให้เป็นศูนย์) เป็นกลางมีโอกาสสูญเสียคุณสมบัติที่สำคัญมากในภาพในกระบวนการฝึกอบรมของเรา


2

หากฉันไม่ผิดคุณสามารถเพิ่มได้หลังจากการไม่เป็นเชิงเส้นของทุกเซลล์:

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

บรรทัดแรกคือฟังก์ชั่นการเปิดใช้งานและอันสุดท้ายคือการเพิ่มดรอปเอาท์ให้กับผลลัพธ์ โปรดอ้างอิงถึงบล็อกนี้ หวังว่านี่จะช่วยได้

หรือคุณสามารถวางลงในอินพุตที่ฝังไว้ในข้อมูลโค้ดนี้:

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

ที่มา: https://github.com/spro/practical-pytorch/blob/master/seq2seq-translation/seq2seq-translation.ipynb

ในทางเทคนิคคุณสามารถเพิ่มเลเยอร์ดร็อปดาวน์ที่จุดสิ้นสุดของบล็อกตัวอย่างเช่นหลังจากการแปลงหรือหลังจากการเข้ารหัส RNN


GeneralAttn กำหนดไว้ที่ไหน
rafaelvalle
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.