The TensorFlow programming model signifies how to structure your predictive models. A TensorFlow program is generally divided into four phases when you have imported the TensorFlow library:

These main phases define the programming model in TensorFlow. Consider the following example, in which we want to multiply two numbers:

import tensorflow as tf # Import TensorFlow

x = tf.constant(8) # X op
y = tf.constant(9) # Y op
z = tf.multiply(x, y) # New op Z

sess = tf.Session() # Create TensorFlow session

out_z = sess.run(z) # execute Z op
sess.close() # Close TensorFlow session
print('The multiplication of x and y: %d' % out_z)# print result

The preceding code segment can be represented by the following figure:

Figure 5: A simple multiplication executed and returned on a client-master architecture

To make the preceding program more efficient, TensorFlow also allows exchanging data in your graph variables through placeholders (to be discussed later). Now imagine the following code segment that does the same thing but more efficiently:

import tensorflow as tf

# Build a graph and create session passing the graph
with tf.Session() as sess:
    x = tf.placeholder(tf.float32, name="x")
    y = tf.placeholder(tf.float32, name="y")
    z = tf.multiply(x,y)

# Put the values 8,9 on the placeholders x,y and execute the graph
z_output = sess.run(z,feed_dict={x: 8, y:9})
print(z_output)

TensorFlow is not necessary for multiplying two numbers. Also, there are many lines of code for this simple operation. The purpose of the example is to clarify how to structure code, from the simplest (as in this instance) to the most complex. Furthermore, the example also contains some basic instructions that we will find in all the other examples given in this book.

This single import in the first line imports TensorFlow for your command; it can be instantiated with tf, as stated earlier. The TensorFlow operator will then be expressed by tf and by the name of the operator to use. In the next line, we construct the session object by means of the tf.Session() instruction:

with tf.Session() as sess:

This object contains the computation graph, which, as we said earlier, contains the calculations to be carried out. The following two lines define variables x and y, using a placeholder. Through a placeholder, you may define both an input (such as the variable x of our example) and an output variable (such as the variable y):

x = tf.placeholder(tf.float32, name="x")
y = tf.placeholder(tf.float32, name="y")

To define a data or tensor (we will introduce you to the concept of tensor soon) via the placeholder function, three arguments are required:

So, we can introduce the model that we want to compute with two arguments, the placeholder and the constant, that were previously defined. Next, we define the computational model.

The following statement, inside the session, builds the data structure of the product of x and y, and the subsequent assignment of the result of the operation to tensor z. Then it goes as follows:

     z = tf.multiply(x, y)

Since the result is already held by the placeholder z, we execute the graph through the sess.run statement. Here, we feed two values to patch a tensor into a graph node. It temporarily replaces the output of an operation with a tensor value:

z_output = sess.run(z,feed_dict={x: 8, y:9})

In the final instruction, we print the result:

     print(z_output)

This prints the output, 72.0.

tf.enable_eager_execution(
        config=None,
        device_policy=None
)

import tensorflow as tf

x = tf.placeholder(tf.float32, shape=[1, 1]) # a placeholder for variable x
y = tf.placeholder(tf.float32, shape=[1, 1]) # a placeholder for variable y
m = tf.matmul(x, y)

with tf.Session() as sess:
    print(sess.run(m, feed_dict={x: [[2.]], y: [[4.]]}))

>>>
8.

import tensorflow as tf

# Eager execution (from TF v1.7 onwards):
tf.eager.enable_eager_execution()
x = [[2.]]
y = [[4.]]
m = tf.matmul(x, y)

print(m)

>>>
tf.Tensor([[8.]], shape=(1, 1), dtype=float32)