## Understanding order of execution and control dependencies As we discussed in the first item, TensorFlow doesn't immediately run the operations that are defined but rather creates corresponding nodes in a graph that can be evaluated with Session.run() method. This also enables TensorFlow to do optimizations at run time to determine the optimal order of execution and possible trimming of unused nodes. If you only have tf.Tensors in your graph you don't need to worry about dependencies but you most probably have tf.Variables too, and tf.Variables make things much more difficult. My advice to is to only use Variables if Tensors don't do the job. This might not make a lot of sense to you now, so let's start with an example. ```python import tensorflow as tf a = tf.constant(1) b = tf.constant(2) a = a + b tf.Session().run(a) ``` Evaluating "a" will return the value 3 as expected. Note that here we are creating 3 tensors, two constant tensors and another tensor that stores the result of the addition. Note that you can't overwrite the value of a tensor. If you want to modify it you have to create a new tensor. As we did here. *** __TIP__: If you don't define a new graph, TensorFlow automatically creates a graph for you by default. You can use tf.get_default_graph() to get a handle to the graph. You can then inspect the graph, for example by printing all its tensors: ```python print(tf.contrib.graph_editor.get_tensors(tf.get_default_graph())) ``` *** Unlike tensors, variables can be updated. So let's see how we may use variables to do the same thing: ```python a = tf.Variable(1) b = tf.constant(2) assign = tf.assign(a, a + b) sess = tf.Session() sess.run(tf.global_variables_initializer()) print(sess.run(assign)) ``` Again, we get 3 as expected. Note that tf.assign returns a tensor representing the value of the assignment. So far everything seemed to be fine, but let's look at a slightly more complicated example: ```python a = tf.Variable(1) b = tf.constant(2) c = a + b assign = tf.assign(a, 5) sess = tf.Session() for i in range(10): sess.run(tf.global_variables_initializer()) print(sess.run([assign, c])) ``` Note that the tensor c here won't have a deterministic value. This value might be 3 or 7 depending on whether addition or assignment gets executed first. You should note that the order that you define ops in your code doesn't matter to TensorFlow runtime. The only thing that matters is the control dependencies. Control dependencies for tensors are straightforward. Every time you use a tensor in an operation that op will define an implicit dependency to that tensor. But things get complicated with variables because they can take many values. When dealing with variables, you may need to explicitly define dependencies using tf.control_dependencies() as follows: ```python a = tf.Variable(1) b = tf.constant(2) c = a + b with tf.control_dependencies([c]): assign = tf.assign(a, 5) sess = tf.Session() for i in range(10): sess.run(tf.global_variables_initializer()) print(sess.run([assign, c])) ``` This will make sure that the assign op will be called after the addition.