MNIST: x est juste un espace réservé, Comment les données de MNIST vont-elles dans l'espace réservé x?

Question

Ceci est le code des didacticiels senddex: Comment les données du jeu MNIST sont-elles transférées dans l'espace réservé x.

S'il vous plaît aidez-moi, compte tenu que je suis juste un débutant en tensorflow, si cela a quelque chose à voir avec l'espace réservé alors s'il vous plaît expliquer.

Merci d'avance!

""" 
os.environ removes the warning 
""" 
import os 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' 
""" 
tensorflow starts below 
""" 

import tensorflow as tf 

from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/",one_hot=True) 

# 10 classes , 0-9 

""" 
nodes for the hidden layers 
""" 
n_nodes_hl1 = 500 
n_nodes_hl2 = 500 
n_nodes_hl3 = 500 

n_classes = 10 # 0-9 

batch_size = 100 

""" 
placeholders 
""" 

x = tf.placeholder('float',[None,784]) # 784 is 28*28 ,i.e., the size of mnist images 
y = tf.placeholder('float') 


# y is the label of data 

def neural_network_model(data): 


    # biases are added so that the some neurons get fired even when input_data is 0 

    hidden_1_layer = {'weights':tf.Variable(tf.random_normal([784,n_nodes_hl1])),'biases':tf.Variable(tf.random_normal([n_nodes_hl1]))} 
    hidden_2_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl1,n_nodes_hl2])),'biases':tf.Variable(tf.random_normal([n_nodes_hl2]))} 
    hidden_3_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl2,n_nodes_hl3])),'biases':tf.Variable(tf.random_normal([n_nodes_hl3]))} 

    output_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl3,n_classes])), 
    'biases':tf.Variable(tf.random_normal([n_classes]))} 


    # (input_data * weights) + biases 

    l1 = tf.add(tf.matmul(data,hidden_1_layer['weights']) , hidden_1_layer['biases']) 
    l1 = tf.nn.relu(l1) # activation func 

    l2 = tf.add(tf.matmul(l1,hidden_2_layer['weights']) , hidden_2_layer['biases']) 
    l2 = tf.nn.relu(l2) # activation func 

    l3 = tf.add(tf.matmul(l2,hidden_3_layer['weights']) , hidden_3_layer['biases']) 
    l3 = tf.nn.relu(l3) # activation func 

    output = tf.matmul(l3,output_layer['weights']) + output_layer['biases'] 

    return output 

# we now have modeled a neural network 

def train_neural_network(x): 
    prediction = neural_network_model(x) 
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction,labels=y)) 
    # softmax_cross_entropy_with_logits ==> for changing weights 
    # we wanna minimize the difference 

    # AdamOptimizer optionally has a learning_reate : 0.0001 
    optimizer = tf.train.AdamOptimizer().minimize(cost) 

    hm_epochs = 5 # cycles of feed forward + back 

    with tf.Session() as sess: 
     sess.run(tf.global_variables_initializer()) # replace it with global_variable_initializer 

     for epoch in range(hm_epochs): 
      epoch_loss = 0 
      for _ in range(int(mnist.train.num_examples/batch_size)): 
       epoch_x,epoch_y = mnist.train.next_batch(batch_size) 
       _,c = sess.run([optimizer, cost], feed_dict = {x: epoch_x, y: epoch_y}) 
       epoch_loss += c 
      print('Epoch',epoch,'completed out of',hm_epochs,' loss:',epoch_loss) 


     correct = tf.equal(tf.argmax(prediction,1),tf.argmax(y,1)) 
     accuracy = tf.reduce_mean(tf.cast(correct,'float')) # cast changes the data type of a tensor 
     print('Accuracy: ',accuracy.eval({x:mnist.test.images,y:mnist.test.labels})) 


if __name__ == "__main__": 
    train_neural_network(x) 

Answer 1

Pour voir où les données de MNIST est transféré dans les tf.placeholder() tenseurs x et y, se concentrer sur ces lignes:

for _ in range(int(mnist.train.num_examples/batch_size)): 
    epoch_x, epoch_y = mnist.train.next_batch(batch_size) 
    _, c = sess.run([optimizer, cost], feed_dict = {x: epoch_x, y: epoch_y}) 

Les tableaux epoch_x et epoch_y sont une paire de (un peu confusément nommé) NumPy tableaux qui contiennent un lot de batch_size images et étiquettes respectivement à partir du MNIST formation ensemble de données. Ils contiendront un lot différent dans chaque itération de la boucle for.

L'argument feed_dict-sess.run() dit tensorflow de remplacer la valeur de epoch_x pour espace réservé x, et la valeur de epoch_y pour espace réservé y. TensorFlow utilisera donc ces valeurs pour exécuter une étape de l'algorithme d'optimisation (Adam, dans ce cas).

Notez que les données de MNIST est également utilisé sur cette ligne:

print('Accuracy: ', accuracy.eval({x: mnist.test.images, y: mnist.test.labels})) 

... sauf qu'ici le programme utilise l'ensemble essai ensemble de données pour évaluer la précision du modèle.