TensorFlow - l'introduction de deux L2 de régularisation et d'abandon dans le réseau. Est-il un sens?
Je suis en train de jouer avec ANN qui est une partie de Udactity DeepLearning cours.
J'ai réussi construit et réseau de trains de banlieue et introduit la régularisation L2 sur tous les poids et les biais. Maintenant je suis d'essayer d'abandon pour la couche cachée afin d'améliorer la généralisation. Je me demande, est-il un sens à la fois d'introduire la régularisation L2 dans la couche cachée et de l'abandon sur la même couche? Si oui, comment le faire correctement?
Cours d'abandon nous avons littéralement éteindre la moitié des activations de la couche cachée et le double de la quantité délivrée par le repos des neurones. Lors de l'utilisation de la L2, nous calculons la norme L2 sur tous cachés poids. Mais je ne suis pas sûr de la façon de calculer L2 dans le cas où nous utilisons des abandons. Nous éteindre certaines activations, ne devrait-on pas supprimer les poids qui sont "non utilisé" maintenant à partir de la L2 calcul? Toutes les références à ce sujet sera utile, je n'ai pas trouvé d'info.
Juste au cas où vous êtes intéressé, mon code pour ANN avec régularisation L2 est ci-dessous:
#for NeuralNetwork model code is below
#We will use SGD for training to save our time. Code is from Assignment 2
#beta is the new parameter - controls level of regularization. Default is 0.01
#but feel free to play with it
#notice, we introduce L2 for both biases and weights of all layers
beta = 0.01
#building tensorflow graph
graph = tf.Graph()
with graph.as_default():
# Input data. For the training data, we use a placeholder that will be fed
# at run time with a training minibatch.
tf_train_dataset = tf.placeholder(tf.float32,
shape=(batch_size, image_size * image_size))
tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
tf_valid_dataset = tf.constant(valid_dataset)
tf_test_dataset = tf.constant(test_dataset)
#now let's build our new hidden layer
#that's how many hidden neurons we want
num_hidden_neurons = 1024
#its weights
hidden_weights = tf.Variable(
tf.truncated_normal([image_size * image_size, num_hidden_neurons]))
hidden_biases = tf.Variable(tf.zeros([num_hidden_neurons]))
#now the layer itself. It multiplies data by weights, adds biases
#and takes ReLU over result
hidden_layer = tf.nn.relu(tf.matmul(tf_train_dataset, hidden_weights) + hidden_biases)
#time to go for output linear layer
#out weights connect hidden neurons to output labels
#biases are added to output labels
out_weights = tf.Variable(
tf.truncated_normal([num_hidden_neurons, num_labels]))
out_biases = tf.Variable(tf.zeros([num_labels]))
#compute output
out_layer = tf.matmul(hidden_layer,out_weights) + out_biases
#our real output is a softmax of prior result
#and we also compute its cross-entropy to get our loss
#Notice - we introduce our L2 here
loss = (tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
out_layer, tf_train_labels) +
beta*tf.nn.l2_loss(hidden_weights) +
beta*tf.nn.l2_loss(hidden_biases) +
beta*tf.nn.l2_loss(out_weights) +
beta*tf.nn.l2_loss(out_biases)))
#now we just minimize this loss to actually train the network
optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)
#nice, now let's calculate the predictions on each dataset for evaluating the
#performance so far
# Predictions for the training, validation, and test data.
train_prediction = tf.nn.softmax(out_layer)
valid_relu = tf.nn.relu( tf.matmul(tf_valid_dataset, hidden_weights) + hidden_biases)
valid_prediction = tf.nn.softmax( tf.matmul(valid_relu, out_weights) + out_biases)
test_relu = tf.nn.relu( tf.matmul( tf_test_dataset, hidden_weights) + hidden_biases)
test_prediction = tf.nn.softmax(tf.matmul(test_relu, out_weights) + out_biases)
#now is the actual training on the ANN we built
#we will run it for some number of steps and evaluate the progress after
#every 500 steps
#number of steps we will train our ANN
num_steps = 3001
#actual training
with tf.Session(graph=graph) as session:
tf.initialize_all_variables().run()
print("Initialized")
for step in range(num_steps):
# Pick an offset within the training data, which has been randomized.
# Note: we could use better randomization across epochs.
offset = (step * batch_size) % (train_labels.shape[0] - batch_size)
# Generate a minibatch.
batch_data = train_dataset[offset:(offset + batch_size), :]
batch_labels = train_labels[offset:(offset + batch_size), :]
# Prepare a dictionary telling the session where to feed the minibatch.
# The key of the dictionary is the placeholder node of the graph to be fed,
# and the value is the numpy array to feed to it.
feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels}
_, l, predictions = session.run(
[optimizer, loss, train_prediction], feed_dict=feed_dict)
if (step % 500 == 0):
print("Minibatch loss at step %d: %f" % (step, l))
print("Minibatch accuracy: %.1f%%" % accuracy(predictions, batch_labels))
print("Validation accuracy: %.1f%%" % accuracy(
valid_prediction.eval(), valid_labels))
print("Test accuracy: %.1f%%" % accuracy(test_prediction.eval(), test_labels))
- Pourquoi êtes-vous régulariser les préjugés?
Vous devez vous connecter pour publier un commentaire.
Ok, après quelques autres efforts, j'ai réussi à le résoudre et introduire L2 et d'abandon dans mon réseau, le code est ci-dessous. J'ai eu une légère amélioration sur le même réseau sans le décrochage scolaire (avec L2 en place). Je ne sais pas si cela vaut vraiment la peine l'effort d'introduire les deux d'entre eux, L2 et d'abandon, mais au moins il travaille et s'améliore légèrement les résultats.
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits( out_layer, tf_train_labels)) + beta*tf.nn.l2_loss(hidden_weights) + ...
beta
être multiplié par la perte de fonction. Est-ce normal? Cela doit un être un paramètre qui est à l'écoute?Il n'y a aucun inconvénient à l'utilisation de plusieurs régularisations. En fait, il s'agit d'un papier Abandon scolaire: Une Façon Simple d'Éviter les Réseaux de Neurones à partir de
Le surajustement où les auteurs ont vérifié combien ça aide. Clairement, pour les différents ensembles de données, vous aurez des résultats différents, mais pour votre MNIST:
vous pouvez voir que
Dropout + Max-norm
donne la plus faible erreur. En dehors de cela, vous avez un grosse erreur dans votre code.Vous utilisez l2_loss sur les poids et les biais:
Vous ne devrait pas pénaliser élevé de biais. Donc, supprimer l2_loss plus de préjugés.
En fait, le document original utilise max-norme de la régularisation et de ne pas en L2, en plus d'abandon:
"Le réseau de neurones a été optimisé sous la contrainte ||w||2 ≤ c. Cette
la contrainte a été imposée lors de l'optimisation, par la projection de w sur la surface d'une boule de rayon c, lorsque w est allé hors de lui. Il est également appelé max-norme de régularisation, puisqu'elle implique que la valeur maximale que la norme de tout le poids est c" (http://jmlr.org/papers/volume15/srivastava14a/srivastava14a.pdf)
Vous pouvez trouver une belle discussion à propos de cette méthode de régularisation ici: https://plus.google.com/+IanGoodfellow/posts/QUaCJfvDpni