Walidacja i test z TensorFlow

Question

Stworzyłem jedną ukrytą warstwę sieci neuronowej o architekturze piramidalnej za pomocą TensorFlow. Oto kod:

num_classes = 10 
image_size = 28 

#Read the data 
train_dataset, train_labels, valid_dataset, valid_labels, test_dataset, test_labels = OpenDataSets("...") 
#Create and convert what is needed. 
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) 

#Then I create the NN. 
Wh = tf.Variable(tf.truncated_normal([image_size * image_size, image_size * image_size/2])) 
bh = tf.Variable(tf.truncated_normal([image_size * image_size/2])) 
hidden = tf.nn.relu(tf.matmul(tf_train_dataset, Wh) + bh) 

Wout = tf.Variable(tf.truncated_normal([image_size * image_size/2, num_labels])) 
bout = tf.Variable(tf.truncated_normal([num_labels])) 
logits = tf.nn.relu(tf.matmul(hidden, Wout) + bout) 

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)) 
optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss) 
train_prediction = tf.nn.softmax(logits) 

A teraz trenuję moją NN:

with tf.Session(graph=graph) as session: 
    tf.initialize_all_variables().run() 
    for step in range(1000): 
     offset = (step * batch_size) % (train_labels.shape[0] - batch_size) 
     batch_data = train_dataset[offset:(offset + batch_size), :] 
     batch_labels = train_labels[offset:(offset + batch_size), :] 
     feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels} 
     _, l, predictions = session.run([optimizer, loss, train_prediction], feed_dict=feed_dict) 

teraz chciałbym do sprawdzania i testowania mojego NN po treningu. Ale nie wiem, jak utworzyć nowy feed_dict i użyć session.run w celu sprawdzenia poprawności/testu.

Dzięki za pomoc!

Answer 1

Najpierw należy utworzyć odpowiednie funkcje tensora sprawdzania/testowania. W przypadku jednowarstwowego MPL polega ono na zagnieżdżaniu pomnożonym przez wagi i dodawaniu błędów (a także Relu, ponieważ masz je w oryginalnym modelu). Definiować te tuż pod swoimi przewidywaniami kolejowych

valid_prediction = tf.nn.softmax(
         tf.nn.relu(tf.matmul(
         tf.nn.relu(tf.matmul(tf_valid_dataset, Wh) + bh)), Wout) + bout))) 
test_prediction = tf.nn.softmax(
         tf.nn.relu(tf.matmul(
         tf.nn.relu(tf.matmul(tf_test_dataset, Wh) + bh)), Wout) + bout))) 

Wyrażenia te są w rzeczywistości zupełnie identycznym logit zmiennej zdefiniowanej w kodzie, tylko przy użyciu tf_valid_dataset i tf_test_dataset odpowiednio. Możesz utworzyć pośrednie zmienne, aby je uprościć.

Następnie należy utworzyć funkcję sprawdzania poprawności/testu, aby sprawdzić dokładność. Najprostszym byłoby przetestowanie najprawdopodobniej przewidywanej klasy (w przybliżeniu błąd klasyfikacji błędów). Zdefiniuj to poza wykresem/sesją.

def accuracy(predictions, labels): 
     pred_class = np.argmax(predictions, 1) 
     true_class = np.argmax(labels, 1) 
     return (100.0 * np.sum(pred_class == true_class)/predictions.shape[0]) 

Po tym można po prostu przekazać tę funkcję dokładności wewnątrz tej samej sesji/feed_dict, aby obliczyć wynik weryfikacji/testu.

print 'Validation accuracy: %.1f%%' % accuracy(valid_prediction.eval(), valid_labels) 
print 'Test accuracy: %.1f%%' % accuracy(test_prediction.eval(), test_labels)