Chapter 10. Library Installation and Additional Tips

• An AMD64-based image running on the cloud
• An AMD64 instruction capable computer (commonly called a 64 bit processor)

In order to install TensorFlow and all its dependencies, we only need a simple command line (as long as we have implemented the preparation task).

So this is the required command line, for the standard Python 2.7:

$ sudo pip install --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.9.0-cp27-none-linux_x86_64.whl

Then you will find the different dependent packages being downloaded and if no problem is detected, a corresponding message will be displayed:

Pip installation output

After the installation steps we can do a very simple test, calling the Python interpreter, and then importing the TensorFlow library, defining two numbers as a constant, and getting its sum after all:

$ python
>>> import tensorflow as tf
>>> a = tf.constant(2)
>>> b = tf.constant(20)
>>> print(sess.run(a + b))

In order to install the GPU-supporting TensorFlow libraries, first you have to perform all the steps in the section the GPU support, from Install from source.

Then you will invoke:

$ sudo pip install -upgrade https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.10.0rc0-cp27-none-linux_x86_64.whl

They follow the following form:

https://storage.googleapis.com/tensorflow/linux/[processor type]/tensorflow-[version]-cp[python version]-none-linux_x86_64.whl

1. Set the LC_ALL variable:

   $ export LC_ALL=C
   

2. Install the virtualenv Ubuntu package from the installer:

   $ sudo apt-get install python-virtualenv
   

3. Install the virtualenv package:

   virtualenv --system-site-packages ~/tensorflow
   

4. Then to make use of the new TensorFlow, you will always need to remember to activate the TensorFlow environment:

   source ~/tensorflow/bin/activate
   

5. Then install the tensorflow package via pip:

   pip install --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.9.0-cp27-none-linux_x86_64.whl
   

Here we will do a minimal test of TensorFlow.

First, we will activate the newly-created TensorFlow environment:

$ source ~/tensorflow/bin/activate

Then, the prompt will change with a (tensorflow) prefix, and we can execute simple code which loads TensorFlow, and sums two values:

(tensorflow) $ python
>>> import tensorflow as tf
>>> a = tf.constant(2)
>>> b = tf.constant(3)
>>> print(sess.run(a * b))
6

After your work is done, and if you want to return to normal environment, you can simply deactivate the environment:

(tensorflow)$ deactivate

First of all, we will install docker via the apt package:

sudo apt-get install docker.io

In this step, we create a Docker group to be able to use Docker as a user:

sudo groupadd docker

Then we add the current user to the Docker group:

sudo usermod -aG docker [your user]

After this step, a reboot is needed for the changes to apply.

After the reboot, you can try calling the hello world Docker example, with the command line:

$ docker run hello-world

Docker Hello World container

Then we run (and install if it was not installed before) the TensorFlow binary image (in this case the vanilla CPU binary image):

docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow

TensorFlow installation via PIP

After the installation is finished, you will see the final installation steps, and Jupyter notebook starting:

Git is one of the most well-known source code version managers in existence, and is the one chosen by Google, publishing its code on GitHub.

In order to download the source code of TensorFlow, we will first install the Git source code manager:

$ sudo apt-get install git

Bazel (bazel.io) is a build tool, based on the internal build tool Google has used for more than seven years, known as Blaze, and released as beta on September 9, 2015.

It is additionally used as the main build tool in TensorFlow, so in order to do some advanced tasks, a minimal knowledge of the tool is needed.

Adding the Bazel distribution URI as a package source

First we will add the Bazel repository to the list of available repositories, and its respective key to the configuration of the apt tool, which manages dependencies on the Ubuntu operating system.

$ echo "deb http://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
$ curl https://storage.googleapis.com/bazel-apt/doc/apt-key.pub.gpg | sudo apt-key add -

Bazel installation

$ sudo apt-get update && sudo apt-get install bazel

This section will teach us to install the required packages needed to have GPU support in our Linux setup.

Actually the only way to get GPU computing support is through CUDA.

Check that the nouveau NVIDIA graphic card drivers don't exist. To test this, execute the following command and check if there is any output:

lsmod | grep nouveau

If there is no output, see Installing CUDA system packages, if not, execute the following commands:

$ echo -e "blacklist nouveau\nblacklist lbm-nouveau\noptions nouveau modeset=0\nalias nouveau off\nalias lbm-nouveau off\n" | sudo tee /etc/modprobe.d/blacklist-nouveau.conf
$ echo options nouveau modeset=0 | sudo tee -a /etc/modprobe.d/nouveau-kms.conf
$ sudo update-initramfs -u
$ sudo reboot (a reboot will occur)

The first step is to install the required packages from the repositories:

sudo apt-get install -y linux-source linux-headers-`uname -r` 
nvidia-graphics-drivers-361
nvidia-cuda-dev
sudo apt install nvidia-cuda-toolkit
sudo apt-get install libcupti-dev

sudo apt-get install linux-image-extra-virtual

sudo mkdir /usr/local/cuda
cd /usr/local/cuda
sudo ln -s /usr/lib/x86_64-linux-gnu/ lib64
sudo ln -s /usr/include/ include
sudo ln -s /usr/bin/ bin
sudo ln -s /usr/lib/x86_64-linux-gnu/ nvvm
sudo mkdir -p extras/CUPTI
cd extras/CUPTI
sudo ln -s /usr/lib/x86_64-linux-gnu/ lib64
sudo ln -s /usr/include/ include
sudo ln -s /usr/include/cuda.h /usr/local/cuda/include/cuda.h
sudo ln -s /usr/include/cublas.h /usr/local/cuda/include/cublas.h
sudo ln -s /usr/include/cudnn.h /usr/local/cuda/include/cudnn.h
sudo ln -s /usr/include/cupti.h /usr/local/cuda/extras/CUPTI/include/cupti.h
sudo ln -s /usr/lib/x86_64-linux-gnu/libcudart_static.a /usr/local/cuda/lib64/libcudart_static.a
sudo ln -s /usr/lib/x86_64-linux-gnu/libcublas.so /usr/local/cuda/lib64/libcublas.so
sudo ln -s /usr/lib/x86_64-linux-gnu/libcudart.so /usr/local/cuda/lib64/libcudart.so
sudo ln -s /usr/lib/x86_64-linux-gnu/libcudnn.so /usr/local/cuda/lib64/libcudnn.so
sudo ln -s /usr/lib/x86_64-linux-gnu/libcufft.so /usr/local/cuda/lib64/libcufft.so
sudo ln -s /usr/lib/x86_64-linux-gnu/libcupti.so /usr/local/cuda/extras/CUPTI/lib64/libcupti.so

$ wget http://developer.download.nvidia.com/compute/redist/cudnn/v5/cudnn-7.5-linux-x64-v5.0-ga.tgz

$ sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64
$ sudo cp cuda/include/cudnn.h /usr/local/cuda/include/

Finally, we arrive at the task of getting TensorFlow source code.

Getting it is as easy as executing the following command:

$ git clone https://github.com/tensorflow/tensorflow

Git installation

Then we access the tensorflow main directory:

$ cd tensorflow

And then we simply run the configure script:

$ ./configure

In the following figure you can see the answers to most of the questions (they are almost all enters and yes)

CUDA configuration

So we are now ready to proceed with the building of the library.

TF_UNOFFICIAL_SETTING=1 ./configure

After all the preparation steps, we will finally compile TensorFlow. The following line could get your attention because it refers to a tutorial. The reason we build the example is that it includes the base installation, and provides a means of testing if the installation worked.

Run the following command:

$ bazel build -c opt --config=cuda //tensorflow/cc:tutorials_example_trainer

Now it is time to test the installation. From the main tensorflow installation directory, just execute the following command:

$ bazel-bin/tensorflow/cc/tutorials_example_trainer --use_gpu

This is a sample representation of the commands output:

TensorFlow GPU test

Windows installation

The current URL for the installer is located at https://github.com/docker/toolbox/releases/download/v1.12.0/DockerToolbox-1.12.0.exe.

After executing the installer, we will see the first installation screen:

Docker Toolbox installation first screen

Docker toolbox installer path chooser

Then we select all the components we will need in our installation:

Docker Toolbox package selection screen

After various installation operations, our Docker installation will be ready:

Docker toolbox installation final screen

In order to create the initial machine, we will execute the following command in the Docker Terminal:

docker-machine create vdocker -d virtualbox

Docker initial image installation

Then, in a command window, type the following:

FOR /f "tokens=*" %i IN ('docker-machine env --shell cmd vdocker') DO %i docker run -it b.gcr.io/tensorflow/tensorflow

This will print and read a lot of variables needed to run the recently-created virtual machine.

Then finally, to install the tensorflow container, we proceed as we did with the Linux counterpart, from the same console:

docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow

run -it -p 8888:8888 gcr.io/tensorflow/tensorflow bash

MacOS X installation

Summary