An Introduction to TensorFlow Programming in Python

0
1618

Deep learning is now widely used for the development of intelligent systems and has become a powerful tool for Big Data analysis. TensorFlow is the leading open source software for deep learning and is used for computer based natural language processing (NLP), computer vision, speech recognition, fault diagnosis, predictive maintenance, mineral exploration and much more.

This article will acquaint readers with the basic environment of TensorFlow, its computational library, and with dataflow graphs, which will help them with its advanced applications. Since TensorFlow’s computational environment is graph based processing, it is of utmost necessity to understand it at the outset. Here we shall learn how graph based computing in TensorFlow is performed within a Python Anaconda environment. TensorFlow building blocks are constants, placeholders and variables, all of which form the graph based machine learning computation environment where computing operations interact with each other.

A higher level TensorFlow API assists in building prototype models, but the knowledge of lower level TensorFlow core is valuable for experimentation and debugging code. It gives an inner view of the operation model of the code, which helps us to understand the code using higher level APIs.

Graphs and sessions
TensorFlow uses a dataflow graph to represent all computations in terms of the dependencies between individual operations. At the outset, programming requires a dataflow graph to define all operations, after which a TensorFlow session is created to run parts of the graph across a set of local and remote devices. High level APIs such as tf.estimator.Estimator and Keras hide the details of graphs and sessions from the end user. Low level programming is useful to understand how the graph model works under the process session.
In a dataflow graph, the nodes represent units of computation and the edges represent the data consumed or produced by a computation. For example, in a matrix multiplication operation, tf.matmul is a node in a TensorFlow graph and the multiplicand, multiplier and the result of multiplication are the three edges. This dataflow graph processing environment is helpful for distributed and parallel computing. It also speeds up the compilation process to convert the graph to code. Since the dataflow graph is a language-independent representation of the entire process environment, it is portable amongst different programming platforms. The dataflow representation of a process environment can be saved in one programming environment and transported to another programming environment.
The TensorFlow token tf.Graph contains dual information — the graph structure and graph collection. Using nodes and edges, the graph structure represents the composition of each individual operation, but it does not prescribe the methods of their use. Graph collections, on the other hand, provide a general mechanism for storing a collection of metadata within the graph. The graph collection mechanism provides ways to add and view relevant objects to and from key fields.

Creating a graph
In general, a TensorFlow program starts with a graph building phase. During this process, the API adds a new node and edge to a default graph instance. For example, a ts.constant(x) creates a single operation to produce x, then adds the value to the default graph and returns a tensor that represents the constant value. In the case of a variable, tf.Variable(0) adds an operation to store a writeable tensor value. The variable survives in between two session runs (tf.Session.run). If we consider a matrix multiplication operation tf.matmul(a,b), then it will create and add a matrix multiplication operation to the default graph to multiply matrices a and b. It will return a tensor tf.Tensor to represent the multiplication.
In most cases a default graph is sufficient to run a program, but in the case of multiple graphs, API tf.estimator is used to manage the default graph, and it uses different graphs for training and evaluation.

Session
An interactive session TensorFlow class is used in interactive contexts, such as a shell. This is convenient in interactive shells and IPython notebooks, as it is not required to pass an explicit session object to run an operation. The following example shows how a tensor constant c can be evaluated without an explicit call to a ‘session run’ operation. ‘Method close’ terminates an open interactive session.

sess = tf.InteractiveSession()
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a * b
# We can just use ‘c.eval()’ without passing ‘sess’
print(c.eval())
sess.close()

In the case of a regular session activation using a with statement, in non-interactive programs the tensor object is executed as follows:

a = tf.constant(5.0)
b = tf.constant(6.0)
c = a * b
with tf.Session():
# We can also use ‘c.eval()’ here.
print(c.eval())

Session method as_default returns a context manager that makes the session object a default session. When used by the with keyword tf.Operation.run or tf.Tensor.eval should be executed in this session.

c = tf.constant(599)
sess = tf.Session()
with sess.as_default():
#assert tf.get_default_session() is sess
print(c.eval())

Since the as_default context manager does not close the session upon exit from the context, it is mandatory to close the session explicitly on exiting the context. This can be avoided by invoking the session with tf.Session() directly within the ‘with statement’. This class closes the session upon exiting from the context.
The default session is a property of the current thread. To attach the default session to a new thread, it is necessary to explicitly use with sess.as_default() in that thread. In the case of multiple graphs, if sess.graph() is different from the default graph (tf_get_default_graph), it is necessary to set sess.graph.as_default() for that graph.

list_devices
Session method list_devices() lists available devices in an activated session.

devices = sess.list_devices()
for d in devices:
print(d.name)

This will display the full name of the device along with its type and the maximum amount of memory available. For example, a typical display of the above script may be
/job:localhost/replica:0/task:0/device:CPU:0.

Slice
This operation is performed with tf.slice(), and it extracts a slice from a tensor object starting at the marked template location. The slice size is represented as a tensor shape, where size[i] is the number of elements of the ith dimension of the input that are to be sliced. The starting location begin of a slice is an offset in each dimension of the input. This starting location is zero-based, whereas the size is one-based. A value -1 of size[i] indicates that all remaining elements in dimension i are included in the slice and can be written as:

size[i] = input.dim_size(i) - begin[i]

For example:

t = tf.constant([[[1, 1, 1], [2, 2, 2]],
[[3, 3, 3], [4, 4, 4]],
[[5, 5, 5], [6, 6, 6]]])
init_op = tf.global_variables_initializer()
withtf.Session() as sess:
sess.run(init_op)

tf.slice(t, [1, 0, 0], [1, 1, 3]) 
tf.slice(t, [1, 0, 0], [1, 2, 3]) 
tf.slice(t, [1, 0, 0], [2, 1, 3])

init_op = tf.global_variables_initializer()

withtf.Session() as sess:
sess.run(init_op)
print( “Slice 1:”,sess.run(tf.slice(t, [1, 0, 0], [1, 1, 3])),”\n”)

withtf.Session() as sess:
sess.run(init_op)
print( “Slice 2:”,sess.run(tf.slice(t, [1, 0, 0], [1, 2, 3])),”\n”)

withtf.Session() as sess:
sess.run(init_op)
print( “Slice 2:”,sess.run(tf.slice(t, [1, 0, 0], [2, 1, 3])),”\n”)Conclusion
Output:
Slice 1: [[[3 3 3]]] 
Slice 2: [[[3 3 3]
[4 4 4]]] 
Slice 2: [[[3 3 3]]
[[5 5 5]]]

Placeholder
A placeholder is simply a variable that we will assign data at a later state. It allows us to create our operations and build our computation graphs, without needing the data. In TensorFlow terminology, we then feed data into the graph through these placeholders.

import tensorflow as tf 
x = tf.placeholder(“float”, None)
y = x + 2.5
withtf.Session() as session:
result = session.run(y, feed_dict={x: [1, 2, 3]})
print(result)

Output:

[3.5 4.5 5.5]

The first line creates a placeholder called x. It reserves a place in memory to store values at a later stage. This is used only to define the structure in the memory and no initial value is assigned into that location. Then a tensor call is used for adding x with 2.5. At a later stage, one can use this storage space and the defined operation to perform a vector addition. For this it is necessary to initiate a session and execute the defined operation within the session for a set of values of x.
Running y requires values of x. This can be assigned to run inside the feed_dict argument. Here, values of x are [1, 2, 3]. The run of the session of y will produce [3.5 4.5 5.5].
A larger graph consisting of numerous computations can be divided into small segments of atomic operations, and each of these operations can be performed individually. Such partial executions of a larger graph operation are an exclusive feature of TensorFlow and are not available in many other libraries that do similar jobs. During operation, placeholders do not require any static shape and can hold values of any length.

import tensorflow as tf 
x = tf.placeholder(“float”, None)
y = x + 2.5
with tf.Session() as session:
result = session.run(y, feed_dict={x: [1, 2, 3, 4]})
print(result)

This script will run for four values of vector x and will produce: [3.5 4.5 5.5 6.5].
To perform the same operation of adding 2.5 with an array of three columns with no upper boundary for the number of rows, one can modify the above script as follows:

x = tf.placeholder(“float”, [None, 3]) 
y = x + 5

with tf.Session() as session:
x_data = [[2, 3, 1],
[4, 7, 6],]
result = session.run(y, feed_dict={x: x_data})
print(result)

Output:

[[ 7. 8. 6.]
[ 9. 12. 11.]]

The placeholder can be extended to an arbitrary number of None dimensions. For example, to load an RGB image, a placeholder needs to have three slices to store all the three RGB image planes. Therefore, the placeholder needs two None for the first two dimensions and three for the last dimension. Then TensorFlow’s slice method can be used to take a sub-segment out of the image.

importmatplotlib.image as mpimg
importmatplotlib.pyplot as plt
import os

# First, load the image again
dir_path = os.path.dirname(os.path.realpath(__file__))

filename = dir_path + “\MarshOrchid.jpg”

print(dir_path)

raw_image_data = mpimg.imread(filename)
print(raw_image_data.shape)
plt.imshow(raw_image_data)
plt.show()
image = tf.placeholder(“int32”, [None, None, 3])
slice = tf.slice(image, [0, 0, 0], [300, -1, 1])

withtf.Session() as session:
result = session.run(slice, feed_dict={image: raw_image_data})
print(result.shape)

plt.imshow(result)
plt.show()

Variables
In TensorFlow, variables are used to manage data. A TensorFlow variable is the best way to represent shared and persistent tensor states to be manipulated by a program. Specific operations are required to read and modify the values of this tensor. Since a tf.Variable exists outside the context of a single session.run call, modified values are visible across multiple tf.Session, and multiple users can view the same values. These variables can be accessed via the tf.Variable class objects.
Many parts of the TensorFlow library use this facility. For example, when a variable is created, it is added by default to collections representing global variables and trainable variables. When in later stages tf.train.Saver or tf.train.Optimizer are created, the variables in these collections are used as the default arguments.

Variable initialisers
Global tensor variables can be initialised using the following TensorFlow methods:

tf.global_variables_initializer
tf.initializers.global_variables
tf.initializers.global_variables()

There is an alternative shortcut to implicitly initialise a variable list. The shortcut is tf.variables_initializer(var_list, name=’init’). If there is no definition of the variables before calling tf.global_variables_initializer, the variable list is essentially empty.
The code below illustrates this:

import tensorflow as tf

with tf.Graph().as_default():
# Nothing is printed
for v in tf.global_variables():
print(“List Global variable 1”, v,”\n”)


init_op = tf.global_variables_initializer()

a = tf.Variable(0)
b = tf.Variable(0)
c = tf.Variable(0)

init_op = tf.global_variables_initializer()

# 3 Variables are printed here
for v in tf.global_variables():
print(“List Global Variable 2”, v,”\n”)

with tf.Session() as sess:
sess.run(init_op)
print( “List session”,sess.run(a),”\n”)

Execution of this script will not generate the variable list of the first loop, whereas the second for-loop will iterate four times over the global variable list and will display the variable graph in four lines.

init_op = tf.global_variables_initializer()

After this, the following lines:

a = tf.Variable(0)
b = tf.Variable(0)
c = tf.Variable(0)
d = tf.Variable(0)

…will initialise all the global variables lists for further processing of the graph.

A simple mathematical operation
Here is an example of a simple TensorFlow mathematical operation using variables a and b:

a = tf.Variable([4])
b = tf.Variable([7])
with tf.Session() as session:
session.run(tf.global_variables_initializer())
b = a + b
result = session.run(a)
print(a)
result = session.run(b)
print(b)
print(session.run(a))
print(session.run(b))

TensorFlow software is a new programming concept designed on graph based computing. This article is an introductory tutorial to understand this open source programming environment. The building blocks of this computing environment have been discussed with simple examples. The reader will hopefully get an idea of TensorFlow programming from this brief introduction.

Advertisement

LEAVE A REPLY

Please enter your comment!
Please enter your name here