Configuring Ubuntu 18.04 + CUDA 10.0 + NVIDIA GPU For Deep Learning With Tensorflow & OpenCV Python Bindings

This guide will essentially adapt existing guides for 16.04 and address the areas where those guides need to be altered or worked around to achieve the desired results. This solution isn't as well supported as 16.04 so if you're just looking for an easy way to get started with machine learning, you should probably look elsewhere. Here we're all about breaking things and figuring out how to fix them.

This guide draws especially heavily from one written by Adrian Rosebrock over at PyImageSearch.com. And if you're reading this post, you might also be interested in his latest book, Deep Learning For Computer Vision With Python.

I'm going to assume you'll be interacting with your development machine remotely over SSH. This is better than running everything locally anyway because running the X11 server that runs your Graphical User Interface (GUI) while you set up your development environment can eff things up.

If you have no other choice but to run these commands locally, you can switch to another virtual console by pressing:

CTRL + ALT + F3

...logging in and then running:

Make sure your package lists are up-to-date:

This is the first area where we start to run into differences between configuring 16.04 and 18.04.

First, let's install all of the packages that install painlessly for both systems:

The following packages require a bit more work:

• libjasper-dev
  
• libpng12-dev

Thanks to a handy SE answer, we can fix this issue pretty easily:

This package has since been dropped. Instead, we use libpng-dev which conveniently was already installed when we installed libgtk-3-dev.

We'll be compiling OpenCV with python binding so we'll need these development packages to do so:

We'll need to change out the default graphics drivers so we'll need to install some packages in preparation for that change:

Now we need to disable the default Nouveau driver by creating a blacklist file. Open up the nano text editor with this command:

To this file, add the following lines:

You can now close out the editor by hitting CTRL + X, being careful to select 'Y' when prompted to save your changes.

Now we disable Nouveau in the Kernel Mode Settings (KMS):

The above command edits the file without us having to open a text editor. The first part of the command, echo, returns everything after it, in this case options nouveau modeset=0. The vertical pipe character | in the middle, indicates that we want that output to be fed into the other part of our command, in this case tee. We append that command with sudo because we need admin writes to edit the file located at /etc/modprobe.d/nouveau-kms.conf. The tee command splits what is fed to it between the given file and the terminal output so we can see what it is doing. In this case, we've also included the -a flag which instructs the tee command to append the input to the file rather than just overwriting everything in the file.

Now we update run the command that makes note of our previous changes so they will be respected at boot time:

And now we can restart the machine:

Now we download the CUDA Toolkit from the NVIDIA website. Because we like the pain and frustration of the bleeding edge, we'll be using CUDA Toolkit 10.0 so we'll select Linux > x86_64 > Ubuntu > 18.04 > deb (network).

If you've navigated to the website on a machine that isn't the one you're configuring, just copy the link address to the download file and use wget on your Ubuntu machine:

Now we just install it:

We need to update our path variable so the computer knows where CUDA lives. 

Note that I'm editing my ~/.profile file which only gets read when the user logs in. You could replace the ~/.profile part of the following command with ~/.bashrc which I imagine some people would recommend, but those people aren't me.

To refresh the PATH variable in your current session, you can either close and reopen a new terminal session or use the source command:

You can check to make sure /usr/local/cuda-10.0/bin is included in your path variable by echoing it:

After rebooting we can verify that things are working properly. Check that the NVIDIA Persistence Daemon is running:

It should say something like:

nvidia-persistenced.service - NVIDIA Persistence Daemon
  Loaded: loaded (/lib/systemd/system/nvidia-persistenced.service; static; vendor preset: enabled)
  Active: active (running)

Now check that the NVIDA driver version:

You would expect something like:

NVRM version: NVIDIA UNIX x86_64 Kernel Module  410.48  Thu Sep  6 06:36:33 CDT 2018
GCC version:  gcc version 7.3.0 (Ubuntu 7.3.0-27ubuntu1~18.04)

Check the version of CUDA Toolkit:

It should say something like:

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2018 NVIDIA Corporation
Built on Sat_Aug_25_21:08:01_CDT_2018
Cuda compilation tools, release 10.0, V10.0.130

Now let's get the CUDA samples and make sure they run correctly. Change into whatever directory you'd like to download them to and run:

There should now be a directory called NVIDIA_CUDA-10.0_Samples in your current directory. Let's cd into it and compile the samples:

Note that the make command uses a single CPU core by default but will go much faster if you tell it to use more. You can find out how many cores your system has available by using the command:

lscpu | grep -E '^Thread|^Core|^Socket|^CPU\('

That will give you output like:

CPU(s):              12
Thread(s) per core:  2
Core(s) per socket:  6
Socket(s):           1

So in my make command I can say make -j6 to make things go much faster than if I had just executed make without any additional arguments.

Once that's done, we'll execute the deviceQuery script to check if our GPU is working with CUDA. From the same directory you ran the make command, you can run the script like this:

Note the period (.) at the beginning of the command.

This command gives you a bunch of info and at the bottom it should hopefully say:

Result = PASS

Downloading cuDNN requires the creation of an account on the developer.nvidia.com website so it's probably easier to download the files on the machine you're sshing from and then copy them over using scp.

The three downloads we're looking for are cuDNN v7.3.1 for CUDA 10.0. Specifically we'll be installing the runtime and development libraries plus the code samples and user guide so look for:

• cuDNN v7.3.1 Runtime Library for Ubuntu18.04 (Deb)
• cuDNN v7.3.1 Developer Library for Ubuntu18.04 (Deb)
• cuDNN v7.3.1 Code Samples and User Guide for Ubuntu18.04 (Deb)
  

When you have all of those downloaded, you can copy them to your development machine. You'll need to replace < user > and < dev-machine-ip > with their appropriate values. Make sure you run this command from the same directory you downloaded the files to.

Now, back on the development machine, let's install them. We copied them over to users Download directory so you can look for the files there. When you find them, install them like so:

We can verify the installation by running some sample code. First, we copy it over to our home directory:

Now we can change into the directory and compile the samples. As before we can speed up the make command by giving it the number of CPU cores we have available (e.g. make -j4).

We then run the sample (again, note the period at the beginning):

If all went well, you should see at the bottom of the output:

Test passed!

Back in our home directory, let's setup a virtual environment for our python code to run. This is standard practice since it separates our own python libraries from the system level ones and also helps us stay organized.

There are quite a few ways to do this, so feel free to use whatever method you want or do what I do:

If you followed my way, we created our virtual environment in a directory called dl4cv which you could have named whatever you want. This directory itself is located in the venv directory in your home directory.

Now, whenever you want to work inside of your virtual environment, you'll need to activate it:

When activated, you'll notice that the name of your virtual environment appears in parentheses to the left side of your command prompt.

Once inside our virtual python environment, we'll be using the python package manager pip to install new python packages. First, let's upgrade it to the latest version:

Next, let's install the python package NumPy which we'll need to compile and install OpenCV:

We now need to download both opencv and opencv_contrib to our Downloads directory:

Unzip both of the archives we just downloaded:

Now we change directory into the ~/opencv-3.4.3/ directory, create a new directory called build and configure OpenCV inside of it:

When it's done make note of the output, focusing on the regions as highlighted in the image below.

You'll want to make sure that both your Python and NumPy versions are the ones from your virtual environment.

If for some reason they aren't you can always delete the build folder and repeat the above steps, make sure you have the commands correct and that you have activated your virtual python environment before running the command.

As an aside, I had originally tried to compile with CUDA support as well but it ends up not playing well at compile time so that's why it's disabled in this example.

Now we are ready to compile. This command again runs faster if you specify more cores, but if you run into errors, try running make clean and then rerunning make without specifying additional cores.

Then we install and update our file links before returning to our home directory:

To make our OpenCV bindings available to our virtual python environment, we need to symbolically link them, which is kind of like copying but without the copying part:

Time to test it out! Make sure you have your virtual python environment activated and just type python and hit enter to enter the virtual environment.

From there you can try importing the OpenCV library:

No errors? Congrats!

We'll install a few more python packages before adding Tensorflow support:

Tensorflow with GPU support can be pip installed for earlier versions of CUDA + cuDNN but not for the latest versions that we've installed so we'll need to build tensorflow from source ourselves.

Let's start by downloading the source into our Downloads/ folder:

By default, we're on the master branch of the source code which is more likely to have bugs and stability issues. Let's switch to the latest release version:

We can test out the code branch with Bazel but we'll need to install it. First the dependencies:

Then we can install Bazel itself:

...and change back into our tensorflow directory to run the test (expect it to take awhile):

You'll see plenty of WARNING messages, but we just want to make sure things don't completely go to shit. For me, my results were:

INFO: Build completed, 23 tests FAILED, 27775 total actions

The documentation offers no clues as to whether 23 errors is good or bad, so I'll just assume it's totally fine.

Now we run the configure script which essential surveys the user for which values to use to compile with. The things we care about are telling it to compile with the python executable in our virtual environment, enabling CUDA support, and telling it the correct versions of our tools. We'll just leave everything else as their default values.

So the only non-default answers we need to give are:

1. Do you wish to build TensorFlow with CUDA support? [y/N]: Y
2. Please specify the CUDA SDK version you want to use. [Leave empty to default to CUDA 9.0]: 10.0
3. Please specify the cuDNN version you want to use. [Leave empty to default to cuDNN 7.0]: 7.3
   
4. Please specify the NCCL version you want to use. If NCCL 2.2 is not installed, then you can use version 1.3 that can be fetched automatically but it may have worse performance with multiple GPUs. [Default is 2.2]: 1.3

Now we make the package builder:

...build the package:

And install it using pip and change back to our home directory:

We can test by opening up another python interactive shell and trying to import tensorflow:

If you don't get any errors, you can move onto installing Keras:

If you open up another Python shell and import keras, you should get a message saying:

Using TensorFlow backend.

If you do, you're done! Go play with some deep learning models. Maybe start here?