Ensure that you have installed pip; if have not, please use the following commands to install the Python package installation manager for Ubuntu/Linux:

# Ubuntu/Linux 64-bit 
$ sudo apt-get install python-pip python-dev

For Mac OS, you would use the following commands:

# macOS 
$ sudo easy_install pip 
$ sudo easy_install --upgrade six

Note, for Ubuntu/Linux, you may also want to upgrade pip as the pip within the Ubuntu repository is old and may not be compatible with newer packages. To do this, you can run the command:

# Ubuntu/Linux pip upgrade
$ pip install --upgrade pip 

To install TensorFlow (with pip already installed), you only need to execute the following command:

$ pip install tensorflow

If you have a computer that has GPU support, you can instead use the following command:

$ pip install tensorflow-gpu

Note that if the preceding command does not work, there are specific instructions to install TensorFlow with GPU support based on your Python version (that is, 2.7, 3.4, or 3.5) and GPU support.

For example, if I wanted to install TensorFlow on Python 2.7 with GPU enabled on Mac OS, execute the following commands:

# macOS, GPU enabled, Python 2.7: 
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow_gpu-0.12.0rc1-py2-none-any.whl
# Python 2 
$ sudo pip install --upgrade $TF_BINARY_URL

To better describe tensors and how TensorFlow works, let's start with a matrix multiplication calculation involving two constants. As noted in the following diagram, we have c 1 (3x1 matrix) and c 2 (1x3 matrix), where the operation (op 1) is a matrix multiplication:

We will now define c 1 (1x3 matrix) and c 2 (3x1 matrix) using the following code:

# Import TensorFlow
import tensorflow as tf
# Setup the matrix
#   c1: 1x3 matrix
#   c2: 3x1 matrix
c1 = tf.constant([[3., 2., 1.]])
c2 = tf.constant([[-1.], [2.], [1.]])

Now that we have our constants, let's run our matrix multiplication using the following code. Within the context of a TensorFlow graph, recall that the nodes in the graph are called operations (or ops). The following matrix multiplication is the ops, while the two matrices (c 1, c 2) are the tensors (typed multi-dimensional array). An op takes zero or more tensors as its input, performs the operation such as a mathematical calculation, with the output being zero or more tensors in the form of numpy ndarray objects (http://www.numpy.org/) or tensorflow::Tensor interfaces in C, C++:

# m3: matrix multiplication (m1 x m3)
mp = tf.matmul(c1, c2)

Now that this TensorFlow graph has been established, execution of this operation (for example, in this case, the matrix multiplication) is done within the context of a session; the session places the graph ops into the CPU or GPU (that is, devices) to be executed:

# Launch the default graph
s = tf.Session()

# run: Execute the ops in graph
r = s.run(mp)
print(r)

With the output being:

# [[ 2.]]

Once you have completed your operations, you can close the session:

# Close the Session when completed
s.close()

Now we will perform the same task as before, except this time, we will use tensors instead of constants. As noted in the following diagram, we will start off with two matrices (m1: 3x1, m2: 1x3) using the same values as in the previous section:

Within TensorFlow, we will use placeholder to define our two tensors as per the following code snippet:

# Setup placeholder for your model
#   t1: placeholder tensor
#   t2: placeholder tensor
t1 = tf.placeholder(tf.float32)
t2 = tf.placeholder(tf.float32)

# t3: matrix multiplication (m1 x m3)
tp = tf.matmul(t1, t2)

The advantage of this approach is that, with placeholders you can use the same operations (that is, in this case, the matrix multiplication) with tensors of different sizes and shape (provided they meet the criteria of the operation). Like the operations in the previous section, let's define two matrices and execute the graph (with a simplified session execution).

# Define input matrices
m1 = [[3., 2., 1.]]
m2 = [[-1.], [2.], [1.]]

# Execute the graph within a session
with tf.Session() as s:
     print(s.run([tp], feed_dict={t1:m1, t2:m2}))

[array([[ 2.]], dtype=float32)]

Running another model

Now that we have a graph (albeit a simple one) using placeholders, we can use different tensors to perform the same operation using different input matrices. As noted in the following figure, we have m1 (4x1) and m2 (1x4):

Because we're using placeholders, we can easily reuse the same graph within a new session using new input:

# setup input matrices
m1 = [[3., 2., 1., 0.]]
m2 = [[-5.], [-4.], [-3.], [-2.]]
# Execute the graph within a session
with tf.Session() as s:
     print(s.run([tp], feed_dict={t1:m1, t2:m2}))

With the output being:

[array([[-26.]], dtype=float32)]

As noted previously, TensorFlow provides users with the ability to perform deep learning using Python libraries by representing computations as graphs where the tensors represent the data (edges of the graph) and operations represent what is to be executed (for example, mathematical computations) (vertices of the graph).

For more information, please refer to: