¿Hay alguna guía general sobre dónde colocar capas de abandono en una red neuronal?
¿Hay alguna guía general sobre dónde colocar capas de abandono en una red neuronal?
Respuestas:
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.
relu
activació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?
RELU
de cada capa CONV. No creo que hayan investigado el efecto de agregar abandono después de las capas de agrupación máxima.
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.