Retard TensorFlow: comment appliquer différentes valeurs à Train vs Test?

Question

Je suis en train de mettre en œuvre abandon scolaire dans tensorflow pour un simple réseau de neurones 3 couches pour la classification et me présente des problèmes. Plus précisément, Je suis en train d'appliquer différents paramètres d'abandon des valeurs pkeep quand je train aux tests.

Je prends l'approche comme suit:

1) create_placeholders def (n_x, n_y):

X = tf.placeholder("float", [n_x, None]) 
Y = tf.placeholder("float", [n_y, None]) 
pkeep = tf.placeholder(tf.float32) 
return X,Y,pkeep 

2) Dans la fonction forward_propagation (X, paramètres, pkeep), je joue les éléments suivants:

Z1 = tf.add(tf.matmul(W1, X), b1) 
A1 = tf.nn.relu(Z1) 
A1d = tf.nn.dropout(A1, pkeep) 
Z2 = tf.add(tf.matmul(W2, A1d),b2) 
A2 = tf.nn.relu(Z2) 
A2d = tf.nn.dropout(A2, pkeep) 
Z3 = tf.add(tf.matmul(W3, A2d),b3) 

return Z3 

3) Plus tard, quand tensorflow session est appelé (entre les lignes de code omis pour plus de clarté):

X, Y, pkeep = create_placeholders(n_x, n_y) 

Z3 = forward_propagation(X, parameters, pkeep) 

sess.run([optimizer,cost], feed_dict={X:minibatch_X, Y:minibatch_Y, pkeep: 0.75}) 

Au-dessus courraient sans donner aucune erreur. Cependant, je pense que ce qui précède établirait la valeur pkeep à 0,75 pour les courses d'entraînement et de test. La minibatching est effectuée uniquement sur l'ensemble de données du train, mais je ne définis pas la valeur pkeep nulle part ailleurs. Je voudrais définir pkeep = 0.75 pour la formation et pkeep = 1.0 pour les tests.

4) Il ne donne une erreur quand je fais quelque chose comme ceci:

x_train_eval = Z3.eval(feed_dict={X: X_train, Y: Y_train, pkeep: 0.75}) 

x_test_eval = Z3.eval(feed_dict={X: X_test, Y: Y_test, pkeep: 1.0}) 

Le message d'erreur que je reçois est:

InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'Placeholder_2' with dtype float 
    [[Node: Placeholder_2 = Placeholder[dtype=DT_FLOAT, shape=[], _device="/job:localhost/replica:0/task:0/cpu:0"]()]] 

Quelle est la meilleure façon de passer différents pkeep valeurs pour la formation et les tests? Vos conseils seraient grandement appréciés.

Answer 1

En supposant que vous avez, vous pouvez faire quelque chose comme une opération pour les tests définis comme test_op (par exemple, ce qui permet d'évaluer la précision des données d'entrée et étiquettes):

for i in range(num_iters): 
    # Run your training process. 
    _, loss = sess.run([optimizer, cost], 
         feed_dict={X:minibatch_X, Y:minibatch_Y, pkeep: 0.75}) 
# Test the model after training 
test_accuracy = sess.run(test_op, 
         feed_dict={X:test_X, Y:test_Y, pkeep: 1.0}) 

Fondamentalement, vous ne testez pas la modèle lorsque vous êtes de formation, donc vous pouvez simplement appeler votre test_op lorsque vous êtes prêt à tester, nourrir différentes hyperparam'etres comme pkeep. La même chose vaut pour la validation du modèle périodiquement au cours de la formation sur un ensemble de données détenus sur: tous si souvent exécuter vos op d'évaluation sur l'ensemble de données détenus en passant différentes hyperparam'etres que ceux utilisés au cours de la formation, et vous pouvez enregistrer de configurations ou d'arrêter tôt basé sur votre précision de validation.

Votre test_op pourrait retourner quelque chose comme la précision de prédiction pour un classificateur:

correct = tf.equal(tf.argmax(y, 1), tf.argmax(predict, 1)) 
test_op = tf.reduce_mean(tf.cast(correct, tf.float32)) 

où y sont vos étiquettes cibles et predict est le nom de votre op de prédiction.

Answer 2

Dans les réseaux de neurones, vous propagez avant de calculer les probabilités de logits (chaque étiquette) et le comparer avec la valeur réelle pour obtenir l'erreur.

L'entraînement consiste à minimiser l'erreur, en propageant vers l'arrière, c'est-à-dire en trouvant la dérivée d'erreur par rapport à chaque poids, puis en soustrayant cette valeur de la valeur de poids.

L'application de différents paramètres de suppression est plus facile lorsque vous séparez les opérations nécessaires à la formation et à l'évaluation de votre modèle.

La formation est tout simplement de minimiser la perte:

def loss(logits, labels): 
    ''' 
    Calculate cross entropy loss 
    ''' 
    cross_entropy = tf.nn.softmax_cross_entropy_with_logits(
     labels=labels, logits=logits) 
    return tf.reduce_mean(cross_entropy, name='loss_op') 


def train(loss, learning_rate): 
    ''' 
    Train model by optimizing gradient descent 
    ''' 
    optimizer = tf.train.AdamOptimizer(learning_rate) 
    train_op = optimizer.minimize(loss, name='train_op') 
    return train_op 

L'évaluation est juste le calcul de la précision:

def accuracy(logits, labels): 
    ''' 
    Calculate accuracy of logits at predicting labels 
    ''' 
    correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1)) 
    accuracy_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32), 
           name='accuracy_op') 
    return accuracy_op 

Puis dans votre session de tensorflow, après avoir généré des espaces réservés et en ajoutant les opérations nécessaires à le graphique etc juste alimentent différentes valeurs keep_prob_pl dans les méthodes d'exécution:

# Train model 
sess.run(train_op, feed_dict={x_pl: x_train, y_train: y, keep_prob_pl: 0.75}}) 

# Evaluate test data 
batch_size = 100 
epoch = data.num_examples // batch_size 
acc = 0.0 
for i in range(epoch): 
    batch_x, batch_y = data.next_batch(batch_size) 
    feed_dict = {x_pl: batch_x, y_pl: batch_y, keep_prob_pl: 1} 
    acc += sess.run(accuracy_op, feed_dict=feed_dict) 

print(("Epoch Accuracy: {:.4f}").format(acc/epoch))