TensorFlow Working mechanism

TensorFlow Let's implement machine learning algorithms by creating and computing interactive operations . These interactions form what we call “ Calculation chart ”, Through the calculation diagram, we can intuitively express the complex functional structure .

What is a calculation chart ？

Calculation diagram components ：

• node （ Indicates the operation to be performed ）
• edge  （ For the flow of data ）

Use TensorFlow There are two main steps ：

• Create diagrams
• Execute the diagram

stay TensorFlow When we create related operations in , Not immediately executed , Instead, one node after another is created in the diagram , These nodes record the operations we want to perform , But it will not be carried out .

After completing the description of the calculation diagram , You can run the calculation shown in the diagram . To achieve this , We need to create and run sessions .

• First, in the tf.Session() Start up diagram in
• And then call Session Object's .run() Method completes the run （ This method starts from the output of the request , Then reverse the calculation , Here, the calculation of nodes must be performed according to the dependency set . So the final calculated part of the graph actually depends on our output demand ）
• When the task is completed , Best use sess.close() Command to close session , Ensure that the resources used by the session are freed

Take an example ：

import tensorflow as tf
# Create the first three nodes , Will value 5,2 and 3 Give to a,b,c
a= tf.constant(5)
print(a)
b= tf.constant(2)
print(b)
c=tf.constant(3)
print(c)
# Create the last three nodes , Perform simple arithmetic operations 
d=tf.multiply(a,b)
print(d)
e=tf.add(c,b)
print(e)
f=tf.subtract(d,e)
print(f)
# Execution diagram 
'''sess=tf.Session()
out=sess.run(f)
sess.close()'''
with tf.Session() as sess:
    print(sess.run(a))
    print(sess.run(b))
    print(sess.run(c))
    print(sess.run(d))
    print(sess.run(e))
    print(sess.run(f))

Variable 、 Placeholders and simple optimizations

Variable ：

The function of the optimization process is to adjust the parameters of some given models . So ,TensorFlow Using variables . With others every time you run a session “ Refill ” Data Tensor Objects of different , Variables remain fixed in the graph . It's important , Because their current state may affect their changes in the next iteration . Like other Tensor object , Variables can be used as inputs to other operations in the diagram .

Using variables is done in two stages ：

• First call tf.Variable() Function to create a variable and define the value it will be initialized .
• Then you must use tf.global_variables_initializer() Method to run the session to explicitly perform the initialization operation .

Like other Tensor object , Variables are calculated only when the model is running .

init_val = tf.random_normal((1,5),0,1)
var=tf.Variable(init_val,name='var')
print('pre run\n {} '.format(var))
# When defining variables, you must follow steps   Perform initialization operation   This step is essential 
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print('\n post run:\n{}'.format(sess.run(var)))

Place holder ：

Placeholders are empty variables for filling in data . It can be understood that in the figure, we first create a structure , There is nothing in this structure, just occupying a place in the figure , We can fill these places with the data we want to fill as needed .

The placeholder has an optional shape parameter （shape）. If a shape has no input value or the input value is None, Then the placeholder can be used to input data of any size .

There are two steps to using placeholders ：

• Create placeholders
• input data （ To define a placeholder, you must give it some input values , Otherwise an exception is thrown ）

The input data is passed as a dictionary to session.run() Method , Each key corresponds to a placeholder variable name , Matching values are in list or Numpy Data values given in array form

x_data=np.random.randn(5,10)
w_data=np.random.randn(10,1)
with tf.Graph().as_default():
    # Create placeholders 
    x=tf.placeholder(tf.float32,shape=(5,10))
    w=tf.placeholder(tf.float32,shape=(10,1))
    b=tf.fill((5,1),-1)
    xw=tf.matmul(x,w)
    xwb=xw+b
    s=tf.reduce_max(xwb)
    with tf.Session() as sess:
        # Pass data into placeholders 
        outs=sess.run(s,feed_dict={x:x_data,w:w_data})
print("outs={}".format(outs))