¿Dónde debo colocar capas de abandono en una red neuronal?

65

¿Hay alguna guía general sobre dónde colocar capas de abandono en una red neuronal?

Franck Dernoncourt
fuente
1
El uso de la regularización del abandono deshabilita aleatoriamente una parte de las neuronas en una capa oculta. En la biblioteca de Keras, puede agregar el abandono después de cualquier capa oculta, y puede especificar una tasa de abandono, que determina el porcentaje de neuronas deshabilitadas en la capa anterior.
reparación
¿se permite la agricultura de karma aquí?
reparación
44
@redress que cultivó, y cómo?
Franck Dernoncourt
¿Resolviste esta respuesta?
Blaszard
¿Qué tipos de redes neuronales? CNN, RNN, otro?
Wayne

Respuestas:

34

En el documento original que propuso capas de abandono, por Hinton (2012) , se utilizó el abandono (con p = 0.5) en cada una de las capas completamente conectadas (densas) antes de la salida; no se usó en las capas convolucionales. Esta se convirtió en la configuración más utilizada.

Investigaciones más recientes han demostrado cierto valor en la aplicación de la deserción escolar también a capas convolucionales, aunque a niveles mucho más bajos: p = 0.1 o 0.2. El abandono se usó después de la función de activación de cada capa convolucional: CONV-> RELU-> DROP.

4Oh4
fuente
Entonces, ¿deberían colocarse después de todas las capas, o solo las que tienen una activación no lineal? Por ejemplo, dada una convolución 2D con una reluactivación seguida de una capa de agrupación máxima, ¿la capa de abandono (2D) debe ir inmediatamente después de la convolución, o después de la capa de agrupación máxima, o ambas, o no importa?
z0r
1
He actualizado la respuesta para aclarar que en el trabajo de Park et al., El abandono se aplicó después RELUde cada capa CONV. No creo que hayan investigado el efecto de agregar abandono después de las capas de agrupación máxima.
4Oh4
Vale la pena señalar que en el documento de Hinton, en la página 10 (1938), escriben que el uso de abandono en capas convolucionales al probar contra el conjunto de datos de Google Street View redujo el error de clasificación.
Miki P
9

En frente de todas las proyecciones lineales. Consulte Srivastava et al. (2014) .

jnhwkim
fuente
55
Las otras respuestas describen cómo aplicar el abandono, pero esta es la única respuesta que responde a la pregunta de OP de dónde aplicar el abandono.
Stormont
3

El documento original propuso capas de abandono que se usaron en cada una de las capas completamente conectadas (densas) antes de la salida; no se usó en las capas convolucionales.

No debemos usar la capa de abandono después de la capa convolucional a medida que deslizamos el filtro sobre el ancho y la altura de la imagen de entrada, producimos un mapa de activación bidimensional que da las respuestas de ese filtro en cada posición espacial. Entonces, a medida que la capa de abandono neutraliza (hace que sea cero) las neuronas aleatorias, hay posibilidades de perder una característica muy importante en una imagen en nuestro proceso de entrenamiento.

Pooja Sonkar
fuente
2

Si no me equivoco, puede agregarlo después de la no linealidad de cada celda:

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 primera línea es la función de activación, y la última es agregar el abandono al resultado. Por favor, consulte este blog . Espero que esto ayude.

O puede colocarlo en la incrustación de entrada como en este fragmento:

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

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

Técnicamente, puede agregar la capa de abandono al final de un bloque, por ejemplo, después de la convolución o después de la codificación RNN.

Lerner Zhang
fuente
¿Dónde se define GeneralAttn?
rafaelvalle