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

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

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.

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

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.

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.